X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Freorg_tests.rs;h=6d89268cdc34357808178ec5a99d2330dcff61dd;hb=783e8188a7bd6470d5926bf5d1bae1350996801a;hp=0440e2135144c6efe27a53e12c0ab6d3ac836011;hpb=e94e403dda57e1443fdeda9f1d0b2cb8a9e7fb0f;p=rust-lightning diff --git a/lightning/src/ln/reorg_tests.rs b/lightning/src/ln/reorg_tests.rs index 0440e213..6d89268c 100644 --- a/lightning/src/ln/reorg_tests.rs +++ b/lightning/src/ln/reorg_tests.rs @@ -9,29 +9,26 @@ //! Further functional tests which test blockchain reorganizations. -use chain::channelmonitor::{ANTI_REORG_DELAY, ChannelMonitor}; -use chain::transaction::OutPoint; -use chain::{Confirm, Watch}; -use ln::channelmanager::{ChannelManager, ChannelManagerReadArgs}; -use ln::features::InitFeatures; -use ln::msgs::ChannelMessageHandler; -use util::enforcing_trait_impls::EnforcingSigner; -use util::events::{Event, MessageSendEvent, MessageSendEventsProvider, ClosureReason, HTLCDestination}; -use util::test_utils; -use util::ser::{ReadableArgs, Writeable}; +use crate::chain::channelmonitor::ANTI_REORG_DELAY; +use crate::chain::transaction::OutPoint; +use crate::chain::Confirm; +use crate::events::{Event, MessageSendEventsProvider, ClosureReason, HTLCDestination}; +use crate::ln::channelmanager::ChannelManager; +use crate::ln::msgs::{ChannelMessageHandler, Init}; +use crate::util::test_utils; +use crate::util::ser::Writeable; +use crate::util::string::UntrustedString; use bitcoin::blockdata::block::{Block, BlockHeader}; use bitcoin::blockdata::script::Builder; use bitcoin::blockdata::opcodes; -use bitcoin::hash_types::BlockHash; use bitcoin::secp256k1::Secp256k1; -use prelude::*; -use core::mem; +use crate::prelude::*; use bitcoin::hashes::Hash; use bitcoin::TxMerkleNode; -use ln::functional_test_utils::*; +use crate::ln::functional_test_utils::*; fn do_test_onchain_htlc_reorg(local_commitment: bool, claim: bool) { // Our on-chain HTLC-claim learning has a few properties worth testing: @@ -54,8 +51,8 @@ fn do_test_onchain_htlc_reorg(local_commitment: bool, claim: bool) { let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); let nodes = create_network(3, &node_cfgs, &node_chanmgrs); - create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()); - let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known()); + create_announced_chan_between_nodes(&nodes, 0, 1); + let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); // Make sure all nodes are at the same starting height connect_blocks(&nodes[0], 2*CHAN_CONFIRM_DEPTH + 1 - nodes[0].best_block_info().1); @@ -85,10 +82,7 @@ fn do_test_onchain_htlc_reorg(local_commitment: bool, claim: bool) { check_closed_broadcast!(nodes[2], true); // We should get a BroadcastChannelUpdate (and *only* a BroadcstChannelUpdate) check_closed_event!(nodes[2], 1, ClosureReason::CommitmentTxConfirmed); let node_2_commitment_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); - assert_eq!(node_2_commitment_txn.len(), 3); // ChannelMonitor: 1 offered HTLC-Claim, ChannelManger: 1 local commitment tx, 1 Received HTLC-Claim - assert_eq!(node_2_commitment_txn[1].output.len(), 2); // to-remote and Received HTLC (to-self is dust) - check_spends!(node_2_commitment_txn[1], chan_2.3); - check_spends!(node_2_commitment_txn[2], node_2_commitment_txn[1]); + assert_eq!(node_2_commitment_txn.len(), 1); // ChannelMonitor: 1 offered HTLC-Claim check_spends!(node_2_commitment_txn[0], node_1_commitment_txn[0]); // Make sure node 1's height is the same as the !local_commitment case @@ -111,13 +105,11 @@ fn do_test_onchain_htlc_reorg(local_commitment: bool, claim: bool) { mine_transaction(&nodes[1], &node_2_commitment_txn[0]); connect_blocks(&nodes[1], TEST_FINAL_CLTV - 1); // Confirm blocks until the HTLC expires let node_1_commitment_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); - assert_eq!(node_1_commitment_txn.len(), 2); // ChannelMonitor: 1 offered HTLC-Timeout, ChannelManger: 1 local commitment tx - assert_eq!(node_1_commitment_txn[0].output.len(), 2); // to-local and Offered HTLC (to-remote is dust) - check_spends!(node_1_commitment_txn[0], chan_2.3); - check_spends!(node_1_commitment_txn[1], node_2_commitment_txn[0]); + assert_eq!(node_1_commitment_txn.len(), 1); // ChannelMonitor: 1 offered HTLC-Timeout + check_spends!(node_1_commitment_txn[0], node_2_commitment_txn[0]); // Confirm node 1's HTLC-Timeout on node 1 - mine_transaction(&nodes[1], &node_1_commitment_txn[1]); + mine_transaction(&nodes[1], &node_1_commitment_txn[0]); // ...but return node 2's commitment tx (and claim) in case claim is set and we're preparing to reorg vec![node_2_commitment_txn.pop().unwrap()] }; @@ -199,7 +191,7 @@ fn test_counterparty_revoked_reorg() { let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000, InitFeatures::known(), InitFeatures::known()); + let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000); // Get the initial commitment transaction for broadcast, before any HTLCs are added at all. let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan.2); @@ -268,35 +260,55 @@ fn do_test_unconf_chan(reload_node: bool, reorg_after_reload: bool, use_funding_ let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let persister: test_utils::TestPersister; let new_chain_monitor: test_utils::TestChainMonitor; - let nodes_0_deserialized: ChannelManager; + let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestKeysInterface, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>; let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); *nodes[0].connect_style.borrow_mut() = connect_style; - let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()); + let chan_conf_height = core::cmp::max(nodes[0].best_block_info().1 + 1, nodes[1].best_block_info().1 + 1); + let chan = create_announced_chan_between_nodes(&nodes, 0, 1); + + { + let per_peer_state = nodes[0].node.per_peer_state.read().unwrap(); + let peer_state = per_peer_state.get(&nodes[1].node.get_our_node_id()).unwrap().lock().unwrap(); + assert_eq!(peer_state.channel_by_id.len(), 1); + assert_eq!(nodes[0].node.short_to_chan_info.read().unwrap().len(), 2); + } - let channel_state = nodes[0].node.channel_state.lock().unwrap(); - assert_eq!(channel_state.by_id.len(), 1); - assert_eq!(channel_state.short_to_chan_info.len(), 2); - mem::drop(channel_state); + assert_eq!(nodes[0].node.list_channels()[0].confirmations, Some(10)); + assert_eq!(nodes[1].node.list_channels()[0].confirmations, Some(10)); if !reorg_after_reload { if use_funding_unconfirmed { let relevant_txids = nodes[0].node.get_relevant_txids(); - assert_eq!(&relevant_txids[..], &[chan.3.txid()]); - nodes[0].node.transaction_unconfirmed(&relevant_txids[0]); + assert_eq!(relevant_txids.len(), 1); + let block_hash_opt = relevant_txids[0].1; + let expected_hash = nodes[0].get_block_header(chan_conf_height).block_hash(); + assert_eq!(block_hash_opt, Some(expected_hash)); + let txid = relevant_txids[0].0; + assert_eq!(txid, chan.3.txid()); + nodes[0].node.transaction_unconfirmed(&txid); + assert_eq!(nodes[0].node.list_usable_channels().len(), 0); } else if connect_style == ConnectStyle::FullBlockViaListen { disconnect_blocks(&nodes[0], CHAN_CONFIRM_DEPTH - 1); assert_eq!(nodes[0].node.list_usable_channels().len(), 1); + assert_eq!(nodes[0].node.list_channels()[0].confirmations, Some(1)); disconnect_blocks(&nodes[0], 1); + assert_eq!(nodes[0].node.list_usable_channels().len(), 0); } else { disconnect_all_blocks(&nodes[0]); + assert_eq!(nodes[0].node.list_usable_channels().len(), 0); } + + let relevant_txids = nodes[0].node.get_relevant_txids(); + assert_eq!(relevant_txids.len(), 0); + handle_announce_close_broadcast_events(&nodes, 0, 1, true, "Channel closed because of an exception: Funding transaction was un-confirmed. Locked at 6 confs, now have 0 confs."); check_added_monitors!(nodes[1], 1); { - let channel_state = nodes[0].node.channel_state.lock().unwrap(); - assert_eq!(channel_state.by_id.len(), 0); - assert_eq!(channel_state.short_to_chan_info.len(), 0); + let per_peer_state = nodes[0].node.per_peer_state.read().unwrap(); + let peer_state = per_peer_state.get(&nodes[1].node.get_our_node_id()).unwrap().lock().unwrap(); + assert_eq!(peer_state.channel_by_id.len(), 0); + assert_eq!(nodes[0].node.short_to_chan_info.read().unwrap().len(), 0); } } @@ -306,65 +318,44 @@ fn do_test_unconf_chan(reload_node: bool, reorg_after_reload: bool, use_funding_ // the Channel object from the ChannelManager, but still having a monitor event pending for // it when we go to deserialize, and then use the ChannelManager. let nodes_0_serialized = nodes[0].node.encode(); - let mut chan_0_monitor_serialized = test_utils::TestVecWriter(Vec::new()); - get_monitor!(nodes[0], chan.2).write(&mut chan_0_monitor_serialized).unwrap(); - - persister = test_utils::TestPersister::new(); - let keys_manager = &chanmon_cfgs[0].keys_manager; - new_chain_monitor = test_utils::TestChainMonitor::new(Some(nodes[0].chain_source), nodes[0].tx_broadcaster.clone(), nodes[0].logger, node_cfgs[0].fee_estimator, &persister, keys_manager); - nodes[0].chain_monitor = &new_chain_monitor; - let mut chan_0_monitor_read = &chan_0_monitor_serialized.0[..]; - let (_, mut chan_0_monitor) = <(BlockHash, ChannelMonitor)>::read( - &mut chan_0_monitor_read, keys_manager).unwrap(); - assert!(chan_0_monitor_read.is_empty()); - - let mut nodes_0_read = &nodes_0_serialized[..]; - nodes_0_deserialized = { - let mut channel_monitors = HashMap::new(); - channel_monitors.insert(chan_0_monitor.get_funding_txo().0, &mut chan_0_monitor); - <(BlockHash, ChannelManager)>::read( - &mut nodes_0_read, ChannelManagerReadArgs { - default_config: *nodes[0].node.get_current_default_configuration(), - keys_manager, - fee_estimator: node_cfgs[0].fee_estimator, - chain_monitor: nodes[0].chain_monitor, - tx_broadcaster: nodes[0].tx_broadcaster.clone(), - logger: nodes[0].logger, - channel_monitors, - }).unwrap().1 - }; - nodes[0].node = &nodes_0_deserialized; - assert!(nodes_0_read.is_empty()); - if !reorg_after_reload { - // If the channel is already closed when we reload the node, we'll broadcast a closing - // transaction via the ChannelMonitor which is missing a corresponding channel. - assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1); - nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clear(); - } + let chan_0_monitor_serialized = get_monitor!(nodes[0], chan.2).encode(); - nodes[0].chain_monitor.watch_channel(chan_0_monitor.get_funding_txo().0.clone(), chan_0_monitor).unwrap(); - check_added_monitors!(nodes[0], 1); + reload_node!(nodes[0], *nodes[0].node.get_current_default_configuration(), &nodes_0_serialized, &[&chan_0_monitor_serialized], persister, new_chain_monitor, nodes_0_deserialized); + assert!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().is_empty()); } if reorg_after_reload { if use_funding_unconfirmed { let relevant_txids = nodes[0].node.get_relevant_txids(); - assert_eq!(&relevant_txids[..], &[chan.3.txid()]); - nodes[0].node.transaction_unconfirmed(&relevant_txids[0]); + assert_eq!(relevant_txids.len(), 1); + let block_hash_opt = relevant_txids[0].1; + let expected_hash = nodes[0].get_block_header(chan_conf_height).block_hash(); + assert_eq!(block_hash_opt, Some(expected_hash)); + let txid = relevant_txids[0].0; + assert_eq!(txid, chan.3.txid()); + nodes[0].node.transaction_unconfirmed(&txid); + assert_eq!(nodes[0].node.list_channels().len(), 0); } else if connect_style == ConnectStyle::FullBlockViaListen { disconnect_blocks(&nodes[0], CHAN_CONFIRM_DEPTH - 1); assert_eq!(nodes[0].node.list_channels().len(), 1); + assert_eq!(nodes[0].node.list_channels()[0].confirmations, Some(1)); disconnect_blocks(&nodes[0], 1); + assert_eq!(nodes[0].node.list_usable_channels().len(), 0); } else { disconnect_all_blocks(&nodes[0]); + assert_eq!(nodes[0].node.list_usable_channels().len(), 0); } + + let relevant_txids = nodes[0].node.get_relevant_txids(); + assert_eq!(relevant_txids.len(), 0); + handle_announce_close_broadcast_events(&nodes, 0, 1, true, "Channel closed because of an exception: Funding transaction was un-confirmed. Locked at 6 confs, now have 0 confs."); check_added_monitors!(nodes[1], 1); { - let channel_state = nodes[0].node.channel_state.lock().unwrap(); - assert_eq!(channel_state.by_id.len(), 0); - assert_eq!(channel_state.short_to_chan_info.len(), 0); + let per_peer_state = nodes[0].node.per_peer_state.read().unwrap(); + let peer_state = per_peer_state.get(&nodes[1].node.get_our_node_id()).unwrap().lock().unwrap(); + assert_eq!(peer_state.channel_by_id.len(), 0); + assert_eq!(nodes[0].node.short_to_chan_info.read().unwrap().len(), 0); } } // With expect_channel_force_closed set the TestChainMonitor will enforce that the next update @@ -373,13 +364,19 @@ fn do_test_unconf_chan(reload_node: bool, reorg_after_reload: bool, use_funding_ nodes[0].node.test_process_background_events(); // Required to free the pending background monitor update check_added_monitors!(nodes[0], 1); let expected_err = "Funding transaction was un-confirmed. Locked at 6 confs, now have 0 confs."; - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyForceClosed { peer_msg: "Channel closed because of an exception: ".to_owned() + expected_err }); + check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyForceClosed { peer_msg: UntrustedString(format!("Channel closed because of an exception: {}", expected_err)) }); check_closed_event!(nodes[0], 1, ClosureReason::ProcessingError { err: expected_err.to_owned() }); assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1); nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clear(); // Now check that we can create a new channel - create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()); + if reload_node && nodes[0].node.per_peer_state.read().unwrap().len() == 0 { + // If we dropped the channel before reloading the node, nodes[1] was also dropped from + // nodes[0] storage, and hence not connected again on startup. We therefore need to + // reconnect to the node before attempting to create a new channel. + nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &Init { features: nodes[1].node.init_features(), remote_network_address: None }, true).unwrap(); + } + create_announced_chan_between_nodes(&nodes, 0, 1); send_payment(&nodes[0], &[&nodes[1]], 8000000); } @@ -432,7 +429,7 @@ fn test_set_outpoints_partial_claiming() { let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known()); + let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000); let (payment_preimage_1, payment_hash_1, _) = route_payment(&nodes[1], &[&nodes[0]], 3_000_000); let (payment_preimage_2, payment_hash_2, _) = route_payment(&nodes[1], &[&nodes[0]], 3_000_000); @@ -462,12 +459,9 @@ fn test_set_outpoints_partial_claiming() { // Verify node A broadcast tx claiming both HTLCs { let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap(); - // ChannelMonitor: claim tx, ChannelManager: local commitment tx + HTLC-Success*2 - assert_eq!(node_txn.len(), 4); + // ChannelMonitor: claim tx + assert_eq!(node_txn.len(), 1); check_spends!(node_txn[0], remote_txn[0]); - check_spends!(node_txn[1], chan.3); - check_spends!(node_txn[2], node_txn[1]); - check_spends!(node_txn[3], node_txn[1]); assert_eq!(node_txn[0].input.len(), 2); node_txn.clear(); } @@ -537,7 +531,7 @@ fn do_test_to_remote_after_local_detection(style: ConnectStyle) { *nodes[1].connect_style.borrow_mut() = style; let (_, _, chan_id, funding_tx) = - create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 100_000_000, InitFeatures::known(), InitFeatures::known()); + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 100_000_000); let funding_outpoint = OutPoint { txid: funding_tx.txid(), index: 0 }; assert_eq!(funding_outpoint.to_channel_id(), chan_id); @@ -556,11 +550,6 @@ fn do_test_to_remote_after_local_detection(style: ConnectStyle) { check_added_monitors!(nodes[1], 1); check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed); - // Drop transactions broadcasted in response to the first commitment transaction (we have good - // test coverage of these things already elsewhere). - assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0).len(), 1); - assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0).len(), 1); - assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty()); assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());