_ 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};
  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 std::collections::{BTreeSet, HashMap, HashSet};
  47 use std::default::Default;
  48 use std::sync::{Arc, Mutex};
  49 use std::sync::atomic::Ordering;
  50 use std::{mem, io};
  51
  52 use ln::functional_test_utils::*;
  53
  54 #[test]
  55 fn test_insane_channel_opens() {
  56         // Stand up a network of 2 nodes
  57         let chanmon_cfgs = create_chanmon_cfgs(2);
  58         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
  59         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
  60         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  61
  62         // Instantiate channel parameters where we push the maximum msats given our
  63         // funding satoshis
  64         let channel_value_sat = 31337; // same as funding satoshis
  65         let channel_reserve_satoshis = Channel::<EnforcingChannelKeys>::get_remote_channel_reserve_satoshis(channel_value_sat);
  66         let push_msat = (channel_value_sat - channel_reserve_satoshis) * 1000;
  67
  68         // Have node0 initiate a channel to node1 with aforementioned parameters
  69         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_sat, push_msat, 42, None).unwrap();
  70
  71         // Extract the channel open message from node0 to node1
  72         let open_channel_message = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
  73
  74         // Test helper that asserts we get the correct error string given a mutator
  75         // that supposedly makes the channel open message insane
  76         let insane_open_helper = |expected_error_str: &str, message_mutator: fn(msgs::OpenChannel) -> msgs::OpenChannel| {
  77                 nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &message_mutator(open_channel_message.clone()));
  78                 let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
  79                 assert_eq!(msg_events.len(), 1);
  80                 if let MessageSendEvent::HandleError { ref action, .. } = msg_events[0] {
  81                         match action {
  82                                 &ErrorAction::SendErrorMessage { .. } => {
  83                                         nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), expected_error_str.to_string(), 1);
  84                                 },
  85                                 _ => panic!("unexpected event!"),
  86                         }
  87                 } else { assert!(false); }
  88         };
  89
  90         use ln::channel::MAX_FUNDING_SATOSHIS;
  91         use ln::channelmanager::MAX_LOCAL_BREAKDOWN_TIMEOUT;
  92
  93         // Test all mutations that would make the channel open message insane
  94         insane_open_helper("funding value > 2^24", |mut msg| { msg.funding_satoshis = MAX_FUNDING_SATOSHIS; msg });
  95
  96         insane_open_helper("Bogus channel_reserve_satoshis", |mut msg| { msg.channel_reserve_satoshis = msg.funding_satoshis + 1; msg });
  97
  98         insane_open_helper("push_msat larger than funding value", |mut msg| { msg.push_msat = (msg.funding_satoshis - msg.channel_reserve_satoshis) * 1000 + 1; msg });
  99
 100         insane_open_helper("Peer never wants payout outputs?", |mut msg| { msg.dust_limit_satoshis = msg.funding_satoshis + 1 ; msg });
 101
 102         insane_open_helper("Bogus; channel reserve is less than dust limit", |mut msg| { msg.dust_limit_satoshis = msg.channel_reserve_satoshis + 1; msg });
 103
 104         insane_open_helper("Minimum htlc value is full channel value", |mut msg| { msg.htlc_minimum_msat = (msg.funding_satoshis - msg.channel_reserve_satoshis) * 1000; msg });
 105
 106         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 });
 107
 108         insane_open_helper("0 max_accpted_htlcs makes for a useless channel", |mut msg| { msg.max_accepted_htlcs = 0; msg });
 109
 110         insane_open_helper("max_accpted_htlcs > 483", |mut msg| { msg.max_accepted_htlcs = 484; msg });
 111 }
 112
 113 #[test]
 114 fn test_async_inbound_update_fee() {
 115         let chanmon_cfgs = create_chanmon_cfgs(2);
 116         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 117         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 118         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 119         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 120         let logger = test_utils::TestLogger::new();
 121         let channel_id = chan.2;
 122
 123         // balancing
 124         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 125
 126         // A                                        B
 127         // update_fee                            ->
 128         // send (1) commitment_signed            -.
 129         //                                       <- update_add_htlc/commitment_signed
 130         // send (2) RAA (awaiting remote revoke) -.
 131         // (1) commitment_signed is delivered    ->
 132         //                                       .- send (3) RAA (awaiting remote revoke)
 133         // (2) RAA is delivered                  ->
 134         //                                       .- send (4) commitment_signed
 135         //                                       <- (3) RAA is delivered
 136         // send (5) commitment_signed            -.
 137         //                                       <- (4) commitment_signed is delivered
 138         // send (6) RAA                          -.
 139         // (5) commitment_signed is delivered    ->
 140         //                                       <- RAA
 141         // (6) RAA is delivered                  ->
 142
 143         // First nodes[0] generates an update_fee
 144         nodes[0].node.update_fee(channel_id, get_feerate!(nodes[0], channel_id) + 20).unwrap();
 145         check_added_monitors!(nodes[0], 1);
 146
 147         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 148         assert_eq!(events_0.len(), 1);
 149         let (update_msg, commitment_signed) = match events_0[0] { // (1)
 150                 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fee, ref commitment_signed, .. }, .. } => {
 151                         (update_fee.as_ref(), commitment_signed)
 152                 },
 153                 _ => panic!("Unexpected event"),
 154         };
 155
 156         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
 157
 158         // ...but before it's delivered, nodes[1] starts to send a payment back to nodes[0]...
 159         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 160         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 161         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();
 162         check_added_monitors!(nodes[1], 1);
 163
 164         let payment_event = {
 165                 let mut events_1 = nodes[1].node.get_and_clear_pending_msg_events();
 166                 assert_eq!(events_1.len(), 1);
 167                 SendEvent::from_event(events_1.remove(0))
 168         };
 169         assert_eq!(payment_event.node_id, nodes[0].node.get_our_node_id());
 170         assert_eq!(payment_event.msgs.len(), 1);
 171
 172         // ...now when the messages get delivered everyone should be happy
 173         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
 174         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &payment_event.commitment_msg); // (2)
 175         let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 176         // nodes[0] is awaiting nodes[1] revoke_and_ack so get_event_msg's assert(len == 1) passes
 177         check_added_monitors!(nodes[0], 1);
 178
 179         // deliver(1), generate (3):
 180         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed);
 181         let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 182         // nodes[1] is awaiting nodes[0] revoke_and_ack so get_event_msg's assert(len == 1) passes
 183         check_added_monitors!(nodes[1], 1);
 184
 185         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack); // deliver (2)
 186         let bs_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 187         assert!(bs_update.update_add_htlcs.is_empty()); // (4)
 188         assert!(bs_update.update_fulfill_htlcs.is_empty()); // (4)
 189         assert!(bs_update.update_fail_htlcs.is_empty()); // (4)
 190         assert!(bs_update.update_fail_malformed_htlcs.is_empty()); // (4)
 191         assert!(bs_update.update_fee.is_none()); // (4)
 192         check_added_monitors!(nodes[1], 1);
 193
 194         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack); // deliver (3)
 195         let as_update = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 196         assert!(as_update.update_add_htlcs.is_empty()); // (5)
 197         assert!(as_update.update_fulfill_htlcs.is_empty()); // (5)
 198         assert!(as_update.update_fail_htlcs.is_empty()); // (5)
 199         assert!(as_update.update_fail_malformed_htlcs.is_empty()); // (5)
 200         assert!(as_update.update_fee.is_none()); // (5)
 201         check_added_monitors!(nodes[0], 1);
 202
 203         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_update.commitment_signed); // deliver (4)
 204         let as_second_revoke = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 205         // only (6) so get_event_msg's assert(len == 1) passes
 206         check_added_monitors!(nodes[0], 1);
 207
 208         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_update.commitment_signed); // deliver (5)
 209         let bs_second_revoke = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 210         check_added_monitors!(nodes[1], 1);
 211
 212         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_second_revoke);
 213         check_added_monitors!(nodes[0], 1);
 214
 215         let events_2 = nodes[0].node.get_and_clear_pending_events();
 216         assert_eq!(events_2.len(), 1);
 217         match events_2[0] {
 218                 Event::PendingHTLCsForwardable {..} => {}, // If we actually processed we'd receive the payment
 219                 _ => panic!("Unexpected event"),
 220         }
 221
 222         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_second_revoke); // deliver (6)
 223         check_added_monitors!(nodes[1], 1);
 224 }
 225
 226 #[test]
 227 fn test_update_fee_unordered_raa() {
 228         // Just the intro to the previous test followed by an out-of-order RAA (which caused a
 229         // crash in an earlier version of the update_fee patch)
 230         let chanmon_cfgs = create_chanmon_cfgs(2);
 231         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 232         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 233         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 234         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 235         let channel_id = chan.2;
 236         let logger = test_utils::TestLogger::new();
 237
 238         // balancing
 239         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 240
 241         // First nodes[0] generates an update_fee
 242         nodes[0].node.update_fee(channel_id, get_feerate!(nodes[0], channel_id) + 20).unwrap();
 243         check_added_monitors!(nodes[0], 1);
 244
 245         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 246         assert_eq!(events_0.len(), 1);
 247         let update_msg = match events_0[0] { // (1)
 248                 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fee, .. }, .. } => {
 249                         update_fee.as_ref()
 250                 },
 251                 _ => panic!("Unexpected event"),
 252         };
 253
 254         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
 255
 256         // ...but before it's delivered, nodes[1] starts to send a payment back to nodes[0]...
 257         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 258         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 259         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();
 260         check_added_monitors!(nodes[1], 1);
 261
 262         let payment_event = {
 263                 let mut events_1 = nodes[1].node.get_and_clear_pending_msg_events();
 264                 assert_eq!(events_1.len(), 1);
 265                 SendEvent::from_event(events_1.remove(0))
 266         };
 267         assert_eq!(payment_event.node_id, nodes[0].node.get_our_node_id());
 268         assert_eq!(payment_event.msgs.len(), 1);
 269
 270         // ...now when the messages get delivered everyone should be happy
 271         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
 272         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &payment_event.commitment_msg); // (2)
 273         let as_revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 274         // nodes[0] is awaiting nodes[1] revoke_and_ack so get_event_msg's assert(len == 1) passes
 275         check_added_monitors!(nodes[0], 1);
 276
 277         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_msg); // deliver (2)
 278         check_added_monitors!(nodes[1], 1);
 279
 280         // We can't continue, sadly, because our (1) now has a bogus signature
 281 }
 282
 283 #[test]
 284 fn test_multi_flight_update_fee() {
 285         let chanmon_cfgs = create_chanmon_cfgs(2);
 286         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 287         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 288         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 289         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 290         let channel_id = chan.2;
 291
 292         // A                                        B
 293         // update_fee/commitment_signed          ->
 294         //                                       .- send (1) RAA and (2) commitment_signed
 295         // update_fee (never committed)          ->
 296         // (3) update_fee                        ->
 297         // We have to manually generate the above update_fee, it is allowed by the protocol but we
 298         // don't track which updates correspond to which revoke_and_ack responses so we're in
 299         // AwaitingRAA mode and will not generate the update_fee yet.
 300         //                                       <- (1) RAA delivered
 301         // (3) is generated and send (4) CS      -.
 302         // Note that A cannot generate (4) prior to (1) being delivered as it otherwise doesn't
 303         // know the per_commitment_point to use for it.
 304         //                                       <- (2) commitment_signed delivered
 305         // revoke_and_ack                        ->
 306         //                                          B should send no response here
 307         // (4) commitment_signed delivered       ->
 308         //                                       <- RAA/commitment_signed delivered
 309         // revoke_and_ack                        ->
 310
 311         // First nodes[0] generates an update_fee
 312         let initial_feerate = get_feerate!(nodes[0], channel_id);
 313         nodes[0].node.update_fee(channel_id, initial_feerate + 20).unwrap();
 314         check_added_monitors!(nodes[0], 1);
 315
 316         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 317         assert_eq!(events_0.len(), 1);
 318         let (update_msg_1, commitment_signed_1) = match events_0[0] { // (1)
 319                 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fee, ref commitment_signed, .. }, .. } => {
 320                         (update_fee.as_ref().unwrap(), commitment_signed)
 321                 },
 322                 _ => panic!("Unexpected event"),
 323         };
 324
 325         // Deliver first update_fee/commitment_signed pair, generating (1) and (2):
 326         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg_1);
 327         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed_1);
 328         let (bs_revoke_msg, bs_commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 329         check_added_monitors!(nodes[1], 1);
 330
 331         // nodes[0] is awaiting a revoke from nodes[1] before it will create a new commitment
 332         // transaction:
 333         nodes[0].node.update_fee(channel_id, initial_feerate + 40).unwrap();
 334         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
 335         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 336
 337         // Create the (3) update_fee message that nodes[0] will generate before it does...
 338         let mut update_msg_2 = msgs::UpdateFee {
 339                 channel_id: update_msg_1.channel_id.clone(),
 340                 feerate_per_kw: (initial_feerate + 30) as u32,
 341         };
 342
 343         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &update_msg_2);
 344
 345         update_msg_2.feerate_per_kw = (initial_feerate + 40) as u32;
 346         // Deliver (3)
 347         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &update_msg_2);
 348
 349         // Deliver (1), generating (3) and (4)
 350         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_msg);
 351         let as_second_update = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 352         check_added_monitors!(nodes[0], 1);
 353         assert!(as_second_update.update_add_htlcs.is_empty());
 354         assert!(as_second_update.update_fulfill_htlcs.is_empty());
 355         assert!(as_second_update.update_fail_htlcs.is_empty());
 356         assert!(as_second_update.update_fail_malformed_htlcs.is_empty());
 357         // Check that the update_fee newly generated matches what we delivered:
 358         assert_eq!(as_second_update.update_fee.as_ref().unwrap().channel_id, update_msg_2.channel_id);
 359         assert_eq!(as_second_update.update_fee.as_ref().unwrap().feerate_per_kw, update_msg_2.feerate_per_kw);
 360
 361         // Deliver (2) commitment_signed
 362         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_commitment_signed);
 363         let as_revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 364         check_added_monitors!(nodes[0], 1);
 365         // No commitment_signed so get_event_msg's assert(len == 1) passes
 366
 367         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_msg);
 368         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 369         check_added_monitors!(nodes[1], 1);
 370
 371         // Delever (4)
 372         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_second_update.commitment_signed);
 373         let (bs_second_revoke, bs_second_commitment) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 374         check_added_monitors!(nodes[1], 1);
 375
 376         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_second_revoke);
 377         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 378         check_added_monitors!(nodes[0], 1);
 379
 380         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_second_commitment);
 381         let as_second_revoke = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 382         // No commitment_signed so get_event_msg's assert(len == 1) passes
 383         check_added_monitors!(nodes[0], 1);
 384
 385         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_second_revoke);
 386         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 387         check_added_monitors!(nodes[1], 1);
 388 }
 389
 390 #[test]
 391 fn test_1_conf_open() {
 392         // Previously, if the minium_depth config was set to 1, we'd never send a funding_locked. This
 393         // tests that we properly send one in that case.
 394         let mut alice_config = UserConfig::default();
 395         alice_config.own_channel_config.minimum_depth = 1;
 396         alice_config.channel_options.announced_channel = true;
 397         alice_config.peer_channel_config_limits.force_announced_channel_preference = false;
 398         let mut bob_config = UserConfig::default();
 399         bob_config.own_channel_config.minimum_depth = 1;
 400         bob_config.channel_options.announced_channel = true;
 401         bob_config.peer_channel_config_limits.force_announced_channel_preference = false;
 402         let chanmon_cfgs = create_chanmon_cfgs(2);
 403         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 404         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(alice_config), Some(bob_config)]);
 405         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 406
 407         let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
 408         assert!(nodes[0].chain_monitor.does_match_tx(&tx));
 409         assert!(nodes[1].chain_monitor.does_match_tx(&tx));
 410
 411         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
 412         nodes[1].block_notifier.block_connected_checked(&header, 1, &[&tx; 1], &[tx.version as usize; 1]);
 413         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()));
 414
 415         nodes[0].block_notifier.block_connected_checked(&header, 1, &[&tx; 1], &[tx.version as usize; 1]);
 416         let (funding_locked, _) = create_chan_between_nodes_with_value_confirm_second(&nodes[1], &nodes[0]);
 417         let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked);
 418
 419         for node in nodes {
 420                 assert!(node.net_graph_msg_handler.handle_channel_announcement(&announcement).unwrap());
 421                 node.net_graph_msg_handler.handle_channel_update(&as_update).unwrap();
 422                 node.net_graph_msg_handler.handle_channel_update(&bs_update).unwrap();
 423         }
 424 }
 425
 426 fn do_test_sanity_on_in_flight_opens(steps: u8) {
 427         // Previously, we had issues deserializing channels when we hadn't connected the first block
 428         // after creation. To catch that and similar issues, we lean on the Node::drop impl to test
 429         // serialization round-trips and simply do steps towards opening a channel and then drop the
 430         // Node objects.
 431
 432         let chanmon_cfgs = create_chanmon_cfgs(2);
 433         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 434         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 435         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 436
 437         if steps & 0b1000_0000 != 0{
 438                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
 439                 nodes[0].block_notifier.block_connected_checked(&header, 1, &Vec::new(), &[0; 0]);
 440                 nodes[1].block_notifier.block_connected_checked(&header, 1, &Vec::new(), &[0; 0]);
 441         }
 442
 443         if steps & 0x0f == 0 { return; }
 444         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None).unwrap();
 445         let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
 446
 447         if steps & 0x0f == 1 { return; }
 448         nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &open_channel);
 449         let accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
 450
 451         if steps & 0x0f == 2 { return; }
 452         nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), InitFeatures::known(), &accept_channel);
 453
 454         let (temporary_channel_id, tx, funding_output) = create_funding_transaction(&nodes[0], 100000, 42);
 455
 456         if steps & 0x0f == 3 { return; }
 457         nodes[0].node.funding_transaction_generated(&temporary_channel_id, funding_output);
 458         check_added_monitors!(nodes[0], 0);
 459         let funding_created = get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id());
 460
 461         if steps & 0x0f == 4 { return; }
 462         nodes[1].node.handle_funding_created(&nodes[0].node.get_our_node_id(), &funding_created);
 463         {
 464                 let mut added_monitors = nodes[1].chan_monitor.added_monitors.lock().unwrap();
 465                 assert_eq!(added_monitors.len(), 1);
 466                 assert_eq!(added_monitors[0].0, funding_output);
 467                 added_monitors.clear();
 468         }
 469         let funding_signed = get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, nodes[0].node.get_our_node_id());
 470
 471         if steps & 0x0f == 5 { return; }
 472         nodes[0].node.handle_funding_signed(&nodes[1].node.get_our_node_id(), &funding_signed);
 473         {
 474                 let mut added_monitors = nodes[0].chan_monitor.added_monitors.lock().unwrap();
 475                 assert_eq!(added_monitors.len(), 1);
 476                 assert_eq!(added_monitors[0].0, funding_output);
 477                 added_monitors.clear();
 478         }
 479
 480         let events_4 = nodes[0].node.get_and_clear_pending_events();
 481         assert_eq!(events_4.len(), 1);
 482         match events_4[0] {
 483                 Event::FundingBroadcastSafe { ref funding_txo, user_channel_id } => {
 484                         assert_eq!(user_channel_id, 42);
 485                         assert_eq!(*funding_txo, funding_output);
 486                 },
 487                 _ => panic!("Unexpected event"),
 488         };
 489
 490         if steps & 0x0f == 6 { return; }
 491         create_chan_between_nodes_with_value_confirm_first(&nodes[0], &nodes[1], &tx);
 492
 493         if steps & 0x0f == 7 { return; }
 494         confirm_transaction(&nodes[0].block_notifier, &nodes[0].chain_monitor, &tx, tx.version);
 495         create_chan_between_nodes_with_value_confirm_second(&nodes[1], &nodes[0]);
 496 }
 497
 498 #[test]
 499 fn test_sanity_on_in_flight_opens() {
 500         do_test_sanity_on_in_flight_opens(0);
 501         do_test_sanity_on_in_flight_opens(0 | 0b1000_0000);
 502         do_test_sanity_on_in_flight_opens(1);
 503         do_test_sanity_on_in_flight_opens(1 | 0b1000_0000);
 504         do_test_sanity_on_in_flight_opens(2);
 505         do_test_sanity_on_in_flight_opens(2 | 0b1000_0000);
 506         do_test_sanity_on_in_flight_opens(3);
 507         do_test_sanity_on_in_flight_opens(3 | 0b1000_0000);
 508         do_test_sanity_on_in_flight_opens(4);
 509         do_test_sanity_on_in_flight_opens(4 | 0b1000_0000);
 510         do_test_sanity_on_in_flight_opens(5);
 511         do_test_sanity_on_in_flight_opens(5 | 0b1000_0000);
 512         do_test_sanity_on_in_flight_opens(6);
 513         do_test_sanity_on_in_flight_opens(6 | 0b1000_0000);
 514         do_test_sanity_on_in_flight_opens(7);
 515         do_test_sanity_on_in_flight_opens(7 | 0b1000_0000);
 516         do_test_sanity_on_in_flight_opens(8);
 517         do_test_sanity_on_in_flight_opens(8 | 0b1000_0000);
 518 }
 519
 520 #[test]
 521 fn test_update_fee_vanilla() {
 522         let chanmon_cfgs = create_chanmon_cfgs(2);
 523         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 524         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 525         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 526         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 527         let channel_id = chan.2;
 528
 529         let feerate = get_feerate!(nodes[0], channel_id);
 530         nodes[0].node.update_fee(channel_id, feerate+25).unwrap();
 531         check_added_monitors!(nodes[0], 1);
 532
 533         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 534         assert_eq!(events_0.len(), 1);
 535         let (update_msg, commitment_signed) = match events_0[0] {
 536                         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 } } => {
 537                         (update_fee.as_ref(), commitment_signed)
 538                 },
 539                 _ => panic!("Unexpected event"),
 540         };
 541         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
 542
 543         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed);
 544         let (revoke_msg, commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 545         check_added_monitors!(nodes[1], 1);
 546
 547         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke_msg);
 548         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 549         check_added_monitors!(nodes[0], 1);
 550
 551         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed);
 552         let revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 553         // No commitment_signed so get_event_msg's assert(len == 1) passes
 554         check_added_monitors!(nodes[0], 1);
 555
 556         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke_msg);
 557         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 558         check_added_monitors!(nodes[1], 1);
 559 }
 560
 561 #[test]
 562 fn test_update_fee_that_funder_cannot_afford() {
 563         let chanmon_cfgs = create_chanmon_cfgs(2);
 564         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 565         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 566         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 567         let channel_value = 1888;
 568         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, channel_value, 700000, InitFeatures::known(), InitFeatures::known());
 569         let channel_id = chan.2;
 570
 571         let feerate = 260;
 572         nodes[0].node.update_fee(channel_id, feerate).unwrap();
 573         check_added_monitors!(nodes[0], 1);
 574         let update_msg = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 575
 576         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &update_msg.update_fee.unwrap());
 577
 578         commitment_signed_dance!(nodes[1], nodes[0], update_msg.commitment_signed, false);
 579
 580         //Confirm that the new fee based on the last local commitment txn is what we expected based on the feerate of 260 set above.
 581         //This value results in a fee that is exactly what the funder can afford (277 sat + 1000 sat channel reserve)
 582         {
 583                 let commitment_tx = get_local_commitment_txn!(nodes[1], channel_id)[0].clone();
 584
 585                 //We made sure neither party's funds are below the dust limit so -2 non-HTLC txns from number of outputs
 586                 let num_htlcs = commitment_tx.output.len() - 2;
 587                 let total_fee: u64 = feerate as u64 * (COMMITMENT_TX_BASE_WEIGHT + (num_htlcs as u64) * COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000;
 588                 let mut actual_fee = commitment_tx.output.iter().fold(0, |acc, output| acc + output.value);
 589                 actual_fee = channel_value - actual_fee;
 590                 assert_eq!(total_fee, actual_fee);
 591         }
 592
 593         //Add 2 to the previous fee rate to the final fee increases by 1 (with no HTLCs the fee is essentially
 594         //fee_rate*(724/1000) so the increment of 1*0.724 is rounded back down)
 595         nodes[0].node.update_fee(channel_id, feerate+2).unwrap();
 596         check_added_monitors!(nodes[0], 1);
 597
 598         let update2_msg = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 599
 600         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &update2_msg.update_fee.unwrap());
 601
 602         //While producing the commitment_signed response after handling a received update_fee request the
 603         //check to see if the funder, who sent the update_fee request, can afford the new fee (funder_balance >= fee+channel_reserve)
 604         //Should produce and error.
 605         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &update2_msg.commitment_signed);
 606         nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Funding remote cannot afford proposed new fee".to_string(), 1);
 607         check_added_monitors!(nodes[1], 1);
 608         check_closed_broadcast!(nodes[1], true);
 609 }
 610
 611 #[test]
 612 fn test_update_fee_with_fundee_update_add_htlc() {
 613         let chanmon_cfgs = create_chanmon_cfgs(2);
 614         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 615         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 616         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 617         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 618         let channel_id = chan.2;
 619         let logger = test_utils::TestLogger::new();
 620
 621         // balancing
 622         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 623
 624         let feerate = get_feerate!(nodes[0], channel_id);
 625         nodes[0].node.update_fee(channel_id, feerate+20).unwrap();
 626         check_added_monitors!(nodes[0], 1);
 627
 628         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 629         assert_eq!(events_0.len(), 1);
 630         let (update_msg, commitment_signed) = match events_0[0] {
 631                         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 } } => {
 632                         (update_fee.as_ref(), commitment_signed)
 633                 },
 634                 _ => panic!("Unexpected event"),
 635         };
 636         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
 637         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed);
 638         let (revoke_msg, commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 639         check_added_monitors!(nodes[1], 1);
 640
 641         let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[1]);
 642         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 643         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();
 644
 645         // nothing happens since node[1] is in AwaitingRemoteRevoke
 646         nodes[1].node.send_payment(&route, our_payment_hash, &None).unwrap();
 647         {
 648                 let mut added_monitors = nodes[0].chan_monitor.added_monitors.lock().unwrap();
 649                 assert_eq!(added_monitors.len(), 0);
 650                 added_monitors.clear();
 651         }
 652         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
 653         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 654         // node[1] has nothing to do
 655
 656         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke_msg);
 657         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 658         check_added_monitors!(nodes[0], 1);
 659
 660         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed);
 661         let revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 662         // No commitment_signed so get_event_msg's assert(len == 1) passes
 663         check_added_monitors!(nodes[0], 1);
 664         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke_msg);
 665         check_added_monitors!(nodes[1], 1);
 666         // AwaitingRemoteRevoke ends here
 667
 668         let commitment_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 669         assert_eq!(commitment_update.update_add_htlcs.len(), 1);
 670         assert_eq!(commitment_update.update_fulfill_htlcs.len(), 0);
 671         assert_eq!(commitment_update.update_fail_htlcs.len(), 0);
 672         assert_eq!(commitment_update.update_fail_malformed_htlcs.len(), 0);
 673         assert_eq!(commitment_update.update_fee.is_none(), true);
 674
 675         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &commitment_update.update_add_htlcs[0]);
 676         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_update.commitment_signed);
 677         check_added_monitors!(nodes[0], 1);
 678         let (revoke, commitment_signed) = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 679
 680         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke);
 681         check_added_monitors!(nodes[1], 1);
 682         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 683
 684         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &commitment_signed);
 685         check_added_monitors!(nodes[1], 1);
 686         let revoke = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 687         // No commitment_signed so get_event_msg's assert(len == 1) passes
 688
 689         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke);
 690         check_added_monitors!(nodes[0], 1);
 691         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 692
 693         expect_pending_htlcs_forwardable!(nodes[0]);
 694
 695         let events = nodes[0].node.get_and_clear_pending_events();
 696         assert_eq!(events.len(), 1);
 697         match events[0] {
 698                 Event::PaymentReceived { .. } => { },
 699                 _ => panic!("Unexpected event"),
 700         };
 701
 702         claim_payment(&nodes[1], &vec!(&nodes[0])[..], our_payment_preimage, 800_000);
 703
 704         send_payment(&nodes[1], &vec!(&nodes[0])[..], 800000, 800_000);
 705         send_payment(&nodes[0], &vec!(&nodes[1])[..], 800000, 800_000);
 706         close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true);
 707 }
 708
 709 #[test]
 710 fn test_update_fee() {
 711         let chanmon_cfgs = create_chanmon_cfgs(2);
 712         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 713         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 714         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 715         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 716         let channel_id = chan.2;
 717
 718         // A                                        B
 719         // (1) update_fee/commitment_signed      ->
 720         //                                       <- (2) revoke_and_ack
 721         //                                       .- send (3) commitment_signed
 722         // (4) update_fee/commitment_signed      ->
 723         //                                       .- send (5) revoke_and_ack (no CS as we're awaiting a revoke)
 724         //                                       <- (3) commitment_signed delivered
 725         // send (6) revoke_and_ack               -.
 726         //                                       <- (5) deliver revoke_and_ack
 727         // (6) deliver revoke_and_ack            ->
 728         //                                       .- send (7) commitment_signed in response to (4)
 729         //                                       <- (7) deliver commitment_signed
 730         // revoke_and_ack                        ->
 731
 732         // Create and deliver (1)...
 733         let feerate = get_feerate!(nodes[0], channel_id);
 734         nodes[0].node.update_fee(channel_id, feerate+20).unwrap();
 735         check_added_monitors!(nodes[0], 1);
 736
 737         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 738         assert_eq!(events_0.len(), 1);
 739         let (update_msg, commitment_signed) = match events_0[0] {
 740                         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 } } => {
 741                         (update_fee.as_ref(), commitment_signed)
 742                 },
 743                 _ => panic!("Unexpected event"),
 744         };
 745         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
 746
 747         // Generate (2) and (3):
 748         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed);
 749         let (revoke_msg, commitment_signed_0) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 750         check_added_monitors!(nodes[1], 1);
 751
 752         // Deliver (2):
 753         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke_msg);
 754         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 755         check_added_monitors!(nodes[0], 1);
 756
 757         // Create and deliver (4)...
 758         nodes[0].node.update_fee(channel_id, feerate+30).unwrap();
 759         check_added_monitors!(nodes[0], 1);
 760         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 761         assert_eq!(events_0.len(), 1);
 762         let (update_msg, commitment_signed) = match events_0[0] {
 763                         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 } } => {
 764                         (update_fee.as_ref(), commitment_signed)
 765                 },
 766                 _ => panic!("Unexpected event"),
 767         };
 768
 769         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
 770         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed);
 771         check_added_monitors!(nodes[1], 1);
 772         // ... creating (5)
 773         let revoke_msg = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 774         // No commitment_signed so get_event_msg's assert(len == 1) passes
 775
 776         // Handle (3), creating (6):
 777         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed_0);
 778         check_added_monitors!(nodes[0], 1);
 779         let revoke_msg_0 = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 780         // No commitment_signed so get_event_msg's assert(len == 1) passes
 781
 782         // Deliver (5):
 783         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke_msg);
 784         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 785         check_added_monitors!(nodes[0], 1);
 786
 787         // Deliver (6), creating (7):
 788         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke_msg_0);
 789         let commitment_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 790         assert!(commitment_update.update_add_htlcs.is_empty());
 791         assert!(commitment_update.update_fulfill_htlcs.is_empty());
 792         assert!(commitment_update.update_fail_htlcs.is_empty());
 793         assert!(commitment_update.update_fail_malformed_htlcs.is_empty());
 794         assert!(commitment_update.update_fee.is_none());
 795         check_added_monitors!(nodes[1], 1);
 796
 797         // Deliver (7)
 798         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_update.commitment_signed);
 799         check_added_monitors!(nodes[0], 1);
 800         let revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 801         // No commitment_signed so get_event_msg's assert(len == 1) passes
 802
 803         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke_msg);
 804         check_added_monitors!(nodes[1], 1);
 805         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 806
 807         assert_eq!(get_feerate!(nodes[0], channel_id), feerate + 30);
 808         assert_eq!(get_feerate!(nodes[1], channel_id), feerate + 30);
 809         close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true);
 810 }
 811
 812 #[test]
 813 fn pre_funding_lock_shutdown_test() {
 814         // Test sending a shutdown prior to funding_locked after funding generation
 815         let chanmon_cfgs = create_chanmon_cfgs(2);
 816         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 817         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 818         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 819         let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 8000000, 0, InitFeatures::known(), InitFeatures::known());
 820         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
 821         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![tx.clone()]}, 1);
 822         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![tx.clone()]}, 1);
 823
 824         nodes[0].node.close_channel(&OutPoint { txid: tx.txid(), index: 0 }.to_channel_id()).unwrap();
 825         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 826         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
 827         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 828         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
 829
 830         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
 831         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 832         let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
 833         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap());
 834         let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 835         assert!(node_0_none.is_none());
 836
 837         assert!(nodes[0].node.list_channels().is_empty());
 838         assert!(nodes[1].node.list_channels().is_empty());
 839 }
 840
 841 #[test]
 842 fn updates_shutdown_wait() {
 843         // Test sending a shutdown with outstanding updates pending
 844         let chanmon_cfgs = create_chanmon_cfgs(3);
 845         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
 846         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
 847         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
 848         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 849         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
 850         let logger = test_utils::TestLogger::new();
 851
 852         let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
 853
 854         nodes[0].node.close_channel(&chan_1.2).unwrap();
 855         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 856         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
 857         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 858         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
 859
 860         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 861         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 862
 863         let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
 864
 865         let net_graph_msg_handler0 = &nodes[0].net_graph_msg_handler;
 866         let net_graph_msg_handler1 = &nodes[1].net_graph_msg_handler;
 867         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();
 868         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();
 869         unwrap_send_err!(nodes[0].node.send_payment(&route_1, payment_hash, &None), true, APIError::ChannelUnavailable {..}, {});
 870         unwrap_send_err!(nodes[1].node.send_payment(&route_2, payment_hash, &None), true, APIError::ChannelUnavailable {..}, {});
 871
 872         assert!(nodes[2].node.claim_funds(our_payment_preimage, &None, 100_000));
 873         check_added_monitors!(nodes[2], 1);
 874         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
 875         assert!(updates.update_add_htlcs.is_empty());
 876         assert!(updates.update_fail_htlcs.is_empty());
 877         assert!(updates.update_fail_malformed_htlcs.is_empty());
 878         assert!(updates.update_fee.is_none());
 879         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
 880         nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
 881         check_added_monitors!(nodes[1], 1);
 882         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 883         commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
 884
 885         assert!(updates_2.update_add_htlcs.is_empty());
 886         assert!(updates_2.update_fail_htlcs.is_empty());
 887         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
 888         assert!(updates_2.update_fee.is_none());
 889         assert_eq!(updates_2.update_fulfill_htlcs.len(), 1);
 890         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]);
 891         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
 892
 893         let events = nodes[0].node.get_and_clear_pending_events();
 894         assert_eq!(events.len(), 1);
 895         match events[0] {
 896                 Event::PaymentSent { ref payment_preimage } => {
 897                         assert_eq!(our_payment_preimage, *payment_preimage);
 898                 },
 899                 _ => panic!("Unexpected event"),
 900         }
 901
 902         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
 903         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 904         let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
 905         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap());
 906         let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 907         assert!(node_0_none.is_none());
 908
 909         assert!(nodes[0].node.list_channels().is_empty());
 910
 911         assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
 912         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
 913         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
 914         assert!(nodes[1].node.list_channels().is_empty());
 915         assert!(nodes[2].node.list_channels().is_empty());
 916 }
 917
 918 #[test]
 919 fn htlc_fail_async_shutdown() {
 920         // Test HTLCs fail if shutdown starts even if messages are delivered out-of-order
 921         let chanmon_cfgs = create_chanmon_cfgs(3);
 922         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
 923         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
 924         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
 925         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 926         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
 927         let logger = test_utils::TestLogger::new();
 928
 929         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 930         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 931         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();
 932         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 933         check_added_monitors!(nodes[0], 1);
 934         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 935         assert_eq!(updates.update_add_htlcs.len(), 1);
 936         assert!(updates.update_fulfill_htlcs.is_empty());
 937         assert!(updates.update_fail_htlcs.is_empty());
 938         assert!(updates.update_fail_malformed_htlcs.is_empty());
 939         assert!(updates.update_fee.is_none());
 940
 941         nodes[1].node.close_channel(&chan_1.2).unwrap();
 942         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 943         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
 944         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 945
 946         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
 947         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &updates.commitment_signed);
 948         check_added_monitors!(nodes[1], 1);
 949         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
 950         commitment_signed_dance!(nodes[1], nodes[0], (), false, true, false);
 951
 952         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 953         assert!(updates_2.update_add_htlcs.is_empty());
 954         assert!(updates_2.update_fulfill_htlcs.is_empty());
 955         assert_eq!(updates_2.update_fail_htlcs.len(), 1);
 956         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
 957         assert!(updates_2.update_fee.is_none());
 958
 959         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fail_htlcs[0]);
 960         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
 961
 962         expect_payment_failed!(nodes[0], our_payment_hash, false);
 963
 964         let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
 965         assert_eq!(msg_events.len(), 2);
 966         let node_0_closing_signed = match msg_events[0] {
 967                 MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => {
 968                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
 969                         (*msg).clone()
 970                 },
 971                 _ => panic!("Unexpected event"),
 972         };
 973         match msg_events[1] {
 974                 MessageSendEvent::PaymentFailureNetworkUpdate { update: msgs::HTLCFailChannelUpdate::ChannelUpdateMessage { ref msg }} => {
 975                         assert_eq!(msg.contents.short_channel_id, chan_1.0.contents.short_channel_id);
 976                 },
 977                 _ => panic!("Unexpected event"),
 978         }
 979
 980         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 981         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 982         let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
 983         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap());
 984         let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 985         assert!(node_0_none.is_none());
 986
 987         assert!(nodes[0].node.list_channels().is_empty());
 988
 989         assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
 990         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
 991         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
 992         assert!(nodes[1].node.list_channels().is_empty());
 993         assert!(nodes[2].node.list_channels().is_empty());
 994 }
 995
 996 fn do_test_shutdown_rebroadcast(recv_count: u8) {
 997         // Test that shutdown/closing_signed is re-sent on reconnect with a variable number of
 998         // messages delivered prior to disconnect
 999         let chanmon_cfgs = create_chanmon_cfgs(3);
1000         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1001         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
1002         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1003         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
1004         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
1005
1006         let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
1007
1008         nodes[1].node.close_channel(&chan_1.2).unwrap();
1009         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1010         if recv_count > 0 {
1011                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
1012                 let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1013                 if recv_count > 1 {
1014                         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
1015                 }
1016         }
1017
1018         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
1019         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
1020
1021         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
1022         let node_0_reestablish = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id());
1023         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
1024         let node_1_reestablish = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
1025
1026         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_reestablish);
1027         let node_1_2nd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1028         assert!(node_1_shutdown == node_1_2nd_shutdown);
1029
1030         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &node_1_reestablish);
1031         let node_0_2nd_shutdown = if recv_count > 0 {
1032                 let node_0_2nd_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1033                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown);
1034                 node_0_2nd_shutdown
1035         } else {
1036                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1037                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown);
1038                 get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id())
1039         };
1040         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_2nd_shutdown);
1041
1042         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1043         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1044
1045         assert!(nodes[2].node.claim_funds(our_payment_preimage, &None, 100_000));
1046         check_added_monitors!(nodes[2], 1);
1047         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
1048         assert!(updates.update_add_htlcs.is_empty());
1049         assert!(updates.update_fail_htlcs.is_empty());
1050         assert!(updates.update_fail_malformed_htlcs.is_empty());
1051         assert!(updates.update_fee.is_none());
1052         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
1053         nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
1054         check_added_monitors!(nodes[1], 1);
1055         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1056         commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
1057
1058         assert!(updates_2.update_add_htlcs.is_empty());
1059         assert!(updates_2.update_fail_htlcs.is_empty());
1060         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
1061         assert!(updates_2.update_fee.is_none());
1062         assert_eq!(updates_2.update_fulfill_htlcs.len(), 1);
1063         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]);
1064         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
1065
1066         let events = nodes[0].node.get_and_clear_pending_events();
1067         assert_eq!(events.len(), 1);
1068         match events[0] {
1069                 Event::PaymentSent { ref payment_preimage } => {
1070                         assert_eq!(our_payment_preimage, *payment_preimage);
1071                 },
1072                 _ => panic!("Unexpected event"),
1073         }
1074
1075         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
1076         if recv_count > 0 {
1077                 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
1078                 let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
1079                 assert!(node_1_closing_signed.is_some());
1080         }
1081
1082         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
1083         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
1084
1085         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
1086         let node_0_2nd_reestablish = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id());
1087         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
1088         if recv_count == 0 {
1089                 // If all closing_signeds weren't delivered we can just resume where we left off...
1090                 let node_1_2nd_reestablish = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
1091
1092                 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &node_1_2nd_reestablish);
1093                 let node_0_3rd_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1094                 assert!(node_0_2nd_shutdown == node_0_3rd_shutdown);
1095
1096                 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_2nd_reestablish);
1097                 let node_1_3rd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1098                 assert!(node_1_3rd_shutdown == node_1_2nd_shutdown);
1099
1100                 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_3rd_shutdown);
1101                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1102
1103                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_3rd_shutdown);
1104                 let node_0_2nd_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
1105                 assert!(node_0_closing_signed == node_0_2nd_closing_signed);
1106
1107                 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed);
1108                 let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
1109                 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap());
1110                 let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
1111                 assert!(node_0_none.is_none());
1112         } else {
1113                 // If one node, however, received + responded with an identical closing_signed we end
1114                 // up erroring and node[0] will try to broadcast its own latest commitment transaction.
1115                 // There isn't really anything better we can do simply, but in the future we might
1116                 // explore storing a set of recently-closed channels that got disconnected during
1117                 // closing_signed and avoiding broadcasting local commitment txn for some timeout to
1118                 // give our counterparty enough time to (potentially) broadcast a cooperative closing
1119                 // transaction.
1120                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1121
1122                 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_2nd_reestablish);
1123                 let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
1124                 assert_eq!(msg_events.len(), 1);
1125                 if let MessageSendEvent::HandleError { ref action, .. } = msg_events[0] {
1126                         match action {
1127                                 &ErrorAction::SendErrorMessage { ref msg } => {
1128                                         nodes[0].node.handle_error(&nodes[1].node.get_our_node_id(), &msg);
1129                                         assert_eq!(msg.channel_id, chan_1.2);
1130                                 },
1131                                 _ => panic!("Unexpected event!"),
1132                         }
1133                 } else { panic!("Needed SendErrorMessage close"); }
1134
1135                 // get_closing_signed_broadcast usually eats the BroadcastChannelUpdate for us and
1136                 // checks it, but in this case nodes[0] didn't ever get a chance to receive a
1137                 // closing_signed so we do it ourselves
1138                 check_closed_broadcast!(nodes[0], false);
1139                 check_added_monitors!(nodes[0], 1);
1140         }
1141
1142         assert!(nodes[0].node.list_channels().is_empty());
1143
1144         assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
1145         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
1146         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
1147         assert!(nodes[1].node.list_channels().is_empty());
1148         assert!(nodes[2].node.list_channels().is_empty());
1149 }
1150
1151 #[test]
1152 fn test_shutdown_rebroadcast() {
1153         do_test_shutdown_rebroadcast(0);
1154         do_test_shutdown_rebroadcast(1);
1155         do_test_shutdown_rebroadcast(2);
1156 }
1157
1158 #[test]
1159 fn fake_network_test() {
1160         // Simple test which builds a network of ChannelManagers, connects them to each other, and
1161         // tests that payments get routed and transactions broadcast in semi-reasonable ways.
1162         let chanmon_cfgs = create_chanmon_cfgs(4);
1163         let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
1164         let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
1165         let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
1166
1167         // Create some initial channels
1168         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
1169         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
1170         let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
1171
1172         // Rebalance the network a bit by relaying one payment through all the channels...
1173         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
1174         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
1175         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
1176         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
1177
1178         // Send some more payments
1179         send_payment(&nodes[1], &vec!(&nodes[2], &nodes[3])[..], 1000000, 1_000_000);
1180         send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1], &nodes[0])[..], 1000000, 1_000_000);
1181         send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1])[..], 1000000, 1_000_000);
1182
1183         // Test failure packets
1184         let payment_hash_1 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 1000000).1;
1185         fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], payment_hash_1);
1186
1187         // Add a new channel that skips 3
1188         let chan_4 = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known());
1189
1190         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 1000000, 1_000_000);
1191         send_payment(&nodes[2], &vec!(&nodes[3])[..], 1000000, 1_000_000);
1192         send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
1193         send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
1194         send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_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
1198         // Do some rebalance loop payments, simultaneously
1199         let mut hops = Vec::with_capacity(3);
1200         hops.push(RouteHop {
1201                 pubkey: nodes[2].node.get_our_node_id(),
1202                 node_features: NodeFeatures::empty(),
1203                 short_channel_id: chan_2.0.contents.short_channel_id,
1204                 channel_features: ChannelFeatures::empty(),
1205                 fee_msat: 0,
1206                 cltv_expiry_delta: chan_3.0.contents.cltv_expiry_delta as u32
1207         });
1208         hops.push(RouteHop {
1209                 pubkey: nodes[3].node.get_our_node_id(),
1210                 node_features: NodeFeatures::empty(),
1211                 short_channel_id: chan_3.0.contents.short_channel_id,
1212                 channel_features: ChannelFeatures::empty(),
1213                 fee_msat: 0,
1214                 cltv_expiry_delta: chan_4.1.contents.cltv_expiry_delta as u32
1215         });
1216         hops.push(RouteHop {
1217                 pubkey: nodes[1].node.get_our_node_id(),
1218                 node_features: NodeFeatures::empty(),
1219                 short_channel_id: chan_4.0.contents.short_channel_id,
1220                 channel_features: ChannelFeatures::empty(),
1221                 fee_msat: 1000000,
1222                 cltv_expiry_delta: TEST_FINAL_CLTV,
1223         });
1224         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;
1225         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;
1226         let payment_preimage_1 = send_along_route(&nodes[1], Route { paths: vec![hops] }, &vec!(&nodes[2], &nodes[3], &nodes[1])[..], 1000000).0;
1227
1228         let mut hops = Vec::with_capacity(3);
1229         hops.push(RouteHop {
1230                 pubkey: nodes[3].node.get_our_node_id(),
1231                 node_features: NodeFeatures::empty(),
1232                 short_channel_id: chan_4.0.contents.short_channel_id,
1233                 channel_features: ChannelFeatures::empty(),
1234                 fee_msat: 0,
1235                 cltv_expiry_delta: chan_3.1.contents.cltv_expiry_delta as u32
1236         });
1237         hops.push(RouteHop {
1238                 pubkey: nodes[2].node.get_our_node_id(),
1239                 node_features: NodeFeatures::empty(),
1240                 short_channel_id: chan_3.0.contents.short_channel_id,
1241                 channel_features: ChannelFeatures::empty(),
1242                 fee_msat: 0,
1243                 cltv_expiry_delta: chan_2.1.contents.cltv_expiry_delta as u32
1244         });
1245         hops.push(RouteHop {
1246                 pubkey: nodes[1].node.get_our_node_id(),
1247                 node_features: NodeFeatures::empty(),
1248                 short_channel_id: chan_2.0.contents.short_channel_id,
1249                 channel_features: ChannelFeatures::empty(),
1250                 fee_msat: 1000000,
1251                 cltv_expiry_delta: TEST_FINAL_CLTV,
1252         });
1253         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;
1254         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;
1255         let payment_hash_2 = send_along_route(&nodes[1], Route { paths: vec![hops] }, &vec!(&nodes[3], &nodes[2], &nodes[1])[..], 1000000).1;
1256
1257         // Claim the rebalances...
1258         fail_payment(&nodes[1], &vec!(&nodes[3], &nodes[2], &nodes[1])[..], payment_hash_2);
1259         claim_payment(&nodes[1], &vec!(&nodes[2], &nodes[3], &nodes[1])[..], payment_preimage_1, 1_000_000);
1260
1261         // Add a duplicate new channel from 2 to 4
1262         let chan_5 = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known());
1263
1264         // Send some payments across both channels
1265         let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0;
1266         let payment_preimage_4 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0;
1267         let payment_preimage_5 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0;
1268
1269
1270         route_over_limit(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000);
1271         let events = nodes[0].node.get_and_clear_pending_msg_events();
1272         assert_eq!(events.len(), 0);
1273         nodes[0].logger.assert_log("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);
1274
1275         //TODO: Test that routes work again here as we've been notified that the channel is full
1276
1277         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_3, 3_000_000);
1278         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_4, 3_000_000);
1279         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_5, 3_000_000);
1280
1281         // Close down the channels...
1282         close_channel(&nodes[0], &nodes[1], &chan_1.2, chan_1.3, true);
1283         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, false);
1284         close_channel(&nodes[2], &nodes[3], &chan_3.2, chan_3.3, true);
1285         close_channel(&nodes[1], &nodes[3], &chan_4.2, chan_4.3, false);
1286         close_channel(&nodes[1], &nodes[3], &chan_5.2, chan_5.3, false);
1287 }
1288
1289 #[test]
1290 fn holding_cell_htlc_counting() {
1291         // Tests that HTLCs in the holding cell count towards the pending HTLC limits on outbound HTLCs
1292         // to ensure we don't end up with HTLCs sitting around in our holding cell for several
1293         // commitment dance rounds.
1294         let chanmon_cfgs = create_chanmon_cfgs(3);
1295         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1296         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
1297         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1298         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
1299         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
1300         let logger = test_utils::TestLogger::new();
1301
1302         let mut payments = Vec::new();
1303         for _ in 0..::ln::channel::OUR_MAX_HTLCS {
1304                 let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[0]);
1305                 let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
1306                 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();
1307                 nodes[1].node.send_payment(&route, payment_hash, &None).unwrap();
1308                 payments.push((payment_preimage, payment_hash));
1309         }
1310         check_added_monitors!(nodes[1], 1);
1311
1312         let mut events = nodes[1].node.get_and_clear_pending_msg_events();
1313         assert_eq!(events.len(), 1);
1314         let initial_payment_event = SendEvent::from_event(events.pop().unwrap());
1315         assert_eq!(initial_payment_event.node_id, nodes[2].node.get_our_node_id());
1316
1317         // There is now one HTLC in an outbound commitment transaction and (OUR_MAX_HTLCS - 1) HTLCs in
1318         // the holding cell waiting on B's RAA to send. At this point we should not be able to add
1319         // another HTLC.
1320         let (_, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
1321         {
1322                 let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
1323                 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();
1324                 unwrap_send_err!(nodes[1].node.send_payment(&route, payment_hash_1, &None), true, APIError::ChannelUnavailable { err },
1325                         assert_eq!(err, "Cannot push more than their max accepted HTLCs"));
1326                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1327                 nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Cannot push more than their max accepted HTLCs".to_string(), 1);
1328         }
1329
1330         // This should also be true if we try to forward a payment.
1331         let (_, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1332         {
1333                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
1334                 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();
1335                 nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap();
1336                 check_added_monitors!(nodes[0], 1);
1337         }
1338
1339         let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1340         assert_eq!(events.len(), 1);
1341         let payment_event = SendEvent::from_event(events.pop().unwrap());
1342         assert_eq!(payment_event.node_id, nodes[1].node.get_our_node_id());
1343
1344         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
1345         commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
1346         // We have to forward pending HTLCs twice - once tries to forward the payment forward (and
1347         // fails), the second will process the resulting failure and fail the HTLC backward.
1348         expect_pending_htlcs_forwardable!(nodes[1]);
1349         expect_pending_htlcs_forwardable!(nodes[1]);
1350         check_added_monitors!(nodes[1], 1);
1351
1352         let bs_fail_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1353         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &bs_fail_updates.update_fail_htlcs[0]);
1354         commitment_signed_dance!(nodes[0], nodes[1], bs_fail_updates.commitment_signed, false, true);
1355
1356         let events = nodes[0].node.get_and_clear_pending_msg_events();
1357         assert_eq!(events.len(), 1);
1358         match events[0] {
1359                 MessageSendEvent::PaymentFailureNetworkUpdate { update: msgs::HTLCFailChannelUpdate::ChannelUpdateMessage { ref msg }} => {
1360                         assert_eq!(msg.contents.short_channel_id, chan_2.0.contents.short_channel_id);
1361                 },
1362                 _ => panic!("Unexpected event"),
1363         }
1364
1365         expect_payment_failed!(nodes[0], payment_hash_2, false);
1366
1367         // Now forward all the pending HTLCs and claim them back
1368         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &initial_payment_event.msgs[0]);
1369         nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &initial_payment_event.commitment_msg);
1370         check_added_monitors!(nodes[2], 1);
1371
1372         let (bs_revoke_and_ack, bs_commitment_signed) = get_revoke_commit_msgs!(nodes[2], nodes[1].node.get_our_node_id());
1373         nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_revoke_and_ack);
1374         check_added_monitors!(nodes[1], 1);
1375         let as_updates = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
1376
1377         nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &bs_commitment_signed);
1378         check_added_monitors!(nodes[1], 1);
1379         let as_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[2].node.get_our_node_id());
1380
1381         for ref update in as_updates.update_add_htlcs.iter() {
1382                 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), update);
1383         }
1384         nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &as_updates.commitment_signed);
1385         check_added_monitors!(nodes[2], 1);
1386         nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_raa);
1387         check_added_monitors!(nodes[2], 1);
1388         let (bs_revoke_and_ack, bs_commitment_signed) = get_revoke_commit_msgs!(nodes[2], nodes[1].node.get_our_node_id());
1389
1390         nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_revoke_and_ack);
1391         check_added_monitors!(nodes[1], 1);
1392         nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &bs_commitment_signed);
1393         check_added_monitors!(nodes[1], 1);
1394         let as_final_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[2].node.get_our_node_id());
1395
1396         nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_final_raa);
1397         check_added_monitors!(nodes[2], 1);
1398
1399         expect_pending_htlcs_forwardable!(nodes[2]);
1400
1401         let events = nodes[2].node.get_and_clear_pending_events();
1402         assert_eq!(events.len(), payments.len());
1403         for (event, &(_, ref hash)) in events.iter().zip(payments.iter()) {
1404                 match event {
1405                         &Event::PaymentReceived { ref payment_hash, .. } => {
1406                                 assert_eq!(*payment_hash, *hash);
1407                         },
1408                         _ => panic!("Unexpected event"),
1409                 };
1410         }
1411
1412         for (preimage, _) in payments.drain(..) {
1413                 claim_payment(&nodes[1], &[&nodes[2]], preimage, 100_000);
1414         }
1415
1416         send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000, 1_000_000);
1417 }
1418
1419 #[test]
1420 fn duplicate_htlc_test() {
1421         // Test that we accept duplicate payment_hash HTLCs across the network and that
1422         // claiming/failing them are all separate and don't affect each other
1423         let chanmon_cfgs = create_chanmon_cfgs(6);
1424         let node_cfgs = create_node_cfgs(6, &chanmon_cfgs);
1425         let node_chanmgrs = create_node_chanmgrs(6, &node_cfgs, &[None, None, None, None, None, None]);
1426         let mut nodes = create_network(6, &node_cfgs, &node_chanmgrs);
1427
1428         // Create some initial channels to route via 3 to 4/5 from 0/1/2
1429         create_announced_chan_between_nodes(&nodes, 0, 3, InitFeatures::known(), InitFeatures::known());
1430         create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known());
1431         create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
1432         create_announced_chan_between_nodes(&nodes, 3, 4, InitFeatures::known(), InitFeatures::known());
1433         create_announced_chan_between_nodes(&nodes, 3, 5, InitFeatures::known(), InitFeatures::known());
1434
1435         let (payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], 1000000);
1436
1437         *nodes[0].network_payment_count.borrow_mut() -= 1;
1438         assert_eq!(route_payment(&nodes[1], &vec!(&nodes[3])[..], 1000000).0, payment_preimage);
1439
1440         *nodes[0].network_payment_count.borrow_mut() -= 1;
1441         assert_eq!(route_payment(&nodes[2], &vec!(&nodes[3], &nodes[5])[..], 1000000).0, payment_preimage);
1442
1443         claim_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], payment_preimage, 1_000_000);
1444         fail_payment(&nodes[2], &vec!(&nodes[3], &nodes[5])[..], payment_hash);
1445         claim_payment(&nodes[1], &vec!(&nodes[3])[..], payment_preimage, 1_000_000);
1446 }
1447
1448 #[test]
1449 fn test_duplicate_htlc_different_direction_onchain() {
1450         // Test that ChannelMonitor doesn't generate 2 preimage txn
1451         // when we have 2 HTLCs with same preimage that go across a node
1452         // in opposite directions.
1453         let chanmon_cfgs = create_chanmon_cfgs(2);
1454         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1455         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1456         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1457
1458         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
1459         let logger = test_utils::TestLogger::new();
1460
1461         // balancing
1462         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
1463
1464         let (payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 900_000);
1465
1466         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
1467         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();
1468         send_along_route_with_hash(&nodes[1], route, &vec!(&nodes[0])[..], 800_000, payment_hash);
1469
1470         // Provide preimage to node 0 by claiming payment
1471         nodes[0].node.claim_funds(payment_preimage, &None, 800_000);
1472         check_added_monitors!(nodes[0], 1);
1473
1474         // Broadcast node 1 commitment txn
1475         let remote_txn = get_local_commitment_txn!(nodes[1], chan_1.2);
1476
1477         assert_eq!(remote_txn[0].output.len(), 4); // 1 local, 1 remote, 1 htlc inbound, 1 htlc outbound
1478         let mut has_both_htlcs = 0; // check htlcs match ones committed
1479         for outp in remote_txn[0].output.iter() {
1480                 if outp.value == 800_000 / 1000 {
1481                         has_both_htlcs += 1;
1482                 } else if outp.value == 900_000 / 1000 {
1483                         has_both_htlcs += 1;
1484                 }
1485         }
1486         assert_eq!(has_both_htlcs, 2);
1487
1488         let header = BlockHeader { version: 0x2000_0000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
1489         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![remote_txn[0].clone()] }, 1);
1490         check_added_monitors!(nodes[0], 1);
1491
1492         // Check we only broadcast 1 timeout tx
1493         let claim_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
1494         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()) };
1495         assert_eq!(claim_txn.len(), 5);
1496         check_spends!(claim_txn[2], chan_1.3);
1497         check_spends!(claim_txn[3], claim_txn[2]);
1498         assert_eq!(htlc_pair.0.input.len(), 1);
1499         assert_eq!(htlc_pair.0.input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT); // HTLC 1 <--> 0, preimage tx
1500         check_spends!(htlc_pair.0, remote_txn[0]);
1501         assert_eq!(htlc_pair.1.input.len(), 1);
1502         assert_eq!(htlc_pair.1.input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT); // HTLC 0 <--> 1, timeout tx
1503         check_spends!(htlc_pair.1, remote_txn[0]);
1504
1505         let events = nodes[0].node.get_and_clear_pending_msg_events();
1506         assert_eq!(events.len(), 2);
1507         for e in events {
1508                 match e {
1509                         MessageSendEvent::BroadcastChannelUpdate { .. } => {},
1510                         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, .. } } => {
1511                                 assert!(update_add_htlcs.is_empty());
1512                                 assert!(update_fail_htlcs.is_empty());
1513                                 assert_eq!(update_fulfill_htlcs.len(), 1);
1514                                 assert!(update_fail_malformed_htlcs.is_empty());
1515                                 assert_eq!(nodes[1].node.get_our_node_id(), *node_id);
1516                         },
1517                         _ => panic!("Unexpected event"),
1518                 }
1519         }
1520 }
1521
1522 #[test]
1523 fn test_basic_channel_reserve() {
1524         let chanmon_cfgs = create_chanmon_cfgs(2);
1525         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1526         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1527         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1528         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
1529         let logger = test_utils::TestLogger::new();
1530
1531         let chan_stat = get_channel_value_stat!(nodes[0], chan.2);
1532         let channel_reserve = chan_stat.channel_reserve_msat;
1533
1534         // The 2* and +1 are for the fee spike reserve.
1535         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
1536         let commit_tx_fee = 2 * commit_tx_fee_msat(get_feerate!(nodes[0], chan.2), 1 + 1);
1537         let max_can_send = 5000000 - channel_reserve - commit_tx_fee;
1538         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
1539         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();
1540         let err = nodes[0].node.send_payment(&route, our_payment_hash, &None).err().unwrap();
1541         match err {
1542                 PaymentSendFailure::AllFailedRetrySafe(ref fails) => {
1543                         match fails[0] {
1544                                 APIError::ChannelUnavailable{err} =>
1545                                         assert_eq!(err, "Cannot send value that would put us under local channel reserve value"),
1546                                 _ => panic!("Unexpected error variant"),
1547                         }
1548                 },
1549                 _ => panic!("Unexpected error variant"),
1550         }
1551         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1552         nodes[0].logger.assert_log("lightning::ln::channelmanager".to_string(), "Cannot send value that would put us under local channel reserve value".to_string(), 1);
1553
1554         send_payment(&nodes[0], &vec![&nodes[1]], max_can_send, max_can_send);
1555 }
1556
1557 #[test]
1558 fn test_fee_spike_violation_fails_htlc() {
1559         let chanmon_cfgs = create_chanmon_cfgs(2);
1560         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1561         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1562         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1563         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
1564         let logger = test_utils::TestLogger::new();
1565
1566         macro_rules! get_route_and_payment_hash {
1567                 ($recv_value: expr) => {{
1568                         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[1]);
1569                         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
1570                         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();
1571                         (route, payment_hash, payment_preimage)
1572                 }}
1573         };
1574
1575         let (route, payment_hash, _) = get_route_and_payment_hash!(3460001);
1576         // Need to manually create the update_add_htlc message to go around the channel reserve check in send_htlc()
1577         let secp_ctx = Secp256k1::new();
1578         let session_priv = SecretKey::from_slice(&[42; 32]).expect("RNG is bad!");
1579
1580         let cur_height = nodes[1].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
1581
1582         let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route.paths[0], &session_priv).unwrap();
1583         let (onion_payloads, htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 3460001, &None, cur_height).unwrap();
1584         let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash);
1585         let msg = msgs::UpdateAddHTLC {
1586                 channel_id: chan.2,
1587                 htlc_id: 0,
1588                 amount_msat: htlc_msat,
1589                 payment_hash: payment_hash,
1590                 cltv_expiry: htlc_cltv,
1591                 onion_routing_packet: onion_packet,
1592         };
1593
1594         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &msg);
1595
1596         // Now manually create the commitment_signed message corresponding to the update_add
1597         // nodes[0] just sent. In the code for construction of this message, "local" refers
1598         // to the sender of the message, and "remote" refers to the receiver.
1599
1600         let feerate_per_kw = get_feerate!(nodes[0], chan.2);
1601
1602         // Get the EnforcingChannelKeys for each channel, which will be used to (1) get the keys
1603         // needed to sign the new commitment tx and (2) sign the new commitment tx.
1604         let (local_revocation_basepoint, local_htlc_basepoint, local_payment_point, local_chan_commitment_seed) = {
1605                 let chan_lock = nodes[0].node.channel_state.lock().unwrap();
1606                 let local_chan = chan_lock.by_id.get(&chan.2).unwrap();
1607                 let chan_keys = local_chan.get_local_keys();
1608                 let pubkeys = chan_keys.pubkeys();
1609                 (pubkeys.revocation_basepoint, pubkeys.htlc_basepoint, pubkeys.payment_point, *chan_keys.commitment_seed())
1610         };
1611         let (remote_delayed_payment_basepoint, remote_htlc_basepoint, remote_payment_point, remote_chan_commitment_seed) = {
1612                 let chan_lock = nodes[1].node.channel_state.lock().unwrap();
1613                 let remote_chan = chan_lock.by_id.get(&chan.2).unwrap();
1614                 let chan_keys = remote_chan.get_local_keys();
1615                 let pubkeys = chan_keys.pubkeys();
1616                 (pubkeys.delayed_payment_basepoint, pubkeys.htlc_basepoint, pubkeys.payment_point, *chan_keys.commitment_seed())
1617         };
1618
1619         // Assemble the set of keys we can use for signatures for our commitment_signed message.
1620         const INITIAL_COMMITMENT_NUMBER: u64 = (1 << 48) - 1;
1621         let commitment_secret = {
1622                 let res = chan_utils::build_commitment_secret(&remote_chan_commitment_seed, INITIAL_COMMITMENT_NUMBER - 1);
1623                 SecretKey::from_slice(&res).unwrap()
1624         };
1625         let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &commitment_secret);
1626         let commit_tx_keys = chan_utils::TxCreationKeys::new(&secp_ctx, &per_commitment_point, &remote_delayed_payment_basepoint,
1627                 &remote_htlc_basepoint, &local_revocation_basepoint, &local_htlc_basepoint).unwrap();
1628
1629         // Build the remote commitment transaction so we can sign it, and then later use the
1630         // signature for the commitment_signed message.
1631         let local_chan_balance = 1313;
1632         let static_payment_pk = local_payment_point.serialize();
1633         let remote_commit_tx_output = TxOut {
1634                                 script_pubkey: Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0)
1635                                                              .push_slice(&WPubkeyHash::hash(&static_payment_pk)[..])
1636                                                              .into_script(),
1637                 value: local_chan_balance as u64
1638         };
1639
1640         let local_commit_tx_output = TxOut {
1641                 script_pubkey: chan_utils::get_revokeable_redeemscript(&commit_tx_keys.revocation_key,
1642                                                                                BREAKDOWN_TIMEOUT,
1643                                                                                &commit_tx_keys.a_delayed_payment_key).to_v0_p2wsh(),
1644                                 value: 95000,
1645         };
1646
1647         let accepted_htlc_info = chan_utils::HTLCOutputInCommitment {
1648                 offered: false,
1649                 amount_msat: 3460001,
1650                 cltv_expiry: htlc_cltv,
1651                 payment_hash: payment_hash,
1652                 transaction_output_index: Some(1),
1653         };
1654
1655         let htlc_output = TxOut {
1656                 script_pubkey: chan_utils::get_htlc_redeemscript(&accepted_htlc_info, &commit_tx_keys).to_v0_p2wsh(),
1657                 value: 3460001 / 1000
1658         };
1659
1660         let commit_tx_obscure_factor = {
1661                 let mut sha = Sha256::engine();
1662                 let remote_payment_point = &remote_payment_point.serialize();
1663                 sha.input(&local_payment_point.serialize());
1664                 sha.input(remote_payment_point);
1665                 let res = Sha256::from_engine(sha).into_inner();
1666
1667                 ((res[26] as u64) << 5*8) |
1668                 ((res[27] as u64) << 4*8) |
1669                 ((res[28] as u64) << 3*8) |
1670                 ((res[29] as u64) << 2*8) |
1671                 ((res[30] as u64) << 1*8) |
1672                 ((res[31] as u64) << 0*8)
1673         };
1674         let commitment_number = 1;
1675         let obscured_commitment_transaction_number = commit_tx_obscure_factor ^ commitment_number;
1676         let lock_time = ((0x20 as u32) << 8*3) | ((obscured_commitment_transaction_number & 0xffffffu64) as u32);
1677         let input = TxIn {
1678                 previous_output: BitcoinOutPoint { txid: chan.3.txid(), vout: 0 },
1679                 script_sig: Script::new(),
1680                 sequence: ((0x80 as u32) << 8*3) | ((obscured_commitment_transaction_number >> 3*8) as u32),
1681                 witness: Vec::new(),
1682         };
1683
1684         let commit_tx = Transaction {
1685                 version: 2,
1686                 lock_time,
1687                 input: vec![input],
1688                 output: vec![remote_commit_tx_output, htlc_output, local_commit_tx_output],
1689         };
1690         let res = {
1691                 let local_chan_lock = nodes[0].node.channel_state.lock().unwrap();
1692                 let local_chan = local_chan_lock.by_id.get(&chan.2).unwrap();
1693                 let local_chan_keys = local_chan.get_local_keys();
1694                 local_chan_keys.sign_remote_commitment(feerate_per_kw, &commit_tx, &commit_tx_keys, &[&accepted_htlc_info],
1695                 BREAKDOWN_TIMEOUT, &secp_ctx).unwrap()
1696         };
1697
1698         let commit_signed_msg = msgs::CommitmentSigned {
1699                 channel_id: chan.2,
1700                 signature: res.0,
1701                 htlc_signatures: res.1
1702         };
1703
1704         // Send the commitment_signed message to the nodes[1].
1705         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &commit_signed_msg);
1706         let _ = nodes[1].node.get_and_clear_pending_msg_events();
1707
1708         // Send the RAA to nodes[1].
1709         let per_commitment_secret = chan_utils::build_commitment_secret(&local_chan_commitment_seed, INITIAL_COMMITMENT_NUMBER);
1710         let next_secret = SecretKey::from_slice(&chan_utils::build_commitment_secret(&local_chan_commitment_seed, INITIAL_COMMITMENT_NUMBER - 2)).unwrap();
1711         let next_per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &next_secret);
1712         let raa_msg = msgs::RevokeAndACK{ channel_id: chan.2, per_commitment_secret, next_per_commitment_point};
1713         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &raa_msg);
1714
1715         let events = nodes[1].node.get_and_clear_pending_msg_events();
1716         assert_eq!(events.len(), 1);
1717         // Make sure the HTLC failed in the way we expect.
1718         match events[0] {
1719                 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fail_htlcs, .. }, .. } => {
1720                         assert_eq!(update_fail_htlcs.len(), 1);
1721                         update_fail_htlcs[0].clone()
1722                 },
1723                 _ => panic!("Unexpected event"),
1724         };
1725         nodes[1].logger.assert_log("lightning::ln::channel".to_string(), "Attempting to fail HTLC due to fee spike buffer violation".to_string(), 1);
1726
1727         check_added_monitors!(nodes[1], 2);
1728 }
1729
1730 #[test]
1731 fn test_chan_reserve_violation_outbound_htlc_inbound_chan() {
1732         let mut chanmon_cfgs = create_chanmon_cfgs(2);
1733         // Set the fee rate for the channel very high, to the point where the fundee
1734         // sending any amount would result in a channel reserve violation. In this test
1735         // we check that we would be prevented from sending an HTLC in this situation.
1736         chanmon_cfgs[0].fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 6000 };
1737         chanmon_cfgs[1].fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 6000 };
1738         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1739         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1740         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1741         let _ = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
1742         let logger = test_utils::TestLogger::new();
1743
1744         macro_rules! get_route_and_payment_hash {
1745                 ($recv_value: expr) => {{
1746                         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[1]);
1747                         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
1748                         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();
1749                         (route, payment_hash, payment_preimage)
1750                 }}
1751         };
1752
1753         let (route, our_payment_hash, _) = get_route_and_payment_hash!(1000);
1754         unwrap_send_err!(nodes[1].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { err },
1755                 assert_eq!(err, "Cannot send value that would put them under remote channel reserve value"));
1756         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1757         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);
1758 }
1759
1760 #[test]
1761 fn test_chan_reserve_violation_inbound_htlc_outbound_channel() {
1762         let mut chanmon_cfgs = create_chanmon_cfgs(2);
1763         // Set the fee rate for the channel very high, to the point where the funder
1764         // receiving 1 update_add_htlc would result in them closing the channel due
1765         // to channel reserve violation. This close could also happen if the fee went
1766         // up a more realistic amount, but many HTLCs were outstanding at the time of
1767         // the update_add_htlc.
1768         chanmon_cfgs[0].fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 6000 };
1769         chanmon_cfgs[1].fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 6000 };
1770         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1771         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1772         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1773         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
1774         let logger = test_utils::TestLogger::new();
1775
1776         macro_rules! get_route_and_payment_hash {
1777                 ($recv_value: expr) => {{
1778                         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[1]);
1779                         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
1780                         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();
1781                         (route, payment_hash, payment_preimage)
1782                 }}
1783         };
1784
1785         let (route, payment_hash, _) = get_route_and_payment_hash!(1000);
1786         // Need to manually create the update_add_htlc message to go around the channel reserve check in send_htlc()
1787         let secp_ctx = Secp256k1::new();
1788         let session_priv = SecretKey::from_slice(&[42; 32]).unwrap();
1789         let cur_height = nodes[1].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
1790         let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route.paths[0], &session_priv).unwrap();
1791         let (onion_payloads, htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 1000, &None, cur_height).unwrap();
1792         let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash);
1793         let msg = msgs::UpdateAddHTLC {
1794                 channel_id: chan.2,
1795                 htlc_id: 1,
1796                 amount_msat: htlc_msat + 1,
1797                 payment_hash: payment_hash,
1798                 cltv_expiry: htlc_cltv,
1799                 onion_routing_packet: onion_packet,
1800         };
1801
1802         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &msg);
1803         // Check that the payment failed and the channel is closed in response to the malicious UpdateAdd.
1804         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);
1805         assert_eq!(nodes[0].node.list_channels().len(), 0);
1806         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
1807         assert_eq!(err_msg.data, "Cannot receive value that would put us under local channel reserve value");
1808         check_added_monitors!(nodes[0], 1);
1809 }
1810
1811 #[test]
1812 fn test_chan_reserve_violation_inbound_htlc_inbound_chan() {
1813         let chanmon_cfgs = create_chanmon_cfgs(3);
1814         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1815         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
1816         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1817         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
1818         let _ = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
1819         let logger = test_utils::TestLogger::new();
1820
1821         macro_rules! get_route_and_payment_hash {
1822                 ($recv_value: expr) => {{
1823                         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[0]);
1824                         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
1825                         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();
1826                         (route, payment_hash, payment_preimage)
1827                 }}
1828         };
1829
1830         let feemsat = 239;
1831         let total_routing_fee_msat = (nodes.len() - 2) as u64 * feemsat;
1832         let chan_stat = get_channel_value_stat!(nodes[0], chan.2);
1833         let feerate = get_feerate!(nodes[0], chan.2);
1834
1835         // Add a 2* and +1 for the fee spike reserve.
1836         let commit_tx_fee_2_htlc = 2*commit_tx_fee_msat(feerate, 2 + 1);
1837         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;
1838         let amt_msat_1 = recv_value_1 + total_routing_fee_msat;
1839
1840         // Add a pending HTLC.
1841         let (route_1, our_payment_hash_1, _) = get_route_and_payment_hash!(amt_msat_1);
1842         let payment_event_1 = {
1843                 nodes[0].node.send_payment(&route_1, our_payment_hash_1, &None).unwrap();
1844                 check_added_monitors!(nodes[0], 1);
1845
1846                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1847                 assert_eq!(events.len(), 1);
1848                 SendEvent::from_event(events.remove(0))
1849         };
1850         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event_1.msgs[0]);
1851
1852         // Attempt to trigger a channel reserve violation --> payment failure.
1853         let commit_tx_fee_2_htlcs = commit_tx_fee_msat(feerate, 2);
1854         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;
1855         let amt_msat_2 = recv_value_2 + total_routing_fee_msat;
1856         let (route_2, _, _) = get_route_and_payment_hash!(amt_msat_2);
1857
1858         // Need to manually create the update_add_htlc message to go around the channel reserve check in send_htlc()
1859         let secp_ctx = Secp256k1::new();
1860         let session_priv = SecretKey::from_slice(&[42; 32]).unwrap();
1861         let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
1862         let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route_2.paths[0], &session_priv).unwrap();
1863         let (onion_payloads, htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route_2.paths[0], recv_value_2, &None, cur_height).unwrap();
1864         let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &our_payment_hash_1);
1865         let msg = msgs::UpdateAddHTLC {
1866                 channel_id: chan.2,
1867                 htlc_id: 1,
1868                 amount_msat: htlc_msat + 1,
1869                 payment_hash: our_payment_hash_1,
1870                 cltv_expiry: htlc_cltv,
1871                 onion_routing_packet: onion_packet,
1872         };
1873
1874         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &msg);
1875         // Check that the payment failed and the channel is closed in response to the malicious UpdateAdd.
1876         nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Remote HTLC add would put them under remote reserve value".to_string(), 1);
1877         assert_eq!(nodes[1].node.list_channels().len(), 1);
1878         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
1879         assert_eq!(err_msg.data, "Remote HTLC add would put them under remote reserve value");
1880         check_added_monitors!(nodes[1], 1);
1881 }
1882
1883 fn commit_tx_fee_msat(feerate: u32, num_htlcs: u64) -> u64 {
1884         (COMMITMENT_TX_BASE_WEIGHT + num_htlcs * COMMITMENT_TX_WEIGHT_PER_HTLC) * feerate as u64 / 1000 * 1000
1885 }
1886
1887 #[test]
1888 fn test_channel_reserve_holding_cell_htlcs() {
1889         let chanmon_cfgs = create_chanmon_cfgs(3);
1890         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1891         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
1892         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1893         let chan_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 190000, 1001, InitFeatures::known(), InitFeatures::known());
1894         let chan_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 190000, 1001, InitFeatures::known(), InitFeatures::known());
1895         let logger = test_utils::TestLogger::new();
1896
1897         let mut stat01 = get_channel_value_stat!(nodes[0], chan_1.2);
1898         let mut stat11 = get_channel_value_stat!(nodes[1], chan_1.2);
1899
1900         let mut stat12 = get_channel_value_stat!(nodes[1], chan_2.2);
1901         let mut stat22 = get_channel_value_stat!(nodes[2], chan_2.2);
1902
1903         macro_rules! get_route_and_payment_hash {
1904                 ($recv_value: expr) => {{
1905                         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[0]);
1906                         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
1907                         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();
1908                         (route, payment_hash, payment_preimage)
1909                 }}
1910         };
1911
1912         macro_rules! expect_forward {
1913                 ($node: expr) => {{
1914                         let mut events = $node.node.get_and_clear_pending_msg_events();
1915                         assert_eq!(events.len(), 1);
1916                         check_added_monitors!($node, 1);
1917                         let payment_event = SendEvent::from_event(events.remove(0));
1918                         payment_event
1919                 }}
1920         }
1921
1922         let feemsat = 239; // somehow we know?
1923         let total_fee_msat = (nodes.len() - 2) as u64 * feemsat;
1924         let feerate = get_feerate!(nodes[0], chan_1.2);
1925
1926         let recv_value_0 = stat01.their_max_htlc_value_in_flight_msat - total_fee_msat;
1927
1928         // attempt to send amt_msat > their_max_htlc_value_in_flight_msat
1929         {
1930                 let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_0 + 1);
1931                 assert!(route.paths[0].iter().rev().skip(1).all(|h| h.fee_msat == feemsat));
1932                 unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { err },
1933                         assert_eq!(err, "Cannot send value that would put us over the max HTLC value in flight our peer will accept"));
1934                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1935                 nodes[0].logger.assert_log("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);
1936         }
1937
1938         // channel reserve is bigger than their_max_htlc_value_in_flight_msat so loop to deplete
1939         // nodes[0]'s wealth
1940         loop {
1941                 let amt_msat = recv_value_0 + total_fee_msat;
1942                 // 3 for the 3 HTLCs that will be sent, 2* and +1 for the fee spike reserve.
1943                 // Also, ensure that each payment has enough to be over the dust limit to
1944                 // ensure it'll be included in each commit tx fee calculation.
1945                 let commit_tx_fee_all_htlcs = 2*commit_tx_fee_msat(feerate, 3 + 1);
1946                 let ensure_htlc_amounts_above_dust_buffer = 3 * (stat01.their_dust_limit_msat + 1000);
1947                 if stat01.value_to_self_msat < stat01.channel_reserve_msat + commit_tx_fee_all_htlcs + ensure_htlc_amounts_above_dust_buffer + amt_msat {
1948                         break;
1949                 }
1950                 send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_0, recv_value_0);
1951
1952                 let (stat01_, stat11_, stat12_, stat22_) = (
1953                         get_channel_value_stat!(nodes[0], chan_1.2),
1954                         get_channel_value_stat!(nodes[1], chan_1.2),
1955                         get_channel_value_stat!(nodes[1], chan_2.2),
1956                         get_channel_value_stat!(nodes[2], chan_2.2),
1957                 );
1958
1959                 assert_eq!(stat01_.value_to_self_msat, stat01.value_to_self_msat - amt_msat);
1960                 assert_eq!(stat11_.value_to_self_msat, stat11.value_to_self_msat + amt_msat);
1961                 assert_eq!(stat12_.value_to_self_msat, stat12.value_to_self_msat - (amt_msat - feemsat));
1962                 assert_eq!(stat22_.value_to_self_msat, stat22.value_to_self_msat + (amt_msat - feemsat));
1963                 stat01 = stat01_; stat11 = stat11_; stat12 = stat12_; stat22 = stat22_;
1964         }
1965
1966         // adding pending output.
1967         // 2* and +1 HTLCs on the commit tx fee for the fee spike reserve.
1968         // The reason we're dividing by two here is as follows: the dividend is the total outbound liquidity
1969         // after fees, the channel reserve, and the fee spike buffer are removed. We eventually want to
1970         // divide this quantity into 3 portions, that will each be sent in an HTLC. This allows us
1971         // to test channel channel reserve policy at the edges of what amount is sendable, i.e.
1972         // cases where 1 msat over X amount will cause a payment failure, but anything less than
1973         // that can be sent successfully. So, dividing by two is a somewhat arbitrary way of getting
1974         // the amount of the first of these aforementioned 3 payments. The reason we split into 3 payments
1975         // is to test the behavior of the holding cell with respect to channel reserve and commit tx fee
1976         // policy.
1977         let commit_tx_fee_2_htlcs = 2*commit_tx_fee_msat(feerate, 2 + 1);
1978         let recv_value_1 = (stat01.value_to_self_msat - stat01.channel_reserve_msat - total_fee_msat - commit_tx_fee_2_htlcs)/2;
1979         let amt_msat_1 = recv_value_1 + total_fee_msat;
1980
1981         let (route_1, our_payment_hash_1, our_payment_preimage_1) = get_route_and_payment_hash!(recv_value_1);
1982         let payment_event_1 = {
1983                 nodes[0].node.send_payment(&route_1, our_payment_hash_1, &None).unwrap();
1984                 check_added_monitors!(nodes[0], 1);
1985
1986                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1987                 assert_eq!(events.len(), 1);
1988                 SendEvent::from_event(events.remove(0))
1989         };
1990         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event_1.msgs[0]);
1991
1992         // channel reserve test with htlc pending output > 0
1993         let recv_value_2 = stat01.value_to_self_msat - amt_msat_1 - stat01.channel_reserve_msat - total_fee_msat - commit_tx_fee_2_htlcs;
1994         {
1995                 let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_2 + 1);
1996                 unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { err },
1997                         assert_eq!(err, "Cannot send value that would put us under local channel reserve value"));
1998                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1999         }
2000
2001         // split the rest to test holding cell
2002         let commit_tx_fee_3_htlcs = 2*commit_tx_fee_msat(feerate, 3 + 1);
2003         let additional_htlc_cost_msat = commit_tx_fee_3_htlcs - commit_tx_fee_2_htlcs;
2004         let recv_value_21 = recv_value_2/2 - additional_htlc_cost_msat/2;
2005         let recv_value_22 = recv_value_2 - recv_value_21 - total_fee_msat - additional_htlc_cost_msat;
2006         {
2007                 let stat = get_channel_value_stat!(nodes[0], chan_1.2);
2008                 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);
2009         }
2010
2011         // now see if they go through on both sides
2012         let (route_21, our_payment_hash_21, our_payment_preimage_21) = get_route_and_payment_hash!(recv_value_21);
2013         // but this will stuck in the holding cell
2014         nodes[0].node.send_payment(&route_21, our_payment_hash_21, &None).unwrap();
2015         check_added_monitors!(nodes[0], 0);
2016         let events = nodes[0].node.get_and_clear_pending_events();
2017         assert_eq!(events.len(), 0);
2018
2019         // test with outbound holding cell amount > 0
2020         {
2021                 let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_22+1);
2022                 unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { err },
2023                         assert_eq!(err, "Cannot send value that would put us under local channel reserve value"));
2024                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
2025                 nodes[0].logger.assert_log("lightning::ln::channelmanager".to_string(), "Cannot send value that would put us under local channel reserve value".to_string(), 2);
2026         }
2027
2028         let (route_22, our_payment_hash_22, our_payment_preimage_22) = get_route_and_payment_hash!(recv_value_22);
2029         // this will also stuck in the holding cell
2030         nodes[0].node.send_payment(&route_22, our_payment_hash_22, &None).unwrap();
2031         check_added_monitors!(nodes[0], 0);
2032         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
2033         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
2034
2035         // flush the pending htlc
2036         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event_1.commitment_msg);
2037         let (as_revoke_and_ack, as_commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
2038         check_added_monitors!(nodes[1], 1);
2039
2040         // the pending htlc should be promoted to committed
2041         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_revoke_and_ack);
2042         check_added_monitors!(nodes[0], 1);
2043         let commitment_update_2 = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
2044
2045         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &as_commitment_signed);
2046         let bs_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
2047         // No commitment_signed so get_event_msg's assert(len == 1) passes
2048         check_added_monitors!(nodes[0], 1);
2049
2050         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &bs_revoke_and_ack);
2051         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
2052         check_added_monitors!(nodes[1], 1);
2053
2054         expect_pending_htlcs_forwardable!(nodes[1]);
2055
2056         let ref payment_event_11 = expect_forward!(nodes[1]);
2057         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_11.msgs[0]);
2058         commitment_signed_dance!(nodes[2], nodes[1], payment_event_11.commitment_msg, false);
2059
2060         expect_pending_htlcs_forwardable!(nodes[2]);
2061         expect_payment_received!(nodes[2], our_payment_hash_1, recv_value_1);
2062
2063         // flush the htlcs in the holding cell
2064         assert_eq!(commitment_update_2.update_add_htlcs.len(), 2);
2065         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &commitment_update_2.update_add_htlcs[0]);
2066         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &commitment_update_2.update_add_htlcs[1]);
2067         commitment_signed_dance!(nodes[1], nodes[0], &commitment_update_2.commitment_signed, false);
2068         expect_pending_htlcs_forwardable!(nodes[1]);
2069
2070         let ref payment_event_3 = expect_forward!(nodes[1]);
2071         assert_eq!(payment_event_3.msgs.len(), 2);
2072         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_3.msgs[0]);
2073         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_3.msgs[1]);
2074
2075         commitment_signed_dance!(nodes[2], nodes[1], &payment_event_3.commitment_msg, false);
2076         expect_pending_htlcs_forwardable!(nodes[2]);
2077
2078         let events = nodes[2].node.get_and_clear_pending_events();
2079         assert_eq!(events.len(), 2);
2080         match events[0] {
2081                 Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
2082                         assert_eq!(our_payment_hash_21, *payment_hash);
2083                         assert_eq!(*payment_secret, None);
2084                         assert_eq!(recv_value_21, amt);
2085                 },
2086                 _ => panic!("Unexpected event"),
2087         }
2088         match events[1] {
2089                 Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
2090                         assert_eq!(our_payment_hash_22, *payment_hash);
2091                         assert_eq!(None, *payment_secret);
2092                         assert_eq!(recv_value_22, amt);
2093                 },
2094                 _ => panic!("Unexpected event"),
2095         }
2096
2097         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_1, recv_value_1);
2098         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_21, recv_value_21);
2099         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_22, recv_value_22);
2100
2101         let commit_tx_fee_0_htlcs = 2*commit_tx_fee_msat(feerate, 1);
2102         let recv_value_3 = commit_tx_fee_2_htlcs - commit_tx_fee_0_htlcs - total_fee_msat;
2103         {
2104                 let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_3 + 1);
2105                 let err = nodes[0].node.send_payment(&route, our_payment_hash, &None).err().unwrap();
2106                 match err {
2107                         PaymentSendFailure::AllFailedRetrySafe(ref fails) => {
2108                                 match fails[0] {
2109                                         APIError::ChannelUnavailable{err} =>
2110                                                 assert_eq!(err, "Cannot send value that would put us under local channel reserve value"),
2111                                         _ => panic!("Unexpected error variant"),
2112                                 }
2113                         },
2114                         _ => panic!("Unexpected error variant"),
2115                 }
2116                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
2117                 nodes[0].logger.assert_log("lightning::ln::channelmanager".to_string(), "Cannot send value that would put us under local channel reserve value".to_string(), 3);
2118         }
2119
2120         send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_3, recv_value_3);
2121
2122         let commit_tx_fee_1_htlc = 2*commit_tx_fee_msat(feerate, 1 + 1);
2123         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);
2124         let stat0 = get_channel_value_stat!(nodes[0], chan_1.2);
2125         assert_eq!(stat0.value_to_self_msat, expected_value_to_self);
2126         assert_eq!(stat0.value_to_self_msat, stat0.channel_reserve_msat + commit_tx_fee_1_htlc);
2127
2128         let stat2 = get_channel_value_stat!(nodes[2], chan_2.2);
2129         assert_eq!(stat2.value_to_self_msat, stat22.value_to_self_msat + recv_value_1 + recv_value_21 + recv_value_22 + recv_value_3);
2130 }
2131
2132 #[test]
2133 fn channel_reserve_in_flight_removes() {
2134         // In cases where one side claims an HTLC, it thinks it has additional available funds that it
2135         // can send to its counterparty, but due to update ordering, the other side may not yet have
2136         // considered those HTLCs fully removed.
2137         // This tests that we don't count HTLCs which will not be included in the next remote
2138         // commitment transaction towards the reserve value (as it implies no commitment transaction
2139         // will be generated which violates the remote reserve value).
2140         // This was broken previously, and discovered by the chanmon_fail_consistency fuzz test.
2141         // To test this we:
2142         //  * route two HTLCs from A to B (note that, at a high level, this test is checking that, when
2143         //    you consider the values of both of these HTLCs, B may not send an HTLC back to A, but if
2144         //    you only consider the value of the first HTLC, it may not),
2145         //  * start routing a third HTLC from A to B,
2146         //  * claim the first two HTLCs (though B will generate an update_fulfill for one, and put
2147         //    the other claim in its holding cell, as it immediately goes into AwaitingRAA),
2148         //  * deliver the first fulfill from B
2149         //  * deliver the update_add and an RAA from A, resulting in B freeing the second holding cell
2150         //    claim,
2151         //  * deliver A's response CS and RAA.
2152         //    This results in A having the second HTLC in AwaitingRemovedRemoteRevoke, but B having
2153         //    removed it fully. B now has the push_msat plus the first two HTLCs in value.
2154         //  * Now B happily sends another HTLC, potentially violating its reserve value from A's point
2155         //    of view (if A counts the AwaitingRemovedRemoteRevoke HTLC).
2156         let chanmon_cfgs = create_chanmon_cfgs(2);
2157         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2158         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
2159         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2160         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2161         let logger = test_utils::TestLogger::new();
2162
2163         let b_chan_values = get_channel_value_stat!(nodes[1], chan_1.2);
2164         // Route the first two HTLCs.
2165         let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], b_chan_values.channel_reserve_msat - b_chan_values.value_to_self_msat - 10000);
2166         let (payment_preimage_2, _) = route_payment(&nodes[0], &[&nodes[1]], 20000);
2167
2168         // Start routing the third HTLC (this is just used to get everyone in the right state).
2169         let (payment_preimage_3, payment_hash_3) = get_payment_preimage_hash!(nodes[0]);
2170         let send_1 = {
2171                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
2172                 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();
2173                 nodes[0].node.send_payment(&route, payment_hash_3, &None).unwrap();
2174                 check_added_monitors!(nodes[0], 1);
2175                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
2176                 assert_eq!(events.len(), 1);
2177                 SendEvent::from_event(events.remove(0))
2178         };
2179
2180         // Now claim both of the first two HTLCs on B's end, putting B in AwaitingRAA and generating an
2181         // initial fulfill/CS.
2182         assert!(nodes[1].node.claim_funds(payment_preimage_1, &None, b_chan_values.channel_reserve_msat - b_chan_values.value_to_self_msat - 10000));
2183         check_added_monitors!(nodes[1], 1);
2184         let bs_removes = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
2185
2186         // This claim goes in B's holding cell, allowing us to have a pending B->A RAA which does not
2187         // remove the second HTLC when we send the HTLC back from B to A.
2188         assert!(nodes[1].node.claim_funds(payment_preimage_2, &None, 20000));
2189         check_added_monitors!(nodes[1], 1);
2190         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
2191
2192         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &bs_removes.update_fulfill_htlcs[0]);
2193         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_removes.commitment_signed);
2194         check_added_monitors!(nodes[0], 1);
2195         let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
2196         expect_payment_sent!(nodes[0], payment_preimage_1);
2197
2198         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_1.msgs[0]);
2199         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &send_1.commitment_msg);
2200         check_added_monitors!(nodes[1], 1);
2201         // B is already AwaitingRAA, so cant generate a CS here
2202         let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
2203
2204         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
2205         check_added_monitors!(nodes[1], 1);
2206         let bs_cs = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
2207
2208         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa);
2209         check_added_monitors!(nodes[0], 1);
2210         let as_cs = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
2211
2212         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_cs.commitment_signed);
2213         check_added_monitors!(nodes[1], 1);
2214         let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
2215
2216         // The second HTLCis removed, but as A is in AwaitingRAA it can't generate a CS here, so the
2217         // RAA that B generated above doesn't fully resolve the second HTLC from A's point of view.
2218         // However, the RAA A generates here *does* fully resolve the HTLC from B's point of view (as A
2219         // can no longer broadcast a commitment transaction with it and B has the preimage so can go
2220         // on-chain as necessary).
2221         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &bs_cs.update_fulfill_htlcs[0]);
2222         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_cs.commitment_signed);
2223         check_added_monitors!(nodes[0], 1);
2224         let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
2225         expect_payment_sent!(nodes[0], payment_preimage_2);
2226
2227         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
2228         check_added_monitors!(nodes[1], 1);
2229         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
2230
2231         expect_pending_htlcs_forwardable!(nodes[1]);
2232         expect_payment_received!(nodes[1], payment_hash_3, 100000);
2233
2234         // Note that as this RAA was generated before the delivery of the update_fulfill it shouldn't
2235         // resolve the second HTLC from A's point of view.
2236         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa);
2237         check_added_monitors!(nodes[0], 1);
2238         let as_cs = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
2239
2240         // Now that B doesn't have the second RAA anymore, but A still does, send a payment from B back
2241         // to A to ensure that A doesn't count the almost-removed HTLC in update_add processing.
2242         let (payment_preimage_4, payment_hash_4) = get_payment_preimage_hash!(nodes[1]);
2243         let send_2 = {
2244                 let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
2245                 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();
2246                 nodes[1].node.send_payment(&route, payment_hash_4, &None).unwrap();
2247                 check_added_monitors!(nodes[1], 1);
2248                 let mut events = nodes[1].node.get_and_clear_pending_msg_events();
2249                 assert_eq!(events.len(), 1);
2250                 SendEvent::from_event(events.remove(0))
2251         };
2252
2253         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &send_2.msgs[0]);
2254         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &send_2.commitment_msg);
2255         check_added_monitors!(nodes[0], 1);
2256         let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
2257
2258         // Now just resolve all the outstanding messages/HTLCs for completeness...
2259
2260         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_cs.commitment_signed);
2261         check_added_monitors!(nodes[1], 1);
2262         let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
2263
2264         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
2265         check_added_monitors!(nodes[1], 1);
2266
2267         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa);
2268         check_added_monitors!(nodes[0], 1);
2269         let as_cs = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
2270
2271         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_cs.commitment_signed);
2272         check_added_monitors!(nodes[1], 1);
2273         let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
2274
2275         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa);
2276         check_added_monitors!(nodes[0], 1);
2277
2278         expect_pending_htlcs_forwardable!(nodes[0]);
2279         expect_payment_received!(nodes[0], payment_hash_4, 10000);
2280
2281         claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_4, 10_000);
2282         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3, 100_000);
2283 }
2284
2285 #[test]
2286 fn channel_monitor_network_test() {
2287         // Simple test which builds a network of ChannelManagers, connects them to each other, and
2288         // tests that ChannelMonitor is able to recover from various states.
2289         let chanmon_cfgs = create_chanmon_cfgs(5);
2290         let node_cfgs = create_node_cfgs(5, &chanmon_cfgs);
2291         let node_chanmgrs = create_node_chanmgrs(5, &node_cfgs, &[None, None, None, None, None]);
2292         let nodes = create_network(5, &node_cfgs, &node_chanmgrs);
2293
2294         // Create some initial channels
2295         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2296         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
2297         let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
2298         let chan_4 = create_announced_chan_between_nodes(&nodes, 3, 4, InitFeatures::known(), InitFeatures::known());
2299
2300         // Rebalance the network a bit by relaying one payment through all the channels...
2301         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
2302         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
2303         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
2304         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
2305
2306         // Simple case with no pending HTLCs:
2307         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), true);
2308         check_added_monitors!(nodes[1], 1);
2309         {
2310                 let mut node_txn = test_txn_broadcast(&nodes[1], &chan_1, None, HTLCType::NONE);
2311                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2312                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![node_txn.drain(..).next().unwrap()] }, 1);
2313                 check_added_monitors!(nodes[0], 1);
2314                 test_txn_broadcast(&nodes[0], &chan_1, None, HTLCType::NONE);
2315         }
2316         get_announce_close_broadcast_events(&nodes, 0, 1);
2317         assert_eq!(nodes[0].node.list_channels().len(), 0);
2318         assert_eq!(nodes[1].node.list_channels().len(), 1);
2319
2320         // One pending HTLC is discarded by the force-close:
2321         let payment_preimage_1 = route_payment(&nodes[1], &vec!(&nodes[2], &nodes[3])[..], 3000000).0;
2322
2323         // Simple case of one pending HTLC to HTLC-Timeout
2324         nodes[1].node.peer_disconnected(&nodes[2].node.get_our_node_id(), true);
2325         check_added_monitors!(nodes[1], 1);
2326         {
2327                 let mut node_txn = test_txn_broadcast(&nodes[1], &chan_2, None, HTLCType::TIMEOUT);
2328                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2329                 nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![node_txn.drain(..).next().unwrap()] }, 1);
2330                 check_added_monitors!(nodes[2], 1);
2331                 test_txn_broadcast(&nodes[2], &chan_2, None, HTLCType::NONE);
2332         }
2333         get_announce_close_broadcast_events(&nodes, 1, 2);
2334         assert_eq!(nodes[1].node.list_channels().len(), 0);
2335         assert_eq!(nodes[2].node.list_channels().len(), 1);
2336
2337         macro_rules! claim_funds {
2338                 ($node: expr, $prev_node: expr, $preimage: expr, $amount: expr) => {
2339                         {
2340                                 assert!($node.node.claim_funds($preimage, &None, $amount));
2341                                 check_added_monitors!($node, 1);
2342
2343                                 let events = $node.node.get_and_clear_pending_msg_events();
2344                                 assert_eq!(events.len(), 1);
2345                                 match events[0] {
2346                                         MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fail_htlcs, .. } } => {
2347                                                 assert!(update_add_htlcs.is_empty());
2348                                                 assert!(update_fail_htlcs.is_empty());
2349                                                 assert_eq!(*node_id, $prev_node.node.get_our_node_id());
2350                                         },
2351                                         _ => panic!("Unexpected event"),
2352                                 };
2353                         }
2354                 }
2355         }
2356
2357         // nodes[3] gets the preimage, but nodes[2] already disconnected, resulting in a nodes[2]
2358         // HTLC-Timeout and a nodes[3] claim against it (+ its own announces)
2359         nodes[2].node.peer_disconnected(&nodes[3].node.get_our_node_id(), true);
2360         check_added_monitors!(nodes[2], 1);
2361         let node2_commitment_txid;
2362         {
2363                 let node_txn = test_txn_broadcast(&nodes[2], &chan_3, None, HTLCType::TIMEOUT);
2364                 node2_commitment_txid = node_txn[0].txid();
2365
2366                 // Claim the payment on nodes[3], giving it knowledge of the preimage
2367                 claim_funds!(nodes[3], nodes[2], payment_preimage_1, 3_000_000);
2368
2369                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2370                 nodes[3].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()] }, 1);
2371                 check_added_monitors!(nodes[3], 1);
2372
2373                 check_preimage_claim(&nodes[3], &node_txn);
2374         }
2375         get_announce_close_broadcast_events(&nodes, 2, 3);
2376         assert_eq!(nodes[2].node.list_channels().len(), 0);
2377         assert_eq!(nodes[3].node.list_channels().len(), 1);
2378
2379         { // Cheat and reset nodes[4]'s height to 1
2380                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2381                 nodes[4].block_notifier.block_connected(&Block { header, txdata: vec![] }, 1);
2382         }
2383
2384         assert_eq!(nodes[3].node.latest_block_height.load(Ordering::Acquire), 1);
2385         assert_eq!(nodes[4].node.latest_block_height.load(Ordering::Acquire), 1);
2386         // One pending HTLC to time out:
2387         let payment_preimage_2 = route_payment(&nodes[3], &vec!(&nodes[4])[..], 3000000).0;
2388         // CLTV expires at TEST_FINAL_CLTV + 1 (current height) + 1 (added in send_payment for
2389         // buffer space).
2390
2391         {
2392                 let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2393                 nodes[3].block_notifier.block_connected_checked(&header, 2, &Vec::new()[..], &[0; 0]);
2394                 for i in 3..TEST_FINAL_CLTV + 2 + LATENCY_GRACE_PERIOD_BLOCKS + 1 {
2395                         header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2396                         nodes[3].block_notifier.block_connected_checked(&header, i, &Vec::new()[..], &[0; 0]);
2397                 }
2398                 check_added_monitors!(nodes[3], 1);
2399
2400                 // Clear bumped claiming txn spending node 2 commitment tx. Bumped txn are generated after reaching some height timer.
2401                 {
2402                         let mut node_txn = nodes[3].tx_broadcaster.txn_broadcasted.lock().unwrap();
2403                         node_txn.retain(|tx| {
2404                                 if tx.input[0].previous_output.txid == node2_commitment_txid {
2405                                         false
2406                                 } else { true }
2407                         });
2408                 }
2409
2410                 let node_txn = test_txn_broadcast(&nodes[3], &chan_4, None, HTLCType::TIMEOUT);
2411
2412                 // Claim the payment on nodes[4], giving it knowledge of the preimage
2413                 claim_funds!(nodes[4], nodes[3], payment_preimage_2, 3_000_000);
2414
2415                 header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2416
2417                 nodes[4].block_notifier.block_connected_checked(&header, 2, &Vec::new()[..], &[0; 0]);
2418                 for i in 3..TEST_FINAL_CLTV + 2 - CLTV_CLAIM_BUFFER + 1 {
2419                         header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2420                         nodes[4].block_notifier.block_connected_checked(&header, i, &Vec::new()[..], &[0; 0]);
2421                 }
2422
2423                 check_added_monitors!(nodes[4], 1);
2424                 test_txn_broadcast(&nodes[4], &chan_4, None, HTLCType::SUCCESS);
2425
2426                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2427                 nodes[4].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()] }, TEST_FINAL_CLTV - 5);
2428
2429                 check_preimage_claim(&nodes[4], &node_txn);
2430         }
2431         get_announce_close_broadcast_events(&nodes, 3, 4);
2432         assert_eq!(nodes[3].node.list_channels().len(), 0);
2433         assert_eq!(nodes[4].node.list_channels().len(), 0);
2434 }
2435
2436 #[test]
2437 fn test_justice_tx() {
2438         // Test justice txn built on revoked HTLC-Success tx, against both sides
2439         let mut alice_config = UserConfig::default();
2440         alice_config.channel_options.announced_channel = true;
2441         alice_config.peer_channel_config_limits.force_announced_channel_preference = false;
2442         alice_config.own_channel_config.our_to_self_delay = 6 * 24 * 5;
2443         let mut bob_config = UserConfig::default();
2444         bob_config.channel_options.announced_channel = true;
2445         bob_config.peer_channel_config_limits.force_announced_channel_preference = false;
2446         bob_config.own_channel_config.our_to_self_delay = 6 * 24 * 3;
2447         let user_cfgs = [Some(alice_config), Some(bob_config)];
2448         let chanmon_cfgs = create_chanmon_cfgs(2);
2449         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2450         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &user_cfgs);
2451         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2452         // Create some new channels:
2453         let chan_5 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2454
2455         // A pending HTLC which will be revoked:
2456         let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
2457         // Get the will-be-revoked local txn from nodes[0]
2458         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_5.2);
2459         assert_eq!(revoked_local_txn.len(), 2); // First commitment tx, then HTLC tx
2460         assert_eq!(revoked_local_txn[0].input.len(), 1);
2461         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_5.3.txid());
2462         assert_eq!(revoked_local_txn[0].output.len(), 2); // Only HTLC and output back to 0 are present
2463         assert_eq!(revoked_local_txn[1].input.len(), 1);
2464         assert_eq!(revoked_local_txn[1].input[0].previous_output.txid, revoked_local_txn[0].txid());
2465         assert_eq!(revoked_local_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT); // HTLC-Timeout
2466         // Revoke the old state
2467         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3, 3_000_000);
2468
2469         {
2470                 let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2471                 nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2472                 {
2473                         let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2474                         assert_eq!(node_txn.len(), 2); // ChannelMonitor: penalty tx, ChannelManager: local commitment tx
2475                         assert_eq!(node_txn[0].input.len(), 2); // We should claim the revoked output and the HTLC output
2476
2477                         check_spends!(node_txn[0], revoked_local_txn[0]);
2478                         node_txn.swap_remove(0);
2479                         node_txn.truncate(1);
2480                 }
2481                 check_added_monitors!(nodes[1], 1);
2482                 test_txn_broadcast(&nodes[1], &chan_5, None, HTLCType::NONE);
2483
2484                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2485                 // Verify broadcast of revoked HTLC-timeout
2486                 let node_txn = test_txn_broadcast(&nodes[0], &chan_5, Some(revoked_local_txn[0].clone()), HTLCType::TIMEOUT);
2487                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2488                 check_added_monitors!(nodes[0], 1);
2489                 // Broadcast revoked HTLC-timeout on node 1
2490                 nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[1].clone()] }, 1);
2491                 test_revoked_htlc_claim_txn_broadcast(&nodes[1], node_txn[1].clone(), revoked_local_txn[0].clone());
2492         }
2493         get_announce_close_broadcast_events(&nodes, 0, 1);
2494
2495         assert_eq!(nodes[0].node.list_channels().len(), 0);
2496         assert_eq!(nodes[1].node.list_channels().len(), 0);
2497
2498         // We test justice_tx build by A on B's revoked HTLC-Success tx
2499         // Create some new channels:
2500         let chan_6 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2501         {
2502                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2503                 node_txn.clear();
2504         }
2505
2506         // A pending HTLC which will be revoked:
2507         let payment_preimage_4 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
2508         // Get the will-be-revoked local txn from B
2509         let revoked_local_txn = get_local_commitment_txn!(nodes[1], chan_6.2);
2510         assert_eq!(revoked_local_txn.len(), 1); // Only commitment tx
2511         assert_eq!(revoked_local_txn[0].input.len(), 1);
2512         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_6.3.txid());
2513         assert_eq!(revoked_local_txn[0].output.len(), 2); // Only HTLC and output back to A are present
2514         // Revoke the old state
2515         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_4, 3_000_000);
2516         {
2517                 let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2518                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2519                 {
2520                         let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
2521                         assert_eq!(node_txn.len(), 2); //ChannelMonitor: penalty tx, ChannelManager: local commitment tx
2522                         assert_eq!(node_txn[0].input.len(), 1); // We claim the received HTLC output
2523
2524                         check_spends!(node_txn[0], revoked_local_txn[0]);
2525                         node_txn.swap_remove(0);
2526                 }
2527                 check_added_monitors!(nodes[0], 1);
2528                 test_txn_broadcast(&nodes[0], &chan_6, None, HTLCType::NONE);
2529
2530                 nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2531                 let node_txn = test_txn_broadcast(&nodes[1], &chan_6, Some(revoked_local_txn[0].clone()), HTLCType::SUCCESS);
2532                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2533                 check_added_monitors!(nodes[1], 1);
2534                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[1].clone()] }, 1);
2535                 test_revoked_htlc_claim_txn_broadcast(&nodes[0], node_txn[1].clone(), revoked_local_txn[0].clone());
2536         }
2537         get_announce_close_broadcast_events(&nodes, 0, 1);
2538         assert_eq!(nodes[0].node.list_channels().len(), 0);
2539         assert_eq!(nodes[1].node.list_channels().len(), 0);
2540 }
2541
2542 #[test]
2543 fn revoked_output_claim() {
2544         // Simple test to ensure a node will claim a revoked output when a stale remote commitment
2545         // transaction is broadcast by its counterparty
2546         let chanmon_cfgs = create_chanmon_cfgs(2);
2547         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2548         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
2549         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2550         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2551         // node[0] is gonna to revoke an old state thus node[1] should be able to claim the revoked output
2552         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
2553         assert_eq!(revoked_local_txn.len(), 1);
2554         // Only output is the full channel value back to nodes[0]:
2555         assert_eq!(revoked_local_txn[0].output.len(), 1);
2556         // Send a payment through, updating everyone's latest commitment txn
2557         send_payment(&nodes[0], &vec!(&nodes[1])[..], 5000000, 5_000_000);
2558
2559         // Inform nodes[1] that nodes[0] broadcast a stale tx
2560         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2561         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2562         check_added_monitors!(nodes[1], 1);
2563         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2564         assert_eq!(node_txn.len(), 2); // ChannelMonitor: justice tx against revoked to_local output, ChannelManager: local commitment tx
2565
2566         check_spends!(node_txn[0], revoked_local_txn[0]);
2567         check_spends!(node_txn[1], chan_1.3);
2568
2569         // Inform nodes[0] that a watchtower cheated on its behalf, so it will force-close the chan
2570         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2571         get_announce_close_broadcast_events(&nodes, 0, 1);
2572         check_added_monitors!(nodes[0], 1)
2573 }
2574
2575 #[test]
2576 fn claim_htlc_outputs_shared_tx() {
2577         // Node revoked old state, htlcs haven't time out yet, claim them in shared justice tx
2578         let chanmon_cfgs = create_chanmon_cfgs(2);
2579         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2580         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
2581         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2582
2583         // Create some new channel:
2584         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2585
2586         // Rebalance the network to generate htlc in the two directions
2587         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
2588         // 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
2589         let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
2590         let (_payment_preimage_2, payment_hash_2) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000);
2591
2592         // Get the will-be-revoked local txn from node[0]
2593         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
2594         assert_eq!(revoked_local_txn.len(), 2); // commitment tx + 1 HTLC-Timeout tx
2595         assert_eq!(revoked_local_txn[0].input.len(), 1);
2596         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
2597         assert_eq!(revoked_local_txn[1].input.len(), 1);
2598         assert_eq!(revoked_local_txn[1].input[0].previous_output.txid, revoked_local_txn[0].txid());
2599         assert_eq!(revoked_local_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT); // HTLC-Timeout
2600         check_spends!(revoked_local_txn[1], revoked_local_txn[0]);
2601
2602         //Revoke the old state
2603         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1, 3_000_000);
2604
2605         {
2606                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2607                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2608                 check_added_monitors!(nodes[0], 1);
2609                 nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2610                 check_added_monitors!(nodes[1], 1);
2611                 connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
2612                 expect_payment_failed!(nodes[1], payment_hash_2, true);
2613
2614                 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2615                 assert_eq!(node_txn.len(), 3); // ChannelMonitor: penalty tx, ChannelManager: local commitment + HTLC-timeout
2616
2617                 assert_eq!(node_txn[0].input.len(), 3); // Claim the revoked output + both revoked HTLC outputs
2618                 check_spends!(node_txn[0], revoked_local_txn[0]);
2619
2620                 let mut witness_lens = BTreeSet::new();
2621                 witness_lens.insert(node_txn[0].input[0].witness.last().unwrap().len());
2622                 witness_lens.insert(node_txn[0].input[1].witness.last().unwrap().len());
2623                 witness_lens.insert(node_txn[0].input[2].witness.last().unwrap().len());
2624                 assert_eq!(witness_lens.len(), 3);
2625                 assert_eq!(*witness_lens.iter().skip(0).next().unwrap(), 77); // revoked to_local
2626                 assert_eq!(*witness_lens.iter().skip(1).next().unwrap(), OFFERED_HTLC_SCRIPT_WEIGHT); // revoked offered HTLC
2627                 assert_eq!(*witness_lens.iter().skip(2).next().unwrap(), ACCEPTED_HTLC_SCRIPT_WEIGHT); // revoked received HTLC
2628
2629                 // Next nodes[1] broadcasts its current local tx state:
2630                 assert_eq!(node_txn[1].input.len(), 1);
2631                 assert_eq!(node_txn[1].input[0].previous_output.txid, chan_1.3.txid()); //Spending funding tx unique txouput, tx broadcasted by ChannelManager
2632
2633                 assert_eq!(node_txn[2].input.len(), 1);
2634                 let witness_script = node_txn[2].clone().input[0].witness.pop().unwrap();
2635                 assert_eq!(witness_script.len(), OFFERED_HTLC_SCRIPT_WEIGHT); //Spending an offered htlc output
2636                 assert_eq!(node_txn[2].input[0].previous_output.txid, node_txn[1].txid());
2637                 assert_ne!(node_txn[2].input[0].previous_output.txid, node_txn[0].input[0].previous_output.txid);
2638                 assert_ne!(node_txn[2].input[0].previous_output.txid, node_txn[0].input[1].previous_output.txid);
2639         }
2640         get_announce_close_broadcast_events(&nodes, 0, 1);
2641         assert_eq!(nodes[0].node.list_channels().len(), 0);
2642         assert_eq!(nodes[1].node.list_channels().len(), 0);
2643 }
2644
2645 #[test]
2646 fn claim_htlc_outputs_single_tx() {
2647         // Node revoked old state, htlcs have timed out, claim each of them in separated justice tx
2648         let chanmon_cfgs = create_chanmon_cfgs(2);
2649         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2650         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
2651         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2652
2653         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2654
2655         // Rebalance the network to generate htlc in the two directions
2656         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
2657         // 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
2658         // time as two different claim transactions as we're gonna to timeout htlc with given a high current height
2659         let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
2660         let (_payment_preimage_2, payment_hash_2) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000);
2661
2662         // Get the will-be-revoked local txn from node[0]
2663         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
2664
2665         //Revoke the old state
2666         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1, 3_000_000);
2667
2668         {
2669                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2670                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 200);
2671                 check_added_monitors!(nodes[0], 1);
2672                 nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 200);
2673                 check_added_monitors!(nodes[1], 1);
2674                 expect_pending_htlcs_forwardable_ignore!(nodes[0]);
2675
2676                 connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 200, true, header.bitcoin_hash());
2677                 expect_payment_failed!(nodes[1], payment_hash_2, true);
2678
2679                 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2680                 assert_eq!(node_txn.len(), 9);
2681                 // ChannelMonitor: justice tx revoked offered htlc, justice tx revoked received htlc, justice tx revoked to_local (3)
2682                 // ChannelManager: local commmitment + local HTLC-timeout (2)
2683                 // 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)
2684                 // ChannelMonitor: local commitment + local HTLC-timeout (2)
2685
2686                 // Check the pair local commitment and HTLC-timeout broadcast due to HTLC expiration
2687                 assert_eq!(node_txn[2].input.len(), 1);
2688                 check_spends!(node_txn[2], chan_1.3);
2689                 assert_eq!(node_txn[3].input.len(), 1);
2690                 let witness_script = node_txn[3].input[0].witness.last().unwrap();
2691                 assert_eq!(witness_script.len(), OFFERED_HTLC_SCRIPT_WEIGHT); //Spending an offered htlc output
2692                 check_spends!(node_txn[3], node_txn[2]);
2693
2694                 // Justice transactions are indices 1-2-4
2695                 assert_eq!(node_txn[0].input.len(), 1);
2696                 assert_eq!(node_txn[1].input.len(), 1);
2697                 assert_eq!(node_txn[4].input.len(), 1);
2698
2699                 check_spends!(node_txn[0], revoked_local_txn[0]);
2700                 check_spends!(node_txn[1], revoked_local_txn[0]);
2701                 check_spends!(node_txn[4], revoked_local_txn[0]);
2702
2703                 let mut witness_lens = BTreeSet::new();
2704                 witness_lens.insert(node_txn[0].input[0].witness.last().unwrap().len());
2705                 witness_lens.insert(node_txn[1].input[0].witness.last().unwrap().len());
2706                 witness_lens.insert(node_txn[4].input[0].witness.last().unwrap().len());
2707                 assert_eq!(witness_lens.len(), 3);
2708                 assert_eq!(*witness_lens.iter().skip(0).next().unwrap(), 77); // revoked to_local
2709                 assert_eq!(*witness_lens.iter().skip(1).next().unwrap(), OFFERED_HTLC_SCRIPT_WEIGHT); // revoked offered HTLC
2710                 assert_eq!(*witness_lens.iter().skip(2).next().unwrap(), ACCEPTED_HTLC_SCRIPT_WEIGHT); // revoked received HTLC
2711         }
2712         get_announce_close_broadcast_events(&nodes, 0, 1);
2713         assert_eq!(nodes[0].node.list_channels().len(), 0);
2714         assert_eq!(nodes[1].node.list_channels().len(), 0);
2715 }
2716
2717 #[test]
2718 fn test_htlc_on_chain_success() {
2719         // Test that in case of a unilateral close onchain, we detect the state of output thanks to
2720         // ChainWatchInterface and pass the preimage backward accordingly. So here we test that ChannelManager is
2721         // broadcasting the right event to other nodes in payment path.
2722         // We test with two HTLCs simultaneously as that was not handled correctly in the past.
2723         // A --------------------> B ----------------------> C (preimage)
2724         // First, C should claim the HTLC outputs via HTLC-Success when its own latest local
2725         // commitment transaction was broadcast.
2726         // Then, B should learn the preimage from said transactions, attempting to claim backwards
2727         // towards B.
2728         // B should be able to claim via preimage if A then broadcasts its local tx.
2729         // Finally, when A sees B's latest local commitment transaction it should be able to claim
2730         // the HTLC outputs via the preimage it learned (which, once confirmed should generate a
2731         // PaymentSent event).
2732
2733         let chanmon_cfgs = create_chanmon_cfgs(3);
2734         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
2735         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
2736         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
2737
2738         // Create some initial channels
2739         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2740         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
2741
2742         // Rebalance the network a bit by relaying one payment through all the channels...
2743         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
2744         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
2745
2746         let (our_payment_preimage, _payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
2747         let (our_payment_preimage_2, _payment_hash_2) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
2748         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
2749
2750         // Broadcast legit commitment tx from C on B's chain
2751         // Broadcast HTLC Success transaction by C on received output from C's commitment tx on B's chain
2752         let commitment_tx = get_local_commitment_txn!(nodes[2], chan_2.2);
2753         assert_eq!(commitment_tx.len(), 1);
2754         check_spends!(commitment_tx[0], chan_2.3);
2755         nodes[2].node.claim_funds(our_payment_preimage, &None, 3_000_000);
2756         nodes[2].node.claim_funds(our_payment_preimage_2, &None, 3_000_000);
2757         check_added_monitors!(nodes[2], 2);
2758         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
2759         assert!(updates.update_add_htlcs.is_empty());
2760         assert!(updates.update_fail_htlcs.is_empty());
2761         assert!(updates.update_fail_malformed_htlcs.is_empty());
2762         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
2763
2764         nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
2765         check_closed_broadcast!(nodes[2], false);
2766         check_added_monitors!(nodes[2], 1);
2767         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)
2768         assert_eq!(node_txn.len(), 5);
2769         assert_eq!(node_txn[0], node_txn[3]);
2770         assert_eq!(node_txn[1], node_txn[4]);
2771         assert_eq!(node_txn[2], commitment_tx[0]);
2772         check_spends!(node_txn[0], commitment_tx[0]);
2773         check_spends!(node_txn[1], commitment_tx[0]);
2774         assert_eq!(node_txn[0].input[0].witness.clone().last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2775         assert_eq!(node_txn[1].input[0].witness.clone().last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2776         assert!(node_txn[0].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2777         assert!(node_txn[1].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2778         assert_eq!(node_txn[0].lock_time, 0);
2779         assert_eq!(node_txn[1].lock_time, 0);
2780
2781         // Verify that B's ChannelManager is able to extract preimage from HTLC Success tx and pass it backward
2782         nodes[1].block_notifier.block_connected(&Block { header, txdata: node_txn}, 1);
2783         {
2784                 let mut added_monitors = nodes[1].chan_monitor.added_monitors.lock().unwrap();
2785                 assert_eq!(added_monitors.len(), 1);
2786                 assert_eq!(added_monitors[0].0.txid, chan_2.3.txid());
2787                 added_monitors.clear();
2788         }
2789         let events = nodes[1].node.get_and_clear_pending_msg_events();
2790         {
2791                 let mut added_monitors = nodes[1].chan_monitor.added_monitors.lock().unwrap();
2792                 assert_eq!(added_monitors.len(), 2);
2793                 assert_eq!(added_monitors[0].0.txid, chan_1.3.txid());
2794                 assert_eq!(added_monitors[1].0.txid, chan_1.3.txid());
2795                 added_monitors.clear();
2796         }
2797         assert_eq!(events.len(), 2);
2798         match events[0] {
2799                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
2800                 _ => panic!("Unexpected event"),
2801         }
2802         match events[1] {
2803                 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, .. } } => {
2804                         assert!(update_add_htlcs.is_empty());
2805                         assert!(update_fail_htlcs.is_empty());
2806                         assert_eq!(update_fulfill_htlcs.len(), 1);
2807                         assert!(update_fail_malformed_htlcs.is_empty());
2808                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
2809                 },
2810                 _ => panic!("Unexpected event"),
2811         };
2812         macro_rules! check_tx_local_broadcast {
2813                 ($node: expr, $htlc_offered: expr, $commitment_tx: expr, $chan_tx: expr) => { {
2814                         let mut node_txn = $node.tx_broadcaster.txn_broadcasted.lock().unwrap();
2815                         assert_eq!(node_txn.len(), 5);
2816                         // Node[1]: ChannelManager: 3 (commitment tx, 2*HTLC-Timeout tx), ChannelMonitor: 2 (timeout tx)
2817                         // Node[0]: ChannelManager: 3 (commtiemtn tx, 2*HTLC-Timeout tx), ChannelMonitor: 2 HTLC-timeout
2818                         check_spends!(node_txn[0], $commitment_tx);
2819                         check_spends!(node_txn[1], $commitment_tx);
2820                         assert_ne!(node_txn[0].lock_time, 0);
2821                         assert_ne!(node_txn[1].lock_time, 0);
2822                         if $htlc_offered {
2823                                 assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2824                                 assert_eq!(node_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2825                                 assert!(node_txn[0].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2826                                 assert!(node_txn[1].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2827                         } else {
2828                                 assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2829                                 assert_eq!(node_txn[1].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2830                                 assert!(node_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
2831                                 assert!(node_txn[1].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
2832                         }
2833                         check_spends!(node_txn[2], $chan_tx);
2834                         check_spends!(node_txn[3], node_txn[2]);
2835                         check_spends!(node_txn[4], node_txn[2]);
2836                         assert_eq!(node_txn[2].input[0].witness.last().unwrap().len(), 71);
2837                         assert_eq!(node_txn[3].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2838                         assert_eq!(node_txn[4].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2839                         assert!(node_txn[3].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2840                         assert!(node_txn[4].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2841                         assert_ne!(node_txn[3].lock_time, 0);
2842                         assert_ne!(node_txn[4].lock_time, 0);
2843                         node_txn.clear();
2844                 } }
2845         }
2846         // nodes[1] now broadcasts its own local state as a fallback, suggesting an alternate
2847         // commitment transaction with a corresponding HTLC-Timeout transactions, as well as a
2848         // timeout-claim of the output that nodes[2] just claimed via success.
2849         check_tx_local_broadcast!(nodes[1], false, commitment_tx[0], chan_2.3);
2850
2851         // Broadcast legit commitment tx from A on B's chain
2852         // Broadcast preimage tx by B on offered output from A commitment tx  on A's chain
2853         let commitment_tx = get_local_commitment_txn!(nodes[0], chan_1.2);
2854         check_spends!(commitment_tx[0], chan_1.3);
2855         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
2856         check_closed_broadcast!(nodes[1], false);
2857         check_added_monitors!(nodes[1], 1);
2858         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 3 (commitment tx + HTLC-Sucess * 2), ChannelMonitor : 1 (HTLC-Success)
2859         assert_eq!(node_txn.len(), 4);
2860         check_spends!(node_txn[0], commitment_tx[0]);
2861         assert_eq!(node_txn[0].input.len(), 2);
2862         assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2863         assert_eq!(node_txn[0].input[1].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2864         assert_eq!(node_txn[0].lock_time, 0);
2865         assert!(node_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
2866         check_spends!(node_txn[1], chan_1.3);
2867         assert_eq!(node_txn[1].input[0].witness.clone().last().unwrap().len(), 71);
2868         check_spends!(node_txn[2], node_txn[1]);
2869         check_spends!(node_txn[3], node_txn[1]);
2870         // We don't bother to check that B can claim the HTLC output on its commitment tx here as
2871         // we already checked the same situation with A.
2872
2873         // Verify that A's ChannelManager is able to extract preimage from preimage tx and generate PaymentSent
2874         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone(), node_txn[0].clone()] }, 1);
2875         check_closed_broadcast!(nodes[0], false);
2876         check_added_monitors!(nodes[0], 1);
2877         let events = nodes[0].node.get_and_clear_pending_events();
2878         assert_eq!(events.len(), 2);
2879         let mut first_claimed = false;
2880         for event in events {
2881                 match event {
2882                         Event::PaymentSent { payment_preimage } => {
2883                                 if payment_preimage == our_payment_preimage {
2884                                         assert!(!first_claimed);
2885                                         first_claimed = true;
2886                                 } else {
2887                                         assert_eq!(payment_preimage, our_payment_preimage_2);
2888                                 }
2889                         },
2890                         _ => panic!("Unexpected event"),
2891                 }
2892         }
2893         check_tx_local_broadcast!(nodes[0], true, commitment_tx[0], chan_1.3);
2894 }
2895
2896 #[test]
2897 fn test_htlc_on_chain_timeout() {
2898         // Test that in case of a unilateral close onchain, we detect the state of output thanks to
2899         // ChainWatchInterface and timeout the HTLC backward accordingly. So here we test that ChannelManager is
2900         // broadcasting the right event to other nodes in payment path.
2901         // A ------------------> B ----------------------> C (timeout)
2902         //    B's commitment tx                 C's commitment tx
2903         //            \                                  \
2904         //         B's HTLC timeout tx               B's timeout tx
2905
2906         let chanmon_cfgs = create_chanmon_cfgs(3);
2907         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
2908         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
2909         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
2910
2911         // Create some intial channels
2912         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2913         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
2914
2915         // Rebalance the network a bit by relaying one payment thorugh all the channels...
2916         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
2917         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
2918
2919         let (_payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
2920         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
2921
2922         // Broadcast legit commitment tx from C on B's chain
2923         let commitment_tx = get_local_commitment_txn!(nodes[2], chan_2.2);
2924         check_spends!(commitment_tx[0], chan_2.3);
2925         nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
2926         check_added_monitors!(nodes[2], 0);
2927         expect_pending_htlcs_forwardable!(nodes[2]);
2928         check_added_monitors!(nodes[2], 1);
2929
2930         let events = nodes[2].node.get_and_clear_pending_msg_events();
2931         assert_eq!(events.len(), 1);
2932         match events[0] {
2933                 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, .. } } => {
2934                         assert!(update_add_htlcs.is_empty());
2935                         assert!(!update_fail_htlcs.is_empty());
2936                         assert!(update_fulfill_htlcs.is_empty());
2937                         assert!(update_fail_malformed_htlcs.is_empty());
2938                         assert_eq!(nodes[1].node.get_our_node_id(), *node_id);
2939                 },
2940                 _ => panic!("Unexpected event"),
2941         };
2942         nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
2943         check_closed_broadcast!(nodes[2], false);
2944         check_added_monitors!(nodes[2], 1);
2945         let node_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 1 (commitment tx)
2946         assert_eq!(node_txn.len(), 1);
2947         check_spends!(node_txn[0], chan_2.3);
2948         assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), 71);
2949
2950         // Broadcast timeout transaction by B on received output from C's commitment tx on B's chain
2951         // Verify that B's ChannelManager is able to detect that HTLC is timeout by its own tx and react backward in consequence
2952         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 200);
2953         let timeout_tx;
2954         {
2955                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2956                 assert_eq!(node_txn.len(), 5); // ChannelManager : 2 (commitment tx, HTLC-Timeout tx), ChannelMonitor : 2 (local commitment tx + HTLC-timeout), 1 timeout tx
2957                 assert_eq!(node_txn[1], node_txn[3]);
2958                 assert_eq!(node_txn[2], node_txn[4]);
2959
2960                 check_spends!(node_txn[0], commitment_tx[0]);
2961                 assert_eq!(node_txn[0].clone().input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2962
2963                 check_spends!(node_txn[1], chan_2.3);
2964                 check_spends!(node_txn[2], node_txn[1]);
2965                 assert_eq!(node_txn[1].clone().input[0].witness.last().unwrap().len(), 71);
2966                 assert_eq!(node_txn[2].clone().input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2967
2968                 timeout_tx = node_txn[0].clone();
2969                 node_txn.clear();
2970         }
2971
2972         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![timeout_tx]}, 1);
2973         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
2974         check_added_monitors!(nodes[1], 1);
2975         check_closed_broadcast!(nodes[1], false);
2976
2977         expect_pending_htlcs_forwardable!(nodes[1]);
2978         check_added_monitors!(nodes[1], 1);
2979         let events = nodes[1].node.get_and_clear_pending_msg_events();
2980         assert_eq!(events.len(), 1);
2981         match events[0] {
2982                 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, .. } } => {
2983                         assert!(update_add_htlcs.is_empty());
2984                         assert!(!update_fail_htlcs.is_empty());
2985                         assert!(update_fulfill_htlcs.is_empty());
2986                         assert!(update_fail_malformed_htlcs.is_empty());
2987                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
2988                 },
2989                 _ => panic!("Unexpected event"),
2990         };
2991         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
2992         assert_eq!(node_txn.len(), 0);
2993
2994         // Broadcast legit commitment tx from B on A's chain
2995         let commitment_tx = get_local_commitment_txn!(nodes[1], chan_1.2);
2996         check_spends!(commitment_tx[0], chan_1.3);
2997
2998         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 200);
2999         check_closed_broadcast!(nodes[0], false);
3000         check_added_monitors!(nodes[0], 1);
3001         let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 2 (commitment tx, HTLC-Timeout tx), ChannelMonitor : 1 timeout tx
3002         assert_eq!(node_txn.len(), 3);
3003         check_spends!(node_txn[0], commitment_tx[0]);
3004         assert_eq!(node_txn[0].clone().input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
3005         check_spends!(node_txn[1], chan_1.3);
3006         check_spends!(node_txn[2], node_txn[1]);
3007         assert_eq!(node_txn[1].clone().input[0].witness.last().unwrap().len(), 71);
3008         assert_eq!(node_txn[2].clone().input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
3009 }
3010
3011 #[test]
3012 fn test_simple_commitment_revoked_fail_backward() {
3013         // Test that in case of a revoked commitment tx, we detect the resolution of output by justice tx
3014         // and fail backward accordingly.
3015
3016         let chanmon_cfgs = create_chanmon_cfgs(3);
3017         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
3018         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
3019         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
3020
3021         // Create some initial channels
3022         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3023         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
3024
3025         let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
3026         // Get the will-be-revoked local txn from nodes[2]
3027         let revoked_local_txn = get_local_commitment_txn!(nodes[2], chan_2.2);
3028         // Revoke the old state
3029         claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage, 3_000_000);
3030
3031         let (_, payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
3032
3033         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
3034         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
3035         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
3036         check_added_monitors!(nodes[1], 1);
3037         check_closed_broadcast!(nodes[1], false);
3038
3039         expect_pending_htlcs_forwardable!(nodes[1]);
3040         check_added_monitors!(nodes[1], 1);
3041         let events = nodes[1].node.get_and_clear_pending_msg_events();
3042         assert_eq!(events.len(), 1);
3043         match events[0] {
3044                 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, .. } } => {
3045                         assert!(update_add_htlcs.is_empty());
3046                         assert_eq!(update_fail_htlcs.len(), 1);
3047                         assert!(update_fulfill_htlcs.is_empty());
3048                         assert!(update_fail_malformed_htlcs.is_empty());
3049                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
3050
3051                         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[0]);
3052                         commitment_signed_dance!(nodes[0], nodes[1], commitment_signed, false, true);
3053
3054                         let events = nodes[0].node.get_and_clear_pending_msg_events();
3055                         assert_eq!(events.len(), 1);
3056                         match events[0] {
3057                                 MessageSendEvent::PaymentFailureNetworkUpdate { .. } => {},
3058                                 _ => panic!("Unexpected event"),
3059                         }
3060                         expect_payment_failed!(nodes[0], payment_hash, false);
3061                 },
3062                 _ => panic!("Unexpected event"),
3063         }
3064 }
3065
3066 fn do_test_commitment_revoked_fail_backward_exhaustive(deliver_bs_raa: bool, use_dust: bool, no_to_remote: bool) {
3067         // Test that if our counterparty broadcasts a revoked commitment transaction we fail all
3068         // pending HTLCs on that channel backwards even if the HTLCs aren't present in our latest
3069         // commitment transaction anymore.
3070         // To do this, we have the peer which will broadcast a revoked commitment transaction send
3071         // a number of update_fail/commitment_signed updates without ever sending the RAA in
3072         // response to our commitment_signed. This is somewhat misbehavior-y, though not
3073         // technically disallowed and we should probably handle it reasonably.
3074         // Note that this is pretty exhaustive as an outbound HTLC which we haven't yet
3075         // failed/fulfilled backwards must be in at least one of the latest two remote commitment
3076         // transactions:
3077         // * Once we move it out of our holding cell/add it, we will immediately include it in a
3078         //   commitment_signed (implying it will be in the latest remote commitment transaction).
3079         // * Once they remove it, we will send a (the first) commitment_signed without the HTLC,
3080         //   and once they revoke the previous commitment transaction (allowing us to send a new
3081         //   commitment_signed) we will be free to fail/fulfill the HTLC backwards.
3082         let chanmon_cfgs = create_chanmon_cfgs(3);
3083         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
3084         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
3085         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
3086
3087         // Create some initial channels
3088         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3089         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
3090
3091         let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], if no_to_remote { 10_000 } else { 3_000_000 });
3092         // Get the will-be-revoked local txn from nodes[2]
3093         let revoked_local_txn = get_local_commitment_txn!(nodes[2], chan_2.2);
3094         assert_eq!(revoked_local_txn[0].output.len(), if no_to_remote { 1 } else { 2 });
3095         // Revoke the old state
3096         claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage, if no_to_remote { 10_000 } else { 3_000_000});
3097
3098         let value = if use_dust {
3099                 // The dust limit applied to HTLC outputs considers the fee of the HTLC transaction as
3100                 // well, so HTLCs at exactly the dust limit will not be included in commitment txn.
3101                 nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().our_dust_limit_satoshis * 1000
3102         } else { 3000000 };
3103
3104         let (_, first_payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], value);
3105         let (_, second_payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], value);
3106         let (_, third_payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], value);
3107
3108         assert!(nodes[2].node.fail_htlc_backwards(&first_payment_hash, &None));
3109         expect_pending_htlcs_forwardable!(nodes[2]);
3110         check_added_monitors!(nodes[2], 1);
3111         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
3112         assert!(updates.update_add_htlcs.is_empty());
3113         assert!(updates.update_fulfill_htlcs.is_empty());
3114         assert!(updates.update_fail_malformed_htlcs.is_empty());
3115         assert_eq!(updates.update_fail_htlcs.len(), 1);
3116         assert!(updates.update_fee.is_none());
3117         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
3118         let bs_raa = commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false, true, false, true);
3119         // Drop the last RAA from 3 -> 2
3120
3121         assert!(nodes[2].node.fail_htlc_backwards(&second_payment_hash, &None));
3122         expect_pending_htlcs_forwardable!(nodes[2]);
3123         check_added_monitors!(nodes[2], 1);
3124         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
3125         assert!(updates.update_add_htlcs.is_empty());
3126         assert!(updates.update_fulfill_htlcs.is_empty());
3127         assert!(updates.update_fail_malformed_htlcs.is_empty());
3128         assert_eq!(updates.update_fail_htlcs.len(), 1);
3129         assert!(updates.update_fee.is_none());
3130         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
3131         nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &updates.commitment_signed);
3132         check_added_monitors!(nodes[1], 1);
3133         // Note that nodes[1] is in AwaitingRAA, so won't send a CS
3134         let as_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[2].node.get_our_node_id());
3135         nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_raa);
3136         check_added_monitors!(nodes[2], 1);
3137
3138         assert!(nodes[2].node.fail_htlc_backwards(&third_payment_hash, &None));
3139         expect_pending_htlcs_forwardable!(nodes[2]);
3140         check_added_monitors!(nodes[2], 1);
3141         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
3142         assert!(updates.update_add_htlcs.is_empty());
3143         assert!(updates.update_fulfill_htlcs.is_empty());
3144         assert!(updates.update_fail_malformed_htlcs.is_empty());
3145         assert_eq!(updates.update_fail_htlcs.len(), 1);
3146         assert!(updates.update_fee.is_none());
3147         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
3148         // At this point first_payment_hash has dropped out of the latest two commitment
3149         // transactions that nodes[1] is tracking...
3150         nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &updates.commitment_signed);
3151         check_added_monitors!(nodes[1], 1);
3152         // Note that nodes[1] is (still) in AwaitingRAA, so won't send a CS
3153         let as_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[2].node.get_our_node_id());
3154         nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_raa);
3155         check_added_monitors!(nodes[2], 1);
3156
3157         // Add a fourth HTLC, this one will get sequestered away in nodes[1]'s holding cell waiting
3158         // on nodes[2]'s RAA.
3159         let (_, fourth_payment_hash) = get_payment_preimage_hash!(nodes[0]);
3160         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
3161         let logger = test_utils::TestLogger::new();
3162         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();
3163         nodes[1].node.send_payment(&route, fourth_payment_hash, &None).unwrap();
3164         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
3165         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
3166         check_added_monitors!(nodes[1], 0);
3167
3168         if deliver_bs_raa {
3169                 nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_raa);
3170                 // One monitor for the new revocation preimage, no second on as we won't generate a new
3171                 // commitment transaction for nodes[0] until process_pending_htlc_forwards().
3172                 check_added_monitors!(nodes[1], 1);
3173                 let events = nodes[1].node.get_and_clear_pending_events();
3174                 assert_eq!(events.len(), 1);
3175                 match events[0] {
3176                         Event::PendingHTLCsForwardable { .. } => { },
3177                         _ => panic!("Unexpected event"),
3178                 };
3179                 // Deliberately don't process the pending fail-back so they all fail back at once after
3180                 // block connection just like the !deliver_bs_raa case
3181         }
3182
3183         let mut failed_htlcs = HashSet::new();
3184         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
3185
3186         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
3187         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
3188         check_added_monitors!(nodes[1], 1);
3189         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
3190
3191         let events = nodes[1].node.get_and_clear_pending_events();
3192         assert_eq!(events.len(), if deliver_bs_raa { 1 } else { 2 });
3193         match events[0] {
3194                 Event::PaymentFailed { ref payment_hash, .. } => {
3195                         assert_eq!(*payment_hash, fourth_payment_hash);
3196                 },
3197                 _ => panic!("Unexpected event"),
3198         }
3199         if !deliver_bs_raa {
3200                 match events[1] {
3201                         Event::PendingHTLCsForwardable { .. } => { },
3202                         _ => panic!("Unexpected event"),
3203                 };
3204         }
3205         nodes[1].node.process_pending_htlc_forwards();
3206         check_added_monitors!(nodes[1], 1);
3207
3208         let events = nodes[1].node.get_and_clear_pending_msg_events();
3209         assert_eq!(events.len(), if deliver_bs_raa { 3 } else { 2 });
3210         match events[if deliver_bs_raa { 1 } else { 0 }] {
3211                 MessageSendEvent::BroadcastChannelUpdate { msg: msgs::ChannelUpdate { .. } } => {},
3212                 _ => panic!("Unexpected event"),
3213         }
3214         if deliver_bs_raa {
3215                 match events[0] {
3216                         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, .. } } => {
3217                                 assert_eq!(nodes[2].node.get_our_node_id(), *node_id);
3218                                 assert_eq!(update_add_htlcs.len(), 1);
3219                                 assert!(update_fulfill_htlcs.is_empty());
3220                                 assert!(update_fail_htlcs.is_empty());
3221                                 assert!(update_fail_malformed_htlcs.is_empty());
3222                         },
3223                         _ => panic!("Unexpected event"),
3224                 }
3225         }
3226         match events[if deliver_bs_raa { 2 } else { 1 }] {
3227                 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, .. } } => {
3228                         assert!(update_add_htlcs.is_empty());
3229                         assert_eq!(update_fail_htlcs.len(), 3);
3230                         assert!(update_fulfill_htlcs.is_empty());
3231                         assert!(update_fail_malformed_htlcs.is_empty());
3232                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
3233
3234                         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[0]);
3235                         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[1]);
3236                         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[2]);
3237
3238                         commitment_signed_dance!(nodes[0], nodes[1], commitment_signed, false, true);
3239
3240                         let events = nodes[0].node.get_and_clear_pending_msg_events();
3241                         // If we delivered B's RAA we got an unknown preimage error, not something
3242                         // that we should update our routing table for.
3243                         assert_eq!(events.len(), if deliver_bs_raa { 2 } else { 3 });
3244                         for event in events {
3245                                 match event {
3246                                         MessageSendEvent::PaymentFailureNetworkUpdate { .. } => {},
3247                                         _ => panic!("Unexpected event"),
3248                                 }
3249                         }
3250                         let events = nodes[0].node.get_and_clear_pending_events();
3251                         assert_eq!(events.len(), 3);
3252                         match events[0] {
3253                                 Event::PaymentFailed { ref payment_hash, .. } => {
3254                                         assert!(failed_htlcs.insert(payment_hash.0));
3255                                 },
3256                                 _ => panic!("Unexpected event"),
3257                         }
3258                         match events[1] {
3259                                 Event::PaymentFailed { ref payment_hash, .. } => {
3260                                         assert!(failed_htlcs.insert(payment_hash.0));
3261                                 },
3262                                 _ => panic!("Unexpected event"),
3263                         }
3264                         match events[2] {
3265                                 Event::PaymentFailed { ref payment_hash, .. } => {
3266                                         assert!(failed_htlcs.insert(payment_hash.0));
3267                                 },
3268                                 _ => panic!("Unexpected event"),
3269                         }
3270                 },
3271                 _ => panic!("Unexpected event"),
3272         }
3273
3274         assert!(failed_htlcs.contains(&first_payment_hash.0));
3275         assert!(failed_htlcs.contains(&second_payment_hash.0));
3276         assert!(failed_htlcs.contains(&third_payment_hash.0));
3277 }
3278
3279 #[test]
3280 fn test_commitment_revoked_fail_backward_exhaustive_a() {
3281         do_test_commitment_revoked_fail_backward_exhaustive(false, true, false);
3282         do_test_commitment_revoked_fail_backward_exhaustive(true, true, false);
3283         do_test_commitment_revoked_fail_backward_exhaustive(false, false, false);
3284         do_test_commitment_revoked_fail_backward_exhaustive(true, false, false);
3285 }
3286
3287 #[test]
3288 fn test_commitment_revoked_fail_backward_exhaustive_b() {
3289         do_test_commitment_revoked_fail_backward_exhaustive(false, true, true);
3290         do_test_commitment_revoked_fail_backward_exhaustive(true, true, true);
3291         do_test_commitment_revoked_fail_backward_exhaustive(false, false, true);
3292         do_test_commitment_revoked_fail_backward_exhaustive(true, false, true);
3293 }
3294
3295 #[test]
3296 fn fail_backward_pending_htlc_upon_channel_failure() {
3297         let chanmon_cfgs = create_chanmon_cfgs(2);
3298         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
3299         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
3300         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
3301         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000, InitFeatures::known(), InitFeatures::known());
3302         let logger = test_utils::TestLogger::new();
3303
3304         // Alice -> Bob: Route a payment but without Bob sending revoke_and_ack.
3305         {
3306                 let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
3307                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3308                 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();
3309                 nodes[0].node.send_payment(&route, payment_hash, &None).unwrap();
3310                 check_added_monitors!(nodes[0], 1);
3311
3312                 let payment_event = {
3313                         let mut events = nodes[0].node.get_and_clear_pending_msg_events();
3314                         assert_eq!(events.len(), 1);
3315                         SendEvent::from_event(events.remove(0))
3316                 };
3317                 assert_eq!(payment_event.node_id, nodes[1].node.get_our_node_id());
3318                 assert_eq!(payment_event.msgs.len(), 1);
3319         }
3320
3321         // Alice -> Bob: Route another payment but now Alice waits for Bob's earlier revoke_and_ack.
3322         let (_, failed_payment_hash) = get_payment_preimage_hash!(nodes[0]);
3323         {
3324                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3325                 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();
3326                 nodes[0].node.send_payment(&route, failed_payment_hash, &None).unwrap();
3327                 check_added_monitors!(nodes[0], 0);
3328
3329                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
3330         }
3331
3332         // Alice <- Bob: Send a malformed update_add_htlc so Alice fails the channel.
3333         {
3334                 let (_, payment_hash) = get_payment_preimage_hash!(nodes[1]);
3335
3336                 let secp_ctx = Secp256k1::new();
3337                 let session_priv = SecretKey::from_slice(&[42; 32]).unwrap();
3338                 let current_height = nodes[1].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
3339                 let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
3340                 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();
3341                 let (onion_payloads, _amount_msat, cltv_expiry) = onion_utils::build_onion_payloads(&route.paths[0], 50_000, &None, current_height).unwrap();
3342                 let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route.paths[0], &session_priv).unwrap();
3343                 let onion_routing_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash);
3344
3345                 // Send a 0-msat update_add_htlc to fail the channel.
3346                 let update_add_htlc = msgs::UpdateAddHTLC {
3347                         channel_id: chan.2,
3348                         htlc_id: 0,
3349                         amount_msat: 0,
3350                         payment_hash,
3351                         cltv_expiry,
3352                         onion_routing_packet,
3353                 };
3354                 nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &update_add_htlc);
3355         }
3356
3357         // Check that Alice fails backward the pending HTLC from the second payment.
3358         expect_payment_failed!(nodes[0], failed_payment_hash, true);
3359         check_closed_broadcast!(nodes[0], true);
3360         check_added_monitors!(nodes[0], 1);
3361 }
3362
3363 #[test]
3364 fn test_htlc_ignore_latest_remote_commitment() {
3365         // Test that HTLC transactions spending the latest remote commitment transaction are simply
3366         // ignored if we cannot claim them. This originally tickled an invalid unwrap().
3367         let chanmon_cfgs = create_chanmon_cfgs(2);
3368         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
3369         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
3370         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
3371         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3372
3373         route_payment(&nodes[0], &[&nodes[1]], 10000000);
3374         nodes[0].node.force_close_channel(&nodes[0].node.list_channels()[0].channel_id);
3375         check_closed_broadcast!(nodes[0], false);
3376         check_added_monitors!(nodes[0], 1);
3377
3378         let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
3379         assert_eq!(node_txn.len(), 2);
3380
3381         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
3382         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone(), node_txn[1].clone()]}, 1);
3383         check_closed_broadcast!(nodes[1], false);
3384         check_added_monitors!(nodes[1], 1);
3385
3386         // Duplicate the block_connected call since this may happen due to other listeners
3387         // registering new transactions
3388         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone(), node_txn[1].clone()]}, 1);
3389 }
3390
3391 #[test]
3392 fn test_force_close_fail_back() {
3393         // Check which HTLCs are failed-backwards on channel force-closure
3394         let chanmon_cfgs = create_chanmon_cfgs(3);
3395         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
3396         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
3397         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
3398         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3399         create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
3400         let logger = test_utils::TestLogger::new();
3401
3402         let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
3403
3404         let mut payment_event = {
3405                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3406                 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();
3407                 nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
3408                 check_added_monitors!(nodes[0], 1);
3409
3410                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
3411                 assert_eq!(events.len(), 1);
3412                 SendEvent::from_event(events.remove(0))
3413         };
3414
3415         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
3416         commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
3417
3418         expect_pending_htlcs_forwardable!(nodes[1]);
3419
3420         let mut events_2 = nodes[1].node.get_and_clear_pending_msg_events();
3421         assert_eq!(events_2.len(), 1);
3422         payment_event = SendEvent::from_event(events_2.remove(0));
3423         assert_eq!(payment_event.msgs.len(), 1);
3424
3425         check_added_monitors!(nodes[1], 1);
3426         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
3427         nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &payment_event.commitment_msg);
3428         check_added_monitors!(nodes[2], 1);
3429         let (_, _) = get_revoke_commit_msgs!(nodes[2], nodes[1].node.get_our_node_id());
3430
3431         // nodes[2] now has the latest commitment transaction, but hasn't revoked its previous
3432         // state or updated nodes[1]' state. Now force-close and broadcast that commitment/HTLC
3433         // transaction and ensure nodes[1] doesn't fail-backwards (this was originally a bug!).
3434
3435         nodes[2].node.force_close_channel(&payment_event.commitment_msg.channel_id);
3436         check_closed_broadcast!(nodes[2], false);
3437         check_added_monitors!(nodes[2], 1);
3438         let tx = {
3439                 let mut node_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap();
3440                 // Note that we don't bother broadcasting the HTLC-Success transaction here as we don't
3441                 // have a use for it unless nodes[2] learns the preimage somehow, the funds will go
3442                 // back to nodes[1] upon timeout otherwise.
3443                 assert_eq!(node_txn.len(), 1);
3444                 node_txn.remove(0)
3445         };
3446
3447         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
3448         nodes[1].block_notifier.block_connected_checked(&header, 1, &[&tx], &[1]);
3449
3450         // Note no UpdateHTLCs event here from nodes[1] to nodes[0]!
3451         check_closed_broadcast!(nodes[1], false);
3452         check_added_monitors!(nodes[1], 1);
3453
3454         // Now check that if we add the preimage to ChannelMonitor it broadcasts our HTLC-Success..
3455         {
3456                 let mut monitors = nodes[2].chan_monitor.simple_monitor.monitors.lock().unwrap();
3457                 monitors.get_mut(&OutPoint{ txid: Txid::from_slice(&payment_event.commitment_msg.channel_id[..]).unwrap(), index: 0 }).unwrap()
3458                         .provide_payment_preimage(&our_payment_hash, &our_payment_preimage);
3459         }
3460         nodes[2].block_notifier.block_connected_checked(&header, 1, &[&tx], &[1]);
3461         let node_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap();
3462         assert_eq!(node_txn.len(), 1);
3463         assert_eq!(node_txn[0].input.len(), 1);
3464         assert_eq!(node_txn[0].input[0].previous_output.txid, tx.txid());
3465         assert_eq!(node_txn[0].lock_time, 0); // Must be an HTLC-Success
3466         assert_eq!(node_txn[0].input[0].witness.len(), 5); // Must be an HTLC-Success
3467
3468         check_spends!(node_txn[0], tx);
3469 }
3470
3471 #[test]
3472 fn test_unconf_chan() {
3473         // After creating a chan between nodes, we disconnect all blocks previously seen to force a channel close on nodes[0] side
3474         let chanmon_cfgs = create_chanmon_cfgs(2);
3475         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
3476         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
3477         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
3478         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3479
3480         let channel_state = nodes[0].node.channel_state.lock().unwrap();
3481         assert_eq!(channel_state.by_id.len(), 1);
3482         assert_eq!(channel_state.short_to_id.len(), 1);
3483         mem::drop(channel_state);
3484
3485         let mut headers = Vec::new();
3486         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
3487         headers.push(header.clone());
3488         for _i in 2..100 {
3489                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
3490                 headers.push(header.clone());
3491         }
3492         let mut height = 99;
3493         while !headers.is_empty() {
3494                 nodes[0].node.block_disconnected(&headers.pop().unwrap(), height);
3495                 height -= 1;
3496         }
3497         check_closed_broadcast!(nodes[0], false);
3498         check_added_monitors!(nodes[0], 1);
3499         let channel_state = nodes[0].node.channel_state.lock().unwrap();
3500         assert_eq!(channel_state.by_id.len(), 0);
3501         assert_eq!(channel_state.short_to_id.len(), 0);
3502 }
3503
3504 #[test]
3505 fn test_simple_peer_disconnect() {
3506         // Test that we can reconnect when there are no lost messages
3507         let chanmon_cfgs = create_chanmon_cfgs(3);
3508         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
3509         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
3510         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
3511         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3512         create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
3513
3514         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3515         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3516         reconnect_nodes(&nodes[0], &nodes[1], (true, true), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3517
3518         let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).0;
3519         let payment_hash_2 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).1;
3520         fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_hash_2);
3521         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_1, 1_000_000);
3522
3523         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3524         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3525         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3526
3527         let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).0;
3528         let payment_preimage_4 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).0;
3529         let payment_hash_5 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).1;
3530         let payment_hash_6 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).1;
3531
3532         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3533         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3534
3535         claim_payment_along_route(&nodes[0], &vec!(&nodes[1], &nodes[2]), true, payment_preimage_3, 1_000_000);
3536         fail_payment_along_route(&nodes[0], &[&nodes[1], &nodes[2]], true, payment_hash_5);
3537
3538         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (1, 0), (1, 0), (false, false));
3539         {
3540                 let events = nodes[0].node.get_and_clear_pending_events();
3541                 assert_eq!(events.len(), 2);
3542                 match events[0] {
3543                         Event::PaymentSent { payment_preimage } => {
3544                                 assert_eq!(payment_preimage, payment_preimage_3);
3545                         },
3546                         _ => panic!("Unexpected event"),
3547                 }
3548                 match events[1] {
3549                         Event::PaymentFailed { payment_hash, rejected_by_dest, .. } => {
3550                                 assert_eq!(payment_hash, payment_hash_5);
3551                                 assert!(rejected_by_dest);
3552                         },
3553                         _ => panic!("Unexpected event"),
3554                 }
3555         }
3556
3557         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_4, 1_000_000);
3558         fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_hash_6);
3559 }
3560
3561 fn do_test_drop_messages_peer_disconnect(messages_delivered: u8) {
3562         // Test that we can reconnect when in-flight HTLC updates get dropped
3563         let chanmon_cfgs = create_chanmon_cfgs(2);
3564         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
3565         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
3566         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
3567         if messages_delivered == 0 {
3568                 create_chan_between_nodes_with_value_a(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
3569                 // nodes[1] doesn't receive the funding_locked message (it'll be re-sent on reconnect)
3570         } else {
3571                 create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3572         }
3573
3574         let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
3575
3576         let logger = test_utils::TestLogger::new();
3577         let payment_event = {
3578                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3579                 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();
3580                 nodes[0].node.send_payment(&route, payment_hash_1, &None).unwrap();
3581                 check_added_monitors!(nodes[0], 1);
3582
3583                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
3584                 assert_eq!(events.len(), 1);
3585                 SendEvent::from_event(events.remove(0))
3586         };
3587         assert_eq!(nodes[1].node.get_our_node_id(), payment_event.node_id);
3588
3589         if messages_delivered < 2 {
3590                 // Drop the payment_event messages, and let them get re-generated in reconnect_nodes!
3591         } else {
3592                 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
3593                 if messages_delivered >= 3 {
3594                         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg);
3595                         check_added_monitors!(nodes[1], 1);
3596                         let (bs_revoke_and_ack, bs_commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
3597
3598                         if messages_delivered >= 4 {
3599                                 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack);
3600                                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
3601                                 check_added_monitors!(nodes[0], 1);
3602
3603                                 if messages_delivered >= 5 {
3604                                         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_commitment_signed);
3605                                         let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
3606                                         // No commitment_signed so get_event_msg's assert(len == 1) passes
3607                                         check_added_monitors!(nodes[0], 1);
3608
3609                                         if messages_delivered >= 6 {
3610                                                 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack);
3611                                                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
3612                                                 check_added_monitors!(nodes[1], 1);
3613                                         }
3614                                 }
3615                         }
3616                 }
3617         }
3618
3619         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3620         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3621         if messages_delivered < 3 {
3622                 // Even if the funding_locked messages get exchanged, as long as nothing further was
3623                 // received on either side, both sides will need to resend them.
3624                 reconnect_nodes(&nodes[0], &nodes[1], (true, true), (0, 1), (0, 0), (0, 0), (0, 0), (false, false));
3625         } else if messages_delivered == 3 {
3626                 // nodes[0] still wants its RAA + commitment_signed
3627                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (-1, 0), (0, 0), (0, 0), (0, 0), (true, false));
3628         } else if messages_delivered == 4 {
3629                 // nodes[0] still wants its commitment_signed
3630                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (-1, 0), (0, 0), (0, 0), (0, 0), (false, false));
3631         } else if messages_delivered == 5 {
3632                 // nodes[1] still wants its final RAA
3633                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, true));
3634         } else if messages_delivered == 6 {
3635                 // Everything was delivered...
3636                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3637         }
3638
3639         let events_1 = nodes[1].node.get_and_clear_pending_events();
3640         assert_eq!(events_1.len(), 1);
3641         match events_1[0] {
3642                 Event::PendingHTLCsForwardable { .. } => { },
3643                 _ => panic!("Unexpected event"),
3644         };
3645
3646         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3647         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3648         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3649
3650         nodes[1].node.process_pending_htlc_forwards();
3651
3652         let events_2 = nodes[1].node.get_and_clear_pending_events();
3653         assert_eq!(events_2.len(), 1);
3654         match events_2[0] {
3655                 Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
3656                         assert_eq!(payment_hash_1, *payment_hash);
3657                         assert_eq!(*payment_secret, None);
3658                         assert_eq!(amt, 1000000);
3659                 },
3660                 _ => panic!("Unexpected event"),
3661         }
3662
3663         nodes[1].node.claim_funds(payment_preimage_1, &None, 1_000_000);
3664         check_added_monitors!(nodes[1], 1);
3665
3666         let events_3 = nodes[1].node.get_and_clear_pending_msg_events();
3667         assert_eq!(events_3.len(), 1);
3668         let (update_fulfill_htlc, commitment_signed) = match events_3[0] {
3669                 MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
3670                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
3671                         assert!(updates.update_add_htlcs.is_empty());
3672                         assert!(updates.update_fail_htlcs.is_empty());
3673                         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
3674                         assert!(updates.update_fail_malformed_htlcs.is_empty());
3675                         assert!(updates.update_fee.is_none());
3676                         (updates.update_fulfill_htlcs[0].clone(), updates.commitment_signed.clone())
3677                 },
3678                 _ => panic!("Unexpected event"),
3679         };
3680
3681         if messages_delivered >= 1 {
3682                 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_htlc);
3683
3684                 let events_4 = nodes[0].node.get_and_clear_pending_events();
3685                 assert_eq!(events_4.len(), 1);
3686                 match events_4[0] {
3687                         Event::PaymentSent { ref payment_preimage } => {
3688                                 assert_eq!(payment_preimage_1, *payment_preimage);
3689                         },
3690                         _ => panic!("Unexpected event"),
3691                 }
3692
3693                 if messages_delivered >= 2 {
3694                         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed);
3695                         check_added_monitors!(nodes[0], 1);
3696                         let (as_revoke_and_ack, as_commitment_signed) = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
3697
3698                         if messages_delivered >= 3 {
3699                                 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack);
3700                                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
3701                                 check_added_monitors!(nodes[1], 1);
3702
3703                                 if messages_delivered >= 4 {
3704                                         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_commitment_signed);
3705                                         let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
3706                                         // No commitment_signed so get_event_msg's assert(len == 1) passes
3707                                         check_added_monitors!(nodes[1], 1);
3708
3709                                         if messages_delivered >= 5 {
3710                                                 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack);
3711                                                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
3712                                                 check_added_monitors!(nodes[0], 1);
3713                                         }
3714                                 }
3715                         }
3716                 }
3717         }
3718
3719         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3720         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3721         if messages_delivered < 2 {
3722                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (1, 0), (0, 0), (0, 0), (false, false));
3723                 //TODO: Deduplicate PaymentSent events, then enable this if:
3724                 //if messages_delivered < 1 {
3725                         let events_4 = nodes[0].node.get_and_clear_pending_events();
3726                         assert_eq!(events_4.len(), 1);
3727                         match events_4[0] {
3728                                 Event::PaymentSent { ref payment_preimage } => {
3729                                         assert_eq!(payment_preimage_1, *payment_preimage);
3730                                 },
3731                                 _ => panic!("Unexpected event"),
3732                         }
3733                 //}
3734         } else if messages_delivered == 2 {
3735                 // nodes[0] still wants its RAA + commitment_signed
3736                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, -1), (0, 0), (0, 0), (0, 0), (false, true));
3737         } else if messages_delivered == 3 {
3738                 // nodes[0] still wants its commitment_signed
3739                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, -1), (0, 0), (0, 0), (0, 0), (false, false));
3740         } else if messages_delivered == 4 {
3741                 // nodes[1] still wants its final RAA
3742                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (true, false));
3743         } else if messages_delivered == 5 {
3744                 // Everything was delivered...
3745                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3746         }
3747
3748         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3749         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3750         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3751
3752         // Channel should still work fine...
3753         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3754         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();
3755         let payment_preimage_2 = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000).0;
3756         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
3757 }
3758
3759 #[test]
3760 fn test_drop_messages_peer_disconnect_a() {
3761         do_test_drop_messages_peer_disconnect(0);
3762         do_test_drop_messages_peer_disconnect(1);
3763         do_test_drop_messages_peer_disconnect(2);
3764         do_test_drop_messages_peer_disconnect(3);
3765 }
3766
3767 #[test]
3768 fn test_drop_messages_peer_disconnect_b() {
3769         do_test_drop_messages_peer_disconnect(4);
3770         do_test_drop_messages_peer_disconnect(5);
3771         do_test_drop_messages_peer_disconnect(6);
3772 }
3773
3774 #[test]
3775 fn test_funding_peer_disconnect() {
3776         // Test that we can lock in our funding tx while disconnected
3777         let chanmon_cfgs = create_chanmon_cfgs(2);
3778         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
3779         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
3780         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
3781         let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
3782
3783         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3784         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3785
3786         confirm_transaction(&nodes[0].block_notifier, &nodes[0].chain_monitor, &tx, tx.version);
3787         let events_1 = nodes[0].node.get_and_clear_pending_msg_events();
3788         assert_eq!(events_1.len(), 1);
3789         match events_1[0] {
3790                 MessageSendEvent::SendFundingLocked { ref node_id, msg: _ } => {
3791                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
3792                 },
3793                 _ => panic!("Unexpected event"),
3794         }
3795
3796         reconnect_nodes(&nodes[0], &nodes[1], (false, true), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3797
3798         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3799         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3800
3801         confirm_transaction(&nodes[1].block_notifier, &nodes[1].chain_monitor, &tx, tx.version);
3802         let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
3803         assert_eq!(events_2.len(), 2);
3804         let funding_locked = match events_2[0] {
3805                 MessageSendEvent::SendFundingLocked { ref node_id, ref msg } => {
3806                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
3807                         msg.clone()
3808                 },
3809                 _ => panic!("Unexpected event"),
3810         };
3811         let bs_announcement_sigs = match events_2[1] {
3812                 MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } => {
3813                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
3814                         msg.clone()
3815                 },
3816                 _ => panic!("Unexpected event"),
3817         };
3818
3819         reconnect_nodes(&nodes[0], &nodes[1], (true, true), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3820
3821         nodes[0].node.handle_funding_locked(&nodes[1].node.get_our_node_id(), &funding_locked);
3822         nodes[0].node.handle_announcement_signatures(&nodes[1].node.get_our_node_id(), &bs_announcement_sigs);
3823         let events_3 = nodes[0].node.get_and_clear_pending_msg_events();
3824         assert_eq!(events_3.len(), 2);
3825         let as_announcement_sigs = match events_3[0] {
3826                 MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } => {
3827                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
3828                         msg.clone()
3829                 },
3830                 _ => panic!("Unexpected event"),
3831         };
3832         let (as_announcement, as_update) = match events_3[1] {
3833                 MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } => {
3834                         (msg.clone(), update_msg.clone())
3835                 },
3836                 _ => panic!("Unexpected event"),
3837         };
3838
3839         nodes[1].node.handle_announcement_signatures(&nodes[0].node.get_our_node_id(), &as_announcement_sigs);
3840         let events_4 = nodes[1].node.get_and_clear_pending_msg_events();
3841         assert_eq!(events_4.len(), 1);
3842         let (_, bs_update) = match events_4[0] {
3843                 MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } => {
3844                         (msg.clone(), update_msg.clone())
3845                 },
3846                 _ => panic!("Unexpected event"),
3847         };
3848
3849         nodes[0].net_graph_msg_handler.handle_channel_announcement(&as_announcement).unwrap();
3850         nodes[0].net_graph_msg_handler.handle_channel_update(&bs_update).unwrap();
3851         nodes[0].net_graph_msg_handler.handle_channel_update(&as_update).unwrap();
3852
3853         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3854         let logger = test_utils::TestLogger::new();
3855         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();
3856         let (payment_preimage, _) = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000);
3857         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage, 1_000_000);
3858 }
3859
3860 #[test]
3861 fn test_drop_messages_peer_disconnect_dual_htlc() {
3862         // Test that we can handle reconnecting when both sides of a channel have pending
3863         // commitment_updates when we disconnect.
3864         let chanmon_cfgs = create_chanmon_cfgs(2);
3865         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
3866         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
3867         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
3868         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3869         let logger = test_utils::TestLogger::new();
3870
3871         let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
3872
3873         // Now try to send a second payment which will fail to send
3874         let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
3875         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3876         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();
3877         nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap();
3878         check_added_monitors!(nodes[0], 1);
3879
3880         let events_1 = nodes[0].node.get_and_clear_pending_msg_events();
3881         assert_eq!(events_1.len(), 1);
3882         match events_1[0] {
3883                 MessageSendEvent::UpdateHTLCs { .. } => {},
3884                 _ => panic!("Unexpected event"),
3885         }
3886
3887         assert!(nodes[1].node.claim_funds(payment_preimage_1, &None, 1_000_000));
3888         check_added_monitors!(nodes[1], 1);
3889
3890         let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
3891         assert_eq!(events_2.len(), 1);
3892         match events_2[0] {
3893                 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 } } => {
3894                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
3895                         assert!(update_add_htlcs.is_empty());
3896                         assert_eq!(update_fulfill_htlcs.len(), 1);
3897                         assert!(update_fail_htlcs.is_empty());
3898                         assert!(update_fail_malformed_htlcs.is_empty());
3899                         assert!(update_fee.is_none());
3900
3901                         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_htlcs[0]);
3902                         let events_3 = nodes[0].node.get_and_clear_pending_events();
3903                         assert_eq!(events_3.len(), 1);
3904                         match events_3[0] {
3905                                 Event::PaymentSent { ref payment_preimage } => {
3906                                         assert_eq!(*payment_preimage, payment_preimage_1);
3907                                 },
3908                                 _ => panic!("Unexpected event"),
3909                         }
3910
3911                         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), commitment_signed);
3912                         let _ = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
3913                         // No commitment_signed so get_event_msg's assert(len == 1) passes
3914                         check_added_monitors!(nodes[0], 1);
3915                 },
3916                 _ => panic!("Unexpected event"),
3917         }
3918
3919         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3920         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3921
3922         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
3923         let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
3924         assert_eq!(reestablish_1.len(), 1);
3925         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
3926         let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
3927         assert_eq!(reestablish_2.len(), 1);
3928
3929         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
3930         let as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
3931         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
3932         let bs_resp = handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
3933
3934         assert!(as_resp.0.is_none());
3935         assert!(bs_resp.0.is_none());
3936
3937         assert!(bs_resp.1.is_none());
3938         assert!(bs_resp.2.is_none());
3939
3940         assert!(as_resp.3 == RAACommitmentOrder::CommitmentFirst);
3941
3942         assert_eq!(as_resp.2.as_ref().unwrap().update_add_htlcs.len(), 1);
3943         assert!(as_resp.2.as_ref().unwrap().update_fulfill_htlcs.is_empty());
3944         assert!(as_resp.2.as_ref().unwrap().update_fail_htlcs.is_empty());
3945         assert!(as_resp.2.as_ref().unwrap().update_fail_malformed_htlcs.is_empty());
3946         assert!(as_resp.2.as_ref().unwrap().update_fee.is_none());
3947         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &as_resp.2.as_ref().unwrap().update_add_htlcs[0]);
3948         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_resp.2.as_ref().unwrap().commitment_signed);
3949         let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
3950         // No commitment_signed so get_event_msg's assert(len == 1) passes
3951         check_added_monitors!(nodes[1], 1);
3952
3953         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), as_resp.1.as_ref().unwrap());
3954         let bs_second_commitment_signed = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
3955         assert!(bs_second_commitment_signed.update_add_htlcs.is_empty());
3956         assert!(bs_second_commitment_signed.update_fulfill_htlcs.is_empty());
3957         assert!(bs_second_commitment_signed.update_fail_htlcs.is_empty());
3958         assert!(bs_second_commitment_signed.update_fail_malformed_htlcs.is_empty());
3959         assert!(bs_second_commitment_signed.update_fee.is_none());
3960         check_added_monitors!(nodes[1], 1);
3961
3962         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack);
3963         let as_commitment_signed = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
3964         assert!(as_commitment_signed.update_add_htlcs.is_empty());
3965         assert!(as_commitment_signed.update_fulfill_htlcs.is_empty());
3966         assert!(as_commitment_signed.update_fail_htlcs.is_empty());
3967         assert!(as_commitment_signed.update_fail_malformed_htlcs.is_empty());
3968         assert!(as_commitment_signed.update_fee.is_none());
3969         check_added_monitors!(nodes[0], 1);
3970
3971         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_second_commitment_signed.commitment_signed);
3972         let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
3973         // No commitment_signed so get_event_msg's assert(len == 1) passes
3974         check_added_monitors!(nodes[0], 1);
3975
3976         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_commitment_signed.commitment_signed);
3977         let bs_second_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
3978         // No commitment_signed so get_event_msg's assert(len == 1) passes
3979         check_added_monitors!(nodes[1], 1);
3980
3981         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack);
3982         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
3983         check_added_monitors!(nodes[1], 1);
3984
3985         expect_pending_htlcs_forwardable!(nodes[1]);
3986
3987         let events_5 = nodes[1].node.get_and_clear_pending_events();
3988         assert_eq!(events_5.len(), 1);
3989         match events_5[0] {
3990                 Event::PaymentReceived { ref payment_hash, ref payment_secret, amt: _ } => {
3991                         assert_eq!(payment_hash_2, *payment_hash);
3992                         assert_eq!(*payment_secret, None);
3993                 },
3994                 _ => panic!("Unexpected event"),
3995         }
3996
3997         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_second_revoke_and_ack);
3998         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
3999         check_added_monitors!(nodes[0], 1);
4000
4001         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
4002 }
4003
4004 fn do_test_htlc_timeout(send_partial_mpp: bool) {
4005         // If the user fails to claim/fail an HTLC within the HTLC CLTV timeout we fail it for them
4006         // to avoid our counterparty failing the channel.
4007         let chanmon_cfgs = create_chanmon_cfgs(2);
4008         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4009         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4010         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4011
4012         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4013         let logger = test_utils::TestLogger::new();
4014
4015         let our_payment_hash = if send_partial_mpp {
4016                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
4017                 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();
4018                 let (_, our_payment_hash) = get_payment_preimage_hash!(&nodes[0]);
4019                 let payment_secret = PaymentSecret([0xdb; 32]);
4020                 // Use the utility function send_payment_along_path to send the payment with MPP data which
4021                 // indicates there are more HTLCs coming.
4022                 nodes[0].node.send_payment_along_path(&route.paths[0], &our_payment_hash, &Some(payment_secret), 200000, CHAN_CONFIRM_DEPTH).unwrap();
4023                 check_added_monitors!(nodes[0], 1);
4024                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
4025                 assert_eq!(events.len(), 1);
4026                 // Now do the relevant commitment_signed/RAA dances along the path, noting that the final
4027                 // hop should *not* yet generate any PaymentReceived event(s).
4028                 pass_along_path(&nodes[0], &[&nodes[1]], 100000, our_payment_hash, Some(payment_secret), events.drain(..).next().unwrap(), false);
4029                 our_payment_hash
4030         } else {
4031                 route_payment(&nodes[0], &[&nodes[1]], 100000).1
4032         };
4033
4034         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4035         nodes[0].block_notifier.block_connected_checked(&header, 101, &[], &[]);
4036         nodes[1].block_notifier.block_connected_checked(&header, 101, &[], &[]);
4037         for i in 102..TEST_FINAL_CLTV + 100 + 1 - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS {
4038                 header.prev_blockhash = header.bitcoin_hash();
4039                 nodes[0].block_notifier.block_connected_checked(&header, i, &[], &[]);
4040                 nodes[1].block_notifier.block_connected_checked(&header, i, &[], &[]);
4041         }
4042
4043         expect_pending_htlcs_forwardable!(nodes[1]);
4044
4045         check_added_monitors!(nodes[1], 1);
4046         let htlc_timeout_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
4047         assert!(htlc_timeout_updates.update_add_htlcs.is_empty());
4048         assert_eq!(htlc_timeout_updates.update_fail_htlcs.len(), 1);
4049         assert!(htlc_timeout_updates.update_fail_malformed_htlcs.is_empty());
4050         assert!(htlc_timeout_updates.update_fee.is_none());
4051
4052         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &htlc_timeout_updates.update_fail_htlcs[0]);
4053         commitment_signed_dance!(nodes[0], nodes[1], htlc_timeout_updates.commitment_signed, false);
4054         // 100_000 msat as u64, followed by a height of 123 as u32
4055         let mut expected_failure_data = byte_utils::be64_to_array(100_000).to_vec();
4056         expected_failure_data.extend_from_slice(&byte_utils::be32_to_array(123));
4057         expect_payment_failed!(nodes[0], our_payment_hash, true, 0x4000 | 15, &expected_failure_data[..]);
4058 }
4059
4060 #[test]
4061 fn test_htlc_timeout() {
4062         do_test_htlc_timeout(true);
4063         do_test_htlc_timeout(false);
4064 }
4065
4066 fn do_test_holding_cell_htlc_add_timeouts(forwarded_htlc: bool) {
4067         // Tests that HTLCs in the holding cell are timed out after the requisite number of blocks.
4068         let chanmon_cfgs = create_chanmon_cfgs(3);
4069         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
4070         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
4071         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
4072         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4073         create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
4074         let logger = test_utils::TestLogger::new();
4075
4076         // Route a first payment to get the 1 -> 2 channel in awaiting_raa...
4077         let (_, first_payment_hash) = get_payment_preimage_hash!(nodes[0]);
4078         {
4079                 let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
4080                 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();
4081                 nodes[1].node.send_payment(&route, first_payment_hash, &None).unwrap();
4082         }
4083         assert_eq!(nodes[1].node.get_and_clear_pending_msg_events().len(), 1);
4084         check_added_monitors!(nodes[1], 1);
4085
4086         // Now attempt to route a second payment, which should be placed in the holding cell
4087         let (_, second_payment_hash) = get_payment_preimage_hash!(nodes[0]);
4088         if forwarded_htlc {
4089                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
4090                 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();
4091                 nodes[0].node.send_payment(&route, second_payment_hash, &None).unwrap();
4092                 check_added_monitors!(nodes[0], 1);
4093                 let payment_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
4094                 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
4095                 commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
4096                 expect_pending_htlcs_forwardable!(nodes[1]);
4097                 check_added_monitors!(nodes[1], 0);
4098         } else {
4099                 let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
4100                 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();
4101                 nodes[1].node.send_payment(&route, second_payment_hash, &None).unwrap();
4102                 check_added_monitors!(nodes[1], 0);
4103         }
4104
4105         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4106         nodes[1].block_notifier.block_connected_checked(&header, 101, &[], &[]);
4107         for i in 102..TEST_FINAL_CLTV + 100 - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS {
4108                 header.prev_blockhash = header.bitcoin_hash();
4109                 nodes[1].block_notifier.block_connected_checked(&header, i, &[], &[]);
4110         }
4111
4112         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4113         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
4114
4115         header.prev_blockhash = header.bitcoin_hash();
4116         nodes[1].block_notifier.block_connected_checked(&header, TEST_FINAL_CLTV + 100 - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS, &[], &[]);
4117
4118         if forwarded_htlc {
4119                 expect_pending_htlcs_forwardable!(nodes[1]);
4120                 check_added_monitors!(nodes[1], 1);
4121                 let fail_commit = nodes[1].node.get_and_clear_pending_msg_events();
4122                 assert_eq!(fail_commit.len(), 1);
4123                 match fail_commit[0] {
4124                         MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fail_htlcs, ref commitment_signed, .. }, .. } => {
4125                                 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[0]);
4126                                 commitment_signed_dance!(nodes[0], nodes[1], commitment_signed, true, true);
4127                         },
4128                         _ => unreachable!(),
4129                 }
4130                 expect_payment_failed!(nodes[0], second_payment_hash, false);
4131                 if let &MessageSendEvent::PaymentFailureNetworkUpdate { ref update } = &nodes[0].node.get_and_clear_pending_msg_events()[0] {
4132                         match update {
4133                                 &HTLCFailChannelUpdate::ChannelUpdateMessage { .. } => {},
4134                                 _ => panic!("Unexpected event"),
4135                         }
4136                 } else {
4137                         panic!("Unexpected event");
4138                 }
4139         } else {
4140                 expect_payment_failed!(nodes[1], second_payment_hash, true);
4141         }
4142 }
4143
4144 #[test]
4145 fn test_holding_cell_htlc_add_timeouts() {
4146         do_test_holding_cell_htlc_add_timeouts(false);
4147         do_test_holding_cell_htlc_add_timeouts(true);
4148 }
4149
4150 #[test]
4151 fn test_invalid_channel_announcement() {
4152         //Test BOLT 7 channel_announcement msg requirement for final node, gather data to build customed channel_announcement msgs
4153         let secp_ctx = Secp256k1::new();
4154         let chanmon_cfgs = create_chanmon_cfgs(2);
4155         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4156         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4157         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4158
4159         let chan_announcement = create_chan_between_nodes(&nodes[0], &nodes[1], InitFeatures::known(), InitFeatures::known());
4160
4161         let a_channel_lock = nodes[0].node.channel_state.lock().unwrap();
4162         let b_channel_lock = nodes[1].node.channel_state.lock().unwrap();
4163         let as_chan = a_channel_lock.by_id.get(&chan_announcement.3).unwrap();
4164         let bs_chan = b_channel_lock.by_id.get(&chan_announcement.3).unwrap();
4165
4166         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 } );
4167
4168         let as_bitcoin_key = as_chan.get_local_keys().inner.local_channel_pubkeys.funding_pubkey;
4169         let bs_bitcoin_key = bs_chan.get_local_keys().inner.local_channel_pubkeys.funding_pubkey;
4170
4171         let as_network_key = nodes[0].node.get_our_node_id();
4172         let bs_network_key = nodes[1].node.get_our_node_id();
4173
4174         let were_node_one = as_bitcoin_key.serialize()[..] < bs_bitcoin_key.serialize()[..];
4175
4176         let mut chan_announcement;
4177
4178         macro_rules! dummy_unsigned_msg {
4179                 () => {
4180                         msgs::UnsignedChannelAnnouncement {
4181                                 features: ChannelFeatures::known(),
4182                                 chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
4183                                 short_channel_id: as_chan.get_short_channel_id().unwrap(),
4184                                 node_id_1: if were_node_one { as_network_key } else { bs_network_key },
4185                                 node_id_2: if were_node_one { bs_network_key } else { as_network_key },
4186                                 bitcoin_key_1: if were_node_one { as_bitcoin_key } else { bs_bitcoin_key },
4187                                 bitcoin_key_2: if were_node_one { bs_bitcoin_key } else { as_bitcoin_key },
4188                                 excess_data: Vec::new(),
4189                         };
4190                 }
4191         }
4192
4193         macro_rules! sign_msg {
4194                 ($unsigned_msg: expr) => {
4195                         let msghash = Message::from_slice(&Sha256dHash::hash(&$unsigned_msg.encode()[..])[..]).unwrap();
4196                         let as_bitcoin_sig = secp_ctx.sign(&msghash, &as_chan.get_local_keys().inner.funding_key);
4197                         let bs_bitcoin_sig = secp_ctx.sign(&msghash, &bs_chan.get_local_keys().inner.funding_key);
4198                         let as_node_sig = secp_ctx.sign(&msghash, &nodes[0].keys_manager.get_node_secret());
4199                         let bs_node_sig = secp_ctx.sign(&msghash, &nodes[1].keys_manager.get_node_secret());
4200                         chan_announcement = msgs::ChannelAnnouncement {
4201                                 node_signature_1 : if were_node_one { as_node_sig } else { bs_node_sig},
4202                                 node_signature_2 : if were_node_one { bs_node_sig } else { as_node_sig},
4203                                 bitcoin_signature_1: if were_node_one { as_bitcoin_sig } else { bs_bitcoin_sig },
4204                                 bitcoin_signature_2 : if were_node_one { bs_bitcoin_sig } else { as_bitcoin_sig },
4205                                 contents: $unsigned_msg
4206                         }
4207                 }
4208         }
4209
4210         let unsigned_msg = dummy_unsigned_msg!();
4211         sign_msg!(unsigned_msg);
4212         assert_eq!(nodes[0].net_graph_msg_handler.handle_channel_announcement(&chan_announcement).unwrap(), true);
4213         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 } );
4214
4215         // Configured with Network::Testnet
4216         let mut unsigned_msg = dummy_unsigned_msg!();
4217         unsigned_msg.chain_hash = genesis_block(Network::Bitcoin).header.bitcoin_hash();
4218         sign_msg!(unsigned_msg);
4219         assert!(nodes[0].net_graph_msg_handler.handle_channel_announcement(&chan_announcement).is_err());
4220
4221         let mut unsigned_msg = dummy_unsigned_msg!();
4222         unsigned_msg.chain_hash = BlockHash::hash(&[1,2,3,4,5,6,7,8,9]);
4223         sign_msg!(unsigned_msg);
4224         assert!(nodes[0].net_graph_msg_handler.handle_channel_announcement(&chan_announcement).is_err());
4225 }
4226
4227 #[test]
4228 fn test_no_txn_manager_serialize_deserialize() {
4229         let chanmon_cfgs = create_chanmon_cfgs(2);
4230         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4231         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4232         let logger: test_utils::TestLogger;
4233         let fee_estimator: test_utils::TestFeeEstimator;
4234         let new_chan_monitor: test_utils::TestChannelMonitor;
4235         let keys_manager: test_utils::TestKeysInterface;
4236         let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>;
4237         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4238
4239         let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
4240
4241         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4242
4243         let nodes_0_serialized = nodes[0].node.encode();
4244         let mut chan_0_monitor_serialized = test_utils::TestVecWriter(Vec::new());
4245         nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter().next().unwrap().1.write_for_disk(&mut chan_0_monitor_serialized).unwrap();
4246
4247         logger = test_utils::TestLogger::new();
4248         fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
4249         new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), &logger, &fee_estimator);
4250         nodes[0].chan_monitor = &new_chan_monitor;
4251         let mut chan_0_monitor_read = &chan_0_monitor_serialized.0[..];
4252         let (_, mut chan_0_monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut chan_0_monitor_read).unwrap();
4253         assert!(chan_0_monitor_read.is_empty());
4254
4255         let mut nodes_0_read = &nodes_0_serialized[..];
4256         let config = UserConfig::default();
4257         keys_manager = test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet);
4258         let (_, nodes_0_deserialized_tmp) = {
4259                 let mut channel_monitors = HashMap::new();
4260                 channel_monitors.insert(chan_0_monitor.get_funding_txo().0, &mut chan_0_monitor);
4261                 <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
4262                         default_config: config,
4263                         keys_manager: &keys_manager,
4264                         fee_estimator: &fee_estimator,
4265                         monitor: nodes[0].chan_monitor,
4266                         tx_broadcaster: nodes[0].tx_broadcaster.clone(),
4267                         logger: &logger,
4268                         channel_monitors: &mut channel_monitors,
4269                 }).unwrap()
4270         };
4271         nodes_0_deserialized = nodes_0_deserialized_tmp;
4272         assert!(nodes_0_read.is_empty());
4273
4274         assert!(nodes[0].chan_monitor.add_monitor(chan_0_monitor.get_funding_txo().0, chan_0_monitor).is_ok());
4275         nodes[0].node = &nodes_0_deserialized;
4276         nodes[0].block_notifier.register_listener(nodes[0].node);
4277         assert_eq!(nodes[0].node.list_channels().len(), 1);
4278         check_added_monitors!(nodes[0], 1);
4279
4280         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
4281         let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
4282         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
4283         let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
4284
4285         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
4286         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4287         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
4288         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
4289
4290         let (funding_locked, _) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
4291         let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked);
4292         for node in nodes.iter() {
4293                 assert!(node.net_graph_msg_handler.handle_channel_announcement(&announcement).unwrap());
4294                 node.net_graph_msg_handler.handle_channel_update(&as_update).unwrap();
4295                 node.net_graph_msg_handler.handle_channel_update(&bs_update).unwrap();
4296         }
4297
4298         send_payment(&nodes[0], &[&nodes[1]], 1000000, 1_000_000);
4299 }
4300
4301 #[test]
4302 fn test_manager_serialize_deserialize_events() {
4303         // This test makes sure the events field in ChannelManager survives de/serialization
4304         let chanmon_cfgs = create_chanmon_cfgs(2);
4305         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4306         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4307         let fee_estimator: test_utils::TestFeeEstimator;
4308         let logger: test_utils::TestLogger;
4309         let new_chan_monitor: test_utils::TestChannelMonitor;
4310         let keys_manager: test_utils::TestKeysInterface;
4311         let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>;
4312         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4313
4314         // Start creating a channel, but stop right before broadcasting the event message FundingBroadcastSafe
4315         let channel_value = 100000;
4316         let push_msat = 10001;
4317         let a_flags = InitFeatures::known();
4318         let b_flags = InitFeatures::known();
4319         let node_a = nodes.pop().unwrap();
4320         let node_b = nodes.pop().unwrap();
4321         node_a.node.create_channel(node_b.node.get_our_node_id(), channel_value, push_msat, 42, None).unwrap();
4322         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()));
4323         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()));
4324
4325         let (temporary_channel_id, tx, funding_output) = create_funding_transaction(&node_a, channel_value, 42);
4326
4327         node_a.node.funding_transaction_generated(&temporary_channel_id, funding_output);
4328         check_added_monitors!(node_a, 0);
4329
4330         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()));
4331         {
4332                 let mut added_monitors = node_b.chan_monitor.added_monitors.lock().unwrap();
4333                 assert_eq!(added_monitors.len(), 1);
4334                 assert_eq!(added_monitors[0].0, funding_output);
4335                 added_monitors.clear();
4336         }
4337
4338         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()));
4339         {
4340                 let mut added_monitors = node_a.chan_monitor.added_monitors.lock().unwrap();
4341                 assert_eq!(added_monitors.len(), 1);
4342                 assert_eq!(added_monitors[0].0, funding_output);
4343                 added_monitors.clear();
4344         }
4345         // Normally, this is where node_a would check for a FundingBroadcastSafe event, but the test de/serializes first instead
4346
4347         nodes.push(node_a);
4348         nodes.push(node_b);
4349
4350         // Start the de/seriailization process mid-channel creation to check that the channel manager will hold onto events that are serialized
4351         let nodes_0_serialized = nodes[0].node.encode();
4352         let mut chan_0_monitor_serialized = test_utils::TestVecWriter(Vec::new());
4353         nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter().next().unwrap().1.write_for_disk(&mut chan_0_monitor_serialized).unwrap();
4354
4355         fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
4356         logger = test_utils::TestLogger::new();
4357         new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), &logger, &fee_estimator);
4358         nodes[0].chan_monitor = &new_chan_monitor;
4359         let mut chan_0_monitor_read = &chan_0_monitor_serialized.0[..];
4360         let (_, mut chan_0_monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut chan_0_monitor_read).unwrap();
4361         assert!(chan_0_monitor_read.is_empty());
4362
4363         let mut nodes_0_read = &nodes_0_serialized[..];
4364         let config = UserConfig::default();
4365         keys_manager = test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet);
4366         let (_, nodes_0_deserialized_tmp) = {
4367                 let mut channel_monitors = HashMap::new();
4368                 channel_monitors.insert(chan_0_monitor.get_funding_txo().0, &mut chan_0_monitor);
4369                 <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
4370                         default_config: config,
4371                         keys_manager: &keys_manager,
4372                         fee_estimator: &fee_estimator,
4373                         monitor: nodes[0].chan_monitor,
4374                         tx_broadcaster: nodes[0].tx_broadcaster.clone(),
4375                         logger: &logger,
4376                         channel_monitors: &mut channel_monitors,
4377                 }).unwrap()
4378         };
4379         nodes_0_deserialized = nodes_0_deserialized_tmp;
4380         assert!(nodes_0_read.is_empty());
4381
4382         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4383
4384         assert!(nodes[0].chan_monitor.add_monitor(chan_0_monitor.get_funding_txo().0, chan_0_monitor).is_ok());
4385         nodes[0].node = &nodes_0_deserialized;
4386
4387         // After deserializing, make sure the FundingBroadcastSafe event is still held by the channel manager
4388         let events_4 = nodes[0].node.get_and_clear_pending_events();
4389         assert_eq!(events_4.len(), 1);
4390         match events_4[0] {
4391                 Event::FundingBroadcastSafe { ref funding_txo, user_channel_id } => {
4392                         assert_eq!(user_channel_id, 42);
4393                         assert_eq!(*funding_txo, funding_output);
4394                 },
4395                 _ => panic!("Unexpected event"),
4396         };
4397
4398         // Make sure the channel is functioning as though the de/serialization never happened
4399         nodes[0].block_notifier.register_listener(nodes[0].node);
4400         assert_eq!(nodes[0].node.list_channels().len(), 1);
4401         check_added_monitors!(nodes[0], 1);
4402
4403         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
4404         let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
4405         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
4406         let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
4407
4408         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
4409         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4410         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
4411         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
4412
4413         let (funding_locked, _) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
4414         let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked);
4415         for node in nodes.iter() {
4416                 assert!(node.net_graph_msg_handler.handle_channel_announcement(&announcement).unwrap());
4417                 node.net_graph_msg_handler.handle_channel_update(&as_update).unwrap();
4418                 node.net_graph_msg_handler.handle_channel_update(&bs_update).unwrap();
4419         }
4420
4421         send_payment(&nodes[0], &[&nodes[1]], 1000000, 1_000_000);
4422 }
4423
4424 #[test]
4425 fn test_simple_manager_serialize_deserialize() {
4426         let chanmon_cfgs = create_chanmon_cfgs(2);
4427         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4428         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4429         let logger: test_utils::TestLogger;
4430         let fee_estimator: test_utils::TestFeeEstimator;
4431         let new_chan_monitor: test_utils::TestChannelMonitor;
4432         let keys_manager: test_utils::TestKeysInterface;
4433         let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>;
4434         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4435         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4436
4437         let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
4438         let (_, our_payment_hash) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
4439
4440         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4441
4442         let nodes_0_serialized = nodes[0].node.encode();
4443         let mut chan_0_monitor_serialized = test_utils::TestVecWriter(Vec::new());
4444         nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter().next().unwrap().1.write_for_disk(&mut chan_0_monitor_serialized).unwrap();
4445
4446         logger = test_utils::TestLogger::new();
4447         fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
4448         new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), &logger, &fee_estimator);
4449         nodes[0].chan_monitor = &new_chan_monitor;
4450         let mut chan_0_monitor_read = &chan_0_monitor_serialized.0[..];
4451         let (_, mut chan_0_monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut chan_0_monitor_read).unwrap();
4452         assert!(chan_0_monitor_read.is_empty());
4453
4454         let mut nodes_0_read = &nodes_0_serialized[..];
4455         keys_manager = test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet);
4456         let (_, nodes_0_deserialized_tmp) = {
4457                 let mut channel_monitors = HashMap::new();
4458                 channel_monitors.insert(chan_0_monitor.get_funding_txo().0, &mut chan_0_monitor);
4459                 <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
4460                         default_config: UserConfig::default(),
4461                         keys_manager: &keys_manager,
4462                         fee_estimator: &fee_estimator,
4463                         monitor: nodes[0].chan_monitor,
4464                         tx_broadcaster: nodes[0].tx_broadcaster.clone(),
4465                         logger: &logger,
4466                         channel_monitors: &mut channel_monitors,
4467                 }).unwrap()
4468         };
4469         nodes_0_deserialized = nodes_0_deserialized_tmp;
4470         assert!(nodes_0_read.is_empty());
4471
4472         assert!(nodes[0].chan_monitor.add_monitor(chan_0_monitor.get_funding_txo().0, chan_0_monitor).is_ok());
4473         nodes[0].node = &nodes_0_deserialized;
4474         check_added_monitors!(nodes[0], 1);
4475
4476         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
4477
4478         fail_payment(&nodes[0], &[&nodes[1]], our_payment_hash);
4479         claim_payment(&nodes[0], &[&nodes[1]], our_payment_preimage, 1_000_000);
4480 }
4481
4482 #[test]
4483 fn test_manager_serialize_deserialize_inconsistent_monitor() {
4484         // Test deserializing a ChannelManager with an out-of-date ChannelMonitor
4485         let chanmon_cfgs = create_chanmon_cfgs(4);
4486         let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
4487         let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
4488         let logger: test_utils::TestLogger;
4489         let fee_estimator: test_utils::TestFeeEstimator;
4490         let new_chan_monitor: test_utils::TestChannelMonitor;
4491         let keys_manager: test_utils::TestKeysInterface;
4492         let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>;
4493         let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
4494         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4495         create_announced_chan_between_nodes(&nodes, 2, 0, InitFeatures::known(), InitFeatures::known());
4496         let (_, _, channel_id, funding_tx) = create_announced_chan_between_nodes(&nodes, 0, 3, InitFeatures::known(), InitFeatures::known());
4497
4498         let mut node_0_stale_monitors_serialized = Vec::new();
4499         for monitor in nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter() {
4500                 let mut writer = test_utils::TestVecWriter(Vec::new());
4501                 monitor.1.write_for_disk(&mut writer).unwrap();
4502                 node_0_stale_monitors_serialized.push(writer.0);
4503         }
4504
4505         let (our_payment_preimage, _) = route_payment(&nodes[2], &[&nodes[0], &nodes[1]], 1000000);
4506
4507         // Serialize the ChannelManager here, but the monitor we keep up-to-date
4508         let nodes_0_serialized = nodes[0].node.encode();
4509
4510         route_payment(&nodes[0], &[&nodes[3]], 1000000);
4511         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4512         nodes[2].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4513         nodes[3].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4514
4515         // Now the ChannelMonitor (which is now out-of-sync with ChannelManager for channel w/
4516         // nodes[3])
4517         let mut node_0_monitors_serialized = Vec::new();
4518         for monitor in nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter() {
4519                 let mut writer = test_utils::TestVecWriter(Vec::new());
4520                 monitor.1.write_for_disk(&mut writer).unwrap();
4521                 node_0_monitors_serialized.push(writer.0);
4522         }
4523
4524         logger = test_utils::TestLogger::new();
4525         fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
4526         new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), &logger, &fee_estimator);
4527         nodes[0].chan_monitor = &new_chan_monitor;
4528
4529         let mut node_0_stale_monitors = Vec::new();
4530         for serialized in node_0_stale_monitors_serialized.iter() {
4531                 let mut read = &serialized[..];
4532                 let (_, monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut read).unwrap();
4533                 assert!(read.is_empty());
4534                 node_0_stale_monitors.push(monitor);
4535         }
4536
4537         let mut node_0_monitors = Vec::new();
4538         for serialized in node_0_monitors_serialized.iter() {
4539                 let mut read = &serialized[..];
4540                 let (_, monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut read).unwrap();
4541                 assert!(read.is_empty());
4542                 node_0_monitors.push(monitor);
4543         }
4544
4545         keys_manager = test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet);
4546
4547         let mut nodes_0_read = &nodes_0_serialized[..];
4548         if let Err(msgs::DecodeError::InvalidValue) =
4549                 <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
4550                 default_config: UserConfig::default(),
4551                 keys_manager: &keys_manager,
4552                 fee_estimator: &fee_estimator,
4553                 monitor: nodes[0].chan_monitor,
4554                 tx_broadcaster: nodes[0].tx_broadcaster.clone(),
4555                 logger: &logger,
4556                 channel_monitors: &mut node_0_stale_monitors.iter_mut().map(|monitor| { (monitor.get_funding_txo().0, monitor) }).collect(),
4557         }) { } else {
4558                 panic!("If the monitor(s) are stale, this indicates a bug and we should get an Err return");
4559         };
4560
4561         let mut nodes_0_read = &nodes_0_serialized[..];
4562         let (_, nodes_0_deserialized_tmp) =
4563                 <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
4564                 default_config: UserConfig::default(),
4565                 keys_manager: &keys_manager,
4566                 fee_estimator: &fee_estimator,
4567                 monitor: nodes[0].chan_monitor,
4568                 tx_broadcaster: nodes[0].tx_broadcaster.clone(),
4569                 logger: &logger,
4570                 channel_monitors: &mut node_0_monitors.iter_mut().map(|monitor| { (monitor.get_funding_txo().0, monitor) }).collect(),
4571         }).unwrap();
4572         nodes_0_deserialized = nodes_0_deserialized_tmp;
4573         assert!(nodes_0_read.is_empty());
4574
4575         { // Channel close should result in a commitment tx and an HTLC tx
4576                 let txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
4577                 assert_eq!(txn.len(), 2);
4578                 assert_eq!(txn[0].input[0].previous_output.txid, funding_tx.txid());
4579                 assert_eq!(txn[1].input[0].previous_output.txid, txn[0].txid());
4580         }
4581
4582         for monitor in node_0_monitors.drain(..) {
4583                 assert!(nodes[0].chan_monitor.add_monitor(monitor.get_funding_txo().0, monitor).is_ok());
4584                 check_added_monitors!(nodes[0], 1);
4585         }
4586         nodes[0].node = &nodes_0_deserialized;
4587
4588         // nodes[1] and nodes[2] have no lost state with nodes[0]...
4589         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
4590         reconnect_nodes(&nodes[0], &nodes[2], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
4591         //... and we can even still claim the payment!
4592         claim_payment(&nodes[2], &[&nodes[0], &nodes[1]], our_payment_preimage, 1_000_000);
4593
4594         nodes[3].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
4595         let reestablish = get_event_msg!(nodes[3], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
4596         nodes[0].node.peer_connected(&nodes[3].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
4597         nodes[0].node.handle_channel_reestablish(&nodes[3].node.get_our_node_id(), &reestablish);
4598         let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
4599         assert_eq!(msg_events.len(), 1);
4600         if let MessageSendEvent::HandleError { ref action, .. } = msg_events[0] {
4601                 match action {
4602                         &ErrorAction::SendErrorMessage { ref msg } => {
4603                                 assert_eq!(msg.channel_id, channel_id);
4604                         },
4605                         _ => panic!("Unexpected event!"),
4606                 }
4607         }
4608 }
4609
4610 macro_rules! check_spendable_outputs {
4611         ($node: expr, $der_idx: expr, $keysinterface: expr, $chan_value: expr) => {
4612                 {
4613                         let events = $node.chan_monitor.simple_monitor.get_and_clear_pending_events();
4614                         let mut txn = Vec::new();
4615                         for event in events {
4616                                 match event {
4617                                         Event::SpendableOutputs { ref outputs } => {
4618                                                 for outp in outputs {
4619                                                         match *outp {
4620                                                                 SpendableOutputDescriptor::StaticOutputRemotePayment { ref outpoint, ref output, ref key_derivation_params } => {
4621                                                                         let input = TxIn {
4622                                                                                 previous_output: outpoint.clone(),
4623                                                                                 script_sig: Script::new(),
4624                                                                                 sequence: 0,
4625                                                                                 witness: Vec::new(),
4626                                                                         };
4627                                                                         let outp = TxOut {
4628                                                                                 script_pubkey: Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(),
4629                                                                                 value: output.value,
4630                                                                         };
4631                                                                         let mut spend_tx = Transaction {
4632                                                                                 version: 2,
4633                                                                                 lock_time: 0,
4634                                                                                 input: vec![input],
4635                                                                                 output: vec![outp],
4636                                                                         };
4637                                                                         let secp_ctx = Secp256k1::new();
4638                                                                         let keys = $keysinterface.derive_channel_keys($chan_value, key_derivation_params.0, key_derivation_params.1);
4639                                                                         let remotepubkey = keys.pubkeys().payment_point;
4640                                                                         let witness_script = Address::p2pkh(&::bitcoin::PublicKey{compressed: true, key: remotepubkey}, Network::Testnet).script_pubkey();
4641                                                                         let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], &witness_script, output.value)[..]).unwrap();
4642                                                                         let remotesig = secp_ctx.sign(&sighash, &keys.inner.payment_key);
4643                                                                         spend_tx.input[0].witness.push(remotesig.serialize_der().to_vec());
4644                                                                         spend_tx.input[0].witness[0].push(SigHashType::All as u8);
4645                                                                         spend_tx.input[0].witness.push(remotepubkey.serialize().to_vec());
4646                                                                         txn.push(spend_tx);
4647                                                                 },
4648                                                                 SpendableOutputDescriptor::DynamicOutputP2WSH { ref outpoint, ref per_commitment_point, ref to_self_delay, ref output, ref key_derivation_params, ref remote_revocation_pubkey } => {
4649                                                                         let input = TxIn {
4650                                                                                 previous_output: outpoint.clone(),
4651                                                                                 script_sig: Script::new(),
4652                                                                                 sequence: *to_self_delay as u32,
4653                                                                                 witness: Vec::new(),
4654                                                                         };
4655                                                                         let outp = TxOut {
4656                                                                                 script_pubkey: Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(),
4657                                                                                 value: output.value,
4658                                                                         };
4659                                                                         let mut spend_tx = Transaction {
4660                                                                                 version: 2,
4661                                                                                 lock_time: 0,
4662                                                                                 input: vec![input],
4663                                                                                 output: vec![outp],
4664                                                                         };
4665                                                                         let secp_ctx = Secp256k1::new();
4666                                                                         let keys = $keysinterface.derive_channel_keys($chan_value, key_derivation_params.0, key_derivation_params.1);
4667                                                                         if let Ok(delayed_payment_key) = chan_utils::derive_private_key(&secp_ctx, &per_commitment_point, &keys.inner.delayed_payment_base_key) {
4668
4669                                                                                 let delayed_payment_pubkey = PublicKey::from_secret_key(&secp_ctx, &delayed_payment_key);
4670                                                                                 let witness_script = chan_utils::get_revokeable_redeemscript(remote_revocation_pubkey, *to_self_delay, &delayed_payment_pubkey);
4671                                                                                 let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], &witness_script, output.value)[..]).unwrap();
4672                                                                                 let local_delayedsig = secp_ctx.sign(&sighash, &delayed_payment_key);
4673                                                                                 spend_tx.input[0].witness.push(local_delayedsig.serialize_der().to_vec());
4674                                                                                 spend_tx.input[0].witness[0].push(SigHashType::All as u8);
4675                                                                                 spend_tx.input[0].witness.push(vec!()); //MINIMALIF
4676                                                                                 spend_tx.input[0].witness.push(witness_script.clone().into_bytes());
4677                                                                         } else { panic!() }
4678                                                                         txn.push(spend_tx);
4679                                                                 },
4680                                                                 SpendableOutputDescriptor::StaticOutput { ref outpoint, ref output } => {
4681                                                                         let secp_ctx = Secp256k1::new();
4682                                                                         let input = TxIn {
4683                                                                                 previous_output: outpoint.clone(),
4684                                                                                 script_sig: Script::new(),
4685                                                                                 sequence: 0,
4686                                                                                 witness: Vec::new(),
4687                                                                         };
4688                                                                         let outp = TxOut {
4689                                                                                 script_pubkey: Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(),
4690                                                                                 value: output.value,
4691                                                                         };
4692                                                                         let mut spend_tx = Transaction {
4693                                                                                 version: 2,
4694                                                                                 lock_time: 0,
4695                                                                                 input: vec![input],
4696                                                                                 output: vec![outp.clone()],
4697                                                                         };
4698                                                                         let secret = {
4699                                                                                 match ExtendedPrivKey::new_master(Network::Testnet, &$node.node_seed) {
4700                                                                                         Ok(master_key) => {
4701                                                                                                 match master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx($der_idx).expect("key space exhausted")) {
4702                                                                                                         Ok(key) => key,
4703                                                                                                         Err(_) => panic!("Your RNG is busted"),
4704                                                                                                 }
4705                                                                                         }
4706                                                                                         Err(_) => panic!("Your rng is busted"),
4707                                                                                 }
4708                                                                         };
4709                                                                         let pubkey = ExtendedPubKey::from_private(&secp_ctx, &secret).public_key;
4710                                                                         let witness_script = Address::p2pkh(&pubkey, Network::Testnet).script_pubkey();
4711                                                                         let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], &witness_script, output.value)[..]).unwrap();
4712                                                                         let sig = secp_ctx.sign(&sighash, &secret.private_key.key);
4713                                                                         spend_tx.input[0].witness.push(sig.serialize_der().to_vec());
4714                                                                         spend_tx.input[0].witness[0].push(SigHashType::All as u8);
4715                                                                         spend_tx.input[0].witness.push(pubkey.key.serialize().to_vec());
4716                                                                         txn.push(spend_tx);
4717                                                                 },
4718                                                         }
4719                                                 }
4720                                         },
4721                                         _ => panic!("Unexpected event"),
4722                                 };
4723                         }
4724                         txn
4725                 }
4726         }
4727 }
4728
4729 #[test]
4730 fn test_claim_sizeable_push_msat() {
4731         // Incidentally test SpendableOutput event generation due to detection of to_local output on commitment tx
4732         let chanmon_cfgs = create_chanmon_cfgs(2);
4733         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4734         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4735         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4736
4737         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 99000000, InitFeatures::known(), InitFeatures::known());
4738         nodes[1].node.force_close_channel(&chan.2);
4739         check_closed_broadcast!(nodes[1], false);
4740         check_added_monitors!(nodes[1], 1);
4741         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
4742         assert_eq!(node_txn.len(), 1);
4743         check_spends!(node_txn[0], chan.3);
4744         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
4745
4746         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4747         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()] }, 0);
4748         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
4749
4750         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
4751         assert_eq!(spend_txn.len(), 1);
4752         check_spends!(spend_txn[0], node_txn[0]);
4753 }
4754
4755 #[test]
4756 fn test_claim_on_remote_sizeable_push_msat() {
4757         // Same test as previous, just test on remote commitment tx, as per_commitment_point registration changes following you're funder/fundee and
4758         // to_remote output is encumbered by a P2WPKH
4759         let chanmon_cfgs = create_chanmon_cfgs(2);
4760         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4761         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4762         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4763
4764         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 99000000, InitFeatures::known(), InitFeatures::known());
4765         nodes[0].node.force_close_channel(&chan.2);
4766         check_closed_broadcast!(nodes[0], false);
4767         check_added_monitors!(nodes[0], 1);
4768
4769         let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
4770         assert_eq!(node_txn.len(), 1);
4771         check_spends!(node_txn[0], chan.3);
4772         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
4773
4774         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4775         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()] }, 0);
4776         check_closed_broadcast!(nodes[1], false);
4777         check_added_monitors!(nodes[1], 1);
4778         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
4779
4780         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
4781         assert_eq!(spend_txn.len(), 2);
4782         assert_eq!(spend_txn[0], spend_txn[1]);
4783         check_spends!(spend_txn[0], node_txn[0]);
4784 }
4785
4786 #[test]
4787 fn test_claim_on_remote_revoked_sizeable_push_msat() {
4788         // Same test as previous, just test on remote revoked commitment tx, as per_commitment_point registration changes following you're funder/fundee and
4789         // to_remote output is encumbered by a P2WPKH
4790
4791         let chanmon_cfgs = create_chanmon_cfgs(2);
4792         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4793         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4794         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4795
4796         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 59000000, InitFeatures::known(), InitFeatures::known());
4797         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
4798         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan.2);
4799         assert_eq!(revoked_local_txn[0].input.len(), 1);
4800         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
4801
4802         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
4803         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4804         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 0);
4805         check_closed_broadcast!(nodes[1], false);
4806         check_added_monitors!(nodes[1], 1);
4807
4808         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
4809         let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4810         nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1);
4811         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
4812
4813         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
4814         assert_eq!(spend_txn.len(), 3);
4815         assert_eq!(spend_txn[0], spend_txn[1]); // to_remote output on revoked remote commitment_tx
4816         check_spends!(spend_txn[0], revoked_local_txn[0]);
4817         check_spends!(spend_txn[2], node_txn[0]);
4818 }
4819
4820 #[test]
4821 fn test_static_spendable_outputs_preimage_tx() {
4822         let chanmon_cfgs = create_chanmon_cfgs(2);
4823         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4824         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4825         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4826
4827         // Create some initial channels
4828         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4829
4830         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
4831
4832         let commitment_tx = get_local_commitment_txn!(nodes[0], chan_1.2);
4833         assert_eq!(commitment_tx[0].input.len(), 1);
4834         assert_eq!(commitment_tx[0].input[0].previous_output.txid, chan_1.3.txid());
4835
4836         // Settle A's commitment tx on B's chain
4837         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4838         assert!(nodes[1].node.claim_funds(payment_preimage, &None, 3_000_000));
4839         check_added_monitors!(nodes[1], 1);
4840         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()] }, 1);
4841         check_added_monitors!(nodes[1], 1);
4842         let events = nodes[1].node.get_and_clear_pending_msg_events();
4843         match events[0] {
4844                 MessageSendEvent::UpdateHTLCs { .. } => {},
4845                 _ => panic!("Unexpected event"),
4846         }
4847         match events[1] {
4848                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
4849                 _ => panic!("Unexepected event"),
4850         }
4851
4852         // Check B's monitor was able to send back output descriptor event for preimage tx on A's commitment tx
4853         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); // ChannelManager : 2 (local commitment tx + HTLC-Success), ChannelMonitor: preimage tx
4854         assert_eq!(node_txn.len(), 3);
4855         check_spends!(node_txn[0], commitment_tx[0]);
4856         assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
4857         check_spends!(node_txn[1], chan_1.3);
4858         check_spends!(node_txn[2], node_txn[1]);
4859
4860         let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4861         nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1);
4862         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
4863
4864         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
4865         assert_eq!(spend_txn.len(), 1);
4866         check_spends!(spend_txn[0], node_txn[0]);
4867 }
4868
4869 #[test]
4870 fn test_static_spendable_outputs_timeout_tx() {
4871         let chanmon_cfgs = create_chanmon_cfgs(2);
4872         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4873         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4874         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4875
4876         // Create some initial channels
4877         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4878
4879         // Rebalance the network a bit by relaying one payment through all the channels ...
4880         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
4881
4882         let (_, our_payment_hash) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000);
4883
4884         let commitment_tx = get_local_commitment_txn!(nodes[0], chan_1.2);
4885         assert_eq!(commitment_tx[0].input.len(), 1);
4886         assert_eq!(commitment_tx[0].input[0].previous_output.txid, chan_1.3.txid());
4887
4888         // Settle A's commitment tx on B' chain
4889         let header = BlockHeader { version: 0x2000_0000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
4890         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()] }, 0);
4891         check_added_monitors!(nodes[1], 1);
4892         let events = nodes[1].node.get_and_clear_pending_msg_events();
4893         match events[0] {
4894                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
4895                 _ => panic!("Unexpected event"),
4896         }
4897
4898         // Check B's monitor was able to send back output descriptor event for timeout tx on A's commitment tx
4899         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
4900         assert_eq!(node_txn.len(), 3); // ChannelManager : 2 (local commitent tx + HTLC-timeout), ChannelMonitor: timeout tx
4901         check_spends!(node_txn[0],  commitment_tx[0].clone());
4902         assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
4903         check_spends!(node_txn[1], chan_1.3.clone());
4904         check_spends!(node_txn[2], node_txn[1]);
4905
4906         let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4907         nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1);
4908         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
4909         expect_payment_failed!(nodes[1], our_payment_hash, true);
4910
4911         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
4912         assert_eq!(spend_txn.len(), 3); // SpendableOutput: remote_commitment_tx.to_remote (*2), timeout_tx.output (*1)
4913         check_spends!(spend_txn[2], node_txn[0].clone());
4914 }
4915
4916 #[test]
4917 fn test_static_spendable_outputs_justice_tx_revoked_commitment_tx() {
4918         let chanmon_cfgs = create_chanmon_cfgs(2);
4919         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4920         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4921         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4922
4923         // Create some initial channels
4924         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4925
4926         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
4927         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
4928         assert_eq!(revoked_local_txn[0].input.len(), 1);
4929         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
4930
4931         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
4932
4933         let  header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4934         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 0);
4935         check_closed_broadcast!(nodes[1], false);
4936         check_added_monitors!(nodes[1], 1);
4937
4938         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
4939         assert_eq!(node_txn.len(), 2);
4940         assert_eq!(node_txn[0].input.len(), 2);
4941         check_spends!(node_txn[0], revoked_local_txn[0]);
4942
4943         let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4944         nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1);
4945         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
4946
4947         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
4948         assert_eq!(spend_txn.len(), 1);
4949         check_spends!(spend_txn[0], node_txn[0]);
4950 }
4951
4952 #[test]
4953 fn test_static_spendable_outputs_justice_tx_revoked_htlc_timeout_tx() {
4954         let chanmon_cfgs = create_chanmon_cfgs(2);
4955         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4956         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4957         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4958
4959         // Create some initial channels
4960         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4961
4962         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
4963         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
4964         assert_eq!(revoked_local_txn[0].input.len(), 1);
4965         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
4966
4967         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
4968
4969         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4970         // A will generate HTLC-Timeout from revoked commitment tx
4971         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
4972         check_closed_broadcast!(nodes[0], false);
4973         check_added_monitors!(nodes[0], 1);
4974
4975         let revoked_htlc_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
4976         assert_eq!(revoked_htlc_txn.len(), 2);
4977         assert_eq!(revoked_htlc_txn[0].input.len(), 1);
4978         assert_eq!(revoked_htlc_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
4979         check_spends!(revoked_htlc_txn[0], revoked_local_txn[0]);
4980         check_spends!(revoked_htlc_txn[1], chan_1.3);
4981
4982         // B will generate justice tx from A's revoked commitment/HTLC tx
4983         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone(), revoked_htlc_txn[0].clone()] }, 0);
4984         check_closed_broadcast!(nodes[1], false);
4985         check_added_monitors!(nodes[1], 1);
4986
4987         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
4988         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
4989         assert_eq!(node_txn[0].input.len(), 2);
4990         check_spends!(node_txn[0], revoked_local_txn[0]);
4991         check_spends!(node_txn[1], chan_1.3);
4992         assert_eq!(node_txn[2].input.len(), 1);
4993         check_spends!(node_txn[2], revoked_htlc_txn[0]);
4994         assert_eq!(node_txn[3].input.len(), 1);
4995         check_spends!(node_txn[3], revoked_local_txn[0]);
4996
4997         let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4998         nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone(), node_txn[2].clone()] }, 1);
4999         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
5000
5001         // Check B's ChannelMonitor was able to generate the right spendable output descriptor
5002         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
5003         assert_eq!(spend_txn.len(), 2);
5004         check_spends!(spend_txn[0], node_txn[0]);
5005         check_spends!(spend_txn[1], node_txn[2]);
5006 }
5007
5008 #[test]
5009 fn test_static_spendable_outputs_justice_tx_revoked_htlc_success_tx() {
5010         let chanmon_cfgs = create_chanmon_cfgs(2);
5011         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
5012         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
5013         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
5014
5015         // Create some initial channels
5016         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5017
5018         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
5019         let revoked_local_txn = get_local_commitment_txn!(nodes[1], chan_1.2);
5020         assert_eq!(revoked_local_txn[0].input.len(), 1);
5021         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
5022
5023         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
5024
5025         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5026         // B will generate HTLC-Success from revoked commitment tx
5027         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
5028         check_closed_broadcast!(nodes[1], false);
5029         check_added_monitors!(nodes[1], 1);
5030         let revoked_htlc_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5031
5032         assert_eq!(revoked_htlc_txn.len(), 2);
5033         assert_eq!(revoked_htlc_txn[0].input.len(), 1);
5034         assert_eq!(revoked_htlc_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5035         check_spends!(revoked_htlc_txn[0], revoked_local_txn[0]);
5036
5037         // A will generate justice tx from B's revoked commitment/HTLC tx
5038         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone(), revoked_htlc_txn[0].clone()] }, 1);
5039         check_closed_broadcast!(nodes[0], false);
5040         check_added_monitors!(nodes[0], 1);
5041
5042         let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
5043         assert_eq!(node_txn.len(), 3); // ChannelMonitor: justice tx on revoked commitment, justice tx on revoked HTLC-success, ChannelManager: local commitment tx
5044         assert_eq!(node_txn[2].input.len(), 1);
5045         check_spends!(node_txn[2], revoked_htlc_txn[0]);
5046
5047         let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5048         nodes[0].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone(), node_txn[2].clone()] }, 1);
5049         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
5050
5051         // Check A's ChannelMonitor was able to generate the right spendable output descriptor
5052         let spend_txn = check_spendable_outputs!(nodes[0], 1, node_cfgs[0].keys_manager, 100000);
5053         assert_eq!(spend_txn.len(), 5); // Duplicated SpendableOutput due to block rescan after revoked htlc output tracking
5054         assert_eq!(spend_txn[0], spend_txn[1]);
5055         assert_eq!(spend_txn[0], spend_txn[2]);
5056         check_spends!(spend_txn[0], revoked_local_txn[0]); // spending to_remote output from revoked local tx
5057         check_spends!(spend_txn[3], node_txn[0]); // spending justice tx output from revoked local tx htlc received output
5058         check_spends!(spend_txn[4], node_txn[2]); // spending justice tx output on htlc success tx
5059 }
5060
5061 #[test]
5062 fn test_onchain_to_onchain_claim() {
5063         // Test that in case of channel closure, we detect the state of output thanks to
5064         // ChainWatchInterface and claim HTLC on downstream peer's remote commitment tx.
5065         // First, have C claim an HTLC against its own latest commitment transaction.
5066         // Then, broadcast these to B, which should update the monitor downstream on the A<->B
5067         // channel.
5068         // Finally, check that B will claim the HTLC output if A's latest commitment transaction
5069         // gets broadcast.
5070
5071         let chanmon_cfgs = create_chanmon_cfgs(3);
5072         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
5073         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
5074         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
5075
5076         // Create some initial channels
5077         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5078         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
5079
5080         // Rebalance the network a bit by relaying one payment through all the channels ...
5081         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
5082         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
5083
5084         let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
5085         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
5086         let commitment_tx = get_local_commitment_txn!(nodes[2], chan_2.2);
5087         check_spends!(commitment_tx[0], chan_2.3);
5088         nodes[2].node.claim_funds(payment_preimage, &None, 3_000_000);
5089         check_added_monitors!(nodes[2], 1);
5090         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
5091         assert!(updates.update_add_htlcs.is_empty());
5092         assert!(updates.update_fail_htlcs.is_empty());
5093         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
5094         assert!(updates.update_fail_malformed_htlcs.is_empty());
5095
5096         nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
5097         check_closed_broadcast!(nodes[2], false);
5098         check_added_monitors!(nodes[2], 1);
5099
5100         let c_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 2 (commitment tx, HTLC-Success tx), ChannelMonitor : 1 (HTLC-Success tx)
5101         assert_eq!(c_txn.len(), 3);
5102         assert_eq!(c_txn[0], c_txn[2]);
5103         assert_eq!(commitment_tx[0], c_txn[1]);
5104         check_spends!(c_txn[1], chan_2.3);
5105         check_spends!(c_txn[2], c_txn[1]);
5106         assert_eq!(c_txn[1].input[0].witness.clone().last().unwrap().len(), 71);
5107         assert_eq!(c_txn[2].input[0].witness.clone().last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5108         assert!(c_txn[0].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
5109         assert_eq!(c_txn[0].lock_time, 0); // Success tx
5110
5111         // 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
5112         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![c_txn[1].clone(), c_txn[2].clone()]}, 1);
5113         {
5114                 let mut b_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5115                 // ChannelMonitor: claim tx, ChannelManager: local commitment tx + HTLC-timeout tx
5116                 assert_eq!(b_txn.len(), 3);
5117                 check_spends!(b_txn[1], chan_2.3); // B local commitment tx, issued by ChannelManager
5118                 check_spends!(b_txn[2], b_txn[1]); // HTLC-Timeout on B local commitment tx, issued by ChannelManager
5119                 assert_eq!(b_txn[2].input[0].witness.clone().last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
5120                 assert!(b_txn[2].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
5121                 assert_ne!(b_txn[2].lock_time, 0); // Timeout tx
5122                 check_spends!(b_txn[0], c_txn[1]); // timeout tx on C remote commitment tx, issued by ChannelMonitor, * 2 due to block rescan
5123                 assert_eq!(b_txn[0].input[0].witness.clone().last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5124                 assert!(b_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
5125                 assert_ne!(b_txn[2].lock_time, 0); // Timeout tx
5126                 b_txn.clear();
5127         }
5128         check_added_monitors!(nodes[1], 1);
5129         let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
5130         check_added_monitors!(nodes[1], 1);
5131         match msg_events[0] {
5132                 MessageSendEvent::BroadcastChannelUpdate {  .. } => {},
5133                 _ => panic!("Unexpected event"),
5134         }
5135         match msg_events[1] {
5136                 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, .. } } => {
5137                         assert!(update_add_htlcs.is_empty());
5138                         assert!(update_fail_htlcs.is_empty());
5139                         assert_eq!(update_fulfill_htlcs.len(), 1);
5140                         assert!(update_fail_malformed_htlcs.is_empty());
5141                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
5142                 },
5143                 _ => panic!("Unexpected event"),
5144         };
5145         // Broadcast A's commitment tx on B's chain to see if we are able to claim inbound HTLC with our HTLC-Success tx
5146         let commitment_tx = get_local_commitment_txn!(nodes[0], chan_1.2);
5147         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
5148         let b_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5149         // ChannelMonitor: HTLC-Success tx, ChannelManager: local commitment tx + HTLC-Success tx
5150         assert_eq!(b_txn.len(), 3);
5151         check_spends!(b_txn[1], chan_1.3);
5152         check_spends!(b_txn[2], b_txn[1]);
5153         check_spends!(b_txn[0], commitment_tx[0]);
5154         assert_eq!(b_txn[0].input[0].witness.clone().last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
5155         assert!(b_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
5156         assert_eq!(b_txn[0].lock_time, 0); // Success tx
5157
5158         check_closed_broadcast!(nodes[1], false);
5159         check_added_monitors!(nodes[1], 1);
5160 }
5161
5162 #[test]
5163 fn test_duplicate_payment_hash_one_failure_one_success() {
5164         // Topology : A --> B --> C
5165         // We route 2 payments with same hash between B and C, one will be timeout, the other successfully claim
5166         let chanmon_cfgs = create_chanmon_cfgs(3);
5167         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
5168         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
5169         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
5170
5171         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5172         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
5173
5174         let (our_payment_preimage, duplicate_payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 900000);
5175         *nodes[0].network_payment_count.borrow_mut() -= 1;
5176         assert_eq!(route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 900000).1, duplicate_payment_hash);
5177
5178         let commitment_txn = get_local_commitment_txn!(nodes[2], chan_2.2);
5179         assert_eq!(commitment_txn[0].input.len(), 1);
5180         check_spends!(commitment_txn[0], chan_2.3);
5181
5182         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5183         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![commitment_txn[0].clone()] }, 1);
5184         check_closed_broadcast!(nodes[1], false);
5185         check_added_monitors!(nodes[1], 1);
5186
5187         let htlc_timeout_tx;
5188         { // Extract one of the two HTLC-Timeout transaction
5189                 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5190                 // ChannelMonitor: timeout tx * 2, ChannelManager: local commitment tx + HTLC-timeout * 2
5191                 assert_eq!(node_txn.len(), 5);
5192                 check_spends!(node_txn[0], commitment_txn[0]);
5193                 assert_eq!(node_txn[0].input.len(), 1);
5194                 check_spends!(node_txn[1], commitment_txn[0]);
5195                 assert_eq!(node_txn[1].input.len(), 1);
5196                 assert_ne!(node_txn[0].input[0], node_txn[1].input[0]);
5197                 assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5198                 assert_eq!(node_txn[1].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5199                 check_spends!(node_txn[2], chan_2.3);
5200                 check_spends!(node_txn[3], node_txn[2]);
5201                 check_spends!(node_txn[4], node_txn[2]);
5202                 htlc_timeout_tx = node_txn[1].clone();
5203         }
5204
5205         nodes[2].node.claim_funds(our_payment_preimage, &None, 900_000);
5206         nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![commitment_txn[0].clone()] }, 1);
5207         check_added_monitors!(nodes[2], 3);
5208         let events = nodes[2].node.get_and_clear_pending_msg_events();
5209         match events[0] {
5210                 MessageSendEvent::UpdateHTLCs { .. } => {},
5211                 _ => panic!("Unexpected event"),
5212         }
5213         match events[1] {
5214                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5215                 _ => panic!("Unexepected event"),
5216         }
5217         let htlc_success_txn: Vec<_> = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
5218         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)
5219         check_spends!(htlc_success_txn[2], chan_2.3);
5220         check_spends!(htlc_success_txn[3], htlc_success_txn[2]);
5221         check_spends!(htlc_success_txn[4], htlc_success_txn[2]);
5222         assert_eq!(htlc_success_txn[0], htlc_success_txn[3]);
5223         assert_eq!(htlc_success_txn[0].input.len(), 1);
5224         assert_eq!(htlc_success_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5225         assert_eq!(htlc_success_txn[1], htlc_success_txn[4]);
5226         assert_eq!(htlc_success_txn[1].input.len(), 1);
5227         assert_eq!(htlc_success_txn[1].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5228         assert_ne!(htlc_success_txn[0].input[0], htlc_success_txn[1].input[0]);
5229         check_spends!(htlc_success_txn[0], commitment_txn[0]);
5230         check_spends!(htlc_success_txn[1], commitment_txn[0]);
5231
5232         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![htlc_timeout_tx] }, 200);
5233         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 200, true, header.bitcoin_hash());
5234         expect_pending_htlcs_forwardable!(nodes[1]);
5235         let htlc_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5236         assert!(htlc_updates.update_add_htlcs.is_empty());
5237         assert_eq!(htlc_updates.update_fail_htlcs.len(), 1);
5238         assert_eq!(htlc_updates.update_fail_htlcs[0].htlc_id, 1);
5239         assert!(htlc_updates.update_fulfill_htlcs.is_empty());
5240         assert!(htlc_updates.update_fail_malformed_htlcs.is_empty());
5241         check_added_monitors!(nodes[1], 1);
5242
5243         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &htlc_updates.update_fail_htlcs[0]);
5244         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
5245         {
5246                 commitment_signed_dance!(nodes[0], nodes[1], &htlc_updates.commitment_signed, false, true);
5247                 let events = nodes[0].node.get_and_clear_pending_msg_events();
5248                 assert_eq!(events.len(), 1);
5249                 match events[0] {
5250                         MessageSendEvent::PaymentFailureNetworkUpdate { update: msgs::HTLCFailChannelUpdate::ChannelClosed { .. }  } => {
5251                         },
5252                         _ => { panic!("Unexpected event"); }
5253                 }
5254         }
5255         expect_payment_failed!(nodes[0], duplicate_payment_hash, false);
5256
5257         // Solve 2nd HTLC by broadcasting on B's chain HTLC-Success Tx from C
5258         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![htlc_success_txn[0].clone()] }, 200);
5259         let updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5260         assert!(updates.update_add_htlcs.is_empty());
5261         assert!(updates.update_fail_htlcs.is_empty());
5262         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
5263         assert_eq!(updates.update_fulfill_htlcs[0].htlc_id, 0);
5264         assert!(updates.update_fail_malformed_htlcs.is_empty());
5265         check_added_monitors!(nodes[1], 1);
5266
5267         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
5268         commitment_signed_dance!(nodes[0], nodes[1], &updates.commitment_signed, false);
5269
5270         let events = nodes[0].node.get_and_clear_pending_events();
5271         match events[0] {
5272                 Event::PaymentSent { ref payment_preimage } => {
5273                         assert_eq!(*payment_preimage, our_payment_preimage);
5274                 }
5275                 _ => panic!("Unexpected event"),
5276         }
5277 }
5278
5279 #[test]
5280 fn test_dynamic_spendable_outputs_local_htlc_success_tx() {
5281         let chanmon_cfgs = create_chanmon_cfgs(2);
5282         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
5283         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
5284         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
5285
5286         // Create some initial channels
5287         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5288
5289         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000).0;
5290         let local_txn = get_local_commitment_txn!(nodes[1], chan_1.2);
5291         assert_eq!(local_txn[0].input.len(), 1);
5292         check_spends!(local_txn[0], chan_1.3);
5293
5294         // Give B knowledge of preimage to be able to generate a local HTLC-Success Tx
5295         nodes[1].node.claim_funds(payment_preimage, &None, 9_000_000);
5296         check_added_monitors!(nodes[1], 1);
5297         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5298         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![local_txn[0].clone()] }, 1);
5299         check_added_monitors!(nodes[1], 1);
5300         let events = nodes[1].node.get_and_clear_pending_msg_events();
5301         match events[0] {
5302                 MessageSendEvent::UpdateHTLCs { .. } => {},
5303                 _ => panic!("Unexpected event"),
5304         }
5305         match events[1] {
5306                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5307                 _ => panic!("Unexepected event"),
5308         }
5309         let node_txn = {
5310                 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5311                 assert_eq!(node_txn[0].input.len(), 1);
5312                 assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5313                 check_spends!(node_txn[0], local_txn[0]);
5314                 vec![node_txn[0].clone(), node_txn[2].clone()]
5315         };
5316
5317         let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5318         nodes[1].block_notifier.block_connected(&Block { header: header_201, txdata: node_txn.clone() }, 201);
5319         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 201, true, header_201.bitcoin_hash());
5320
5321         // Verify that B is able to spend its own HTLC-Success tx thanks to spendable output event given back by its ChannelMonitor
5322         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
5323         assert_eq!(spend_txn.len(), 2);
5324         check_spends!(spend_txn[0], node_txn[0]);
5325         check_spends!(spend_txn[1], node_txn[1]);
5326 }
5327
5328 fn do_test_fail_backwards_unrevoked_remote_announce(deliver_last_raa: bool, announce_latest: bool) {
5329         // Test that we fail backwards the full set of HTLCs we need to when remote broadcasts an
5330         // unrevoked commitment transaction.
5331         // This includes HTLCs which were below the dust threshold as well as HTLCs which were awaiting
5332         // a remote RAA before they could be failed backwards (and combinations thereof).
5333         // We also test duplicate-hash HTLCs by adding two nodes on each side of the target nodes which
5334         // use the same payment hashes.
5335         // Thus, we use a six-node network:
5336         //
5337         // A \         / E
5338         //    - C - D -
5339         // B /         \ F
5340         // And test where C fails back to A/B when D announces its latest commitment transaction
5341         let chanmon_cfgs = create_chanmon_cfgs(6);
5342         let node_cfgs = create_node_cfgs(6, &chanmon_cfgs);
5343         let node_chanmgrs = create_node_chanmgrs(6, &node_cfgs, &[None, None, None, None, None, None]);
5344         let nodes = create_network(6, &node_cfgs, &node_chanmgrs);
5345         let logger = test_utils::TestLogger::new();
5346
5347         create_announced_chan_between_nodes(&nodes, 0, 2, InitFeatures::known(), InitFeatures::known());
5348         create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
5349         let chan = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
5350         create_announced_chan_between_nodes(&nodes, 3, 4, InitFeatures::known(), InitFeatures::known());
5351         create_announced_chan_between_nodes(&nodes, 3, 5, InitFeatures::known(), InitFeatures::known());
5352
5353         // Rebalance and check output sanity...
5354         send_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 500000, 500_000);
5355         send_payment(&nodes[1], &[&nodes[2], &nodes[3], &nodes[5]], 500000, 500_000);
5356         assert_eq!(get_local_commitment_txn!(nodes[3], chan.2)[0].output.len(), 2);
5357
5358         let ds_dust_limit = nodes[3].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
5359         // 0th HTLC:
5360         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
5361         // 1st HTLC:
5362         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
5363         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
5364         let our_node_id = &nodes[1].node.get_our_node_id();
5365         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();
5366         // 2nd HTLC:
5367         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
5368         // 3rd HTLC:
5369         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
5370         // 4th HTLC:
5371         let (_, payment_hash_3) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 1000000);
5372         // 5th HTLC:
5373         let (_, payment_hash_4) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 1000000);
5374         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();
5375         // 6th HTLC:
5376         send_along_route_with_hash(&nodes[1], route.clone(), &[&nodes[2], &nodes[3], &nodes[5]], 1000000, payment_hash_3);
5377         // 7th HTLC:
5378         send_along_route_with_hash(&nodes[1], route, &[&nodes[2], &nodes[3], &nodes[5]], 1000000, payment_hash_4);
5379
5380         // 8th HTLC:
5381         let (_, payment_hash_5) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 1000000);
5382         // 9th HTLC:
5383         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();
5384         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
5385
5386         // 10th HTLC:
5387         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
5388         // 11th HTLC:
5389         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();
5390         send_along_route_with_hash(&nodes[1], route, &[&nodes[2], &nodes[3], &nodes[5]], 1000000, payment_hash_6);
5391
5392         // Double-check that six of the new HTLC were added
5393         // We now have six HTLCs pending over the dust limit and six HTLCs under the dust limit (ie,
5394         // with to_local and to_remote outputs, 8 outputs and 6 HTLCs not included).
5395         assert_eq!(get_local_commitment_txn!(nodes[3], chan.2).len(), 1);
5396         assert_eq!(get_local_commitment_txn!(nodes[3], chan.2)[0].output.len(), 8);
5397
5398         // Now fail back three of the over-dust-limit and three of the under-dust-limit payments in one go.
5399         // Fail 0th below-dust, 4th above-dust, 8th above-dust, 10th below-dust HTLCs
5400         assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_1, &None));
5401         assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_3, &None));
5402         assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_5, &None));
5403         assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_6, &None));
5404         check_added_monitors!(nodes[4], 0);
5405         expect_pending_htlcs_forwardable!(nodes[4]);
5406         check_added_monitors!(nodes[4], 1);
5407
5408         let four_removes = get_htlc_update_msgs!(nodes[4], nodes[3].node.get_our_node_id());
5409         nodes[3].node.handle_update_fail_htlc(&nodes[4].node.get_our_node_id(), &four_removes.update_fail_htlcs[0]);
5410         nodes[3].node.handle_update_fail_htlc(&nodes[4].node.get_our_node_id(), &four_removes.update_fail_htlcs[1]);
5411         nodes[3].node.handle_update_fail_htlc(&nodes[4].node.get_our_node_id(), &four_removes.update_fail_htlcs[2]);
5412         nodes[3].node.handle_update_fail_htlc(&nodes[4].node.get_our_node_id(), &four_removes.update_fail_htlcs[3]);
5413         commitment_signed_dance!(nodes[3], nodes[4], four_removes.commitment_signed, false);
5414
5415         // Fail 3rd below-dust and 7th above-dust HTLCs
5416         assert!(nodes[5].node.fail_htlc_backwards(&payment_hash_2, &None));
5417         assert!(nodes[5].node.fail_htlc_backwards(&payment_hash_4, &None));
5418         check_added_monitors!(nodes[5], 0);
5419         expect_pending_htlcs_forwardable!(nodes[5]);
5420         check_added_monitors!(nodes[5], 1);
5421
5422         let two_removes = get_htlc_update_msgs!(nodes[5], nodes[3].node.get_our_node_id());
5423         nodes[3].node.handle_update_fail_htlc(&nodes[5].node.get_our_node_id(), &two_removes.update_fail_htlcs[0]);
5424         nodes[3].node.handle_update_fail_htlc(&nodes[5].node.get_our_node_id(), &two_removes.update_fail_htlcs[1]);
5425         commitment_signed_dance!(nodes[3], nodes[5], two_removes.commitment_signed, false);
5426
5427         let ds_prev_commitment_tx = get_local_commitment_txn!(nodes[3], chan.2);
5428
5429         expect_pending_htlcs_forwardable!(nodes[3]);
5430         check_added_monitors!(nodes[3], 1);
5431         let six_removes = get_htlc_update_msgs!(nodes[3], nodes[2].node.get_our_node_id());
5432         nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &six_removes.update_fail_htlcs[0]);
5433         nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &six_removes.update_fail_htlcs[1]);
5434         nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &six_removes.update_fail_htlcs[2]);
5435         nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &six_removes.update_fail_htlcs[3]);
5436         nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &six_removes.update_fail_htlcs[4]);
5437         nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &six_removes.update_fail_htlcs[5]);
5438         if deliver_last_raa {
5439                 commitment_signed_dance!(nodes[2], nodes[3], six_removes.commitment_signed, false);
5440         } else {
5441                 let _cs_last_raa = commitment_signed_dance!(nodes[2], nodes[3], six_removes.commitment_signed, false, true, false, true);
5442         }
5443
5444         // D's latest commitment transaction now contains 1st + 2nd + 9th HTLCs (implicitly, they're
5445         // below the dust limit) and the 5th + 6th + 11th HTLCs. It has failed back the 0th, 3rd, 4th,
5446         // 7th, 8th, and 10th, but as we haven't yet delivered the final RAA to C, the fails haven't
5447         // propagated back to A/B yet (and D has two unrevoked commitment transactions).
5448         //
5449         // We now broadcast the latest commitment transaction, which *should* result in failures for
5450         // the 0th, 1st, 2nd, 3rd, 4th, 7th, 8th, 9th, and 10th HTLCs, ie all the below-dust HTLCs and
5451         // the non-broadcast above-dust HTLCs.
5452         //
5453         // Alternatively, we may broadcast the previous commitment transaction, which should only
5454         // result in failures for the below-dust HTLCs, ie the 0th, 1st, 2nd, 3rd, 9th, and 10th HTLCs.
5455         let ds_last_commitment_tx = get_local_commitment_txn!(nodes[3], chan.2);
5456
5457         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5458         if announce_latest {
5459                 nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![ds_last_commitment_tx[0].clone()]}, 1);
5460         } else {
5461                 nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![ds_prev_commitment_tx[0].clone()]}, 1);
5462         }
5463         connect_blocks(&nodes[2].block_notifier, ANTI_REORG_DELAY - 1, 1, true,  header.bitcoin_hash());
5464         check_closed_broadcast!(nodes[2], false);
5465         expect_pending_htlcs_forwardable!(nodes[2]);
5466         check_added_monitors!(nodes[2], 3);
5467
5468         let cs_msgs = nodes[2].node.get_and_clear_pending_msg_events();
5469         assert_eq!(cs_msgs.len(), 2);
5470         let mut a_done = false;
5471         for msg in cs_msgs {
5472                 match msg {
5473                         MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
5474                                 // Both under-dust HTLCs and the one above-dust HTLC that we had already failed
5475                                 // should be failed-backwards here.
5476                                 let target = if *node_id == nodes[0].node.get_our_node_id() {
5477                                         // If announce_latest, expect 0th, 1st, 4th, 8th, 10th HTLCs, else only 0th, 1st, 10th below-dust HTLCs
5478                                         for htlc in &updates.update_fail_htlcs {
5479                                                 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 });
5480                                         }
5481                                         assert_eq!(updates.update_fail_htlcs.len(), if announce_latest { 5 } else { 3 });
5482                                         assert!(!a_done);
5483                                         a_done = true;
5484                                         &nodes[0]
5485                                 } else {
5486                                         // If announce_latest, expect 2nd, 3rd, 7th, 9th HTLCs, else only 2nd, 3rd, 9th below-dust HTLCs
5487                                         for htlc in &updates.update_fail_htlcs {
5488                                                 assert!(htlc.htlc_id == 1 || htlc.htlc_id == 2 || htlc.htlc_id == 5 || if announce_latest { htlc.htlc_id == 4 } else { false });
5489                                         }
5490                                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
5491                                         assert_eq!(updates.update_fail_htlcs.len(), if announce_latest { 4 } else { 3 });
5492                                         &nodes[1]
5493                                 };
5494                                 target.node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
5495                                 target.node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[1]);
5496                                 target.node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[2]);
5497                                 if announce_latest {
5498                                         target.node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[3]);
5499                                         if *node_id == nodes[0].node.get_our_node_id() {
5500                                                 target.node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[4]);
5501                                         }
5502                                 }
5503                                 commitment_signed_dance!(target, nodes[2], updates.commitment_signed, false, true);
5504                         },
5505                         _ => panic!("Unexpected event"),
5506                 }
5507         }
5508
5509         let as_events = nodes[0].node.get_and_clear_pending_events();
5510         assert_eq!(as_events.len(), if announce_latest { 5 } else { 3 });
5511         let mut as_failds = HashSet::new();
5512         for event in as_events.iter() {
5513                 if let &Event::PaymentFailed { ref payment_hash, ref rejected_by_dest, .. } = event {
5514                         assert!(as_failds.insert(*payment_hash));
5515                         if *payment_hash != payment_hash_2 {
5516                                 assert_eq!(*rejected_by_dest, deliver_last_raa);
5517                         } else {
5518                                 assert!(!rejected_by_dest);
5519                         }
5520                 } else { panic!("Unexpected event"); }
5521         }
5522         assert!(as_failds.contains(&payment_hash_1));
5523         assert!(as_failds.contains(&payment_hash_2));
5524         if announce_latest {
5525                 assert!(as_failds.contains(&payment_hash_3));
5526                 assert!(as_failds.contains(&payment_hash_5));
5527         }
5528         assert!(as_failds.contains(&payment_hash_6));
5529
5530         let bs_events = nodes[1].node.get_and_clear_pending_events();
5531         assert_eq!(bs_events.len(), if announce_latest { 4 } else { 3 });
5532         let mut bs_failds = HashSet::new();
5533         for event in bs_events.iter() {
5534                 if let &Event::PaymentFailed { ref payment_hash, ref rejected_by_dest, .. } = event {
5535                         assert!(bs_failds.insert(*payment_hash));
5536                         if *payment_hash != payment_hash_1 && *payment_hash != payment_hash_5 {
5537                                 assert_eq!(*rejected_by_dest, deliver_last_raa);
5538                         } else {
5539                                 assert!(!rejected_by_dest);
5540                         }
5541                 } else { panic!("Unexpected event"); }
5542         }
5543         assert!(bs_failds.contains(&payment_hash_1));
5544         assert!(bs_failds.contains(&payment_hash_2));
5545         if announce_latest {
5546                 assert!(bs_failds.contains(&payment_hash_4));
5547         }
5548         assert!(bs_failds.contains(&payment_hash_5));
5549
5550         // For each HTLC which was not failed-back by normal process (ie deliver_last_raa), we should
5551         // get a PaymentFailureNetworkUpdate. A should have gotten 4 HTLCs which were failed-back due
5552         // to unknown-preimage-etc, B should have gotten 2. Thus, in the
5553         // announce_latest && deliver_last_raa case, we should have 5-4=1 and 4-2=2
5554         // PaymentFailureNetworkUpdates.
5555         let as_msg_events = nodes[0].node.get_and_clear_pending_msg_events();
5556         assert_eq!(as_msg_events.len(), if deliver_last_raa { 1 } else if !announce_latest { 3 } else { 5 });
5557         let bs_msg_events = nodes[1].node.get_and_clear_pending_msg_events();
5558         assert_eq!(bs_msg_events.len(), if deliver_last_raa { 2 } else if !announce_latest { 3 } else { 4 });
5559         for event in as_msg_events.iter().chain(bs_msg_events.iter()) {
5560                 match event {
5561                         &MessageSendEvent::PaymentFailureNetworkUpdate { .. } => {},
5562                         _ => panic!("Unexpected event"),
5563                 }
5564         }
5565 }
5566
5567 #[test]
5568 fn test_fail_backwards_latest_remote_announce_a() {
5569         do_test_fail_backwards_unrevoked_remote_announce(false, true);
5570 }
5571
5572 #[test]
5573 fn test_fail_backwards_latest_remote_announce_b() {
5574         do_test_fail_backwards_unrevoked_remote_announce(true, true);
5575 }
5576
5577 #[test]
5578 fn test_fail_backwards_previous_remote_announce() {
5579         do_test_fail_backwards_unrevoked_remote_announce(false, false);
5580         // Note that true, true doesn't make sense as it implies we announce a revoked state, which is
5581         // tested for in test_commitment_revoked_fail_backward_exhaustive()
5582 }
5583
5584 #[test]
5585 fn test_dynamic_spendable_outputs_local_htlc_timeout_tx() {
5586         let chanmon_cfgs = create_chanmon_cfgs(2);
5587         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
5588         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
5589         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
5590
5591         // Create some initial channels
5592         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5593
5594         let (_, our_payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000);
5595         let local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
5596         assert_eq!(local_txn[0].input.len(), 1);
5597         check_spends!(local_txn[0], chan_1.3);
5598
5599         // Timeout HTLC on A's chain and so it can generate a HTLC-Timeout tx
5600         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5601         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![local_txn[0].clone()] }, 200);
5602         check_closed_broadcast!(nodes[0], false);
5603         check_added_monitors!(nodes[0], 1);
5604
5605         let htlc_timeout = {
5606                 let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
5607                 assert_eq!(node_txn[0].input.len(), 1);
5608                 assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
5609                 check_spends!(node_txn[0], local_txn[0]);
5610                 node_txn[0].clone()
5611         };
5612
5613         let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5614         nodes[0].block_notifier.block_connected(&Block { header: header_201, txdata: vec![htlc_timeout.clone()] }, 201);
5615         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 201, true, header_201.bitcoin_hash());
5616         expect_payment_failed!(nodes[0], our_payment_hash, true);
5617
5618         // Verify that A is able to spend its own HTLC-Timeout tx thanks to spendable output event given back by its ChannelMonitor
5619         let spend_txn = check_spendable_outputs!(nodes[0], 1, node_cfgs[0].keys_manager, 100000);
5620         assert_eq!(spend_txn.len(), 3);
5621         assert_eq!(spend_txn[0], spend_txn[1]);
5622         check_spends!(spend_txn[0], local_txn[0]);
5623         check_spends!(spend_txn[2], htlc_timeout);
5624 }
5625
5626 #[test]
5627 fn test_key_derivation_params() {
5628         // This test is a copy of test_dynamic_spendable_outputs_local_htlc_timeout_tx, with
5629         // a key manager rotation to test that key_derivation_params returned in DynamicOutputP2WSH
5630         // let us re-derive the channel key set to then derive a delayed_payment_key.
5631
5632         let chanmon_cfgs = create_chanmon_cfgs(3);
5633
5634         // We manually create the node configuration to backup the seed.
5635         let seed = [42; 32];
5636         let keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet);
5637         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);
5638         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 };
5639         let mut node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
5640         node_cfgs.remove(0);
5641         node_cfgs.insert(0, node);
5642
5643         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
5644         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
5645
5646         // Create some initial channels
5647         // Create a dummy channel to advance index by one and thus test re-derivation correctness
5648         // for node 0
5649         let chan_0 = create_announced_chan_between_nodes(&nodes, 0, 2, InitFeatures::known(), InitFeatures::known());
5650         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5651         assert_ne!(chan_0.3.output[0].script_pubkey, chan_1.3.output[0].script_pubkey);
5652
5653         let (_, our_payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000);
5654         let local_txn_0 = get_local_commitment_txn!(nodes[0], chan_0.2);
5655         let local_txn_1 = get_local_commitment_txn!(nodes[0], chan_1.2);
5656         assert_eq!(local_txn_1[0].input.len(), 1);
5657         check_spends!(local_txn_1[0], chan_1.3);
5658
5659         // We check funding pubkey are unique
5660         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]));
5661         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]));
5662         if from_0_funding_key_0 == from_1_funding_key_0
5663             || from_0_funding_key_0 == from_1_funding_key_1
5664             || from_0_funding_key_1 == from_1_funding_key_0
5665             || from_0_funding_key_1 == from_1_funding_key_1 {
5666                 panic!("Funding pubkeys aren't unique");
5667         }
5668
5669         // Timeout HTLC on A's chain and so it can generate a HTLC-Timeout tx
5670         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5671         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![local_txn_1[0].clone()] }, 200);
5672         check_closed_broadcast!(nodes[0], false);
5673         check_added_monitors!(nodes[0], 1);
5674
5675         let htlc_timeout = {
5676                 let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
5677                 assert_eq!(node_txn[0].input.len(), 1);
5678                 assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
5679                 check_spends!(node_txn[0], local_txn_1[0]);
5680                 node_txn[0].clone()
5681         };
5682
5683         let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5684         nodes[0].block_notifier.block_connected(&Block { header: header_201, txdata: vec![htlc_timeout.clone()] }, 201);
5685         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 201, true, header_201.bitcoin_hash());
5686         expect_payment_failed!(nodes[0], our_payment_hash, true);
5687
5688         // Verify that A is able to spend its own HTLC-Timeout tx thanks to spendable output event given back by its ChannelMonitor
5689         let new_keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet);
5690         let spend_txn = check_spendable_outputs!(nodes[0], 1, new_keys_manager, 100000);
5691         assert_eq!(spend_txn.len(), 3);
5692         assert_eq!(spend_txn[0], spend_txn[1]);
5693         check_spends!(spend_txn[0], local_txn_1[0]);
5694         check_spends!(spend_txn[2], htlc_timeout);
5695 }
5696
5697 #[test]
5698 fn test_static_output_closing_tx() {
5699         let chanmon_cfgs = create_chanmon_cfgs(2);
5700         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
5701         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
5702         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
5703
5704         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5705
5706         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
5707         let closing_tx = close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true).2;
5708
5709         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5710         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![closing_tx.clone()] }, 0);
5711         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 0, true, header.bitcoin_hash());
5712
5713         let spend_txn = check_spendable_outputs!(nodes[0], 2, node_cfgs[0].keys_manager, 100000);
5714         assert_eq!(spend_txn.len(), 1);
5715         check_spends!(spend_txn[0], closing_tx);
5716
5717         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![closing_tx.clone()] }, 0);
5718         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 0, true, header.bitcoin_hash());
5719
5720         let spend_txn = check_spendable_outputs!(nodes[1], 2, node_cfgs[1].keys_manager, 100000);
5721         assert_eq!(spend_txn.len(), 1);
5722         check_spends!(spend_txn[0], closing_tx);
5723 }
5724
5725 fn do_htlc_claim_local_commitment_only(use_dust: bool) {
5726         let chanmon_cfgs = create_chanmon_cfgs(2);
5727         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
5728         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
5729         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
5730         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5731
5732         let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1]], if use_dust { 50000 } else { 3000000 });
5733
5734         // Claim the payment, but don't deliver A's commitment_signed, resulting in the HTLC only being
5735         // present in B's local commitment transaction, but none of A's commitment transactions.
5736         assert!(nodes[1].node.claim_funds(our_payment_preimage, &None, if use_dust { 50_000 } else { 3_000_000 }));
5737         check_added_monitors!(nodes[1], 1);
5738
5739         let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5740         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &bs_updates.update_fulfill_htlcs[0]);
5741         let events = nodes[0].node.get_and_clear_pending_events();
5742         assert_eq!(events.len(), 1);
5743         match events[0] {
5744                 Event::PaymentSent { payment_preimage } => {
5745                         assert_eq!(payment_preimage, our_payment_preimage);
5746                 },
5747                 _ => panic!("Unexpected event"),
5748         }
5749
5750         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_updates.commitment_signed);
5751         check_added_monitors!(nodes[0], 1);
5752         let as_updates = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
5753         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_updates.0);
5754         check_added_monitors!(nodes[1], 1);
5755
5756         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5757         for i in 1..TEST_FINAL_CLTV - CLTV_CLAIM_BUFFER + CHAN_CONFIRM_DEPTH + 1 {
5758                 nodes[1].block_notifier.block_connected_checked(&header, i, &Vec::new(), &Vec::new());
5759                 header.prev_blockhash = header.bitcoin_hash();
5760         }
5761         test_txn_broadcast(&nodes[1], &chan, None, if use_dust { HTLCType::NONE } else { HTLCType::SUCCESS });
5762         check_closed_broadcast!(nodes[1], false);
5763         check_added_monitors!(nodes[1], 1);
5764 }
5765
5766 fn do_htlc_claim_current_remote_commitment_only(use_dust: bool) {
5767         let chanmon_cfgs = create_chanmon_cfgs(2);
5768         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
5769         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
5770         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
5771         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5772         let logger = test_utils::TestLogger::new();
5773
5774         let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
5775         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
5776         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();
5777         nodes[0].node.send_payment(&route, payment_hash, &None).unwrap();
5778         check_added_monitors!(nodes[0], 1);
5779
5780         let _as_update = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
5781
5782         // As far as A is concerned, the HTLC is now present only in the latest remote commitment
5783         // transaction, however it is not in A's latest local commitment, so we can just broadcast that
5784         // to "time out" the HTLC.
5785
5786         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5787
5788         for i in 1..TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + CHAN_CONFIRM_DEPTH + 1 {
5789                 nodes[0].block_notifier.block_connected(&Block { header, txdata: Vec::new()}, i);
5790                 header.prev_blockhash = header.bitcoin_hash();
5791         }
5792         test_txn_broadcast(&nodes[0], &chan, None, HTLCType::NONE);
5793         check_closed_broadcast!(nodes[0], false);
5794         check_added_monitors!(nodes[0], 1);
5795 }
5796
5797 fn do_htlc_claim_previous_remote_commitment_only(use_dust: bool, check_revoke_no_close: bool) {
5798         let chanmon_cfgs = create_chanmon_cfgs(3);
5799         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
5800         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
5801         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
5802         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5803
5804         // Fail the payment, but don't deliver A's final RAA, resulting in the HTLC only being present
5805         // in B's previous (unrevoked) commitment transaction, but none of A's commitment transactions.
5806         // Also optionally test that we *don't* fail the channel in case the commitment transaction was
5807         // actually revoked.
5808         let htlc_value = if use_dust { 50000 } else { 3000000 };
5809         let (_, our_payment_hash) = route_payment(&nodes[0], &[&nodes[1]], htlc_value);
5810         assert!(nodes[1].node.fail_htlc_backwards(&our_payment_hash, &None));
5811         expect_pending_htlcs_forwardable!(nodes[1]);
5812         check_added_monitors!(nodes[1], 1);
5813
5814         let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5815         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &bs_updates.update_fail_htlcs[0]);
5816         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_updates.commitment_signed);
5817         check_added_monitors!(nodes[0], 1);
5818         let as_updates = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
5819         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_updates.0);
5820         check_added_monitors!(nodes[1], 1);
5821         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_updates.1);
5822         check_added_monitors!(nodes[1], 1);
5823         let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
5824
5825         if check_revoke_no_close {
5826                 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack);
5827                 check_added_monitors!(nodes[0], 1);
5828         }
5829
5830         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5831         for i in 1..TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + CHAN_CONFIRM_DEPTH + 1 {
5832                 nodes[0].block_notifier.block_connected_checked(&header, i, &Vec::new(), &Vec::new());
5833                 header.prev_blockhash = header.bitcoin_hash();
5834         }
5835         if !check_revoke_no_close {
5836                 test_txn_broadcast(&nodes[0], &chan, None, HTLCType::NONE);
5837                 check_closed_broadcast!(nodes[0], false);
5838                 check_added_monitors!(nodes[0], 1);
5839         } else {
5840                 expect_payment_failed!(nodes[0], our_payment_hash, true);
5841         }
5842 }
5843
5844 // Test that we close channels on-chain when broadcastable HTLCs reach their timeout window.
5845 // There are only a few cases to test here:
5846 //  * its not really normative behavior, but we test that below-dust HTLCs "included" in
5847 //    broadcastable commitment transactions result in channel closure,
5848 //  * its included in an unrevoked-but-previous remote commitment transaction,
5849 //  * its included in the latest remote or local commitment transactions.
5850 // We test each of the three possible commitment transactions individually and use both dust and
5851 // non-dust HTLCs.
5852 // Note that we don't bother testing both outbound and inbound HTLC failures for each case, and we
5853 // assume they are handled the same across all six cases, as both outbound and inbound failures are
5854 // tested for at least one of the cases in other tests.
5855 #[test]
5856 fn htlc_claim_single_commitment_only_a() {
5857         do_htlc_claim_local_commitment_only(true);
5858         do_htlc_claim_local_commitment_only(false);
5859
5860         do_htlc_claim_current_remote_commitment_only(true);
5861         do_htlc_claim_current_remote_commitment_only(false);
5862 }
5863
5864 #[test]
5865 fn htlc_claim_single_commitment_only_b() {
5866         do_htlc_claim_previous_remote_commitment_only(true, false);
5867         do_htlc_claim_previous_remote_commitment_only(false, false);
5868         do_htlc_claim_previous_remote_commitment_only(true, true);
5869         do_htlc_claim_previous_remote_commitment_only(false, true);
5870 }
5871
5872 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>)
5873         where F1: for <'a> FnMut(&'a mut msgs::UpdateAddHTLC),
5874                                 F2: FnMut(),
5875 {
5876         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);
5877 }
5878
5879 // test_case
5880 // 0: node1 fails backward
5881 // 1: final node fails backward
5882 // 2: payment completed but the user rejects the payment
5883 // 3: final node fails backward (but tamper onion payloads from node0)
5884 // 100: trigger error in the intermediate node and tamper returning fail_htlc
5885 // 200: trigger error in the final node and tamper returning fail_htlc
5886 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>)
5887         where F1: for <'a> FnMut(&'a mut msgs::UpdateAddHTLC),
5888                                 F2: for <'a> FnMut(&'a mut msgs::UpdateFailHTLC),
5889                                 F3: FnMut(),
5890 {
5891
5892         // reset block height
5893         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5894         for ix in 0..nodes.len() {
5895                 nodes[ix].block_notifier.block_connected_checked(&header, 1, &[], &[]);
5896         }
5897
5898         macro_rules! expect_event {
5899                 ($node: expr, $event_type: path) => {{
5900                         let events = $node.node.get_and_clear_pending_events();
5901                         assert_eq!(events.len(), 1);
5902                         match events[0] {
5903                                 $event_type { .. } => {},
5904                                 _ => panic!("Unexpected event"),
5905                         }
5906                 }}
5907         }
5908
5909         macro_rules! expect_htlc_forward {
5910                 ($node: expr) => {{
5911                         expect_event!($node, Event::PendingHTLCsForwardable);
5912                         $node.node.process_pending_htlc_forwards();
5913                 }}
5914         }
5915
5916         // 0 ~~> 2 send payment
5917         nodes[0].node.send_payment(&route, payment_hash.clone(), &None).unwrap();
5918         check_added_monitors!(nodes[0], 1);
5919         let update_0 = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
5920         // temper update_add (0 => 1)
5921         let mut update_add_0 = update_0.update_add_htlcs[0].clone();
5922         if test_case == 0 || test_case == 3 || test_case == 100 {
5923                 callback_msg(&mut update_add_0);
5924                 callback_node();
5925         }
5926         // 0 => 1 update_add & CS
5927         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &update_add_0);
5928         commitment_signed_dance!(nodes[1], nodes[0], &update_0.commitment_signed, false, true);
5929
5930         let update_1_0 = match test_case {
5931                 0|100 => { // intermediate node failure; fail backward to 0
5932                         let update_1_0 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5933                         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));
5934                         update_1_0
5935                 },
5936                 1|2|3|200 => { // final node failure; forwarding to 2
5937                         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
5938                         // forwarding on 1
5939                         if test_case != 200 {
5940                                 callback_node();
5941                         }
5942                         expect_htlc_forward!(&nodes[1]);
5943
5944                         let update_1 = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
5945                         check_added_monitors!(&nodes[1], 1);
5946                         assert_eq!(update_1.update_add_htlcs.len(), 1);
5947                         // tamper update_add (1 => 2)
5948                         let mut update_add_1 = update_1.update_add_htlcs[0].clone();
5949                         if test_case != 3 && test_case != 200 {
5950                                 callback_msg(&mut update_add_1);
5951                         }
5952
5953                         // 1 => 2
5954                         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &update_add_1);
5955                         commitment_signed_dance!(nodes[2], nodes[1], update_1.commitment_signed, false, true);
5956
5957                         if test_case == 2 || test_case == 200 {
5958                                 expect_htlc_forward!(&nodes[2]);
5959                                 expect_event!(&nodes[2], Event::PaymentReceived);
5960                                 callback_node();
5961                                 expect_pending_htlcs_forwardable!(nodes[2]);
5962                         }
5963
5964                         let update_2_1 = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
5965                         if test_case == 2 || test_case == 200 {
5966                                 check_added_monitors!(&nodes[2], 1);
5967                         }
5968                         assert!(update_2_1.update_fail_htlcs.len() == 1);
5969
5970                         let mut fail_msg = update_2_1.update_fail_htlcs[0].clone();
5971                         if test_case == 200 {
5972                                 callback_fail(&mut fail_msg);
5973                         }
5974
5975                         // 2 => 1
5976                         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &fail_msg);
5977                         commitment_signed_dance!(nodes[1], nodes[2], update_2_1.commitment_signed, true);
5978
5979                         // backward fail on 1
5980                         let update_1_0 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5981                         assert!(update_1_0.update_fail_htlcs.len() == 1);
5982                         update_1_0
5983                 },
5984                 _ => unreachable!(),
5985         };
5986
5987         // 1 => 0 commitment_signed_dance
5988         if update_1_0.update_fail_htlcs.len() > 0 {
5989                 let mut fail_msg = update_1_0.update_fail_htlcs[0].clone();
5990                 if test_case == 100 {
5991                         callback_fail(&mut fail_msg);
5992                 }
5993                 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &fail_msg);
5994         } else {
5995                 nodes[0].node.handle_update_fail_malformed_htlc(&nodes[1].node.get_our_node_id(), &update_1_0.update_fail_malformed_htlcs[0]);
5996         };
5997
5998         commitment_signed_dance!(nodes[0], nodes[1], update_1_0.commitment_signed, false, true);
5999
6000         let events = nodes[0].node.get_and_clear_pending_events();
6001         assert_eq!(events.len(), 1);
6002         if let &Event::PaymentFailed { payment_hash:_, ref rejected_by_dest, ref error_code, error_data: _ } = &events[0] {
6003                 assert_eq!(*rejected_by_dest, !expected_retryable);
6004                 assert_eq!(*error_code, expected_error_code);
6005         } else {
6006                 panic!("Uexpected event");
6007         }
6008
6009         let events = nodes[0].node.get_and_clear_pending_msg_events();
6010         if expected_channel_update.is_some() {
6011                 assert_eq!(events.len(), 1);
6012                 match events[0] {
6013                         MessageSendEvent::PaymentFailureNetworkUpdate { ref update } => {
6014                                 match update {
6015                                         &HTLCFailChannelUpdate::ChannelUpdateMessage { .. } => {
6016                                                 if let HTLCFailChannelUpdate::ChannelUpdateMessage { .. } = expected_channel_update.unwrap() {} else {
6017                                                         panic!("channel_update not found!");
6018                                                 }
6019                                         },
6020                                         &HTLCFailChannelUpdate::ChannelClosed { ref short_channel_id, ref is_permanent } => {
6021                                                 if let HTLCFailChannelUpdate::ChannelClosed { short_channel_id: ref expected_short_channel_id, is_permanent: ref expected_is_permanent } = expected_channel_update.unwrap() {
6022                                                         assert!(*short_channel_id == *expected_short_channel_id);
6023                                                         assert!(*is_permanent == *expected_is_permanent);
6024                                                 } else {
6025                                                         panic!("Unexpected message event");
6026                                                 }
6027                                         },
6028                                         &HTLCFailChannelUpdate::NodeFailure { ref node_id, ref is_permanent } => {
6029                                                 if let HTLCFailChannelUpdate::NodeFailure { node_id: ref expected_node_id, is_permanent: ref expected_is_permanent } = expected_channel_update.unwrap() {
6030                                                         assert!(*node_id == *expected_node_id);
6031                                                         assert!(*is_permanent == *expected_is_permanent);
6032                                                 } else {
6033                                                         panic!("Unexpected message event");
6034                                                 }
6035                                         },
6036                                 }
6037                         },
6038                         _ => panic!("Unexpected message event"),
6039                 }
6040         } else {
6041                 assert_eq!(events.len(), 0);
6042         }
6043 }
6044
6045 impl msgs::ChannelUpdate {
6046         fn dummy() -> msgs::ChannelUpdate {
6047                 use bitcoin::secp256k1::ffi::Signature as FFISignature;
6048                 use bitcoin::secp256k1::Signature;
6049                 msgs::ChannelUpdate {
6050                         signature: Signature::from(FFISignature::new()),
6051                         contents: msgs::UnsignedChannelUpdate {
6052                                 chain_hash: BlockHash::hash(&vec![0u8][..]),
6053                                 short_channel_id: 0,
6054                                 timestamp: 0,
6055                                 flags: 0,
6056                                 cltv_expiry_delta: 0,
6057                                 htlc_minimum_msat: 0,
6058                                 fee_base_msat: 0,
6059                                 fee_proportional_millionths: 0,
6060                                 excess_data: vec![],
6061                         }
6062                 }
6063         }
6064 }
6065
6066 struct BogusOnionHopData {
6067         data: Vec<u8>
6068 }
6069 impl BogusOnionHopData {
6070         fn new(orig: msgs::OnionHopData) -> Self {
6071                 Self { data: orig.encode() }
6072         }
6073 }
6074 impl Writeable for BogusOnionHopData {
6075         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
6076                 writer.write_all(&self.data[..])
6077         }
6078 }
6079
6080 #[test]
6081 fn test_onion_failure() {
6082         use ln::msgs::ChannelUpdate;
6083         use ln::channelmanager::CLTV_FAR_FAR_AWAY;
6084         use bitcoin::secp256k1;
6085
6086         const BADONION: u16 = 0x8000;
6087         const PERM: u16 = 0x4000;
6088         const NODE: u16 = 0x2000;
6089         const UPDATE: u16 = 0x1000;
6090
6091         let chanmon_cfgs = create_chanmon_cfgs(3);
6092         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
6093         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
6094         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
6095         for node in nodes.iter() {
6096                 *node.keys_manager.override_session_priv.lock().unwrap() = Some(SecretKey::from_slice(&[3; 32]).unwrap());
6097         }
6098         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())];
6099         let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
6100         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6101         let logger = test_utils::TestLogger::new();
6102         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();
6103         // positve case
6104         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 40000, 40_000);
6105
6106         // intermediate node failure
6107         run_onion_failure_test("invalid_realm", 0, &nodes, &route, &payment_hash, |msg| {
6108                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6109                 let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
6110                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6111                 let (mut onion_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 40000, &None, cur_height).unwrap();
6112                 let mut new_payloads = Vec::new();
6113                 for payload in onion_payloads.drain(..) {
6114                         new_payloads.push(BogusOnionHopData::new(payload));
6115                 }
6116                 // break the first (non-final) hop payload by swapping the realm (0) byte for a byte
6117                 // describing a length-1 TLV payload, which is obviously bogus.
6118                 new_payloads[0].data[0] = 1;
6119                 msg.onion_routing_packet = onion_utils::construct_onion_packet_bogus_hopdata(new_payloads, onion_keys, [0; 32], &payment_hash);
6120         }, ||{}, 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
6121
6122         // final node failure
6123         run_onion_failure_test("invalid_realm", 3, &nodes, &route, &payment_hash, |msg| {
6124                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6125                 let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
6126                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6127                 let (mut onion_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 40000, &None, cur_height).unwrap();
6128                 let mut new_payloads = Vec::new();
6129                 for payload in onion_payloads.drain(..) {
6130                         new_payloads.push(BogusOnionHopData::new(payload));
6131                 }
6132                 // break the last-hop payload by swapping the realm (0) byte for a byte describing a
6133                 // length-1 TLV payload, which is obviously bogus.
6134                 new_payloads[1].data[0] = 1;
6135                 msg.onion_routing_packet = onion_utils::construct_onion_packet_bogus_hopdata(new_payloads, onion_keys, [0; 32], &payment_hash);
6136         }, ||{}, false, Some(PERM|22), Some(msgs::HTLCFailChannelUpdate::ChannelClosed{short_channel_id: channels[1].0.contents.short_channel_id, is_permanent: true}));
6137
6138         // the following three with run_onion_failure_test_with_fail_intercept() test only the origin node
6139         // receiving simulated fail messages
6140         // intermediate node failure
6141         run_onion_failure_test_with_fail_intercept("temporary_node_failure", 100, &nodes, &route, &payment_hash, |msg| {
6142                 // trigger error
6143                 msg.amount_msat -= 1;
6144         }, |msg| {
6145                 // and tamper returning error message
6146                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6147                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6148                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], NODE|2, &[0;0]);
6149         }, ||{}, true, Some(NODE|2), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.paths[0][0].pubkey, is_permanent: false}));
6150
6151         // final node failure
6152         run_onion_failure_test_with_fail_intercept("temporary_node_failure", 200, &nodes, &route, &payment_hash, |_msg| {}, |msg| {
6153                 // and tamper returning error message
6154                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6155                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6156                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[1].shared_secret[..], NODE|2, &[0;0]);
6157         }, ||{
6158                 nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
6159         }, true, Some(NODE|2), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.paths[0][1].pubkey, is_permanent: false}));
6160
6161         // intermediate node failure
6162         run_onion_failure_test_with_fail_intercept("permanent_node_failure", 100, &nodes, &route, &payment_hash, |msg| {
6163                 msg.amount_msat -= 1;
6164         }, |msg| {
6165                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6166                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6167                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], PERM|NODE|2, &[0;0]);
6168         }, ||{}, true, Some(PERM|NODE|2), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.paths[0][0].pubkey, is_permanent: true}));
6169
6170         // final node failure
6171         run_onion_failure_test_with_fail_intercept("permanent_node_failure", 200, &nodes, &route, &payment_hash, |_msg| {}, |msg| {
6172                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6173                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6174                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[1].shared_secret[..], PERM|NODE|2, &[0;0]);
6175         }, ||{
6176                 nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
6177         }, false, Some(PERM|NODE|2), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.paths[0][1].pubkey, is_permanent: true}));
6178
6179         // intermediate node failure
6180         run_onion_failure_test_with_fail_intercept("required_node_feature_missing", 100, &nodes, &route, &payment_hash, |msg| {
6181                 msg.amount_msat -= 1;
6182         }, |msg| {
6183                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6184                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6185                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], PERM|NODE|3, &[0;0]);
6186         }, ||{
6187                 nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
6188         }, true, Some(PERM|NODE|3), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.paths[0][0].pubkey, is_permanent: true}));
6189
6190         // final node failure
6191         run_onion_failure_test_with_fail_intercept("required_node_feature_missing", 200, &nodes, &route, &payment_hash, |_msg| {}, |msg| {
6192                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6193                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6194                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[1].shared_secret[..], PERM|NODE|3, &[0;0]);
6195         }, ||{
6196                 nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
6197         }, false, Some(PERM|NODE|3), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.paths[0][1].pubkey, is_permanent: true}));
6198
6199         run_onion_failure_test("invalid_onion_version", 0, &nodes, &route, &payment_hash, |msg| { msg.onion_routing_packet.version = 1; }, ||{}, true,
6200                 Some(BADONION|PERM|4), None);
6201
6202         run_onion_failure_test("invalid_onion_hmac", 0, &nodes, &route, &payment_hash, |msg| { msg.onion_routing_packet.hmac = [3; 32]; }, ||{}, true,
6203                 Some(BADONION|PERM|5), None);
6204
6205         run_onion_failure_test("invalid_onion_key", 0, &nodes, &route, &payment_hash, |msg| { msg.onion_routing_packet.public_key = Err(secp256k1::Error::InvalidPublicKey);}, ||{}, true,
6206                 Some(BADONION|PERM|6), None);
6207
6208         run_onion_failure_test_with_fail_intercept("temporary_channel_failure", 100, &nodes, &route, &payment_hash, |msg| {
6209                 msg.amount_msat -= 1;
6210         }, |msg| {
6211                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6212                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6213                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], UPDATE|7, &ChannelUpdate::dummy().encode_with_len()[..]);
6214         }, ||{}, true, Some(UPDATE|7), Some(msgs::HTLCFailChannelUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy()}));
6215
6216         run_onion_failure_test_with_fail_intercept("permanent_channel_failure", 100, &nodes, &route, &payment_hash, |msg| {
6217                 msg.amount_msat -= 1;
6218         }, |msg| {
6219                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6220                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6221                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], PERM|8, &[0;0]);
6222                 // short_channel_id from the processing node
6223         }, ||{}, true, Some(PERM|8), Some(msgs::HTLCFailChannelUpdate::ChannelClosed{short_channel_id: channels[1].0.contents.short_channel_id, is_permanent: true}));
6224
6225         run_onion_failure_test_with_fail_intercept("required_channel_feature_missing", 100, &nodes, &route, &payment_hash, |msg| {
6226                 msg.amount_msat -= 1;
6227         }, |msg| {
6228                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6229                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6230                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], PERM|9, &[0;0]);
6231                 // short_channel_id from the processing node
6232         }, ||{}, true, Some(PERM|9), Some(msgs::HTLCFailChannelUpdate::ChannelClosed{short_channel_id: channels[1].0.contents.short_channel_id, is_permanent: true}));
6233
6234         let mut bogus_route = route.clone();
6235         bogus_route.paths[0][1].short_channel_id -= 1;
6236         run_onion_failure_test("unknown_next_peer", 0, &nodes, &bogus_route, &payment_hash, |_| {}, ||{}, true, Some(PERM|10),
6237           Some(msgs::HTLCFailChannelUpdate::ChannelClosed{short_channel_id: bogus_route.paths[0][1].short_channel_id, is_permanent:true}));
6238
6239         let amt_to_forward = nodes[1].node.channel_state.lock().unwrap().by_id.get(&channels[1].2).unwrap().get_their_htlc_minimum_msat() - 1;
6240         let mut bogus_route = route.clone();
6241         let route_len = bogus_route.paths[0].len();
6242         bogus_route.paths[0][route_len-1].fee_msat = amt_to_forward;
6243         run_onion_failure_test("amount_below_minimum", 0, &nodes, &bogus_route, &payment_hash, |_| {}, ||{}, true, Some(UPDATE|11), Some(msgs::HTLCFailChannelUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy()}));
6244
6245         //TODO: with new config API, we will be able to generate both valid and
6246         //invalid channel_update cases.
6247         run_onion_failure_test("fee_insufficient", 0, &nodes, &route, &payment_hash, |msg| {
6248                 msg.amount_msat -= 1;
6249         }, || {}, true, Some(UPDATE|12), Some(msgs::HTLCFailChannelUpdate::ChannelClosed { short_channel_id: channels[0].0.contents.short_channel_id, is_permanent: true}));
6250
6251         run_onion_failure_test("incorrect_cltv_expiry", 0, &nodes, &route, &payment_hash, |msg| {
6252                 // need to violate: cltv_expiry - cltv_expiry_delta >= outgoing_cltv_value
6253                 msg.cltv_expiry -= 1;
6254         }, || {}, true, Some(UPDATE|13), Some(msgs::HTLCFailChannelUpdate::ChannelClosed { short_channel_id: channels[0].0.contents.short_channel_id, is_permanent: true}));
6255
6256         run_onion_failure_test("expiry_too_soon", 0, &nodes, &route, &payment_hash, |msg| {
6257                 let height = msg.cltv_expiry - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS + 1;
6258                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
6259
6260                 nodes[1].block_notifier.block_connected_checked(&header, height, &[], &[]);
6261         }, ||{}, true, Some(UPDATE|14), Some(msgs::HTLCFailChannelUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy()}));
6262
6263         run_onion_failure_test("unknown_payment_hash", 2, &nodes, &route, &payment_hash, |_| {}, || {
6264                 nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
6265         }, false, Some(PERM|15), None);
6266
6267         run_onion_failure_test("final_expiry_too_soon", 1, &nodes, &route, &payment_hash, |msg| {
6268                 let height = msg.cltv_expiry - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS + 1;
6269                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
6270
6271                 nodes[2].block_notifier.block_connected_checked(&header, height, &[], &[]);
6272         }, || {}, true, Some(17), None);
6273
6274         run_onion_failure_test("final_incorrect_cltv_expiry", 1, &nodes, &route, &payment_hash, |_| {}, || {
6275                 for (_, pending_forwards) in nodes[1].node.channel_state.lock().unwrap().forward_htlcs.iter_mut() {
6276                         for f in pending_forwards.iter_mut() {
6277                                 match f {
6278                                         &mut HTLCForwardInfo::AddHTLC { ref mut forward_info, .. } =>
6279                                                 forward_info.outgoing_cltv_value += 1,
6280                                         _ => {},
6281                                 }
6282                         }
6283                 }
6284         }, true, Some(18), None);
6285
6286         run_onion_failure_test("final_incorrect_htlc_amount", 1, &nodes, &route, &payment_hash, |_| {}, || {
6287                 // violate amt_to_forward > msg.amount_msat
6288                 for (_, pending_forwards) in nodes[1].node.channel_state.lock().unwrap().forward_htlcs.iter_mut() {
6289                         for f in pending_forwards.iter_mut() {
6290                                 match f {
6291                                         &mut HTLCForwardInfo::AddHTLC { ref mut forward_info, .. } =>
6292                                                 forward_info.amt_to_forward -= 1,
6293                                         _ => {},
6294                                 }
6295                         }
6296                 }
6297         }, true, Some(19), None);
6298
6299         run_onion_failure_test("channel_disabled", 0, &nodes, &route, &payment_hash, |_| {}, || {
6300                 // disconnect event to the channel between nodes[1] ~ nodes[2]
6301                 nodes[1].node.peer_disconnected(&nodes[2].node.get_our_node_id(), false);
6302                 nodes[2].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
6303         }, true, Some(UPDATE|20), Some(msgs::HTLCFailChannelUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy()}));
6304         reconnect_nodes(&nodes[1], &nodes[2], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
6305
6306         run_onion_failure_test("expiry_too_far", 0, &nodes, &route, &payment_hash, |msg| {
6307                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6308                 let mut route = route.clone();
6309                 let height = 1;
6310                 route.paths[0][1].cltv_expiry_delta += CLTV_FAR_FAR_AWAY + route.paths[0][0].cltv_expiry_delta + 1;
6311                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6312                 let (onion_payloads, _, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 40000, &None, height).unwrap();
6313                 let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash);
6314                 msg.cltv_expiry = htlc_cltv;
6315                 msg.onion_routing_packet = onion_packet;
6316         }, ||{}, true, Some(21), None);
6317 }
6318
6319 #[test]
6320 #[should_panic]
6321 fn bolt2_open_channel_sending_node_checks_part1() { //This test needs to be on its own as we are catching a panic
6322         let chanmon_cfgs = create_chanmon_cfgs(2);
6323         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6324         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6325         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6326         //Force duplicate channel ids
6327         for node in nodes.iter() {
6328                 *node.keys_manager.override_channel_id_priv.lock().unwrap() = Some([0; 32]);
6329         }
6330
6331         // BOLT #2 spec: Sending node must ensure temporary_channel_id is unique from any other channel ID with the same peer.
6332         let channel_value_satoshis=10000;
6333         let push_msat=10001;
6334         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, push_msat, 42, None).unwrap();
6335         let node0_to_1_send_open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
6336         nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &node0_to_1_send_open_channel);
6337
6338         //Create a second channel with a channel_id collision
6339         assert!(nodes[0].node.create_channel(nodes[0].node.get_our_node_id(), channel_value_satoshis, push_msat, 42, None).is_err());
6340 }
6341
6342 #[test]
6343 fn bolt2_open_channel_sending_node_checks_part2() {
6344         let chanmon_cfgs = create_chanmon_cfgs(2);
6345         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6346         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6347         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6348
6349         // BOLT #2 spec: Sending node must set funding_satoshis to less than 2^24 satoshis
6350         let channel_value_satoshis=2^24;
6351         let push_msat=10001;
6352         assert!(nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, push_msat, 42, None).is_err());
6353
6354         // BOLT #2 spec: Sending node must set push_msat to equal or less than 1000 * funding_satoshis
6355         let channel_value_satoshis=10000;
6356         // Test when push_msat is equal to 1000 * funding_satoshis.
6357         let push_msat=1000*channel_value_satoshis+1;
6358         assert!(nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, push_msat, 42, None).is_err());
6359
6360         // BOLT #2 spec: Sending node must set set channel_reserve_satoshis greater than or equal to dust_limit_satoshis
6361         let channel_value_satoshis=10000;
6362         let push_msat=10001;
6363         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
6364         let node0_to_1_send_open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
6365         assert!(node0_to_1_send_open_channel.channel_reserve_satoshis>=node0_to_1_send_open_channel.dust_limit_satoshis);
6366
6367         // BOLT #2 spec: Sending node must set undefined bits in channel_flags to 0
6368         // 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
6369         assert!(node0_to_1_send_open_channel.channel_flags<=1);
6370
6371         // 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.
6372         assert!(BREAKDOWN_TIMEOUT>0);
6373         assert!(node0_to_1_send_open_channel.to_self_delay==BREAKDOWN_TIMEOUT);
6374
6375         // BOLT #2 spec: Sending node must ensure the chain_hash value identifies the chain it wishes to open the channel within.
6376         let chain_hash=genesis_block(Network::Testnet).header.bitcoin_hash();
6377         assert_eq!(node0_to_1_send_open_channel.chain_hash,chain_hash);
6378
6379         // 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.
6380         assert!(PublicKey::from_slice(&node0_to_1_send_open_channel.funding_pubkey.serialize()).is_ok());
6381         assert!(PublicKey::from_slice(&node0_to_1_send_open_channel.revocation_basepoint.serialize()).is_ok());
6382         assert!(PublicKey::from_slice(&node0_to_1_send_open_channel.htlc_basepoint.serialize()).is_ok());
6383         assert!(PublicKey::from_slice(&node0_to_1_send_open_channel.payment_point.serialize()).is_ok());
6384         assert!(PublicKey::from_slice(&node0_to_1_send_open_channel.delayed_payment_basepoint.serialize()).is_ok());
6385 }
6386
6387 // BOLT 2 Requirements for the Sender when constructing and sending an update_add_htlc message.
6388 // 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.
6389 //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.
6390
6391 #[test]
6392 fn test_update_add_htlc_bolt2_sender_value_below_minimum_msat() {
6393         //BOLT2 Requirement: MUST NOT offer amount_msat below the receiving node's htlc_minimum_msat (same validation check catches both of these)
6394         let chanmon_cfgs = create_chanmon_cfgs(2);
6395         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6396         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6397         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6398         let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6399
6400         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6401         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6402         let logger = test_utils::TestLogger::new();
6403         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();
6404         route.paths[0][0].fee_msat = 100;
6405
6406         unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { err },
6407                 assert_eq!(err, "Cannot send less than their minimum HTLC value"));
6408         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
6409         nodes[0].logger.assert_log("lightning::ln::channelmanager".to_string(), "Cannot send less than their minimum HTLC value".to_string(), 1);
6410 }
6411
6412 #[test]
6413 fn test_update_add_htlc_bolt2_sender_zero_value_msat() {
6414         //BOLT2 Requirement: MUST offer amount_msat greater than 0.
6415         let chanmon_cfgs = create_chanmon_cfgs(2);
6416         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6417         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6418         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6419         let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6420         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6421
6422         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6423         let logger = test_utils::TestLogger::new();
6424         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();
6425         route.paths[0][0].fee_msat = 0;
6426         unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { err },
6427                 assert_eq!(err, "Cannot send 0-msat HTLC"));
6428
6429         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
6430         nodes[0].logger.assert_log("lightning::ln::channelmanager".to_string(), "Cannot send 0-msat HTLC".to_string(), 1);
6431 }
6432
6433 #[test]
6434 fn test_update_add_htlc_bolt2_receiver_zero_value_msat() {
6435         //BOLT2 Requirement: MUST offer amount_msat greater than 0.
6436         let chanmon_cfgs = create_chanmon_cfgs(2);
6437         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6438         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6439         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6440         let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6441
6442         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6443         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6444         let logger = test_utils::TestLogger::new();
6445         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();
6446         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6447         check_added_monitors!(nodes[0], 1);
6448         let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6449         updates.update_add_htlcs[0].amount_msat = 0;
6450
6451         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6452         nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Remote side tried to send a 0-msat HTLC".to_string(), 1);
6453         check_closed_broadcast!(nodes[1], true).unwrap();
6454         check_added_monitors!(nodes[1], 1);
6455 }
6456
6457 #[test]
6458 fn test_update_add_htlc_bolt2_sender_cltv_expiry_too_high() {
6459         //BOLT 2 Requirement: MUST set cltv_expiry less than 500000000.
6460         //It is enforced when constructing a route.
6461         let chanmon_cfgs = create_chanmon_cfgs(2);
6462         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6463         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6464         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6465         let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 0, InitFeatures::known(), InitFeatures::known());
6466         let logger = test_utils::TestLogger::new();
6467
6468         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6469
6470         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6471         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();
6472         unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::RouteError { err },
6473                 assert_eq!(err, "Channel CLTV overflowed?!"));
6474 }
6475
6476 #[test]
6477 fn test_update_add_htlc_bolt2_sender_exceed_max_htlc_num_and_htlc_id_increment() {
6478         //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.
6479         //BOLT 2 Requirement: for the first HTLC it offers MUST set id to 0.
6480         //BOLT 2 Requirement: MUST increase the value of id by 1 for each successive offer.
6481         let chanmon_cfgs = create_chanmon_cfgs(2);
6482         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6483         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6484         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6485         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 0, InitFeatures::known(), InitFeatures::known());
6486         let max_accepted_htlcs = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().their_max_accepted_htlcs as u64;
6487
6488         let logger = test_utils::TestLogger::new();
6489         for i in 0..max_accepted_htlcs {
6490                 let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6491                 let payment_event = {
6492                         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6493                         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();
6494                         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6495                         check_added_monitors!(nodes[0], 1);
6496
6497                         let mut events = nodes[0].node.get_and_clear_pending_msg_events();
6498                         assert_eq!(events.len(), 1);
6499                         if let MessageSendEvent::UpdateHTLCs { node_id: _, updates: msgs::CommitmentUpdate{ update_add_htlcs: ref htlcs, .. }, } = events[0] {
6500                                 assert_eq!(htlcs[0].htlc_id, i);
6501                         } else {
6502                                 assert!(false);
6503                         }
6504                         SendEvent::from_event(events.remove(0))
6505                 };
6506                 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
6507                 check_added_monitors!(nodes[1], 0);
6508                 commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
6509
6510                 expect_pending_htlcs_forwardable!(nodes[1]);
6511                 expect_payment_received!(nodes[1], our_payment_hash, 100000);
6512         }
6513         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6514         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6515         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();
6516         unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { err },
6517                 assert_eq!(err, "Cannot push more than their max accepted HTLCs"));
6518
6519         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
6520         nodes[0].logger.assert_log("lightning::ln::channelmanager".to_string(), "Cannot push more than their max accepted HTLCs".to_string(), 1);
6521 }
6522
6523 #[test]
6524 fn test_update_add_htlc_bolt2_sender_exceed_max_htlc_value_in_flight() {
6525         //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.
6526         let chanmon_cfgs = create_chanmon_cfgs(2);
6527         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6528         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6529         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6530         let channel_value = 100000;
6531         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, channel_value, 0, InitFeatures::known(), InitFeatures::known());
6532         let max_in_flight = get_channel_value_stat!(nodes[0], chan.2).their_max_htlc_value_in_flight_msat;
6533
6534         send_payment(&nodes[0], &vec!(&nodes[1])[..], max_in_flight, max_in_flight);
6535
6536         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6537         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6538         let logger = test_utils::TestLogger::new();
6539         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();
6540         unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { err },
6541                 assert_eq!(err, "Cannot send value that would put us over the max HTLC value in flight our peer will accept"));
6542
6543         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
6544         nodes[0].logger.assert_log("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);
6545
6546         send_payment(&nodes[0], &[&nodes[1]], max_in_flight, max_in_flight);
6547 }
6548
6549 // BOLT 2 Requirements for the Receiver when handling an update_add_htlc message.
6550 #[test]
6551 fn test_update_add_htlc_bolt2_receiver_check_amount_received_more_than_min() {
6552         //BOLT2 Requirement: receiving an amount_msat equal to 0, OR less than its own htlc_minimum_msat -> SHOULD fail the channel.
6553         let chanmon_cfgs = create_chanmon_cfgs(2);
6554         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6555         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6556         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6557         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6558         let htlc_minimum_msat: u64;
6559         {
6560                 let chan_lock = nodes[0].node.channel_state.lock().unwrap();
6561                 let channel = chan_lock.by_id.get(&chan.2).unwrap();
6562                 htlc_minimum_msat = channel.get_our_htlc_minimum_msat();
6563         }
6564
6565         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6566         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6567         let logger = test_utils::TestLogger::new();
6568         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();
6569         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6570         check_added_monitors!(nodes[0], 1);
6571         let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6572         updates.update_add_htlcs[0].amount_msat = htlc_minimum_msat-1;
6573         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6574         assert!(nodes[1].node.list_channels().is_empty());
6575         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
6576         assert_eq!(err_msg.data, "Remote side tried to send less than our minimum HTLC value");
6577         check_added_monitors!(nodes[1], 1);
6578 }
6579
6580 #[test]
6581 fn test_update_add_htlc_bolt2_receiver_sender_can_afford_amount_sent() {
6582         //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
6583         let chanmon_cfgs = create_chanmon_cfgs(2);
6584         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6585         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6586         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6587         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6588         let logger = test_utils::TestLogger::new();
6589
6590         let chan_stat = get_channel_value_stat!(nodes[0], chan.2);
6591         let channel_reserve = chan_stat.channel_reserve_msat;
6592         let feerate = get_feerate!(nodes[0], chan.2);
6593         // The 2* and +1 are for the fee spike reserve.
6594         let commit_tx_fee_outbound = 2 * commit_tx_fee_msat(feerate, 1 + 1);
6595
6596         let max_can_send = 5000000 - channel_reserve - commit_tx_fee_outbound;
6597         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6598         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6599         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();
6600         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6601         check_added_monitors!(nodes[0], 1);
6602         let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6603
6604         // Even though channel-initiator senders are required to respect the fee_spike_reserve,
6605         // at this time channel-initiatee receivers are not required to enforce that senders
6606         // respect the fee_spike_reserve.
6607         updates.update_add_htlcs[0].amount_msat = max_can_send + commit_tx_fee_outbound + 1;
6608         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6609
6610         assert!(nodes[1].node.list_channels().is_empty());
6611         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
6612         assert_eq!(err_msg.data, "Remote HTLC add would put them under remote reserve value");
6613         check_added_monitors!(nodes[1], 1);
6614 }
6615
6616 #[test]
6617 fn test_update_add_htlc_bolt2_receiver_check_max_htlc_limit() {
6618         //BOLT 2 Requirement: if a sending node adds more than its max_accepted_htlcs HTLCs to its local commitment transaction: SHOULD fail the channel
6619         //BOLT 2 Requirement: MUST allow multiple HTLCs with the same payment_hash.
6620         let chanmon_cfgs = create_chanmon_cfgs(2);
6621         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6622         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6623         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6624         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6625         let logger = test_utils::TestLogger::new();
6626
6627         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6628         let session_priv = SecretKey::from_slice(&[42; 32]).unwrap();
6629
6630         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6631         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();
6632
6633         let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
6634         let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::signing_only(), &route.paths[0], &session_priv).unwrap();
6635         let (onion_payloads, _htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 3999999, &None, cur_height).unwrap();
6636         let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &our_payment_hash);
6637
6638         let mut msg = msgs::UpdateAddHTLC {
6639                 channel_id: chan.2,
6640                 htlc_id: 0,
6641                 amount_msat: 1000,
6642                 payment_hash: our_payment_hash,
6643                 cltv_expiry: htlc_cltv,
6644                 onion_routing_packet: onion_packet.clone(),
6645         };
6646
6647         for i in 0..super::channel::OUR_MAX_HTLCS {
6648                 msg.htlc_id = i as u64;
6649                 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &msg);
6650         }
6651         msg.htlc_id = (super::channel::OUR_MAX_HTLCS) as u64;
6652         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &msg);
6653
6654         assert!(nodes[1].node.list_channels().is_empty());
6655         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
6656         assert_eq!(err_msg.data, "Remote tried to push more than our max accepted HTLCs");
6657         check_added_monitors!(nodes[1], 1);
6658 }
6659
6660 #[test]
6661 fn test_update_add_htlc_bolt2_receiver_check_max_in_flight_msat() {
6662         //OR adds more than its max_htlc_value_in_flight_msat worth of offered HTLCs to its local commitment transaction: SHOULD fail the channel
6663         let chanmon_cfgs = create_chanmon_cfgs(2);
6664         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6665         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6666         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6667         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
6668         let logger = test_utils::TestLogger::new();
6669
6670         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6671         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6672         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();
6673         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6674         check_added_monitors!(nodes[0], 1);
6675         let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6676         updates.update_add_htlcs[0].amount_msat = get_channel_value_stat!(nodes[1], chan.2).their_max_htlc_value_in_flight_msat + 1;
6677         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6678
6679         assert!(nodes[1].node.list_channels().is_empty());
6680         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
6681         assert_eq!(err_msg.data,"Remote HTLC add would put them over our max HTLC value");
6682         check_added_monitors!(nodes[1], 1);
6683 }
6684
6685 #[test]
6686 fn test_update_add_htlc_bolt2_receiver_check_cltv_expiry() {
6687         //BOLT2 Requirement: if sending node sets cltv_expiry to greater or equal to 500000000: SHOULD fail the channel.
6688         let chanmon_cfgs = create_chanmon_cfgs(2);
6689         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6690         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6691         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6692         let logger = test_utils::TestLogger::new();
6693
6694         create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6695         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6696         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6697         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();
6698         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6699         check_added_monitors!(nodes[0], 1);
6700         let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6701         updates.update_add_htlcs[0].cltv_expiry = 500000000;
6702         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6703
6704         assert!(nodes[1].node.list_channels().is_empty());
6705         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
6706         assert_eq!(err_msg.data,"Remote provided CLTV expiry in seconds instead of block height");
6707         check_added_monitors!(nodes[1], 1);
6708 }
6709
6710 #[test]
6711 fn test_update_add_htlc_bolt2_receiver_check_repeated_id_ignore() {
6712         //BOLT 2 requirement: if the sender did not previously acknowledge the commitment of that HTLC: MUST ignore a repeated id value after a reconnection.
6713         // We test this by first testing that that repeated HTLCs pass commitment signature checks
6714         // after disconnect and that non-sequential htlc_ids result in a channel failure.
6715         let chanmon_cfgs = create_chanmon_cfgs(2);
6716         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6717         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6718         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6719         let logger = test_utils::TestLogger::new();
6720
6721         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
6722         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6723         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6724         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();
6725         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6726         check_added_monitors!(nodes[0], 1);
6727         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6728         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6729
6730         //Disconnect and Reconnect
6731         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
6732         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
6733         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
6734         let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
6735         assert_eq!(reestablish_1.len(), 1);
6736         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
6737         let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
6738         assert_eq!(reestablish_2.len(), 1);
6739         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
6740         handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
6741         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
6742         handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
6743
6744         //Resend HTLC
6745         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6746         assert_eq!(updates.commitment_signed.htlc_signatures.len(), 1);
6747         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &updates.commitment_signed);
6748         check_added_monitors!(nodes[1], 1);
6749         let _bs_responses = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
6750
6751         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6752
6753         assert!(nodes[1].node.list_channels().is_empty());
6754         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
6755         assert_eq!(err_msg.data, "Remote skipped HTLC ID");
6756         check_added_monitors!(nodes[1], 1);
6757 }
6758
6759 #[test]
6760 fn test_update_fulfill_htlc_bolt2_update_fulfill_htlc_before_commitment() {
6761         //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.
6762
6763         let chanmon_cfgs = create_chanmon_cfgs(2);
6764         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6765         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6766         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6767         let logger = test_utils::TestLogger::new();
6768         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
6769         let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6770         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6771         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();
6772         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6773
6774         check_added_monitors!(nodes[0], 1);
6775         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6776         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6777
6778         let update_msg = msgs::UpdateFulfillHTLC{
6779                 channel_id: chan.2,
6780                 htlc_id: 0,
6781                 payment_preimage: our_payment_preimage,
6782         };
6783
6784         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_msg);
6785
6786         assert!(nodes[0].node.list_channels().is_empty());
6787         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
6788         assert_eq!(err_msg.data, "Remote tried to fulfill/fail HTLC before it had been committed");
6789         check_added_monitors!(nodes[0], 1);
6790 }
6791
6792 #[test]
6793 fn test_update_fulfill_htlc_bolt2_update_fail_htlc_before_commitment() {
6794         //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.
6795
6796         let chanmon_cfgs = create_chanmon_cfgs(2);
6797         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6798         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6799         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6800         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
6801         let logger = test_utils::TestLogger::new();
6802
6803         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6804         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6805         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();
6806         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6807         check_added_monitors!(nodes[0], 1);
6808         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6809         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6810
6811         let update_msg = msgs::UpdateFailHTLC{
6812                 channel_id: chan.2,
6813                 htlc_id: 0,
6814                 reason: msgs::OnionErrorPacket { data: Vec::new()},
6815         };
6816
6817         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_msg);
6818
6819         assert!(nodes[0].node.list_channels().is_empty());
6820         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
6821         assert_eq!(err_msg.data, "Remote tried to fulfill/fail HTLC before it had been committed");
6822         check_added_monitors!(nodes[0], 1);
6823 }
6824
6825 #[test]
6826 fn test_update_fulfill_htlc_bolt2_update_fail_malformed_htlc_before_commitment() {
6827         //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.
6828
6829         let chanmon_cfgs = create_chanmon_cfgs(2);
6830         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6831         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6832         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6833         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
6834         let logger = test_utils::TestLogger::new();
6835
6836         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6837         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6838         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();
6839         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6840         check_added_monitors!(nodes[0], 1);
6841         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6842         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6843
6844         let update_msg = msgs::UpdateFailMalformedHTLC{
6845                 channel_id: chan.2,
6846                 htlc_id: 0,
6847                 sha256_of_onion: [1; 32],
6848                 failure_code: 0x8000,
6849         };
6850
6851         nodes[0].node.handle_update_fail_malformed_htlc(&nodes[1].node.get_our_node_id(), &update_msg);
6852
6853         assert!(nodes[0].node.list_channels().is_empty());
6854         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
6855         assert_eq!(err_msg.data, "Remote tried to fulfill/fail HTLC before it had been committed");
6856         check_added_monitors!(nodes[0], 1);
6857 }
6858
6859 #[test]
6860 fn test_update_fulfill_htlc_bolt2_incorrect_htlc_id() {
6861         //BOLT 2 Requirement: A receiving node: if the id does not correspond to an HTLC in its current commitment transaction MUST fail the channel.
6862
6863         let chanmon_cfgs = create_chanmon_cfgs(2);
6864         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6865         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6866         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6867         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
6868
6869         let our_payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 100000).0;
6870
6871         nodes[1].node.claim_funds(our_payment_preimage, &None, 100_000);
6872         check_added_monitors!(nodes[1], 1);
6873
6874         let events = nodes[1].node.get_and_clear_pending_msg_events();
6875         assert_eq!(events.len(), 1);
6876         let mut update_fulfill_msg: msgs::UpdateFulfillHTLC = {
6877                 match events[0] {
6878                         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, .. } } => {
6879                                 assert!(update_add_htlcs.is_empty());
6880                                 assert_eq!(update_fulfill_htlcs.len(), 1);
6881                                 assert!(update_fail_htlcs.is_empty());
6882                                 assert!(update_fail_malformed_htlcs.is_empty());
6883                                 assert!(update_fee.is_none());
6884                                 update_fulfill_htlcs[0].clone()
6885                         },
6886                         _ => panic!("Unexpected event"),
6887                 }
6888         };
6889
6890         update_fulfill_msg.htlc_id = 1;
6891
6892         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_msg);
6893
6894         assert!(nodes[0].node.list_channels().is_empty());
6895         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
6896         assert_eq!(err_msg.data, "Remote tried to fulfill/fail an HTLC we couldn't find");
6897         check_added_monitors!(nodes[0], 1);
6898 }
6899
6900 #[test]
6901 fn test_update_fulfill_htlc_bolt2_wrong_preimage() {
6902         //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.
6903
6904         let chanmon_cfgs = create_chanmon_cfgs(2);
6905         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6906         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6907         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6908         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
6909
6910         let our_payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 100000).0;
6911
6912         nodes[1].node.claim_funds(our_payment_preimage, &None, 100_000);
6913         check_added_monitors!(nodes[1], 1);
6914
6915         let events = nodes[1].node.get_and_clear_pending_msg_events();
6916         assert_eq!(events.len(), 1);
6917         let mut update_fulfill_msg: msgs::UpdateFulfillHTLC = {
6918                 match events[0] {
6919                         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, .. } } => {
6920                                 assert!(update_add_htlcs.is_empty());
6921                                 assert_eq!(update_fulfill_htlcs.len(), 1);
6922                                 assert!(update_fail_htlcs.is_empty());
6923                                 assert!(update_fail_malformed_htlcs.is_empty());
6924                                 assert!(update_fee.is_none());
6925                                 update_fulfill_htlcs[0].clone()
6926                         },
6927                         _ => panic!("Unexpected event"),
6928                 }
6929         };
6930
6931         update_fulfill_msg.payment_preimage = PaymentPreimage([1; 32]);
6932
6933         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_msg);
6934
6935         assert!(nodes[0].node.list_channels().is_empty());
6936         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
6937         assert_eq!(err_msg.data, "Remote tried to fulfill HTLC with an incorrect preimage");
6938         check_added_monitors!(nodes[0], 1);
6939 }
6940
6941 #[test]
6942 fn test_update_fulfill_htlc_bolt2_missing_badonion_bit_for_malformed_htlc_message() {
6943         //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.
6944
6945         let chanmon_cfgs = create_chanmon_cfgs(2);
6946         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6947         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6948         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6949         create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
6950         let logger = test_utils::TestLogger::new();
6951
6952         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6953         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6954         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();
6955         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6956         check_added_monitors!(nodes[0], 1);
6957
6958         let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6959         updates.update_add_htlcs[0].onion_routing_packet.version = 1; //Produce a malformed HTLC message
6960
6961         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6962         check_added_monitors!(nodes[1], 0);
6963         commitment_signed_dance!(nodes[1], nodes[0], updates.commitment_signed, false, true);
6964
6965         let events = nodes[1].node.get_and_clear_pending_msg_events();
6966
6967         let mut update_msg: msgs::UpdateFailMalformedHTLC = {
6968                 match events[0] {
6969                         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, .. } } => {
6970                                 assert!(update_add_htlcs.is_empty());
6971                                 assert!(update_fulfill_htlcs.is_empty());
6972                                 assert!(update_fail_htlcs.is_empty());
6973                                 assert_eq!(update_fail_malformed_htlcs.len(), 1);
6974                                 assert!(update_fee.is_none());
6975                                 update_fail_malformed_htlcs[0].clone()
6976                         },
6977                         _ => panic!("Unexpected event"),
6978                 }
6979         };
6980         update_msg.failure_code &= !0x8000;
6981         nodes[0].node.handle_update_fail_malformed_htlc(&nodes[1].node.get_our_node_id(), &update_msg);
6982
6983         assert!(nodes[0].node.list_channels().is_empty());
6984         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
6985         assert_eq!(err_msg.data, "Got update_fail_malformed_htlc with BADONION not set");
6986         check_added_monitors!(nodes[0], 1);
6987 }
6988
6989 #[test]
6990 fn test_update_fulfill_htlc_bolt2_after_malformed_htlc_message_must_forward_update_fail_htlc() {
6991         //BOLT 2 Requirement: a receiving node which has an outgoing HTLC canceled by update_fail_malformed_htlc:
6992         //    * 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.
6993
6994         let chanmon_cfgs = create_chanmon_cfgs(3);
6995         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
6996         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
6997         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
6998         create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
6999         create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
7000         let logger = test_utils::TestLogger::new();
7001
7002         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
7003
7004         //First hop
7005         let mut payment_event = {
7006                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
7007                 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();
7008                 nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
7009                 check_added_monitors!(nodes[0], 1);
7010                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
7011                 assert_eq!(events.len(), 1);
7012                 SendEvent::from_event(events.remove(0))
7013         };
7014         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
7015         check_added_monitors!(nodes[1], 0);
7016         commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
7017         expect_pending_htlcs_forwardable!(nodes[1]);
7018         let mut events_2 = nodes[1].node.get_and_clear_pending_msg_events();
7019         assert_eq!(events_2.len(), 1);
7020         check_added_monitors!(nodes[1], 1);
7021         payment_event = SendEvent::from_event(events_2.remove(0));
7022         assert_eq!(payment_event.msgs.len(), 1);
7023
7024         //Second Hop
7025         payment_event.msgs[0].onion_routing_packet.version = 1; //Produce a malformed HTLC message
7026         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
7027         check_added_monitors!(nodes[2], 0);
7028         commitment_signed_dance!(nodes[2], nodes[1], payment_event.commitment_msg, false, true);
7029
7030         let events_3 = nodes[2].node.get_and_clear_pending_msg_events();
7031         assert_eq!(events_3.len(), 1);
7032         let update_msg : (msgs::UpdateFailMalformedHTLC, msgs::CommitmentSigned) = {
7033                 match events_3[0] {
7034                         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 } } => {
7035                                 assert!(update_add_htlcs.is_empty());
7036                                 assert!(update_fulfill_htlcs.is_empty());
7037                                 assert!(update_fail_htlcs.is_empty());
7038                                 assert_eq!(update_fail_malformed_htlcs.len(), 1);
7039                                 assert!(update_fee.is_none());
7040                                 (update_fail_malformed_htlcs[0].clone(), commitment_signed.clone())
7041                         },
7042                         _ => panic!("Unexpected event"),
7043                 }
7044         };
7045
7046         nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), &update_msg.0);
7047
7048         check_added_monitors!(nodes[1], 0);
7049         commitment_signed_dance!(nodes[1], nodes[2], update_msg.1, false, true);
7050         expect_pending_htlcs_forwardable!(nodes[1]);
7051         let events_4 = nodes[1].node.get_and_clear_pending_msg_events();
7052         assert_eq!(events_4.len(), 1);
7053
7054         //Confirm that handlinge the update_malformed_htlc message produces an update_fail_htlc message to be forwarded back along the route
7055         match events_4[0] {
7056                 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, .. } } => {
7057                         assert!(update_add_htlcs.is_empty());
7058                         assert!(update_fulfill_htlcs.is_empty());
7059                         assert_eq!(update_fail_htlcs.len(), 1);
7060                         assert!(update_fail_malformed_htlcs.is_empty());
7061                         assert!(update_fee.is_none());
7062                 },
7063                 _ => panic!("Unexpected event"),
7064         };
7065
7066         check_added_monitors!(nodes[1], 1);
7067 }
7068
7069 fn do_test_failure_delay_dust_htlc_local_commitment(announce_latest: bool) {
7070         // Dust-HTLC failure updates must be delayed until failure-trigger tx (in this case local commitment) reach ANTI_REORG_DELAY
7071         // 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
7072         // HTLC could have been removed from lastest local commitment tx but still valid until we get remote RAA
7073
7074         let chanmon_cfgs = create_chanmon_cfgs(2);
7075         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7076         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7077         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7078         let chan =create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
7079
7080         let bs_dust_limit = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
7081
7082         // We route 2 dust-HTLCs between A and B
7083         let (_, payment_hash_1) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
7084         let (_, payment_hash_2) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
7085         route_payment(&nodes[0], &[&nodes[1]], 1000000);
7086
7087         // Cache one local commitment tx as previous
7088         let as_prev_commitment_tx = get_local_commitment_txn!(nodes[0], chan.2);
7089
7090         // Fail one HTLC to prune it in the will-be-latest-local commitment tx
7091         assert!(nodes[1].node.fail_htlc_backwards(&payment_hash_2, &None));
7092         check_added_monitors!(nodes[1], 0);
7093         expect_pending_htlcs_forwardable!(nodes[1]);
7094         check_added_monitors!(nodes[1], 1);
7095
7096         let remove = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
7097         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &remove.update_fail_htlcs[0]);
7098         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &remove.commitment_signed);
7099         check_added_monitors!(nodes[0], 1);
7100
7101         // Cache one local commitment tx as lastest
7102         let as_last_commitment_tx = get_local_commitment_txn!(nodes[0], chan.2);
7103
7104         let events = nodes[0].node.get_and_clear_pending_msg_events();
7105         match events[0] {
7106                 MessageSendEvent::SendRevokeAndACK { node_id, .. } => {
7107                         assert_eq!(node_id, nodes[1].node.get_our_node_id());
7108                 },
7109                 _ => panic!("Unexpected event"),
7110         }
7111         match events[1] {
7112                 MessageSendEvent::UpdateHTLCs { node_id, .. } => {
7113                         assert_eq!(node_id, nodes[1].node.get_our_node_id());
7114                 },
7115                 _ => panic!("Unexpected event"),
7116         }
7117
7118         assert_ne!(as_prev_commitment_tx, as_last_commitment_tx);
7119         // Fail the 2 dust-HTLCs, move their failure in maturation buffer (htlc_updated_waiting_threshold_conf)
7120         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7121
7122         if announce_latest {
7123                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![as_last_commitment_tx[0].clone()]}, 1);
7124         } else {
7125                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![as_prev_commitment_tx[0].clone()]}, 1);
7126         }
7127
7128         check_closed_broadcast!(nodes[0], false);
7129         check_added_monitors!(nodes[0], 1);
7130
7131         assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7132         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 1, true,  header.bitcoin_hash());
7133         let events = nodes[0].node.get_and_clear_pending_events();
7134         // Only 2 PaymentFailed events should show up, over-dust HTLC has to be failed by timeout tx
7135         assert_eq!(events.len(), 2);
7136         let mut first_failed = false;
7137         for event in events {
7138                 match event {
7139                         Event::PaymentFailed { payment_hash, .. } => {
7140                                 if payment_hash == payment_hash_1 {
7141                                         assert!(!first_failed);
7142                                         first_failed = true;
7143                                 } else {
7144                                         assert_eq!(payment_hash, payment_hash_2);
7145                                 }
7146                         }
7147                         _ => panic!("Unexpected event"),
7148                 }
7149         }
7150 }
7151
7152 #[test]
7153 fn test_failure_delay_dust_htlc_local_commitment() {
7154         do_test_failure_delay_dust_htlc_local_commitment(true);
7155         do_test_failure_delay_dust_htlc_local_commitment(false);
7156 }
7157
7158 #[test]
7159 fn test_no_failure_dust_htlc_local_commitment() {
7160         // Transaction filters for failing back dust htlc based on local commitment txn infos has been
7161         // prone to error, we test here that a dummy transaction don't fail them.
7162
7163         let chanmon_cfgs = create_chanmon_cfgs(2);
7164         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7165         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7166         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7167         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
7168
7169         // Rebalance a bit
7170         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
7171
7172         let as_dust_limit = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
7173         let bs_dust_limit = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
7174
7175         // We route 2 dust-HTLCs between A and B
7176         let (preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
7177         let (preimage_2, _) = route_payment(&nodes[1], &[&nodes[0]], as_dust_limit*1000);
7178
7179         // Build a dummy invalid transaction trying to spend a commitment tx
7180         let input = TxIn {
7181                 previous_output: BitcoinOutPoint { txid: chan.3.txid(), vout: 0 },
7182                 script_sig: Script::new(),
7183                 sequence: 0,
7184                 witness: Vec::new(),
7185         };
7186
7187         let outp = TxOut {
7188                 script_pubkey: Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(),
7189                 value: 10000,
7190         };
7191
7192         let dummy_tx = Transaction {
7193                 version: 2,
7194                 lock_time: 0,
7195                 input: vec![input],
7196                 output: vec![outp]
7197         };
7198
7199         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7200         nodes[0].chan_monitor.simple_monitor.block_connected(&header, 1, &[&dummy_tx], &[1;1]);
7201         assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7202         assert_eq!(nodes[0].node.get_and_clear_pending_msg_events().len(), 0);
7203         // We broadcast a few more block to check everything is all right
7204         connect_blocks(&nodes[0].block_notifier, 20, 1, true,  header.bitcoin_hash());
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
7208         claim_payment(&nodes[0], &vec!(&nodes[1])[..], preimage_1, bs_dust_limit*1000);
7209         claim_payment(&nodes[1], &vec!(&nodes[0])[..], preimage_2, as_dust_limit*1000);
7210 }
7211
7212 fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) {
7213         // Outbound HTLC-failure updates must be cancelled if we get a reorg before we reach ANTI_REORG_DELAY.
7214         // Broadcast of revoked remote commitment tx, trigger failure-update of dust/non-dust HTLCs
7215         // Broadcast of remote commitment tx, trigger failure-update of dust-HTLCs
7216         // Broadcast of timeout tx on remote commitment tx, trigger failure-udate of non-dust HTLCs
7217         // Broadcast of local commitment tx, trigger failure-update of dust-HTLCs
7218         // Broadcast of HTLC-timeout tx on local commitment tx, trigger failure-update of non-dust HTLCs
7219
7220         let chanmon_cfgs = create_chanmon_cfgs(3);
7221         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
7222         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
7223         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
7224         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
7225
7226         let bs_dust_limit = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
7227
7228         let (_payment_preimage_1, dust_hash) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
7229         let (_payment_preimage_2, non_dust_hash) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
7230
7231         let as_commitment_tx = get_local_commitment_txn!(nodes[0], chan.2);
7232         let bs_commitment_tx = get_local_commitment_txn!(nodes[1], chan.2);
7233
7234         // We revoked bs_commitment_tx
7235         if revoked {
7236                 let (payment_preimage_3, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
7237                 claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3, 1_000_000);
7238         }
7239
7240         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7241         let mut timeout_tx = Vec::new();
7242         if local {
7243                 // We fail dust-HTLC 1 by broadcast of local commitment tx
7244                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![as_commitment_tx[0].clone()]}, 1);
7245                 check_closed_broadcast!(nodes[0], false);
7246                 check_added_monitors!(nodes[0], 1);
7247                 assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7248                 timeout_tx.push(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap()[0].clone());
7249                 let parent_hash  = connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 2, true, header.bitcoin_hash());
7250                 expect_payment_failed!(nodes[0], dust_hash, true);
7251                 assert_eq!(timeout_tx[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
7252                 // We fail non-dust-HTLC 2 by broadcast of local HTLC-timeout tx on local commitment tx
7253                 let header_2 = BlockHeader { version: 0x20000000, prev_blockhash: parent_hash, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7254                 assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7255                 nodes[0].block_notifier.block_connected(&Block { header: header_2, txdata: vec![timeout_tx[0].clone()]}, 7);
7256                 let header_3 = BlockHeader { version: 0x20000000, prev_blockhash: header_2.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7257                 connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 8, true, header_3.bitcoin_hash());
7258                 expect_payment_failed!(nodes[0], non_dust_hash, true);
7259         } else {
7260                 // We fail dust-HTLC 1 by broadcast of remote commitment tx. If revoked, fail also non-dust HTLC
7261                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![bs_commitment_tx[0].clone()]}, 1);
7262                 check_closed_broadcast!(nodes[0], false);
7263                 check_added_monitors!(nodes[0], 1);
7264                 assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7265                 timeout_tx.push(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap()[0].clone());
7266                 let parent_hash  = connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 2, true, header.bitcoin_hash());
7267                 let header_2 = BlockHeader { version: 0x20000000, prev_blockhash: parent_hash, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7268                 if !revoked {
7269                         expect_payment_failed!(nodes[0], dust_hash, true);
7270                         assert_eq!(timeout_tx[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
7271                         // We fail non-dust-HTLC 2 by broadcast of local timeout tx on remote commitment tx
7272                         nodes[0].block_notifier.block_connected(&Block { header: header_2, txdata: vec![timeout_tx[0].clone()]}, 7);
7273                         assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7274                         let header_3 = BlockHeader { version: 0x20000000, prev_blockhash: header_2.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7275                         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 8, true, header_3.bitcoin_hash());
7276                         expect_payment_failed!(nodes[0], non_dust_hash, true);
7277                 } else {
7278                         // If revoked, both dust & non-dust HTLCs should have been failed after ANTI_REORG_DELAY confs of revoked
7279                         // commitment tx
7280                         let events = nodes[0].node.get_and_clear_pending_events();
7281                         assert_eq!(events.len(), 2);
7282                         let first;
7283                         match events[0] {
7284                                 Event::PaymentFailed { payment_hash, .. } => {
7285                                         if payment_hash == dust_hash { first = true; }
7286                                         else { first = false; }
7287                                 },
7288                                 _ => panic!("Unexpected event"),
7289                         }
7290                         match events[1] {
7291                                 Event::PaymentFailed { payment_hash, .. } => {
7292                                         if first { assert_eq!(payment_hash, non_dust_hash); }
7293                                         else { assert_eq!(payment_hash, dust_hash); }
7294                                 },
7295                                 _ => panic!("Unexpected event"),
7296                         }
7297                 }
7298         }
7299 }
7300
7301 #[test]
7302 fn test_sweep_outbound_htlc_failure_update() {
7303         do_test_sweep_outbound_htlc_failure_update(false, true);
7304         do_test_sweep_outbound_htlc_failure_update(false, false);
7305         do_test_sweep_outbound_htlc_failure_update(true, false);
7306 }
7307
7308 #[test]
7309 fn test_upfront_shutdown_script() {
7310         // BOLT 2 : Option upfront shutdown script, if peer commit its closing_script at channel opening
7311         // enforce it at shutdown message
7312
7313         let mut config = UserConfig::default();
7314         config.channel_options.announced_channel = true;
7315         config.peer_channel_config_limits.force_announced_channel_preference = false;
7316         config.channel_options.commit_upfront_shutdown_pubkey = false;
7317         let user_cfgs = [None, Some(config), None];
7318         let chanmon_cfgs = create_chanmon_cfgs(3);
7319         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
7320         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
7321         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
7322
7323         // We test that in case of peer committing upfront to a script, if it changes at closing, we refuse to sign
7324         let flags = InitFeatures::known();
7325         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000, flags.clone(), flags.clone());
7326         nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
7327         let mut node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id());
7328         node_0_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh();
7329         // Test we enforce upfront_scriptpbukey if by providing a diffrent one at closing that  we disconnect peer
7330         nodes[2].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
7331         assert_eq!(check_closed_broadcast!(nodes[2], true).unwrap().data, "Got shutdown request with a scriptpubkey which did not match their previous scriptpubkey");
7332         check_added_monitors!(nodes[2], 1);
7333
7334         // We test that in case of peer committing upfront to a script, if it doesn't change at closing, we sign
7335         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000, flags.clone(), flags.clone());
7336         nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
7337         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id());
7338         // We test that in case of peer committing upfront to a script, if it oesn't change at closing, we sign
7339         nodes[2].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
7340         let events = nodes[2].node.get_and_clear_pending_msg_events();
7341         assert_eq!(events.len(), 1);
7342         match events[0] {
7343                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[0].node.get_our_node_id()) }
7344                 _ => panic!("Unexpected event"),
7345         }
7346
7347         // We test that if case of peer non-signaling we don't enforce committed script at channel opening
7348         let flags_no = InitFeatures::known().clear_upfront_shutdown_script();
7349         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, flags_no, flags.clone());
7350         nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
7351         let mut node_1_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
7352         node_1_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh();
7353         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_1_shutdown);
7354         let events = nodes[1].node.get_and_clear_pending_msg_events();
7355         assert_eq!(events.len(), 1);
7356         match events[0] {
7357                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[0].node.get_our_node_id()) }
7358                 _ => panic!("Unexpected event"),
7359         }
7360
7361         // We test that if user opt-out, we provide a zero-length script at channel opening and we are able to close
7362         // channel smoothly, opt-out is from channel initiator here
7363         let chan = create_announced_chan_between_nodes_with_value(&nodes, 1, 0, 1000000, 1000000, flags.clone(), flags.clone());
7364         nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
7365         let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
7366         node_0_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh();
7367         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
7368         let events = nodes[0].node.get_and_clear_pending_msg_events();
7369         assert_eq!(events.len(), 1);
7370         match events[0] {
7371                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
7372                 _ => panic!("Unexpected event"),
7373         }
7374
7375         //// We test that if user opt-out, we provide a zero-length script at channel opening and we are able to close
7376         //// channel smoothly
7377         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, flags.clone(), flags.clone());
7378         nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
7379         let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
7380         node_0_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh();
7381         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
7382         let events = nodes[0].node.get_and_clear_pending_msg_events();
7383         assert_eq!(events.len(), 2);
7384         match events[0] {
7385                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
7386                 _ => panic!("Unexpected event"),
7387         }
7388         match events[1] {
7389                 MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
7390                 _ => panic!("Unexpected event"),
7391         }
7392 }
7393
7394 #[test]
7395 fn test_user_configurable_csv_delay() {
7396         // We test our channel constructors yield errors when we pass them absurd csv delay
7397
7398         let mut low_our_to_self_config = UserConfig::default();
7399         low_our_to_self_config.own_channel_config.our_to_self_delay = 6;
7400         let mut high_their_to_self_config = UserConfig::default();
7401         high_their_to_self_config.peer_channel_config_limits.their_to_self_delay = 100;
7402         let user_cfgs = [Some(high_their_to_self_config.clone()), None];
7403         let chanmon_cfgs = create_chanmon_cfgs(2);
7404         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7405         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &user_cfgs);
7406         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7407
7408         // We test config.our_to_self > BREAKDOWN_TIMEOUT is enforced in Channel::new_outbound()
7409         let keys_manager: Arc<KeysInterface<ChanKeySigner = EnforcingChannelKeys>> = Arc::new(test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet));
7410         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) {
7411                 match error {
7412                         APIError::APIMisuseError { err } => { assert_eq!(err, "Configured with an unreasonable our_to_self_delay putting user funds at risks"); },
7413                         _ => panic!("Unexpected event"),
7414                 }
7415         } else { assert!(false) }
7416
7417         // We test config.our_to_self > BREAKDOWN_TIMEOUT is enforced in Channel::new_from_req()
7418         nodes[1].node.create_channel(nodes[0].node.get_our_node_id(), 1000000, 1000000, 42, None).unwrap();
7419         let mut open_channel = get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, nodes[0].node.get_our_node_id());
7420         open_channel.to_self_delay = 200;
7421         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) {
7422                 match error {
7423                         ChannelError::Close(err) => { assert_eq!(err, "Configured with an unreasonable our_to_self_delay putting user funds at risks"); },
7424                         _ => panic!("Unexpected event"),
7425                 }
7426         } else { assert!(false); }
7427
7428         // We test msg.to_self_delay <= config.their_to_self_delay is enforced in Chanel::accept_channel()
7429         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 1000000, 1000000, 42, None).unwrap();
7430         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()));
7431         let mut accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
7432         accept_channel.to_self_delay = 200;
7433         nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), InitFeatures::known(), &accept_channel);
7434         if let MessageSendEvent::HandleError { ref action, .. } = nodes[0].node.get_and_clear_pending_msg_events()[0] {
7435                 match action {
7436                         &ErrorAction::SendErrorMessage { ref msg } => {
7437                                 assert_eq!(msg.data,"They wanted our payments to be delayed by a needlessly long period");
7438                         },
7439                         _ => { assert!(false); }
7440                 }
7441         } else { assert!(false); }
7442
7443         // We test msg.to_self_delay <= config.their_to_self_delay is enforced in Channel::new_from_req()
7444         nodes[1].node.create_channel(nodes[0].node.get_our_node_id(), 1000000, 1000000, 42, None).unwrap();
7445         let mut open_channel = get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, nodes[0].node.get_our_node_id());
7446         open_channel.to_self_delay = 200;
7447         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) {
7448                 match error {
7449                         ChannelError::Close(err) => { assert_eq!(err, "They wanted our payments to be delayed by a needlessly long period"); },
7450                         _ => panic!("Unexpected event"),
7451                 }
7452         } else { assert!(false); }
7453 }
7454
7455 #[test]
7456 fn test_data_loss_protect() {
7457         // We want to be sure that :
7458         // * we don't broadcast our Local Commitment Tx in case of fallen behind
7459         // * we close channel in case of detecting other being fallen behind
7460         // * we are able to claim our own outputs thanks to to_remote being static
7461         let keys_manager;
7462         let logger;
7463         let fee_estimator;
7464         let tx_broadcaster;
7465         let chain_monitor;
7466         let monitor;
7467         let node_state_0;
7468         let chanmon_cfgs = create_chanmon_cfgs(2);
7469         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7470         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7471         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7472
7473         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
7474
7475         // Cache node A state before any channel update
7476         let previous_node_state = nodes[0].node.encode();
7477         let mut previous_chan_monitor_state = test_utils::TestVecWriter(Vec::new());
7478         nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter().next().unwrap().1.write_for_disk(&mut previous_chan_monitor_state).unwrap();
7479
7480         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
7481         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
7482
7483         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
7484         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
7485
7486         // Restore node A from previous state
7487         logger = test_utils::TestLogger::with_id(format!("node {}", 0));
7488         let mut chan_monitor = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut ::std::io::Cursor::new(previous_chan_monitor_state.0)).unwrap().1;
7489         chain_monitor = ChainWatchInterfaceUtil::new(Network::Testnet);
7490         tx_broadcaster = test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new())};
7491         fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
7492         keys_manager = test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet);
7493         monitor = test_utils::TestChannelMonitor::new(&chain_monitor, &tx_broadcaster, &logger, &fee_estimator);
7494         node_state_0 = {
7495                 let mut channel_monitors = HashMap::new();
7496                 channel_monitors.insert(OutPoint { txid: chan.3.txid(), index: 0 }, &mut chan_monitor);
7497                 <(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 {
7498                         keys_manager: &keys_manager,
7499                         fee_estimator: &fee_estimator,
7500                         monitor: &monitor,
7501                         logger: &logger,
7502                         tx_broadcaster: &tx_broadcaster,
7503                         default_config: UserConfig::default(),
7504                         channel_monitors: &mut channel_monitors,
7505                 }).unwrap().1
7506         };
7507         nodes[0].node = &node_state_0;
7508         assert!(monitor.add_monitor(OutPoint { txid: chan.3.txid(), index: 0 }, chan_monitor).is_ok());
7509         nodes[0].chan_monitor = &monitor;
7510         nodes[0].chain_monitor = &chain_monitor;
7511
7512         nodes[0].block_notifier = BlockNotifier::new(&nodes[0].chain_monitor);
7513         nodes[0].block_notifier.register_listener(&nodes[0].chan_monitor.simple_monitor);
7514         nodes[0].block_notifier.register_listener(nodes[0].node);
7515
7516         check_added_monitors!(nodes[0], 1);
7517
7518         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
7519         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
7520
7521         let reestablish_0 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
7522
7523         // Check we don't broadcast any transactions following learning of per_commitment_point from B
7524         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_0[0]);
7525         check_added_monitors!(nodes[0], 1);
7526
7527         {
7528                 let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
7529                 assert_eq!(node_txn.len(), 0);
7530         }
7531
7532         let mut reestablish_1 = Vec::with_capacity(1);
7533         for msg in nodes[0].node.get_and_clear_pending_msg_events() {
7534                 if let MessageSendEvent::SendChannelReestablish { ref node_id, ref msg } = msg {
7535                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
7536                         reestablish_1.push(msg.clone());
7537                 } else if let MessageSendEvent::BroadcastChannelUpdate { .. } = msg {
7538                 } else if let MessageSendEvent::HandleError { ref action, .. } = msg {
7539                         match action {
7540                                 &ErrorAction::SendErrorMessage { ref msg } => {
7541                                         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");
7542                                 },
7543                                 _ => panic!("Unexpected event!"),
7544                         }
7545                 } else {
7546                         panic!("Unexpected event")
7547                 }
7548         }
7549
7550         // Check we close channel detecting A is fallen-behind
7551         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
7552         assert_eq!(check_closed_broadcast!(nodes[1], true).unwrap().data, "Peer attempted to reestablish channel with a very old local commitment transaction");
7553         check_added_monitors!(nodes[1], 1);
7554
7555
7556         // Check A is able to claim to_remote output
7557         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
7558         assert_eq!(node_txn.len(), 1);
7559         check_spends!(node_txn[0], chan.3);
7560         assert_eq!(node_txn[0].output.len(), 2);
7561         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
7562         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()]}, 0);
7563         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 0, true, header.bitcoin_hash());
7564         let spend_txn = check_spendable_outputs!(nodes[0], 1, node_cfgs[0].keys_manager, 100000);
7565         assert_eq!(spend_txn.len(), 1);
7566         check_spends!(spend_txn[0], node_txn[0]);
7567 }
7568
7569 #[test]
7570 fn test_check_htlc_underpaying() {
7571         // Send payment through A -> B but A is maliciously
7572         // sending a probe payment (i.e less than expected value0
7573         // to B, B should refuse payment.
7574
7575         let chanmon_cfgs = create_chanmon_cfgs(2);
7576         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7577         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7578         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7579
7580         // Create some initial channels
7581         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
7582
7583         let (payment_preimage, payment_hash) = route_payment(&nodes[0], &[&nodes[1]], 10_000);
7584
7585         // Node 3 is expecting payment of 100_000 but receive 10_000,
7586         // fail htlc like we didn't know the preimage.
7587         nodes[1].node.claim_funds(payment_preimage, &None, 100_000);
7588         nodes[1].node.process_pending_htlc_forwards();
7589
7590         let events = nodes[1].node.get_and_clear_pending_msg_events();
7591         assert_eq!(events.len(), 1);
7592         let (update_fail_htlc, commitment_signed) = match events[0] {
7593                 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 } } => {
7594                         assert!(update_add_htlcs.is_empty());
7595                         assert!(update_fulfill_htlcs.is_empty());
7596                         assert_eq!(update_fail_htlcs.len(), 1);
7597                         assert!(update_fail_malformed_htlcs.is_empty());
7598                         assert!(update_fee.is_none());
7599                         (update_fail_htlcs[0].clone(), commitment_signed)
7600                 },
7601                 _ => panic!("Unexpected event"),
7602         };
7603         check_added_monitors!(nodes[1], 1);
7604
7605         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlc);
7606         commitment_signed_dance!(nodes[0], nodes[1], commitment_signed, false, true);
7607
7608         // 10_000 msat as u64, followed by a height of 99 as u32
7609         let mut expected_failure_data = byte_utils::be64_to_array(10_000).to_vec();
7610         expected_failure_data.extend_from_slice(&byte_utils::be32_to_array(99));
7611         expect_payment_failed!(nodes[0], payment_hash, true, 0x4000|15, &expected_failure_data[..]);
7612         nodes[1].node.get_and_clear_pending_events();
7613 }
7614
7615 #[test]
7616 fn test_announce_disable_channels() {
7617         // Create 2 channels between A and B. Disconnect B. Call timer_chan_freshness_every_min and check for generated
7618         // ChannelUpdate. Reconnect B, reestablish and check there is non-generated ChannelUpdate.
7619
7620         let chanmon_cfgs = create_chanmon_cfgs(2);
7621         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7622         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7623         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7624
7625         let short_id_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
7626         let short_id_2 = create_announced_chan_between_nodes(&nodes, 1, 0, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
7627         let short_id_3 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
7628
7629         // Disconnect peers
7630         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
7631         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
7632
7633         nodes[0].node.timer_chan_freshness_every_min(); // dirty -> stagged
7634         nodes[0].node.timer_chan_freshness_every_min(); // staged -> fresh
7635         let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
7636         assert_eq!(msg_events.len(), 3);
7637         for e in msg_events {
7638                 match e {
7639                         MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
7640                                 let short_id = msg.contents.short_channel_id;
7641                                 // Check generated channel_update match list in PendingChannelUpdate
7642                                 if short_id != short_id_1 && short_id != short_id_2 && short_id != short_id_3 {
7643                                         panic!("Generated ChannelUpdate for wrong chan!");
7644                                 }
7645                         },
7646                         _ => panic!("Unexpected event"),
7647                 }
7648         }
7649         // Reconnect peers
7650         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
7651         let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
7652         assert_eq!(reestablish_1.len(), 3);
7653         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
7654         let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
7655         assert_eq!(reestablish_2.len(), 3);
7656
7657         // Reestablish chan_1
7658         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
7659         handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
7660         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
7661         handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
7662         // Reestablish chan_2
7663         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[1]);
7664         handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
7665         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[1]);
7666         handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
7667         // Reestablish chan_3
7668         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[2]);
7669         handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
7670         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[2]);
7671         handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
7672
7673         nodes[0].node.timer_chan_freshness_every_min();
7674         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
7675 }
7676
7677 #[test]
7678 fn test_bump_penalty_txn_on_revoked_commitment() {
7679         // In case of penalty txn with too low feerates for getting into mempools, RBF-bump them to be sure
7680         // we're able to claim outputs on revoked commitment transaction before timelocks expiration
7681
7682         let chanmon_cfgs = create_chanmon_cfgs(2);
7683         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7684         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7685         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7686
7687         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
7688         let logger = test_utils::TestLogger::new();
7689
7690
7691         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
7692         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
7693         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();
7694         send_along_route(&nodes[1], route, &vec!(&nodes[0])[..], 3000000);
7695
7696         let revoked_txn = get_local_commitment_txn!(nodes[0], chan.2);
7697         // Revoked commitment txn with 4 outputs : to_local, to_remote, 1 outgoing HTLC, 1 incoming HTLC
7698         assert_eq!(revoked_txn[0].output.len(), 4);
7699         assert_eq!(revoked_txn[0].input.len(), 1);
7700         assert_eq!(revoked_txn[0].input[0].previous_output.txid, chan.3.txid());
7701         let revoked_txid = revoked_txn[0].txid();
7702
7703         let mut penalty_sum = 0;
7704         for outp in revoked_txn[0].output.iter() {
7705                 if outp.script_pubkey.is_v0_p2wsh() {
7706                         penalty_sum += outp.value;
7707                 }
7708         }
7709
7710         // Connect blocks to change height_timer range to see if we use right soonest_timelock
7711         let header_114 = connect_blocks(&nodes[1].block_notifier, 114, 0, false, Default::default());
7712
7713         // Actually revoke tx by claiming a HTLC
7714         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
7715         let header = BlockHeader { version: 0x20000000, prev_blockhash: header_114, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7716         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_txn[0].clone()] }, 115);
7717         check_added_monitors!(nodes[1], 1);
7718
7719         // One or more justice tx should have been broadcast, check it
7720         let penalty_1;
7721         let feerate_1;
7722         {
7723                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
7724                 assert_eq!(node_txn.len(), 3); // justice tx (broadcasted from ChannelMonitor) + local commitment tx + local HTLC-timeout (broadcasted from ChannelManager)
7725                 assert_eq!(node_txn[0].input.len(), 3); // Penalty txn claims to_local, offered_htlc and received_htlc outputs
7726                 assert_eq!(node_txn[0].output.len(), 1);
7727                 check_spends!(node_txn[0], revoked_txn[0]);
7728                 let fee_1 = penalty_sum - node_txn[0].output[0].value;
7729                 feerate_1 = fee_1 * 1000 / node_txn[0].get_weight() as u64;
7730                 penalty_1 = node_txn[0].txid();
7731                 node_txn.clear();
7732         };
7733
7734         // After exhaustion of height timer, a new bumped justice tx should have been broadcast, check it
7735         let header = connect_blocks(&nodes[1].block_notifier, 3, 115,  true, header.bitcoin_hash());
7736         let mut penalty_2 = penalty_1;
7737         let mut feerate_2 = 0;
7738         {
7739                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
7740                 assert_eq!(node_txn.len(), 1);
7741                 if node_txn[0].input[0].previous_output.txid == revoked_txid {
7742                         assert_eq!(node_txn[0].input.len(), 3); // Penalty txn claims to_local, offered_htlc and received_htlc outputs
7743                         assert_eq!(node_txn[0].output.len(), 1);
7744                         check_spends!(node_txn[0], revoked_txn[0]);
7745                         penalty_2 = node_txn[0].txid();
7746                         // Verify new bumped tx is different from last claiming transaction, we don't want spurrious rebroadcast
7747                         assert_ne!(penalty_2, penalty_1);
7748                         let fee_2 = penalty_sum - node_txn[0].output[0].value;
7749                         feerate_2 = fee_2 * 1000 / node_txn[0].get_weight() as u64;
7750                         // Verify 25% bump heuristic
7751                         assert!(feerate_2 * 100 >= feerate_1 * 125);
7752                         node_txn.clear();
7753                 }
7754         }
7755         assert_ne!(feerate_2, 0);
7756
7757         // After exhaustion of height timer for a 2nd time, a new bumped justice tx should have been broadcast, check it
7758         connect_blocks(&nodes[1].block_notifier, 3, 118, true, header);
7759         let penalty_3;
7760         let mut feerate_3 = 0;
7761         {
7762                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
7763                 assert_eq!(node_txn.len(), 1);
7764                 if node_txn[0].input[0].previous_output.txid == revoked_txid {
7765                         assert_eq!(node_txn[0].input.len(), 3); // Penalty txn claims to_local, offered_htlc and received_htlc outputs
7766                         assert_eq!(node_txn[0].output.len(), 1);
7767                         check_spends!(node_txn[0], revoked_txn[0]);
7768                         penalty_3 = node_txn[0].txid();
7769                         // Verify new bumped tx is different from last claiming transaction, we don't want spurrious rebroadcast
7770                         assert_ne!(penalty_3, penalty_2);
7771                         let fee_3 = penalty_sum - node_txn[0].output[0].value;
7772                         feerate_3 = fee_3 * 1000 / node_txn[0].get_weight() as u64;
7773                         // Verify 25% bump heuristic
7774                         assert!(feerate_3 * 100 >= feerate_2 * 125);
7775                         node_txn.clear();
7776                 }
7777         }
7778         assert_ne!(feerate_3, 0);
7779
7780         nodes[1].node.get_and_clear_pending_events();
7781         nodes[1].node.get_and_clear_pending_msg_events();
7782 }
7783
7784 #[test]
7785 fn test_bump_penalty_txn_on_revoked_htlcs() {
7786         // In case of penalty txn with too low feerates for getting into mempools, RBF-bump them to sure
7787         // we're able to claim outputs on revoked HTLC transactions before timelocks expiration
7788
7789         let chanmon_cfgs = create_chanmon_cfgs(2);
7790         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7791         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7792         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7793
7794         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
7795         // Lock HTLC in both directions
7796         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3_000_000).0;
7797         route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000).0;
7798
7799         let revoked_local_txn = get_local_commitment_txn!(nodes[1], chan.2);
7800         assert_eq!(revoked_local_txn[0].input.len(), 1);
7801         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
7802
7803         // Revoke local commitment tx
7804         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
7805
7806         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7807         // B will generate both revoked HTLC-timeout/HTLC-preimage txn from revoked commitment tx
7808         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
7809         check_closed_broadcast!(nodes[1], false);
7810         check_added_monitors!(nodes[1], 1);
7811
7812         let revoked_htlc_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
7813         assert_eq!(revoked_htlc_txn.len(), 4);
7814         if revoked_htlc_txn[0].input[0].witness.last().unwrap().len() == ACCEPTED_HTLC_SCRIPT_WEIGHT {
7815                 assert_eq!(revoked_htlc_txn[0].input.len(), 1);
7816                 check_spends!(revoked_htlc_txn[0], revoked_local_txn[0]);
7817                 assert_eq!(revoked_htlc_txn[1].input.len(), 1);
7818                 assert_eq!(revoked_htlc_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
7819                 check_spends!(revoked_htlc_txn[1], revoked_local_txn[0]);
7820         } else if revoked_htlc_txn[1].input[0].witness.last().unwrap().len() == ACCEPTED_HTLC_SCRIPT_WEIGHT {
7821                 assert_eq!(revoked_htlc_txn[1].input.len(), 1);
7822                 check_spends!(revoked_htlc_txn[1], revoked_local_txn[0]);
7823                 assert_eq!(revoked_htlc_txn[0].input.len(), 1);
7824                 assert_eq!(revoked_htlc_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
7825                 check_spends!(revoked_htlc_txn[0], revoked_local_txn[0]);
7826         }
7827
7828         // Broadcast set of revoked txn on A
7829         let header_128 = connect_blocks(&nodes[0].block_notifier, 128, 0, true, header.bitcoin_hash());
7830         expect_pending_htlcs_forwardable_ignore!(nodes[0]);
7831
7832         let header_129 = BlockHeader { version: 0x20000000, prev_blockhash: header_128, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7833         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);
7834         let first;
7835         let feerate_1;
7836         let penalty_txn;
7837         {
7838                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
7839                 assert_eq!(node_txn.len(), 5); // 3 penalty txn on revoked commitment tx + A commitment tx + 1 penalty tnx on revoked HTLC txn
7840                 // Verify claim tx are spending revoked HTLC txn
7841                 assert_eq!(node_txn[4].input.len(), 2);
7842                 assert_eq!(node_txn[4].output.len(), 1);
7843                 check_spends!(node_txn[4], revoked_htlc_txn[0], revoked_htlc_txn[1]);
7844                 first = node_txn[4].txid();
7845                 // Store both feerates for later comparison
7846                 let fee_1 = revoked_htlc_txn[0].output[0].value + revoked_htlc_txn[1].output[0].value - node_txn[4].output[0].value;
7847                 feerate_1 = fee_1 * 1000 / node_txn[4].get_weight() as u64;
7848                 penalty_txn = vec![node_txn[0].clone(), node_txn[1].clone(), node_txn[2].clone()];
7849                 node_txn.clear();
7850         }
7851
7852         // Connect three more block to see if bumped penalty are issued for HTLC txn
7853         let header_130 = BlockHeader { version: 0x20000000, prev_blockhash: header_129.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7854         nodes[0].block_notifier.block_connected(&Block { header: header_130, txdata: penalty_txn }, 130);
7855         {
7856                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
7857                 assert_eq!(node_txn.len(), 2); // 2 bumped penalty txn on revoked commitment tx
7858
7859                 check_spends!(node_txn[0], revoked_local_txn[0]);
7860                 check_spends!(node_txn[1], revoked_local_txn[0]);
7861
7862                 node_txn.clear();
7863         };
7864
7865         // Few more blocks to confirm penalty txn
7866         let header_135 = connect_blocks(&nodes[0].block_notifier, 5, 130, true, header_130.bitcoin_hash());
7867         assert!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().is_empty());
7868         let header_144 = connect_blocks(&nodes[0].block_notifier, 9, 135, true, header_135);
7869         let node_txn = {
7870                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
7871                 assert_eq!(node_txn.len(), 1);
7872
7873                 assert_eq!(node_txn[0].input.len(), 2);
7874                 check_spends!(node_txn[0], revoked_htlc_txn[0], revoked_htlc_txn[1]);
7875                 // Verify bumped tx is different and 25% bump heuristic
7876                 assert_ne!(first, node_txn[0].txid());
7877                 let fee_2 = revoked_htlc_txn[0].output[0].value + revoked_htlc_txn[1].output[0].value - node_txn[0].output[0].value;
7878                 let feerate_2 = fee_2 * 1000 / node_txn[0].get_weight() as u64;
7879                 assert!(feerate_2 * 100 > feerate_1 * 125);
7880                 let txn = vec![node_txn[0].clone()];
7881                 node_txn.clear();
7882                 txn
7883         };
7884         // Broadcast claim txn and confirm blocks to avoid further bumps on this outputs
7885         let header_145 = BlockHeader { version: 0x20000000, prev_blockhash: header_144, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7886         nodes[0].block_notifier.block_connected(&Block { header: header_145, txdata: node_txn }, 145);
7887         connect_blocks(&nodes[0].block_notifier, 20, 145, true, header_145.bitcoin_hash());
7888         {
7889                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
7890                 // We verify than no new transaction has been broadcast because previously
7891                 // we were buggy on this exact behavior by not tracking for monitoring remote HTLC outputs (see #411)
7892                 // which means we wouldn't see a spend of them by a justice tx and bumped justice tx
7893                 // were generated forever instead of safe cleaning after confirmation and ANTI_REORG_SAFE_DELAY blocks.
7894                 // Enforce spending of revoked htlc output by claiming transaction remove request as expected and dry
7895                 // up bumped justice generation.
7896                 assert_eq!(node_txn.len(), 0);
7897                 node_txn.clear();
7898         }
7899         check_closed_broadcast!(nodes[0], false);
7900         check_added_monitors!(nodes[0], 1);
7901 }
7902
7903 #[test]
7904 fn test_bump_penalty_txn_on_remote_commitment() {
7905         // In case of claim txn with too low feerates for getting into mempools, RBF-bump them to be sure
7906         // we're able to claim outputs on remote commitment transaction before timelocks expiration
7907
7908         // Create 2 HTLCs
7909         // Provide preimage for one
7910         // Check aggregation
7911
7912         let chanmon_cfgs = create_chanmon_cfgs(2);
7913         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7914         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7915         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7916
7917         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
7918         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
7919         route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000).0;
7920
7921         // Remote commitment txn with 4 outputs : to_local, to_remote, 1 outgoing HTLC, 1 incoming HTLC
7922         let remote_txn = get_local_commitment_txn!(nodes[0], chan.2);
7923         assert_eq!(remote_txn[0].output.len(), 4);
7924         assert_eq!(remote_txn[0].input.len(), 1);
7925         assert_eq!(remote_txn[0].input[0].previous_output.txid, chan.3.txid());
7926
7927         // Claim a HTLC without revocation (provide B monitor with preimage)
7928         nodes[1].node.claim_funds(payment_preimage, &None, 3_000_000);
7929         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7930         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![remote_txn[0].clone()] }, 1);
7931         check_added_monitors!(nodes[1], 2);
7932
7933         // One or more claim tx should have been broadcast, check it
7934         let timeout;
7935         let preimage;
7936         let feerate_timeout;
7937         let feerate_preimage;
7938         {
7939                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
7940                 assert_eq!(node_txn.len(), 5); // 2 * claim tx (broadcasted from ChannelMonitor) + local commitment tx + local HTLC-timeout + local HTLC-success (broadcasted from ChannelManager)
7941                 assert_eq!(node_txn[0].input.len(), 1);
7942                 assert_eq!(node_txn[1].input.len(), 1);
7943                 check_spends!(node_txn[0], remote_txn[0]);
7944                 check_spends!(node_txn[1], remote_txn[0]);
7945                 check_spends!(node_txn[2], chan.3);
7946                 check_spends!(node_txn[3], node_txn[2]);
7947                 check_spends!(node_txn[4], node_txn[2]);
7948                 if node_txn[0].input[0].witness.last().unwrap().len() == ACCEPTED_HTLC_SCRIPT_WEIGHT {
7949                         timeout = node_txn[0].txid();
7950                         let index = node_txn[0].input[0].previous_output.vout;
7951                         let fee = remote_txn[0].output[index as usize].value - node_txn[0].output[0].value;
7952                         feerate_timeout = fee * 1000 / node_txn[0].get_weight() as u64;
7953
7954                         preimage = node_txn[1].txid();
7955                         let index = node_txn[1].input[0].previous_output.vout;
7956                         let fee = remote_txn[0].output[index as usize].value - node_txn[1].output[0].value;
7957                         feerate_preimage = fee * 1000 / node_txn[1].get_weight() as u64;
7958                 } else {
7959                         timeout = node_txn[1].txid();
7960                         let index = node_txn[1].input[0].previous_output.vout;
7961                         let fee = remote_txn[0].output[index as usize].value - node_txn[1].output[0].value;
7962                         feerate_timeout = fee * 1000 / node_txn[1].get_weight() as u64;
7963
7964                         preimage = node_txn[0].txid();
7965                         let index = node_txn[0].input[0].previous_output.vout;
7966                         let fee = remote_txn[0].output[index as usize].value - node_txn[0].output[0].value;
7967                         feerate_preimage = fee * 1000 / node_txn[0].get_weight() as u64;
7968                 }
7969                 node_txn.clear();
7970         };
7971         assert_ne!(feerate_timeout, 0);
7972         assert_ne!(feerate_preimage, 0);
7973
7974         // After exhaustion of height timer, new bumped claim txn should have been broadcast, check it
7975         connect_blocks(&nodes[1].block_notifier, 15, 1,  true, header.bitcoin_hash());
7976         {
7977                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
7978                 assert_eq!(node_txn.len(), 2);
7979                 assert_eq!(node_txn[0].input.len(), 1);
7980                 assert_eq!(node_txn[1].input.len(), 1);
7981                 check_spends!(node_txn[0], remote_txn[0]);
7982                 check_spends!(node_txn[1], remote_txn[0]);
7983                 if node_txn[0].input[0].witness.last().unwrap().len() == ACCEPTED_HTLC_SCRIPT_WEIGHT {
7984                         let index = node_txn[0].input[0].previous_output.vout;
7985                         let fee = remote_txn[0].output[index as usize].value - node_txn[0].output[0].value;
7986                         let new_feerate = fee * 1000 / node_txn[0].get_weight() as u64;
7987                         assert!(new_feerate * 100 > feerate_timeout * 125);
7988                         assert_ne!(timeout, node_txn[0].txid());
7989
7990                         let index = node_txn[1].input[0].previous_output.vout;
7991                         let fee = remote_txn[0].output[index as usize].value - node_txn[1].output[0].value;
7992                         let new_feerate = fee * 1000 / node_txn[1].get_weight() as u64;
7993                         assert!(new_feerate * 100 > feerate_preimage * 125);
7994                         assert_ne!(preimage, node_txn[1].txid());
7995                 } else {
7996                         let index = node_txn[1].input[0].previous_output.vout;
7997                         let fee = remote_txn[0].output[index as usize].value - node_txn[1].output[0].value;
7998                         let new_feerate = fee * 1000 / node_txn[1].get_weight() as u64;
7999                         assert!(new_feerate * 100 > feerate_timeout * 125);
8000                         assert_ne!(timeout, node_txn[1].txid());
8001
8002                         let index = node_txn[0].input[0].previous_output.vout;
8003                         let fee = remote_txn[0].output[index as usize].value - node_txn[0].output[0].value;
8004                         let new_feerate = fee * 1000 / node_txn[0].get_weight() as u64;
8005                         assert!(new_feerate * 100 > feerate_preimage * 125);
8006                         assert_ne!(preimage, node_txn[0].txid());
8007                 }
8008                 node_txn.clear();
8009         }
8010
8011         nodes[1].node.get_and_clear_pending_events();
8012         nodes[1].node.get_and_clear_pending_msg_events();
8013 }
8014
8015 #[test]
8016 fn test_set_outpoints_partial_claiming() {
8017         // - remote party claim tx, new bump tx
8018         // - disconnect remote claiming tx, new bump
8019         // - disconnect tx, see no tx anymore
8020         let chanmon_cfgs = create_chanmon_cfgs(2);
8021         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8022         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
8023         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8024
8025         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
8026         let payment_preimage_1 = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000).0;
8027         let payment_preimage_2 = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000).0;
8028
8029         // Remote commitment txn with 4 outputs: to_local, to_remote, 2 outgoing HTLC
8030         let remote_txn = get_local_commitment_txn!(nodes[1], chan.2);
8031         assert_eq!(remote_txn.len(), 3);
8032         assert_eq!(remote_txn[0].output.len(), 4);
8033         assert_eq!(remote_txn[0].input.len(), 1);
8034         assert_eq!(remote_txn[0].input[0].previous_output.txid, chan.3.txid());
8035         check_spends!(remote_txn[1], remote_txn[0]);
8036         check_spends!(remote_txn[2], remote_txn[0]);
8037
8038         // Connect blocks on node A to advance height towards TEST_FINAL_CLTV
8039         let prev_header_100 = connect_blocks(&nodes[1].block_notifier, 100, 0, false, Default::default());
8040         // Provide node A with both preimage
8041         nodes[0].node.claim_funds(payment_preimage_1, &None, 3_000_000);
8042         nodes[0].node.claim_funds(payment_preimage_2, &None, 3_000_000);
8043         check_added_monitors!(nodes[0], 2);
8044         nodes[0].node.get_and_clear_pending_events();
8045         nodes[0].node.get_and_clear_pending_msg_events();
8046
8047         // Connect blocks on node A commitment transaction
8048         let header = BlockHeader { version: 0x20000000, prev_blockhash: prev_header_100, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8049         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![remote_txn[0].clone()] }, 101);
8050         check_closed_broadcast!(nodes[0], false);
8051         check_added_monitors!(nodes[0], 1);
8052         // Verify node A broadcast tx claiming both HTLCs
8053         {
8054                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8055                 // ChannelMonitor: claim tx, ChannelManager: local commitment tx + HTLC-Success*2
8056                 assert_eq!(node_txn.len(), 4);
8057                 check_spends!(node_txn[0], remote_txn[0]);
8058                 check_spends!(node_txn[1], chan.3);
8059                 check_spends!(node_txn[2], node_txn[1]);
8060                 check_spends!(node_txn[3], node_txn[1]);
8061                 assert_eq!(node_txn[0].input.len(), 2);
8062                 node_txn.clear();
8063         }
8064
8065         // Connect blocks on node B
8066         connect_blocks(&nodes[1].block_notifier, 135, 0, false, Default::default());
8067         check_closed_broadcast!(nodes[1], false);
8068         check_added_monitors!(nodes[1], 1);
8069         // Verify node B broadcast 2 HTLC-timeout txn
8070         let partial_claim_tx = {
8071                 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
8072                 assert_eq!(node_txn.len(), 3);
8073                 check_spends!(node_txn[1], node_txn[0]);
8074                 check_spends!(node_txn[2], node_txn[0]);
8075                 assert_eq!(node_txn[1].input.len(), 1);
8076                 assert_eq!(node_txn[2].input.len(), 1);
8077                 node_txn[1].clone()
8078         };
8079
8080         // Broadcast partial claim on node A, should regenerate a claiming tx with HTLC dropped
8081         let header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8082         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![partial_claim_tx.clone()] }, 102);
8083         {
8084                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8085                 assert_eq!(node_txn.len(), 1);
8086                 check_spends!(node_txn[0], remote_txn[0]);
8087                 assert_eq!(node_txn[0].input.len(), 1); //dropped HTLC
8088                 node_txn.clear();
8089         }
8090         nodes[0].node.get_and_clear_pending_msg_events();
8091
8092         // Disconnect last block on node A, should regenerate a claiming tx with HTLC dropped
8093         nodes[0].block_notifier.block_disconnected(&header, 102);
8094         {
8095                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8096                 assert_eq!(node_txn.len(), 1);
8097                 check_spends!(node_txn[0], remote_txn[0]);
8098                 assert_eq!(node_txn[0].input.len(), 2); //resurrected HTLC
8099                 node_txn.clear();
8100         }
8101
8102         //// Disconnect one more block and then reconnect multiple no transaction should be generated
8103         nodes[0].block_notifier.block_disconnected(&header, 101);
8104         connect_blocks(&nodes[1].block_notifier, 15, 101, false, prev_header_100);
8105         {
8106                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8107                 assert_eq!(node_txn.len(), 0);
8108                 node_txn.clear();
8109         }
8110 }
8111
8112 #[test]
8113 fn test_counterparty_raa_skip_no_crash() {
8114         // Previously, if our counterparty sent two RAAs in a row without us having provided a
8115         // commitment transaction, we would have happily carried on and provided them the next
8116         // commitment transaction based on one RAA forward. This would probably eventually have led to
8117         // channel closure, but it would not have resulted in funds loss. Still, our
8118         // EnforcingChannelKeys would have paniced as it doesn't like jumps into the future. Here, we
8119         // check simply that the channel is closed in response to such an RAA, but don't check whether
8120         // we decide to punish our counterparty for revoking their funds (as we don't currently
8121         // implement that).
8122         let chanmon_cfgs = create_chanmon_cfgs(2);
8123         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8124         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
8125         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8126         let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).2;
8127
8128         let commitment_seed = nodes[0].node.channel_state.lock().unwrap().by_id.get_mut(&channel_id).unwrap().local_keys.commitment_seed().clone();
8129         const INITIAL_COMMITMENT_NUMBER: u64 = (1 << 48) - 1;
8130         let next_per_commitment_point = PublicKey::from_secret_key(&Secp256k1::new(),
8131                 &SecretKey::from_slice(&chan_utils::build_commitment_secret(&commitment_seed, INITIAL_COMMITMENT_NUMBER - 2)).unwrap());
8132         let per_commitment_secret = chan_utils::build_commitment_secret(&commitment_seed, INITIAL_COMMITMENT_NUMBER);
8133
8134         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(),
8135                 &msgs::RevokeAndACK { channel_id, per_commitment_secret, next_per_commitment_point });
8136         assert_eq!(check_closed_broadcast!(nodes[1], true).unwrap().data, "Received an unexpected revoke_and_ack");
8137         check_added_monitors!(nodes[1], 1);
8138 }
8139
8140 #[test]
8141 fn test_bump_txn_sanitize_tracking_maps() {
8142         // Sanitizing pendning_claim_request and claimable_outpoints used to be buggy,
8143         // verify we clean then right after expiration of ANTI_REORG_DELAY.
8144
8145         let chanmon_cfgs = create_chanmon_cfgs(2);
8146         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8147         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
8148         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8149
8150         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
8151         // Lock HTLC in both directions
8152         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9_000_000).0;
8153         route_payment(&nodes[1], &vec!(&nodes[0])[..], 9_000_000).0;
8154
8155         let revoked_local_txn = get_local_commitment_txn!(nodes[1], chan.2);
8156         assert_eq!(revoked_local_txn[0].input.len(), 1);
8157         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
8158
8159         // Revoke local commitment tx
8160         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 9_000_000);
8161
8162         // Broadcast set of revoked txn on A
8163         let header_128 = connect_blocks(&nodes[0].block_notifier, 128, 0,  false, Default::default());
8164         expect_pending_htlcs_forwardable_ignore!(nodes[0]);
8165
8166         let header_129 = BlockHeader { version: 0x20000000, prev_blockhash: header_128, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8167         nodes[0].block_notifier.block_connected(&Block { header: header_129, txdata: vec![revoked_local_txn[0].clone()] }, 129);
8168         check_closed_broadcast!(nodes[0], false);
8169         check_added_monitors!(nodes[0], 1);
8170         let penalty_txn = {
8171                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8172                 assert_eq!(node_txn.len(), 4); //ChannelMonitor: justice txn * 3, ChannelManager: local commitment tx
8173                 check_spends!(node_txn[0], revoked_local_txn[0]);
8174                 check_spends!(node_txn[1], revoked_local_txn[0]);
8175                 check_spends!(node_txn[2], revoked_local_txn[0]);
8176                 let penalty_txn = vec![node_txn[0].clone(), node_txn[1].clone(), node_txn[2].clone()];
8177                 node_txn.clear();
8178                 penalty_txn
8179         };
8180         let header_130 = BlockHeader { version: 0x20000000, prev_blockhash: header_129.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8181         nodes[0].block_notifier.block_connected(&Block { header: header_130, txdata: penalty_txn }, 130);
8182         connect_blocks(&nodes[0].block_notifier, 5, 130,  false, header_130.bitcoin_hash());
8183         {
8184                 let monitors = nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap();
8185                 if let Some(monitor) = monitors.get(&OutPoint { txid: chan.3.txid(), index: 0 }) {
8186                         assert!(monitor.onchain_tx_handler.pending_claim_requests.is_empty());
8187                         assert!(monitor.onchain_tx_handler.claimable_outpoints.is_empty());
8188                 }
8189         }
8190 }
8191
8192 #[test]
8193 fn test_override_channel_config() {
8194         let chanmon_cfgs = create_chanmon_cfgs(2);
8195         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8196         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
8197         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8198
8199         // Node0 initiates a channel to node1 using the override config.
8200         let mut override_config = UserConfig::default();
8201         override_config.own_channel_config.our_to_self_delay = 200;
8202
8203         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 16_000_000, 12_000_000, 42, Some(override_config)).unwrap();
8204
8205         // Assert the channel created by node0 is using the override config.
8206         let res = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
8207         assert_eq!(res.channel_flags, 0);
8208         assert_eq!(res.to_self_delay, 200);
8209 }
8210
8211 #[test]
8212 fn test_override_0msat_htlc_minimum() {
8213         let mut zero_config = UserConfig::default();
8214         zero_config.own_channel_config.our_htlc_minimum_msat = 0;
8215         let chanmon_cfgs = create_chanmon_cfgs(2);
8216         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8217         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(zero_config.clone())]);
8218         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8219
8220         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 16_000_000, 12_000_000, 42, Some(zero_config)).unwrap();
8221         let res = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
8222         assert_eq!(res.htlc_minimum_msat, 1);
8223
8224         nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &res);
8225         let res = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
8226         assert_eq!(res.htlc_minimum_msat, 1);
8227 }
8228
8229 #[test]
8230 fn test_simple_payment_secret() {
8231         // Simple test of sending a payment with a payment_secret present. This does not use any AMP
8232         // features, however.
8233         let chanmon_cfgs = create_chanmon_cfgs(3);
8234         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
8235         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
8236         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
8237
8238         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
8239         create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
8240         let logger = test_utils::TestLogger::new();
8241
8242         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]);
8243         let payment_secret = PaymentSecret([0xdb; 32]);
8244         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
8245         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();
8246         send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1], &nodes[2]]], 100000, payment_hash, Some(payment_secret.clone()));
8247         // Claiming with all the correct values but the wrong secret should result in nothing...
8248         assert_eq!(nodes[2].node.claim_funds(payment_preimage, &None, 100_000), false);
8249         assert_eq!(nodes[2].node.claim_funds(payment_preimage, &Some(PaymentSecret([42; 32])), 100_000), false);
8250         // ...but with the right secret we should be able to claim all the way back
8251         claim_payment_along_route_with_secret(&nodes[0], &[&[&nodes[1], &nodes[2]]], false, payment_preimage, Some(payment_secret.clone()), 100_000);
8252 }
8253
8254 #[test]
8255 fn test_simple_mpp() {
8256         // Simple test of sending a multi-path payment.
8257         let chanmon_cfgs = create_chanmon_cfgs(4);
8258         let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
8259         let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
8260         let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
8261
8262         let chan_1_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
8263         let chan_2_id = create_announced_chan_between_nodes(&nodes, 0, 2, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
8264         let chan_3_id = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
8265         let chan_4_id = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
8266         let logger = test_utils::TestLogger::new();
8267
8268         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]);
8269         let payment_secret = PaymentSecret([0xdb; 32]);
8270         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
8271         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();
8272         let path = route.paths[0].clone();
8273         route.paths.push(path);
8274         route.paths[0][0].pubkey = nodes[1].node.get_our_node_id();
8275         route.paths[0][0].short_channel_id = chan_1_id;
8276         route.paths[0][1].short_channel_id = chan_3_id;
8277         route.paths[1][0].pubkey = nodes[2].node.get_our_node_id();
8278         route.paths[1][0].short_channel_id = chan_2_id;
8279         route.paths[1][1].short_channel_id = chan_4_id;
8280         send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], 200_000, payment_hash, Some(payment_secret.clone()));
8281         // Claiming with all the correct values but the wrong secret should result in nothing...
8282         assert_eq!(nodes[3].node.claim_funds(payment_preimage, &None, 200_000), false);
8283         assert_eq!(nodes[3].node.claim_funds(payment_preimage, &Some(PaymentSecret([42; 32])), 200_000), false);
8284         // ...but with the right secret we should be able to claim all the way back
8285         claim_payment_along_route_with_secret(&nodes[0], &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], false, payment_preimage, Some(payment_secret), 200_000);
8286 }
8287
8288 #[test]
8289 fn test_update_err_monitor_lockdown() {
8290         // Our monitor will lock update of local commitment transaction if a broadcastion condition
8291         // has been fulfilled (either force-close from Channel or block height requiring a HTLC-
8292         // timeout). Trying to update monitor after lockdown should return a ChannelMonitorUpdateErr.
8293         //
8294         // This scenario may happen in a watchtower setup, where watchtower process a block height
8295         // triggering a timeout while a slow-block-processing ChannelManager receives a local signed
8296         // commitment at same time.
8297
8298         let chanmon_cfgs = create_chanmon_cfgs(2);
8299         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8300         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
8301         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8302
8303         // Create some initial channel
8304         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
8305         let outpoint = OutPoint { txid: chan_1.3.txid(), index: 0 };
8306
8307         // Rebalance the network to generate htlc in the two directions
8308         send_payment(&nodes[0], &vec!(&nodes[1])[..], 10_000_000, 10_000_000);
8309
8310         // Route a HTLC from node 0 to node 1 (but don't settle)
8311         let preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9_000_000).0;
8312
8313         // Copy SimpleManyChannelMonitor to simulate a watchtower and update block height of node 0 until its ChannelMonitor timeout HTLC onchain
8314         let logger = test_utils::TestLogger::with_id(format!("node {}", 0));
8315         let chain_monitor = chaininterface::ChainWatchInterfaceUtil::new(Network::Testnet);
8316         let watchtower = {
8317                 let monitors = nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap();
8318                 let monitor = monitors.get(&outpoint).unwrap();
8319                 let mut w = test_utils::TestVecWriter(Vec::new());
8320                 monitor.write_for_disk(&mut w).unwrap();
8321                 let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<EnforcingChannelKeys>)>::read(
8322                                 &mut ::std::io::Cursor::new(&w.0)).unwrap().1;
8323                 assert!(new_monitor == *monitor);
8324                 let watchtower = test_utils::TestChannelMonitor::new(&chain_monitor, &chanmon_cfgs[0].tx_broadcaster, &logger, &chanmon_cfgs[0].fee_estimator);
8325                 assert!(watchtower.add_monitor(outpoint, new_monitor).is_ok());
8326                 watchtower
8327         };
8328         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8329         watchtower.simple_monitor.block_connected(&header, 200, &vec![], &vec![]);
8330
8331         // Try to update ChannelMonitor
8332         assert!(nodes[1].node.claim_funds(preimage, &None, 9_000_000));
8333         check_added_monitors!(nodes[1], 1);
8334         let updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
8335         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
8336         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
8337         if let Some(ref mut channel) = nodes[0].node.channel_state.lock().unwrap().by_id.get_mut(&chan_1.2) {
8338                 if let Ok((_, _, _, update)) = channel.commitment_signed(&updates.commitment_signed, &node_cfgs[0].fee_estimator, &node_cfgs[0].logger) {
8339                         if let Err(_) =  watchtower.simple_monitor.update_monitor(outpoint, update.clone()) {} else { assert!(false); }
8340                         if let Ok(_) = nodes[0].chan_monitor.update_monitor(outpoint, update) {} else { assert!(false); }
8341                 } else { assert!(false); }
8342         } else { assert!(false); };
8343         // Our local monitor is in-sync and hasn't processed yet timeout
8344         check_added_monitors!(nodes[0], 1);
8345         let events = nodes[0].node.get_and_clear_pending_events();
8346         assert_eq!(events.len(), 1);
8347 }