From: Matt Corallo Date: Mon, 15 Mar 2021 23:49:51 +0000 (-0400) Subject: Enforce block connection ordering in unit and functional tests X-Git-Tag: v0.0.14~44^2~5 X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=commitdiff_plain;h=561f0e22ac6dc3ff664a3698a12c5c920d35ae4d;p=rust-lightning Enforce block connection ordering in unit and functional tests This expands the assertions on block ordering to apply to `#[cfg(test)]` builds in addition to normal builds, requiring that unit and functional tests have syntactically-valid (ie the previous block hash pointer and the heights match the blocks) blockchains. This requires a reasonably nontrivial diff in the functional tests however it is mostly straightforward changes. --- diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs index 997570ea3..50f8ccbb7 100644 --- a/lightning/src/ln/channelmanager.rs +++ b/lightning/src/ln/channelmanager.rs @@ -3302,16 +3302,10 @@ impl ChannelMana let _persistence_guard = PersistenceNotifierGuard::new(&self.total_consistency_lock, &self.persistence_notifier); - - // This assertion should be enforced in tests, however we have a number of tests that - // were written before this requirement and do not meet it. - #[cfg(not(test))] - { - assert_eq!(*self.last_block_hash.read().unwrap(), header.prev_blockhash, - "Blocks must be connected in chain-order - the connected header must build on the last connected header"); - assert_eq!(self.latest_block_height.load(Ordering::Acquire) as u64, height as u64 - 1, - "Blocks must be connected in chain-order - the connected header must build on the last connected header"); - } + assert_eq!(*self.last_block_hash.read().unwrap(), header.prev_blockhash, + "Blocks must be connected in chain-order - the connected header must build on the last connected header"); + assert_eq!(self.latest_block_height.load(Ordering::Acquire) as u64, height as u64 - 1, + "Blocks must be connected in chain-order - the connected header must build on the last connected header"); self.latest_block_height.store(height as usize, Ordering::Release); *self.last_block_hash.write().unwrap() = block_hash; diff --git a/lightning/src/ln/functional_tests.rs b/lightning/src/ln/functional_tests.rs index 7bfff54c0..ea4c088b2 100644 --- a/lightning/src/ln/functional_tests.rs +++ b/lightning/src/ln/functional_tests.rs @@ -11,6 +11,7 @@ //! payments/messages between them, and often checking the resulting ChannelMonitors are able to //! claim outputs on-chain. +use chain; use chain::Watch; use chain::channelmonitor; use chain::channelmonitor::{ChannelMonitor, CLTV_CLAIM_BUFFER, LATENCY_GRACE_PERIOD_BLOCKS, ANTI_REORG_DELAY}; @@ -411,14 +412,10 @@ fn test_1_conf_open() { let nodes = create_network(2, &node_cfgs, &node_chanmgrs); let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known()); - let block = Block { - header: BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }, - txdata: vec![tx], - }; - connect_block(&nodes[1], &block, 1); + mine_transaction(&nodes[1], &tx); 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())); - connect_block(&nodes[0], &block, 1); + mine_transaction(&nodes[0], &tx); let (funding_locked, _) = create_chan_between_nodes_with_value_confirm_second(&nodes[1], &nodes[0]); let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked); @@ -442,7 +439,7 @@ fn do_test_sanity_on_in_flight_opens(steps: u8) { if steps & 0b1000_0000 != 0{ let block = Block { - header: BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }, + header: BlockHeader { version: 0x20000000, prev_blockhash: nodes[0].best_block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }, txdata: vec![], }; connect_block(&nodes[0], &block, 1); @@ -500,7 +497,8 @@ fn do_test_sanity_on_in_flight_opens(steps: u8) { create_chan_between_nodes_with_value_confirm_first(&nodes[0], &nodes[1], &tx, 2); if steps & 0x0f == 7 { return; } - confirm_transaction(&nodes[0], &tx); + confirm_transaction_at(&nodes[0], &tx, 2); + connect_blocks(&nodes[0], CHAN_CONFIRM_DEPTH, 2, false, Default::default()); create_chan_between_nodes_with_value_confirm_second(&nodes[1], &nodes[0]); } @@ -826,9 +824,8 @@ fn pre_funding_lock_shutdown_test() { let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let nodes = create_network(2, &node_cfgs, &node_chanmgrs); let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 8000000, 0, InitFeatures::known(), InitFeatures::known()); - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[0], &Block { header, txdata: vec![tx.clone()]}, 1); - connect_block(&nodes[1], &Block { header, txdata: vec![tx.clone()]}, 1); + mine_transaction(&nodes[0], &tx); + mine_transaction(&nodes[1], &tx); nodes[0].node.close_channel(&OutPoint { txid: tx.txid(), index: 0 }.to_channel_id()).unwrap(); let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); @@ -1494,8 +1491,7 @@ fn test_duplicate_htlc_different_direction_onchain() { } assert_eq!(has_both_htlcs, 2); - let header = BlockHeader { version: 0x2000_0000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[0], &Block { header, txdata: vec![remote_txn[0].clone()] }, 1); + mine_transaction(&nodes[0], &remote_txn[0]); check_added_monitors!(nodes[0], 1); // Check we only broadcast 1 timeout tx @@ -2322,6 +2318,13 @@ fn channel_monitor_network_test() { let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known()); let chan_4 = create_announced_chan_between_nodes(&nodes, 3, 4, InitFeatures::known(), InitFeatures::known()); + // Make sure all nodes are at the same starting height + connect_blocks(&nodes[0], 4*CHAN_CONFIRM_DEPTH + 1 - nodes[0].best_block_info().1, nodes[0].best_block_info().1, false, Default::default()); + connect_blocks(&nodes[1], 4*CHAN_CONFIRM_DEPTH + 1 - nodes[1].best_block_info().1, nodes[1].best_block_info().1, false, Default::default()); + connect_blocks(&nodes[2], 4*CHAN_CONFIRM_DEPTH + 1 - nodes[2].best_block_info().1, nodes[2].best_block_info().1, false, Default::default()); + connect_blocks(&nodes[3], 4*CHAN_CONFIRM_DEPTH + 1 - nodes[3].best_block_info().1, nodes[3].best_block_info().1, false, Default::default()); + connect_blocks(&nodes[4], 4*CHAN_CONFIRM_DEPTH + 1 - nodes[4].best_block_info().1, nodes[4].best_block_info().1, false, Default::default()); + // Rebalance the network a bit by relaying one payment through all the channels... send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000); send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000); @@ -2333,8 +2336,8 @@ fn channel_monitor_network_test() { check_added_monitors!(nodes[1], 1); { let mut node_txn = test_txn_broadcast(&nodes[1], &chan_1, None, HTLCType::NONE); - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[0], &Block { header, txdata: vec![node_txn.drain(..).next().unwrap()] }, 1); + assert_eq!(node_txn.len(), 1); + mine_transaction(&nodes[0], &node_txn[0]); check_added_monitors!(nodes[0], 1); test_txn_broadcast(&nodes[0], &chan_1, None, HTLCType::NONE); } @@ -2350,8 +2353,7 @@ fn channel_monitor_network_test() { check_added_monitors!(nodes[1], 1); { let mut node_txn = test_txn_broadcast(&nodes[1], &chan_2, None, HTLCType::TIMEOUT); - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[2], &Block { header, txdata: vec![node_txn.drain(..).next().unwrap()] }, 1); + mine_transaction(&nodes[2], &node_txn[0]); check_added_monitors!(nodes[2], 1); test_txn_broadcast(&nodes[2], &chan_2, None, HTLCType::NONE); } @@ -2390,42 +2392,25 @@ fn channel_monitor_network_test() { // Claim the payment on nodes[3], giving it knowledge of the preimage claim_funds!(nodes[3], nodes[2], payment_preimage_1, 3_000_000); - - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[3], &Block { header, txdata: vec![node_txn[0].clone()] }, 1); + mine_transaction(&nodes[3], &node_txn[0]); check_added_monitors!(nodes[3], 1); - check_preimage_claim(&nodes[3], &node_txn); } get_announce_close_broadcast_events(&nodes, 2, 3); assert_eq!(nodes[2].node.list_channels().len(), 0); assert_eq!(nodes[3].node.list_channels().len(), 1); - { // Cheat and reset nodes[4]'s height to 1 - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[4], &Block { header, txdata: vec![] }, 1); - } + // Drop the ChannelMonitor for the previous channel to avoid it broadcasting transactions and + // confusing us in the following tests. + let chan_3_mon = nodes[3].chain_monitor.chain_monitor.monitors.write().unwrap().remove(&OutPoint { txid: chan_3.3.txid(), index: 0 }).unwrap(); - assert_eq!(nodes[3].node.latest_block_height.load(Ordering::Acquire), 1); - assert_eq!(nodes[4].node.latest_block_height.load(Ordering::Acquire), 1); // One pending HTLC to time out: let payment_preimage_2 = route_payment(&nodes[3], &vec!(&nodes[4])[..], 3000000).0; // CLTV expires at TEST_FINAL_CLTV + 1 (current height) + 1 (added in send_payment for // buffer space). let (close_chan_update_1, close_chan_update_2) = { - let mut block = Block { - header: BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }, - txdata: vec![], - }; - connect_block(&nodes[3], &block, 2); - for i in 3..TEST_FINAL_CLTV + 2 + LATENCY_GRACE_PERIOD_BLOCKS + 1 { - block = Block { - header: BlockHeader { version: 0x20000000, prev_blockhash: block.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }, - txdata: vec![], - }; - connect_block(&nodes[3], &block, i); - } + connect_blocks(&nodes[3], TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + 1, nodes[3].best_block_info().1, false, Default::default()); let events = nodes[3].node.get_and_clear_pending_msg_events(); assert_eq!(events.len(), 1); let close_chan_update_1 = match events[0] { @@ -2451,19 +2436,7 @@ fn channel_monitor_network_test() { // Claim the payment on nodes[4], giving it knowledge of the preimage claim_funds!(nodes[4], nodes[3], payment_preimage_2, 3_000_000); - block = Block { - header: BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }, - txdata: vec![], - }; - - connect_block(&nodes[4], &block, 2); - for i in 3..TEST_FINAL_CLTV + 2 - CLTV_CLAIM_BUFFER + 1 { - block = Block { - header: BlockHeader { version: 0x20000000, prev_blockhash: block.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }, - txdata: vec![], - }; - connect_block(&nodes[4], &block, i); - } + connect_blocks(&nodes[4], TEST_FINAL_CLTV - CLTV_CLAIM_BUFFER + 2, nodes[4].best_block_info().1, false, Default::default()); let events = nodes[4].node.get_and_clear_pending_msg_events(); assert_eq!(events.len(), 1); let close_chan_update_2 = match events[0] { @@ -2475,12 +2448,7 @@ fn channel_monitor_network_test() { check_added_monitors!(nodes[4], 1); test_txn_broadcast(&nodes[4], &chan_4, None, HTLCType::SUCCESS); - block = Block { - header: BlockHeader { version: 0x20000000, prev_blockhash: block.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }, - txdata: vec![node_txn[0].clone()], - }; - connect_block(&nodes[4], &block, TEST_FINAL_CLTV - 5); - + mine_transaction(&nodes[4], &node_txn[0]); check_preimage_claim(&nodes[4], &node_txn); (close_chan_update_1, close_chan_update_2) }; @@ -2488,6 +2456,8 @@ fn channel_monitor_network_test() { nodes[4].net_graph_msg_handler.handle_channel_update(&close_chan_update_1).unwrap(); assert_eq!(nodes[3].node.list_channels().len(), 0); assert_eq!(nodes[4].node.list_channels().len(), 0); + + nodes[3].chain_monitor.chain_monitor.monitors.write().unwrap().insert(OutPoint { txid: chan_3.3.txid(), index: 0 }, chan_3_mon); } #[test] @@ -2526,8 +2496,7 @@ fn test_justice_tx() { claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3, 3_000_000); { - let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[1], &Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1); + mine_transaction(&nodes[1], &revoked_local_txn[0]); { let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); assert_eq!(node_txn.len(), 2); // ChannelMonitor: penalty tx, ChannelManager: local commitment tx @@ -2540,13 +2509,12 @@ fn test_justice_tx() { check_added_monitors!(nodes[1], 1); test_txn_broadcast(&nodes[1], &chan_5, None, HTLCType::NONE); - connect_block(&nodes[0], &Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1); + mine_transaction(&nodes[0], &revoked_local_txn[0]); // Verify broadcast of revoked HTLC-timeout let node_txn = test_txn_broadcast(&nodes[0], &chan_5, Some(revoked_local_txn[0].clone()), HTLCType::TIMEOUT); - header = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; check_added_monitors!(nodes[0], 1); // Broadcast revoked HTLC-timeout on node 1 - connect_block(&nodes[1], &Block { header, txdata: vec![node_txn[1].clone()] }, 1); + mine_transaction(&nodes[1], &node_txn[1]); test_revoked_htlc_claim_txn_broadcast(&nodes[1], node_txn[1].clone(), revoked_local_txn[0].clone()); } get_announce_close_broadcast_events(&nodes, 0, 1); @@ -2573,8 +2541,7 @@ fn test_justice_tx() { // Revoke the old state claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_4, 3_000_000); { - let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[0], &Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1); + mine_transaction(&nodes[0], &revoked_local_txn[0]); { let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap(); assert_eq!(node_txn.len(), 2); //ChannelMonitor: penalty tx, ChannelManager: local commitment tx @@ -2586,11 +2553,10 @@ fn test_justice_tx() { check_added_monitors!(nodes[0], 1); test_txn_broadcast(&nodes[0], &chan_6, None, HTLCType::NONE); - connect_block(&nodes[1], &Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1); + mine_transaction(&nodes[1], &revoked_local_txn[0]); let node_txn = test_txn_broadcast(&nodes[1], &chan_6, Some(revoked_local_txn[0].clone()), HTLCType::SUCCESS); - header = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; check_added_monitors!(nodes[1], 1); - connect_block(&nodes[0], &Block { header, txdata: vec![node_txn[1].clone()] }, 1); + mine_transaction(&nodes[0], &node_txn[1]); test_revoked_htlc_claim_txn_broadcast(&nodes[0], node_txn[1].clone(), revoked_local_txn[0].clone()); } get_announce_close_broadcast_events(&nodes, 0, 1); @@ -2616,8 +2582,7 @@ fn revoked_output_claim() { send_payment(&nodes[0], &vec!(&nodes[1])[..], 5000000, 5_000_000); // Inform nodes[1] that nodes[0] broadcast a stale tx - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[1], &Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1); + mine_transaction(&nodes[1], &revoked_local_txn[0]); check_added_monitors!(nodes[1], 1); let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); assert_eq!(node_txn.len(), 2); // ChannelMonitor: justice tx against revoked to_local output, ChannelManager: local commitment tx @@ -2626,7 +2591,7 @@ fn revoked_output_claim() { check_spends!(node_txn[1], chan_1.3); // Inform nodes[0] that a watchtower cheated on its behalf, so it will force-close the chan - connect_block(&nodes[0], &Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1); + mine_transaction(&nodes[0], &revoked_local_txn[0]); get_announce_close_broadcast_events(&nodes, 0, 1); check_added_monitors!(nodes[0], 1) } @@ -2726,14 +2691,13 @@ fn claim_htlc_outputs_single_tx() { claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1, 3_000_000); { - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[0], &Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 200); + confirm_transaction_at(&nodes[0], &revoked_local_txn[0], 100); check_added_monitors!(nodes[0], 1); - connect_block(&nodes[1], &Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 200); + confirm_transaction_at(&nodes[1], &revoked_local_txn[0], 100); check_added_monitors!(nodes[1], 1); expect_pending_htlcs_forwardable_ignore!(nodes[0]); - connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, 200, true, header.block_hash()); + connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, nodes[1].best_block_info().1, false, Default::default()); expect_payment_failed!(nodes[1], payment_hash_2, true); let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); @@ -2744,25 +2708,25 @@ fn claim_htlc_outputs_single_tx() { // ChannelMonitor: local commitment + local HTLC-timeout (2) // Check the pair local commitment and HTLC-timeout broadcast due to HTLC expiration - assert_eq!(node_txn[2].input.len(), 1); - check_spends!(node_txn[2], chan_1.3); - assert_eq!(node_txn[3].input.len(), 1); - let witness_script = node_txn[3].input[0].witness.last().unwrap(); + assert_eq!(node_txn[0].input.len(), 1); + check_spends!(node_txn[0], chan_1.3); + assert_eq!(node_txn[1].input.len(), 1); + let witness_script = node_txn[1].input[0].witness.last().unwrap(); assert_eq!(witness_script.len(), OFFERED_HTLC_SCRIPT_WEIGHT); //Spending an offered htlc output - check_spends!(node_txn[3], node_txn[2]); + check_spends!(node_txn[1], node_txn[0]); // Justice transactions are indices 1-2-4 - assert_eq!(node_txn[0].input.len(), 1); - assert_eq!(node_txn[1].input.len(), 1); + assert_eq!(node_txn[2].input.len(), 1); + assert_eq!(node_txn[3].input.len(), 1); assert_eq!(node_txn[4].input.len(), 1); - check_spends!(node_txn[0], revoked_local_txn[0]); - check_spends!(node_txn[1], revoked_local_txn[0]); + check_spends!(node_txn[2], revoked_local_txn[0]); + check_spends!(node_txn[3], revoked_local_txn[0]); check_spends!(node_txn[4], revoked_local_txn[0]); let mut witness_lens = BTreeSet::new(); - witness_lens.insert(node_txn[0].input[0].witness.last().unwrap().len()); - witness_lens.insert(node_txn[1].input[0].witness.last().unwrap().len()); + witness_lens.insert(node_txn[2].input[0].witness.last().unwrap().len()); + witness_lens.insert(node_txn[3].input[0].witness.last().unwrap().len()); witness_lens.insert(node_txn[4].input[0].witness.last().unwrap().len()); assert_eq!(witness_lens.len(), 3); assert_eq!(*witness_lens.iter().skip(0).next().unwrap(), 77); // revoked to_local @@ -2805,7 +2769,6 @@ fn test_htlc_on_chain_success() { let (our_payment_preimage, _payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000); let (our_payment_preimage_2, _payment_hash_2) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000); - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42}; // Broadcast legit commitment tx from C on B's chain // Broadcast HTLC Success transaction by C on received output from C's commitment tx on B's chain @@ -2821,7 +2784,7 @@ fn test_htlc_on_chain_success() { assert!(updates.update_fail_malformed_htlcs.is_empty()); assert_eq!(updates.update_fulfill_htlcs.len(), 1); - connect_block(&nodes[2], &Block { header, txdata: vec![commitment_tx[0].clone()]}, 1); + mine_transaction(&nodes[2], &commitment_tx[0]); check_closed_broadcast!(nodes[2], false); check_added_monitors!(nodes[2], 1); 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) @@ -2839,7 +2802,8 @@ fn test_htlc_on_chain_success() { assert_eq!(node_txn[1].lock_time, 0); // Verify that B's ChannelManager is able to extract preimage from HTLC Success tx and pass it backward - connect_block(&nodes[1], &Block { header, txdata: node_txn}, 1); + let header = BlockHeader { version: 0x20000000, prev_blockhash: nodes[1].best_block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42}; + connect_block(&nodes[1], &Block { header, txdata: node_txn}, nodes[1].best_block_info().1 + 1); { let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap(); assert_eq!(added_monitors.len(), 1); @@ -2912,7 +2876,7 @@ fn test_htlc_on_chain_success() { // Broadcast preimage tx by B on offered output from A commitment tx on A's chain let commitment_tx = get_local_commitment_txn!(nodes[0], chan_1.2); check_spends!(commitment_tx[0], chan_1.3); - connect_block(&nodes[1], &Block { header, txdata: vec![commitment_tx[0].clone()]}, 1); + mine_transaction(&nodes[1], &commitment_tx[0]); check_closed_broadcast!(nodes[1], false); check_added_monitors!(nodes[1], 1); let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 3 (commitment tx + HTLC-Sucess * 2), ChannelMonitor : 1 (HTLC-Success) @@ -2931,7 +2895,8 @@ fn test_htlc_on_chain_success() { // we already checked the same situation with A. // Verify that A's ChannelManager is able to extract preimage from preimage tx and generate PaymentSent - connect_block(&nodes[0], &Block { header, txdata: vec![commitment_tx[0].clone(), node_txn[0].clone()] }, 1); + let mut header = BlockHeader { version: 0x20000000, prev_blockhash: nodes[0].best_block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42}; + connect_block(&nodes[0], &Block { header, txdata: vec![commitment_tx[0].clone(), node_txn[0].clone()] }, nodes[0].best_block_info().1 + 1); check_closed_broadcast!(nodes[0], false); check_added_monitors!(nodes[0], 1); let events = nodes[0].node.get_and_clear_pending_events(); @@ -3103,9 +3068,8 @@ fn test_simple_commitment_revoked_fail_backward() { let (_, payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000); - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42}; - connect_block(&nodes[1], &Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1); - connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, 1, true, header.block_hash()); + mine_transaction(&nodes[1], &revoked_local_txn[0]); + connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, nodes[1].best_block_info().1, false, Default::default()); check_added_monitors!(nodes[1], 1); check_closed_broadcast!(nodes[1], false); @@ -3256,10 +3220,9 @@ fn do_test_commitment_revoked_fail_backward_exhaustive(deliver_bs_raa: bool, use let mut failed_htlcs = HashSet::new(); assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42}; - connect_block(&nodes[1], &Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1); + mine_transaction(&nodes[1], &revoked_local_txn[0]); check_added_monitors!(nodes[1], 1); - connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, 1, true, header.block_hash()); + connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, nodes[1].best_block_info().1, false, Default::default()); let events = nodes[1].node.get_and_clear_pending_events(); assert_eq!(events.len(), if deliver_bs_raa { 1 } else { 2 }); @@ -3451,14 +3414,15 @@ fn test_htlc_ignore_latest_remote_commitment() { let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap(); assert_eq!(node_txn.len(), 2); - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[1], &Block { header, txdata: vec![node_txn[0].clone(), node_txn[1].clone()]}, 1); + let mut header = BlockHeader { version: 0x20000000, prev_blockhash: nodes[1].best_block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + connect_block(&nodes[1], &Block { header, txdata: vec![node_txn[0].clone(), node_txn[1].clone()]}, nodes[1].best_block_info().1 + 1); check_closed_broadcast!(nodes[1], false); check_added_monitors!(nodes[1], 1); // Duplicate the connect_block call since this may happen due to other listeners // registering new transactions - connect_block(&nodes[1], &Block { header, txdata: vec![node_txn[0].clone(), node_txn[1].clone()]}, 1); + header.prev_blockhash = header.block_hash(); + connect_block(&nodes[1], &Block { header, txdata: vec![node_txn[0].clone(), node_txn[1].clone()]}, nodes[1].best_block_info().1 + 1); } #[test] @@ -3517,11 +3481,7 @@ fn test_force_close_fail_back() { node_txn.remove(0) }; - let block = Block { - header: BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }, - txdata: vec![tx.clone()], - }; - connect_block(&nodes[1], &block, 1); + mine_transaction(&nodes[1], &tx); // Note no UpdateHTLCs event here from nodes[1] to nodes[0]! check_closed_broadcast!(nodes[1], false); @@ -3533,7 +3493,7 @@ fn test_force_close_fail_back() { monitors.get(&OutPoint{ txid: Txid::from_slice(&payment_event.commitment_msg.channel_id[..]).unwrap(), index: 0 }).unwrap() .provide_payment_preimage(&our_payment_hash, &our_payment_preimage, &node_cfgs[2].tx_broadcaster, &node_cfgs[2].fee_estimator, &&logger); } - connect_block(&nodes[2], &block, 1); + mine_transaction(&nodes[2], &tx); let node_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap(); assert_eq!(node_txn.len(), 1); assert_eq!(node_txn[0].input.len(), 1); @@ -4706,9 +4666,8 @@ fn test_claim_sizeable_push_msat() { check_spends!(node_txn[0], chan.3); 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 - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[1], &Block { header, txdata: vec![node_txn[0].clone()] }, 0); - connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, 1, true, header.block_hash()); + mine_transaction(&nodes[1], &node_txn[0]); + connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, nodes[1].best_block_info().1, false, Default::default()); let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000); assert_eq!(spend_txn.len(), 1); @@ -4734,11 +4693,10 @@ fn test_claim_on_remote_sizeable_push_msat() { check_spends!(node_txn[0], chan.3); 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 - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[1], &Block { header, txdata: vec![node_txn[0].clone()] }, 0); + mine_transaction(&nodes[1], &node_txn[0]); check_closed_broadcast!(nodes[1], false); check_added_monitors!(nodes[1], 1); - connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, 1, true, header.block_hash()); + connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, nodes[1].best_block_info().1, false, Default::default()); let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000); assert_eq!(spend_txn.len(), 1); @@ -4762,15 +4720,13 @@ fn test_claim_on_remote_revoked_sizeable_push_msat() { assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid()); claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000); - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[1], &Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 0); + mine_transaction(&nodes[1], &revoked_local_txn[0]); check_closed_broadcast!(nodes[1], false); check_added_monitors!(nodes[1], 1); let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); - let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[1], &Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1); - connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, 1, true, header.block_hash()); + mine_transaction(&nodes[1], &node_txn[0]); + connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, nodes[1].best_block_info().1, false, Default::default()); let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000); assert_eq!(spend_txn.len(), 3); @@ -4796,10 +4752,9 @@ fn test_static_spendable_outputs_preimage_tx() { assert_eq!(commitment_tx[0].input[0].previous_output.txid, chan_1.3.txid()); // Settle A's commitment tx on B's chain - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; assert!(nodes[1].node.claim_funds(payment_preimage, &None, 3_000_000)); check_added_monitors!(nodes[1], 1); - connect_block(&nodes[1], &Block { header, txdata: vec![commitment_tx[0].clone()] }, 1); + mine_transaction(&nodes[1], &commitment_tx[0]); check_added_monitors!(nodes[1], 1); let events = nodes[1].node.get_and_clear_pending_msg_events(); match events[0] { @@ -4819,9 +4774,8 @@ fn test_static_spendable_outputs_preimage_tx() { check_spends!(node_txn[1], chan_1.3); check_spends!(node_txn[2], node_txn[1]); - let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[1], &Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1); - connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, 1, true, header.block_hash()); + mine_transaction(&nodes[1], &node_txn[0]); + connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, nodes[1].best_block_info().1, false, Default::default()); let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000); assert_eq!(spend_txn.len(), 1); @@ -4848,8 +4802,7 @@ fn test_static_spendable_outputs_timeout_tx() { assert_eq!(commitment_tx[0].input[0].previous_output.txid, chan_1.3.txid()); // Settle A's commitment tx on B' chain - let header = BlockHeader { version: 0x2000_0000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42}; - connect_block(&nodes[1], &Block { header, txdata: vec![commitment_tx[0].clone()] }, 0); + mine_transaction(&nodes[1], &commitment_tx[0]); check_added_monitors!(nodes[1], 1); let events = nodes[1].node.get_and_clear_pending_msg_events(); match events[0] { @@ -4865,9 +4818,8 @@ fn test_static_spendable_outputs_timeout_tx() { check_spends!(node_txn[1], chan_1.3.clone()); check_spends!(node_txn[2], node_txn[1]); - let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[1], &Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1); - connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, 1, true, header.block_hash()); + mine_transaction(&nodes[1], &node_txn[0]); + connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, nodes[1].best_block_info().1, false, Default::default()); expect_payment_failed!(nodes[1], our_payment_hash, true); let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000); @@ -4894,8 +4846,7 @@ fn test_static_spendable_outputs_justice_tx_revoked_commitment_tx() { claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000); - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[1], &Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 0); + mine_transaction(&nodes[1], &revoked_local_txn[0]); check_closed_broadcast!(nodes[1], false); check_added_monitors!(nodes[1], 1); @@ -4904,9 +4855,8 @@ fn test_static_spendable_outputs_justice_tx_revoked_commitment_tx() { assert_eq!(node_txn[0].input.len(), 2); check_spends!(node_txn[0], revoked_local_txn[0]); - let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[1], &Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1); - connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, 1, true, header.block_hash()); + mine_transaction(&nodes[1], &node_txn[0]); + connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, nodes[1].best_block_info().1, false, Default::default()); let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000); assert_eq!(spend_txn.len(), 1); @@ -4931,9 +4881,8 @@ fn test_static_spendable_outputs_justice_tx_revoked_htlc_timeout_tx() { claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000); - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; // A will generate HTLC-Timeout from revoked commitment tx - connect_block(&nodes[0], &Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1); + mine_transaction(&nodes[0], &revoked_local_txn[0]); check_closed_broadcast!(nodes[0], false); check_added_monitors!(nodes[0], 1); @@ -4945,7 +4894,8 @@ fn test_static_spendable_outputs_justice_tx_revoked_htlc_timeout_tx() { check_spends!(revoked_htlc_txn[1], chan_1.3); // B will generate justice tx from A's revoked commitment/HTLC tx - connect_block(&nodes[1], &Block { header, txdata: vec![revoked_local_txn[0].clone(), revoked_htlc_txn[0].clone()] }, 0); + let header = BlockHeader { version: 0x20000000, prev_blockhash: nodes[1].best_block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + connect_block(&nodes[1], &Block { header, txdata: vec![revoked_local_txn[0].clone(), revoked_htlc_txn[0].clone()] }, nodes[1].best_block_info().1 + 1); check_closed_broadcast!(nodes[1], false); check_added_monitors!(nodes[1], 1); @@ -4969,9 +4919,8 @@ fn test_static_spendable_outputs_justice_tx_revoked_htlc_timeout_tx() { assert_eq!(node_txn[2].input.len(), 1); check_spends!(node_txn[2], chan_1.3); - let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[1], &Block { header: header_1, txdata: vec![node_txn[1].clone()] }, 1); - connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, 1, true, header.block_hash()); + mine_transaction(&nodes[1], &node_txn[1]); + connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, nodes[1].best_block_info().1, false, Default::default()); // Check B's ChannelMonitor was able to generate the right spendable output descriptor let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000); @@ -5001,9 +4950,8 @@ fn test_static_spendable_outputs_justice_tx_revoked_htlc_success_tx() { claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000); - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; // B will generate HTLC-Success from revoked commitment tx - connect_block(&nodes[1], &Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1); + mine_transaction(&nodes[1], &revoked_local_txn[0]); check_closed_broadcast!(nodes[1], false); check_added_monitors!(nodes[1], 1); let revoked_htlc_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); @@ -5018,7 +4966,8 @@ fn test_static_spendable_outputs_justice_tx_revoked_htlc_success_tx() { assert_eq!(revoked_local_txn[0].output[unspent_local_txn_output].script_pubkey.len(), 2 + 20); // P2WPKH // A will generate justice tx from B's revoked commitment/HTLC tx - connect_block(&nodes[0], &Block { header, txdata: vec![revoked_local_txn[0].clone(), revoked_htlc_txn[0].clone()] }, 1); + let header = BlockHeader { version: 0x20000000, prev_blockhash: nodes[0].best_block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + connect_block(&nodes[0], &Block { header, txdata: vec![revoked_local_txn[0].clone(), revoked_htlc_txn[0].clone()] }, nodes[0].best_block_info().1 + 1); check_closed_broadcast!(nodes[0], false); check_added_monitors!(nodes[0], 1); @@ -5042,9 +4991,8 @@ fn test_static_spendable_outputs_justice_tx_revoked_htlc_success_tx() { check_spends!(node_txn[2], chan_1.3); - let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[0], &Block { header: header_1, txdata: vec![node_txn[1].clone()] }, 1); - connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, 1, true, header.block_hash()); + mine_transaction(&nodes[0], &node_txn[1]); + connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, nodes[0].best_block_info().1, false, Default::default()); // Note that nodes[0]'s tx_broadcaster is still locked, so if we get here the channelmonitor // didn't try to generate any new transactions. @@ -5083,7 +5031,6 @@ fn test_onchain_to_onchain_claim() { send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000); let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000); - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42}; let commitment_tx = get_local_commitment_txn!(nodes[2], chan_2.2); check_spends!(commitment_tx[0], chan_2.3); nodes[2].node.claim_funds(payment_preimage, &None, 3_000_000); @@ -5094,7 +5041,7 @@ fn test_onchain_to_onchain_claim() { assert_eq!(updates.update_fulfill_htlcs.len(), 1); assert!(updates.update_fail_malformed_htlcs.is_empty()); - connect_block(&nodes[2], &Block { header, txdata: vec![commitment_tx[0].clone()]}, 1); + mine_transaction(&nodes[2], &commitment_tx[0]); check_closed_broadcast!(nodes[2], false); check_added_monitors!(nodes[2], 1); @@ -5110,7 +5057,8 @@ fn test_onchain_to_onchain_claim() { assert_eq!(c_txn[0].lock_time, 0); // Success tx // 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 - connect_block(&nodes[1], &Block { header, txdata: vec![c_txn[1].clone(), c_txn[2].clone()]}, 1); + let header = BlockHeader { version: 0x20000000, prev_blockhash: nodes[1].best_block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42}; + connect_block(&nodes[1], &Block { header, txdata: vec![c_txn[1].clone(), c_txn[2].clone()]}, nodes[1].best_block_info().1 + 1); { let mut b_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); // ChannelMonitor: claim tx, ChannelManager: local commitment tx + HTLC-timeout tx @@ -5145,7 +5093,7 @@ fn test_onchain_to_onchain_claim() { }; // Broadcast A's commitment tx on B's chain to see if we are able to claim inbound HTLC with our HTLC-Success tx let commitment_tx = get_local_commitment_txn!(nodes[0], chan_1.2); - connect_block(&nodes[1], &Block { header, txdata: vec![commitment_tx[0].clone()]}, 1); + mine_transaction(&nodes[1], &commitment_tx[0]); let b_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); // ChannelMonitor: HTLC-Success tx, ChannelManager: local commitment tx + HTLC-Success tx assert_eq!(b_txn.len(), 3); @@ -5180,8 +5128,7 @@ fn test_duplicate_payment_hash_one_failure_one_success() { assert_eq!(commitment_txn[0].input.len(), 1); check_spends!(commitment_txn[0], chan_2.3); - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[1], &Block { header, txdata: vec![commitment_txn[0].clone()] }, 1); + mine_transaction(&nodes[1], &commitment_txn[0]); check_closed_broadcast!(nodes[1], false); check_added_monitors!(nodes[1], 1); @@ -5204,7 +5151,7 @@ fn test_duplicate_payment_hash_one_failure_one_success() { } nodes[2].node.claim_funds(our_payment_preimage, &None, 900_000); - connect_block(&nodes[2], &Block { header, txdata: vec![commitment_txn[0].clone()] }, 1); + mine_transaction(&nodes[2], &commitment_txn[0]); check_added_monitors!(nodes[2], 3); let events = nodes[2].node.get_and_clear_pending_msg_events(); match events[0] { @@ -5230,8 +5177,8 @@ fn test_duplicate_payment_hash_one_failure_one_success() { check_spends!(htlc_success_txn[0], commitment_txn[0]); check_spends!(htlc_success_txn[1], commitment_txn[0]); - connect_block(&nodes[1], &Block { header, txdata: vec![htlc_timeout_tx] }, 200); - connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, 200, true, header.block_hash()); + mine_transaction(&nodes[1], &htlc_timeout_tx); + connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, nodes[1].best_block_info().1, false, Default::default()); expect_pending_htlcs_forwardable!(nodes[1]); let htlc_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); assert!(htlc_updates.update_add_htlcs.is_empty()); @@ -5256,7 +5203,7 @@ fn test_duplicate_payment_hash_one_failure_one_success() { expect_payment_failed!(nodes[0], duplicate_payment_hash, false); // Solve 2nd HTLC by broadcasting on B's chain HTLC-Success Tx from C - connect_block(&nodes[1], &Block { header, txdata: vec![htlc_success_txn[0].clone()] }, 200); + mine_transaction(&nodes[1], &htlc_success_txn[0]); let updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); assert!(updates.update_add_htlcs.is_empty()); assert!(updates.update_fail_htlcs.is_empty()); @@ -5296,8 +5243,7 @@ fn test_dynamic_spendable_outputs_local_htlc_success_tx() { // Give B knowledge of preimage to be able to generate a local HTLC-Success Tx nodes[1].node.claim_funds(payment_preimage, &None, 9_000_000); check_added_monitors!(nodes[1], 1); - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[1], &Block { header, txdata: vec![local_txn[0].clone()] }, 1); + mine_transaction(&nodes[1], &local_txn[0]); check_added_monitors!(nodes[1], 1); let events = nodes[1].node.get_and_clear_pending_msg_events(); match events[0] { @@ -5308,7 +5254,7 @@ fn test_dynamic_spendable_outputs_local_htlc_success_tx() { MessageSendEvent::BroadcastChannelUpdate { .. } => {}, _ => panic!("Unexepected event"), } - let node_txn = { + let node_tx = { let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); assert_eq!(node_txn.len(), 3); assert_eq!(node_txn[0], node_txn[2]); @@ -5316,17 +5262,16 @@ fn test_dynamic_spendable_outputs_local_htlc_success_tx() { assert_eq!(node_txn[0].input.len(), 1); assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT); check_spends!(node_txn[0], local_txn[0]); - vec![node_txn[0].clone()] + node_txn[0].clone() }; - let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[1], &Block { header: header_201, txdata: node_txn.clone() }, 201); - connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, 201, true, header_201.block_hash()); + mine_transaction(&nodes[1], &node_tx); + connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, nodes[1].best_block_info().1, false, Default::default()); // Verify that B is able to spend its own HTLC-Success tx thanks to spendable output event given back by its ChannelMonitor let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000); assert_eq!(spend_txn.len(), 1); - check_spends!(spend_txn[0], node_txn[0]); + check_spends!(spend_txn[0], node_tx); } fn do_test_fail_backwards_unrevoked_remote_announce(deliver_last_raa: bool, announce_latest: bool) { @@ -5458,13 +5403,12 @@ fn do_test_fail_backwards_unrevoked_remote_announce(deliver_last_raa: bool, anno // result in failures for the below-dust HTLCs, ie the 0th, 1st, 2nd, 3rd, 9th, and 10th HTLCs. let ds_last_commitment_tx = get_local_commitment_txn!(nodes[3], chan.2); - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; if announce_latest { - connect_block(&nodes[2], &Block { header, txdata: vec![ds_last_commitment_tx[0].clone()]}, 1); + mine_transaction(&nodes[2], &ds_last_commitment_tx[0]); } else { - connect_block(&nodes[2], &Block { header, txdata: vec![ds_prev_commitment_tx[0].clone()]}, 1); + mine_transaction(&nodes[2], &ds_prev_commitment_tx[0]); } - connect_blocks(&nodes[2], ANTI_REORG_DELAY - 1, 1, true, header.block_hash()); + connect_blocks(&nodes[2], ANTI_REORG_DELAY - 1, nodes[2].best_block_info().1, false, Default::default()); check_closed_broadcast!(nodes[2], false); expect_pending_htlcs_forwardable!(nodes[2]); check_added_monitors!(nodes[2], 3); @@ -5601,8 +5545,7 @@ fn test_dynamic_spendable_outputs_local_htlc_timeout_tx() { check_spends!(local_txn[0], chan_1.3); // Timeout HTLC on A's chain and so it can generate a HTLC-Timeout tx - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[0], &Block { header, txdata: vec![local_txn[0].clone()] }, 200); + mine_transaction(&nodes[0], &local_txn[0]); check_closed_broadcast!(nodes[0], false); check_added_monitors!(nodes[0], 1); @@ -5614,9 +5557,8 @@ fn test_dynamic_spendable_outputs_local_htlc_timeout_tx() { node_txn[0].clone() }; - let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[0], &Block { header: header_201, txdata: vec![htlc_timeout.clone()] }, 201); - connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, 201, true, header_201.block_hash()); + mine_transaction(&nodes[0], &htlc_timeout); + connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, nodes[0].best_block_info().1, false, Default::default()); expect_payment_failed!(nodes[0], our_payment_hash, true); // Verify that A is able to spend its own HTLC-Timeout tx thanks to spendable output event given back by its ChannelMonitor @@ -5671,8 +5613,7 @@ fn test_key_derivation_params() { } // Timeout HTLC on A's chain and so it can generate a HTLC-Timeout tx - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[0], &Block { header, txdata: vec![local_txn_1[0].clone()] }, 200); + mine_transaction(&nodes[0], &local_txn_1[0]); check_closed_broadcast!(nodes[0], false); check_added_monitors!(nodes[0], 1); @@ -5684,9 +5625,8 @@ fn test_key_derivation_params() { node_txn[0].clone() }; - let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[0], &Block { header: header_201, txdata: vec![htlc_timeout.clone()] }, 201); - connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, 201, true, header_201.block_hash()); + mine_transaction(&nodes[0], &htlc_timeout); + connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, nodes[0].best_block_info().1, false, Default::default()); expect_payment_failed!(nodes[0], our_payment_hash, true); // Verify that A is able to spend its own HTLC-Timeout tx thanks to spendable output event given back by its ChannelMonitor @@ -5710,16 +5650,15 @@ fn test_static_output_closing_tx() { send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000); let closing_tx = close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true).2; - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[0], &Block { header, txdata: vec![closing_tx.clone()] }, 0); - connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, 0, true, header.block_hash()); + mine_transaction(&nodes[0], &closing_tx); + connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, nodes[0].best_block_info().1, false, Default::default()); let spend_txn = check_spendable_outputs!(nodes[0], 2, node_cfgs[0].keys_manager, 100000); assert_eq!(spend_txn.len(), 1); check_spends!(spend_txn[0], closing_tx); - connect_block(&nodes[1], &Block { header, txdata: vec![closing_tx.clone()] }, 0); - connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, 0, true, header.block_hash()); + mine_transaction(&nodes[1], &closing_tx); + connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, nodes[1].best_block_info().1, false, Default::default()); let spend_txn = check_spendable_outputs!(nodes[1], 2, node_cfgs[1].keys_manager, 100000); assert_eq!(spend_txn.len(), 1); @@ -7023,19 +6962,17 @@ fn do_test_failure_delay_dust_htlc_local_commitment(announce_latest: bool) { assert_ne!(as_prev_commitment_tx, as_last_commitment_tx); // Fail the 2 dust-HTLCs, move their failure in maturation buffer (htlc_updated_waiting_threshold_conf) - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - if announce_latest { - connect_block(&nodes[0], &Block { header, txdata: vec![as_last_commitment_tx[0].clone()]}, 1); + mine_transaction(&nodes[0], &as_last_commitment_tx[0]); } else { - connect_block(&nodes[0], &Block { header, txdata: vec![as_prev_commitment_tx[0].clone()]}, 1); + mine_transaction(&nodes[0], &as_prev_commitment_tx[0]); } check_closed_broadcast!(nodes[0], false); check_added_monitors!(nodes[0], 1); assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0); - connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, 1, true, header.block_hash()); + connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, nodes[0].best_block_info().1, false, Default::default()); let events = nodes[0].node.get_and_clear_pending_events(); // Only 2 PaymentFailed events should show up, over-dust HTLC has to be failed by timeout tx assert_eq!(events.len(), 2); @@ -7089,42 +7026,37 @@ fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) { claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3, 1_000_000); } - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; let mut timeout_tx = Vec::new(); if local { // We fail dust-HTLC 1 by broadcast of local commitment tx - connect_block(&nodes[0], &Block { header, txdata: vec![as_commitment_tx[0].clone()]}, 1); + mine_transaction(&nodes[0], &as_commitment_tx[0]); check_closed_broadcast!(nodes[0], false); check_added_monitors!(nodes[0], 1); assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0); timeout_tx.push(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap()[0].clone()); - let parent_hash = connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, 2, true, header.block_hash()); + connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, nodes[0].best_block_info().1, false, Default::default()); expect_payment_failed!(nodes[0], dust_hash, true); assert_eq!(timeout_tx[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT); // We fail non-dust-HTLC 2 by broadcast of local HTLC-timeout tx on local commitment tx - let header_2 = BlockHeader { version: 0x20000000, prev_blockhash: parent_hash, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0); - connect_block(&nodes[0], &Block { header: header_2, txdata: vec![timeout_tx[0].clone()]}, 7); - let header_3 = BlockHeader { version: 0x20000000, prev_blockhash: header_2.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, 8, true, header_3.block_hash()); + mine_transaction(&nodes[0], &timeout_tx[0]); + connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, nodes[0].best_block_info().1, false, Default::default()); expect_payment_failed!(nodes[0], non_dust_hash, true); } else { // We fail dust-HTLC 1 by broadcast of remote commitment tx. If revoked, fail also non-dust HTLC - connect_block(&nodes[0], &Block { header, txdata: vec![bs_commitment_tx[0].clone()]}, 1); + mine_transaction(&nodes[0], &bs_commitment_tx[0]); check_closed_broadcast!(nodes[0], false); check_added_monitors!(nodes[0], 1); assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0); timeout_tx.push(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap()[0].clone()); - let parent_hash = connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, 2, true, header.block_hash()); - let header_2 = BlockHeader { version: 0x20000000, prev_blockhash: parent_hash, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, nodes[0].best_block_info().1, false, Default::default()); if !revoked { expect_payment_failed!(nodes[0], dust_hash, true); assert_eq!(timeout_tx[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT); // We fail non-dust-HTLC 2 by broadcast of local timeout tx on remote commitment tx - connect_block(&nodes[0], &Block { header: header_2, txdata: vec![timeout_tx[0].clone()]}, 7); + mine_transaction(&nodes[0], &timeout_tx[0]); assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0); - let header_3 = BlockHeader { version: 0x20000000, prev_blockhash: header_2.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, 8, true, header_3.block_hash()); + connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, nodes[0].best_block_info().1, false, Default::default()); expect_payment_failed!(nodes[0], non_dust_hash, true); } else { // If revoked, both dust & non-dust HTLCs should have been failed after ANTI_REORG_DELAY confs of revoked @@ -7541,9 +7473,8 @@ fn test_data_loss_protect() { assert_eq!(node_txn.len(), 1); check_spends!(node_txn[0], chan.3); assert_eq!(node_txn[0].output.len(), 2); - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42}; - connect_block(&nodes[0], &Block { header, txdata: vec![node_txn[0].clone()]}, 0); - connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, 0, true, header.block_hash()); + mine_transaction(&nodes[0], &node_txn[0]); + connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, nodes[0].best_block_info().1, false, Default::default()); let spend_txn = check_spendable_outputs!(nodes[0], 1, node_cfgs[0].keys_manager, 1000000); assert_eq!(spend_txn.len(), 1); check_spends!(spend_txn[0], node_txn[0]); @@ -7952,8 +7883,7 @@ fn test_bump_penalty_txn_on_remote_commitment() { // Claim a HTLC without revocation (provide B monitor with preimage) nodes[1].node.claim_funds(payment_preimage, &None, 3_000_000); - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[1], &Block { header, txdata: vec![remote_txn[0].clone()] }, 1); + mine_transaction(&nodes[1], &remote_txn[0]); check_added_monitors!(nodes[1], 2); // One or more claim tx should have been broadcast, check it @@ -7998,7 +7928,7 @@ fn test_bump_penalty_txn_on_remote_commitment() { assert_ne!(feerate_preimage, 0); // After exhaustion of height timer, new bumped claim txn should have been broadcast, check it - connect_blocks(&nodes[1], 15, 1, true, header.block_hash()); + connect_blocks(&nodes[1], 15, nodes[1].best_block_info().1, false, Default::default()); { let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); assert_eq!(node_txn.len(), 2); @@ -8092,11 +8022,11 @@ fn test_bump_txn_sanitize_tracking_maps() { claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 9_000_000); // Broadcast set of revoked txn on A - let header_128 = connect_blocks(&nodes[0], 128, 0, false, Default::default()); + connect_blocks(&nodes[0], 52 - CHAN_CONFIRM_DEPTH, CHAN_CONFIRM_DEPTH, false, Default::default()); expect_pending_htlcs_forwardable_ignore!(nodes[0]); + assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 0); - let header_129 = BlockHeader { version: 0x20000000, prev_blockhash: header_128, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[0], &Block { header: header_129, txdata: vec![revoked_local_txn[0].clone()] }, 129); + mine_transaction(&nodes[0], &revoked_local_txn[0]); check_closed_broadcast!(nodes[0], false); check_added_monitors!(nodes[0], 1); let penalty_txn = { @@ -8109,9 +8039,9 @@ fn test_bump_txn_sanitize_tracking_maps() { node_txn.clear(); penalty_txn }; - let header_130 = BlockHeader { version: 0x20000000, prev_blockhash: header_129.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[0], &Block { header: header_130, txdata: penalty_txn }, 130); - connect_blocks(&nodes[0], 5, 130, false, header_130.block_hash()); + let header_130 = BlockHeader { version: 0x20000000, prev_blockhash: nodes[0].best_block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + connect_block(&nodes[0], &Block { header: header_130, txdata: penalty_txn }, nodes[0].best_block_info().1 + 1); + connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, nodes[0].best_block_info().1, false, Default::default()); { let monitors = nodes[0].chain_monitor.chain_monitor.monitors.read().unwrap(); if let Some(monitor) = monitors.get(&OutPoint { txid: chan.3.txid(), index: 0 }) { @@ -8455,11 +8385,11 @@ fn test_htlc_no_detection() { check_spends!(local_txn[0], chan_1.3); // Timeout HTLC on A's chain and so it can generate a HTLC-Timeout tx - let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[0], &Block { header, txdata: vec![local_txn[0].clone()] }, 200); + let header = BlockHeader { version: 0x20000000, prev_blockhash: nodes[0].best_block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + connect_block(&nodes[0], &Block { header, txdata: vec![local_txn[0].clone()] }, nodes[0].best_block_info().1 + 1); // We deliberately connect the local tx twice as this should provoke a failure calling // this test before #653 fix. - connect_block(&nodes[0], &Block { header, txdata: vec![local_txn[0].clone()] }, 200); + chain::Listen::block_connected(&nodes[0].chain_monitor.chain_monitor, &Block { header, txdata: vec![local_txn[0].clone()] }, nodes[0].best_block_info().1 + 1); check_closed_broadcast!(nodes[0], false); check_added_monitors!(nodes[0], 1); @@ -8472,8 +8402,8 @@ fn test_htlc_no_detection() { }; let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[0], &Block { header: header_201, txdata: vec![htlc_timeout.clone()] }, 201); - connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, 201, true, header_201.block_hash()); + connect_block(&nodes[0], &Block { header: header_201, txdata: vec![htlc_timeout.clone()] }, nodes[0].best_block_info().1 + 1); + connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1, nodes[0].best_block_info().1, false, Default::default()); expect_payment_failed!(nodes[0], our_payment_hash, true); } diff --git a/lightning/src/ln/onion_route_tests.rs b/lightning/src/ln/onion_route_tests.rs index c6730e8ca..eb86d3595 100644 --- a/lightning/src/ln/onion_route_tests.rs +++ b/lightning/src/ln/onion_route_tests.rs @@ -23,7 +23,6 @@ use util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsPro use util::ser::{Writeable, Writer}; use util::config::UserConfig; -use bitcoin::blockdata::block::{Block, BlockHeader}; use bitcoin::hash_types::BlockHash; use bitcoin::hashes::sha256::Hash as Sha256; @@ -33,7 +32,6 @@ use bitcoin::secp256k1::Secp256k1; use bitcoin::secp256k1::key::SecretKey; use std::default::Default; -use std::sync::atomic::Ordering; use std::io; use ln::functional_test_utils::*; @@ -57,16 +55,6 @@ fn run_onion_failure_test_with_fail_intercept(_name: &str, test_case: F2: for <'a> FnMut(&'a mut msgs::UpdateFailHTLC), F3: FnMut(), { - - // reset block height - let block = Block { - header: BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }, - txdata: vec![], - }; - for ix in 0..nodes.len() { - connect_block(&nodes[ix], &block, 1); - } - macro_rules! expect_event { ($node: expr, $event_type: path) => {{ let events = $node.node.get_and_clear_pending_events(); @@ -289,7 +277,7 @@ fn test_onion_failure() { // intermediate node failure run_onion_failure_test("invalid_realm", 0, &nodes, &route, &payment_hash, |msg| { let session_priv = SecretKey::from_slice(&[3; 32]).unwrap(); - let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1; + let cur_height = nodes[0].best_block_info().1 + 1; let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap(); let (mut onion_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 40000, &None, cur_height).unwrap(); let mut new_payloads = Vec::new(); @@ -305,7 +293,7 @@ fn test_onion_failure() { // final node failure run_onion_failure_test("invalid_realm", 3, &nodes, &route, &payment_hash, |msg| { let session_priv = SecretKey::from_slice(&[3; 32]).unwrap(); - let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1; + let cur_height = nodes[0].best_block_info().1 + 1; let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap(); let (mut onion_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 40000, &None, cur_height).unwrap(); let mut new_payloads = Vec::new(); @@ -443,12 +431,9 @@ fn test_onion_failure() { run_onion_failure_test("expiry_too_soon", 0, &nodes, &route, &payment_hash, |msg| { let height = msg.cltv_expiry - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS + 1; - let block = Block { - header: BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }, - txdata: vec![], - }; - - connect_block(&nodes[1], &block, height); + connect_blocks(&nodes[0], height - nodes[0].best_block_info().1, nodes[0].best_block_info().1, false, Default::default()); + connect_blocks(&nodes[1], height - nodes[1].best_block_info().1, nodes[1].best_block_info().1, false, Default::default()); + connect_blocks(&nodes[2], height - nodes[2].best_block_info().1, nodes[2].best_block_info().1, false, Default::default()); }, ||{}, true, Some(UPDATE|14), Some(msgs::HTLCFailChannelUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy()})); run_onion_failure_test("unknown_payment_hash", 2, &nodes, &route, &payment_hash, |_| {}, || { @@ -457,12 +442,9 @@ fn test_onion_failure() { run_onion_failure_test("final_expiry_too_soon", 1, &nodes, &route, &payment_hash, |msg| { let height = msg.cltv_expiry - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS + 1; - let block = Block { - header: BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }, - txdata: vec![], - }; - - connect_block(&nodes[2], &block, height); + connect_blocks(&nodes[0], height - nodes[0].best_block_info().1, nodes[0].best_block_info().1, false, Default::default()); + connect_blocks(&nodes[1], height - nodes[1].best_block_info().1, nodes[1].best_block_info().1, false, Default::default()); + connect_blocks(&nodes[2], height - nodes[2].best_block_info().1, nodes[2].best_block_info().1, false, Default::default()); }, || {}, true, Some(17), None); run_onion_failure_test("final_incorrect_cltv_expiry", 1, &nodes, &route, &payment_hash, |_| {}, || { @@ -500,7 +482,7 @@ fn test_onion_failure() { run_onion_failure_test("expiry_too_far", 0, &nodes, &route, &payment_hash, |msg| { let session_priv = SecretKey::from_slice(&[3; 32]).unwrap(); let mut route = route.clone(); - let height = 1; + let height = nodes[2].best_block_info().1; route.paths[0][1].cltv_expiry_delta += CLTV_FAR_FAR_AWAY + route.paths[0][0].cltv_expiry_delta + 1; let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap(); let (onion_payloads, _, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 40000, &None, height).unwrap(); diff --git a/lightning/src/ln/reorg_tests.rs b/lightning/src/ln/reorg_tests.rs index 92a313f8c..316e165ab 100644 --- a/lightning/src/ln/reorg_tests.rs +++ b/lightning/src/ln/reorg_tests.rs @@ -21,9 +21,7 @@ use util::test_utils; use util::ser::{ReadableArgs, Writeable}; use bitcoin::blockdata::block::{Block, BlockHeader}; -use bitcoin::blockdata::constants::genesis_block; use bitcoin::hash_types::BlockHash; -use bitcoin::network::constants::Network; use std::collections::HashMap; use std::mem; @@ -54,6 +52,11 @@ fn do_test_onchain_htlc_reorg(local_commitment: bool, claim: bool) { 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()); + // 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, nodes[0].best_block_info().1, false, Default::default()); + connect_blocks(&nodes[1], 2*CHAN_CONFIRM_DEPTH + 1 - nodes[1].best_block_info().1, nodes[1].best_block_info().1, false, Default::default()); + connect_blocks(&nodes[2], 2*CHAN_CONFIRM_DEPTH + 1 - nodes[2].best_block_info().1, nodes[2].best_block_info().1, false, Default::default()); + let (our_payment_preimage, our_payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000); // Provide preimage to node 2 by claiming payment @@ -61,7 +64,7 @@ fn do_test_onchain_htlc_reorg(local_commitment: bool, claim: bool) { check_added_monitors!(nodes[2], 1); get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id()); - let header = BlockHeader { version: 0x2000_0000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + let mut header = BlockHeader { version: 0x2000_0000, prev_blockhash: nodes[2].best_block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; let claim_txn = if local_commitment { // Broadcast node 1 commitment txn to broadcast the HTLC-Timeout let node_1_commitment_txn = get_local_commitment_txn!(nodes[1], chan_2.2); @@ -71,7 +74,7 @@ fn do_test_onchain_htlc_reorg(local_commitment: bool, claim: bool) { check_spends!(node_1_commitment_txn[1], node_1_commitment_txn[0]); // Give node 2 node 1's transactions and get its response (claiming the HTLC instead). - connect_block(&nodes[2], &Block { header, txdata: node_1_commitment_txn.clone() }, CHAN_CONFIRM_DEPTH + 1); + connect_block(&nodes[2], &Block { header, txdata: node_1_commitment_txn.clone() }, CHAN_CONFIRM_DEPTH*2 + 2); check_added_monitors!(nodes[2], 1); check_closed_broadcast!(nodes[2], false); // We should get a BroadcastChannelUpdate (and *only* a BroadcstChannelUpdate) let node_2_commitment_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap(); @@ -81,8 +84,11 @@ fn do_test_onchain_htlc_reorg(local_commitment: bool, claim: bool) { check_spends!(node_2_commitment_txn[2], node_2_commitment_txn[1]); 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 + connect_blocks(&nodes[1], 1, CHAN_CONFIRM_DEPTH*2 + 1, false, Default::default()); // Confirm node 1's commitment txn (and HTLC-Timeout) on node 1 - connect_block(&nodes[1], &Block { header, txdata: node_1_commitment_txn.clone() }, CHAN_CONFIRM_DEPTH + 1); + header.prev_blockhash = nodes[1].best_block_hash(); + connect_block(&nodes[1], &Block { header, txdata: node_1_commitment_txn.clone() }, CHAN_CONFIRM_DEPTH*2 + 3); // ...but return node 1's commitment tx in case claim is set and we're preparing to reorg vec![node_1_commitment_txn[0].clone(), node_2_commitment_txn[0].clone()] @@ -95,7 +101,7 @@ fn do_test_onchain_htlc_reorg(local_commitment: bool, claim: bool) { check_spends!(node_2_commitment_txn[1], node_2_commitment_txn[0]); // Give node 1 node 2's commitment transaction and get its response (timing the HTLC out) - connect_block(&nodes[1], &Block { header, txdata: vec![node_2_commitment_txn[0].clone()] }, CHAN_CONFIRM_DEPTH + 1); + mine_transaction(&nodes[1], &node_2_commitment_txn[0]); let node_1_commitment_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); assert_eq!(node_1_commitment_txn.len(), 3); // ChannelMonitor: 1 offered HTLC-Timeout, ChannelManger: 1 local commitment tx, 1 Offered HTLC-Timeout assert_eq!(node_1_commitment_txn[1].output.len(), 2); // to-local and Offered HTLC (to-remote is dust) @@ -104,50 +110,37 @@ fn do_test_onchain_htlc_reorg(local_commitment: bool, claim: bool) { check_spends!(node_1_commitment_txn[0], node_2_commitment_txn[0]); // Confirm node 2's commitment txn (and node 1's HTLC-Timeout) on node 1 - connect_block(&nodes[1], &Block { header, txdata: vec![node_2_commitment_txn[0].clone(), node_1_commitment_txn[0].clone()] }, CHAN_CONFIRM_DEPTH + 1); + header.prev_blockhash = nodes[1].best_block_hash(); + connect_block(&nodes[1], &Block { header, txdata: vec![node_2_commitment_txn[0].clone(), node_1_commitment_txn[0].clone()] }, CHAN_CONFIRM_DEPTH*2 + 3); // ...but return node 2's commitment tx (and claim) in case claim is set and we're preparing to reorg node_2_commitment_txn }; check_added_monitors!(nodes[1], 1); check_closed_broadcast!(nodes[1], false); // We should get a BroadcastChannelUpdate (and *only* a BroadcstChannelUpdate) - let mut block = Block { header, txdata: vec![] }; - let mut blocks = Vec::new(); - blocks.push(block.clone()); - // At CHAN_CONFIRM_DEPTH + 1 we have a confirmation count of 1, so CHAN_CONFIRM_DEPTH + - // ANTI_REORG_DELAY - 1 will give us a confirmation count of ANTI_REORG_DELAY - 1. - for i in CHAN_CONFIRM_DEPTH + 2..CHAN_CONFIRM_DEPTH + ANTI_REORG_DELAY - 1 { - block = Block { - header: BlockHeader { version: 0x20000000, prev_blockhash: block.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }, - txdata: vec![], - }; - connect_block(&nodes[1], &block, i); - blocks.push(block.clone()); - } + // Connect ANTI_REORG_DELAY - 2 blocks, giving us a confirmation count of ANTI_REORG_DELAY - 1. + connect_blocks(&nodes[1], ANTI_REORG_DELAY - 2, nodes[1].best_block_info().1, false, Default::default()); check_added_monitors!(nodes[1], 0); assert_eq!(nodes[1].node.get_and_clear_pending_events().len(), 0); if claim { - // Now reorg back to CHAN_CONFIRM_DEPTH and confirm node 2's broadcasted transactions: - for (height, block) in (CHAN_CONFIRM_DEPTH + 1..CHAN_CONFIRM_DEPTH + ANTI_REORG_DELAY - 1).zip(blocks.iter()).rev() { - disconnect_block(&nodes[1], &block.header, height); - } + disconnect_blocks(&nodes[1], ANTI_REORG_DELAY - 2); - block = Block { - header: BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }, + let block = Block { + header: BlockHeader { version: 0x20000000, prev_blockhash: nodes[1].best_block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }, txdata: claim_txn, }; - connect_block(&nodes[1], &block, CHAN_CONFIRM_DEPTH + 1); + connect_block(&nodes[1], &block, CHAN_CONFIRM_DEPTH*2 + 4); // ChannelManager only polls chain::Watch::release_pending_monitor_events when we // probe it for events, so we probe non-message events here (which should still end up empty): assert_eq!(nodes[1].node.get_and_clear_pending_events().len(), 0); } else { // Confirm the timeout tx and check that we fail the HTLC backwards - block = Block { - header: BlockHeader { version: 0x20000000, prev_blockhash: block.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }, + let block = Block { + header: BlockHeader { version: 0x20000000, prev_blockhash: nodes[1].best_block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }, txdata: vec![], }; - connect_block(&nodes[1], &block, CHAN_CONFIRM_DEPTH + ANTI_REORG_DELAY); + connect_block(&nodes[1], &block, CHAN_CONFIRM_DEPTH*2 + 3 + ANTI_REORG_DELAY - 1); expect_pending_htlcs_forwardable!(nodes[1]); } @@ -309,7 +302,6 @@ fn test_set_outpoints_partial_claiming() { check_spends!(remote_txn[2], remote_txn[0]); // Connect blocks on node A to advance height towards TEST_FINAL_CLTV - let block_hash_100 = connect_blocks(&nodes[1], 100, 0, false, genesis_block(Network::Testnet).header.block_hash()); // Provide node A with both preimage nodes[0].node.claim_funds(payment_preimage_1, &None, 3_000_000); nodes[0].node.claim_funds(payment_preimage_2, &None, 3_000_000); @@ -318,8 +310,7 @@ fn test_set_outpoints_partial_claiming() { nodes[0].node.get_and_clear_pending_msg_events(); // Connect blocks on node A commitment transaction - let header_101 = BlockHeader { version: 0x20000000, prev_blockhash: block_hash_100, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[0], &Block { header: header_101, txdata: vec![remote_txn[0].clone()] }, CHAN_CONFIRM_DEPTH + 1); + mine_transaction(&nodes[0], &remote_txn[0]); check_closed_broadcast!(nodes[0], false); check_added_monitors!(nodes[0], 1); // Verify node A broadcast tx claiming both HTLCs @@ -336,7 +327,7 @@ fn test_set_outpoints_partial_claiming() { } // Connect blocks on node B - connect_blocks(&nodes[1], 135, 0, false, Default::default()); + connect_blocks(&nodes[1], 135, nodes[1].best_block_info().1, false, Default::default()); check_closed_broadcast!(nodes[1], false); check_added_monitors!(nodes[1], 1); // Verify node B broadcast 2 HTLC-timeout txn @@ -351,8 +342,7 @@ fn test_set_outpoints_partial_claiming() { }; // Broadcast partial claim on node A, should regenerate a claiming tx with HTLC dropped - let header_102 = BlockHeader { version: 0x20000000, prev_blockhash: header_101.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; - connect_block(&nodes[0], &Block { header: header_102, txdata: vec![partial_claim_tx.clone()] }, CHAN_CONFIRM_DEPTH + 2); + mine_transaction(&nodes[0], &partial_claim_tx); { let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap(); assert_eq!(node_txn.len(), 1); @@ -363,7 +353,7 @@ fn test_set_outpoints_partial_claiming() { nodes[0].node.get_and_clear_pending_msg_events(); // Disconnect last block on node A, should regenerate a claiming tx with HTLC dropped - disconnect_block(&nodes[0], &header_102, CHAN_CONFIRM_DEPTH + 2); + disconnect_blocks(&nodes[0], 1); { let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap(); assert_eq!(node_txn.len(), 1); @@ -373,8 +363,8 @@ fn test_set_outpoints_partial_claiming() { } //// Disconnect one more block and then reconnect multiple no transaction should be generated - disconnect_block(&nodes[0], &header_101, CHAN_CONFIRM_DEPTH + 1); - connect_blocks(&nodes[1], 15, 101, false, block_hash_100); + disconnect_blocks(&nodes[0], 1); + connect_blocks(&nodes[0], 15, nodes[0].best_block_info().1, false, Default::default()); { let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap(); assert_eq!(node_txn.len(), 0);