From: Matt Corallo Date: Tue, 21 Sep 2021 04:54:02 +0000 (+0000) Subject: f drop spurious test changes X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=commitdiff_plain;h=ccbafc1549025c690553a44805bcd43f6fc922fd;p=rust-lightning f drop spurious test changes --- diff --git a/lightning-persister/src/lib.rs b/lightning-persister/src/lib.rs index 0a813bf07..b0707a4e6 100644 --- a/lightning-persister/src/lib.rs +++ b/lightning-persister/src/lib.rs @@ -182,11 +182,11 @@ mod tests { use bitcoin::Txid; use lightning::chain::channelmonitor::{Persist, ChannelMonitorUpdateErr}; use lightning::chain::transaction::OutPoint; - use lightning::{check_closed_broadcast, check_added_monitors}; + use lightning::{check_closed_broadcast, check_closed_event, check_added_monitors}; use lightning::ln::features::InitFeatures; use lightning::ln::functional_test_utils::*; use lightning::ln::msgs::ErrorAction; - use lightning::util::events::{MessageSendEventsProvider, MessageSendEvent}; + use lightning::util::events::{ClosureReason, Event, MessageSendEventsProvider, MessageSendEvent}; use lightning::util::test_utils; use std::fs; #[cfg(target_os = "windows")] @@ -259,6 +259,7 @@ mod tests { // Force close because cooperative close doesn't result in any persisted // updates. nodes[0].node.force_close_channel(&nodes[0].node.list_channels()[0].channel_id).unwrap(); + check_closed_event!(nodes[0], 1, ClosureReason::HolderForceClosed); check_closed_broadcast!(nodes[0], true); check_added_monitors!(nodes[0], 1); @@ -268,12 +269,11 @@ mod tests { 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[1], &Block { header, txdata: vec![node_txn[0].clone(), node_txn[0].clone()]}); check_closed_broadcast!(nodes[1], true); + check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxBroadcasted); check_added_monitors!(nodes[1], 1); // Make sure everything is persisted as expected after close. check_persisted_data!(11); - nodes[0].node.get_and_clear_pending_events(); - nodes[1].node.get_and_clear_pending_events(); } // Test that if the persister's path to channel data is read-only, writing a @@ -293,6 +293,7 @@ mod tests { let nodes = create_network(2, &node_cfgs, &node_chanmgrs); let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()); nodes[1].node.force_close_channel(&chan.2).unwrap(); + check_closed_event!(nodes[1], 1, ClosureReason::HolderForceClosed); let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap(); // Set the persister's directory to read-only, which should result in @@ -314,7 +315,6 @@ mod tests { nodes[1].node.get_and_clear_pending_msg_events(); added_monitors.clear(); - nodes[1].node.get_and_clear_pending_events(); } // Test that if a persister's directory name is invalid, monitor persistence diff --git a/lightning/src/ln/chanmon_update_fail_tests.rs b/lightning/src/ln/chanmon_update_fail_tests.rs index eed7beea2..36f226823 100644 --- a/lightning/src/ln/chanmon_update_fail_tests.rs +++ b/lightning/src/ln/chanmon_update_fail_tests.rs @@ -763,6 +763,7 @@ fn test_monitor_update_fail_no_rebroadcast() { assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Failed to update ChannelMonitor".to_string(), 1); assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); check_added_monitors!(nodes[1], 1); *nodes[1].chain_monitor.update_ret.lock().unwrap() = Some(Ok(())); @@ -918,6 +919,7 @@ fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) { nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_revoke_and_ack); assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Failed to update ChannelMonitor".to_string(), 1); + assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); check_added_monitors!(nodes[1], 1); @@ -1007,8 +1009,7 @@ fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) { nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &messages_a.0); commitment_signed_dance!(nodes[0], nodes[1], messages_a.1, false); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, payment_hash_1, true); + expect_payment_failed!(nodes[0], payment_hash_1, true); nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &send_event_b.msgs[0]); let as_cs; @@ -1716,8 +1717,7 @@ fn test_monitor_update_fail_claim() { let bs_fulfill_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &bs_fulfill_update.update_fulfill_htlcs[0]); commitment_signed_dance!(nodes[0], nodes[1], bs_fulfill_update.commitment_signed, false); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_sent!(nodes[0], payment_preimage_1, events); + expect_payment_sent!(nodes[0], payment_preimage_1); // Get the payment forwards, note that they were batched into one commitment update. expect_pending_htlcs_forwardable!(nodes[1]); @@ -1928,6 +1928,7 @@ fn do_during_funding_monitor_fail(confirm_a_first: bool, restore_b_before_conf: assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); nodes[0].logger.assert_log("lightning::ln::channelmanager".to_string(), "Failed to update ChannelMonitor".to_string(), 1); check_added_monitors!(nodes[0], 1); + assert!(nodes[0].node.get_and_clear_pending_events().is_empty()); *nodes[0].chain_monitor.update_ret.lock().unwrap() = Some(Ok(())); let (outpoint, latest_update) = nodes[0].chain_monitor.latest_monitor_update_id.lock().unwrap().get(&channel_id).unwrap().clone(); nodes[0].node.channel_monitor_updated(&outpoint, latest_update); @@ -2413,8 +2414,7 @@ fn do_channel_holding_cell_serialize(disconnect: bool, reload_a: bool) { assert!(updates.update_fee.is_none()); assert_eq!(updates.update_fulfill_htlcs.len(), 1); nodes[1].node.handle_update_fulfill_htlc(&nodes[0].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]); - let events = nodes[1].node.get_and_clear_pending_events(); - expect_payment_sent!(nodes[1], payment_preimage_0, events); + expect_payment_sent!(nodes[1], payment_preimage_0); assert_eq!(updates.update_add_htlcs.len(), 1); nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]); updates.commitment_signed @@ -2520,8 +2520,7 @@ fn do_test_reconnect_dup_htlc_claims(htlc_status: HTLCStatusAtDupClaim, second_f bs_updates = Some(get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id())); assert_eq!(bs_updates.as_ref().unwrap().update_fulfill_htlcs.len(), 1); nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &bs_updates.as_ref().unwrap().update_fulfill_htlcs[0]); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_sent!(nodes[0], payment_preimage, events); + expect_payment_sent!(nodes[0], payment_preimage); if htlc_status == HTLCStatusAtDupClaim::Cleared { commitment_signed_dance!(nodes[0], nodes[1], &bs_updates.as_ref().unwrap().commitment_signed, false); } @@ -2547,8 +2546,7 @@ fn do_test_reconnect_dup_htlc_claims(htlc_status: HTLCStatusAtDupClaim, second_f bs_updates = Some(get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id())); assert_eq!(bs_updates.as_ref().unwrap().update_fulfill_htlcs.len(), 1); nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &bs_updates.as_ref().unwrap().update_fulfill_htlcs[0]); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_sent!(nodes[0], payment_preimage, events); + expect_payment_sent!(nodes[0], payment_preimage); } if htlc_status != HTLCStatusAtDupClaim::Cleared { commitment_signed_dance!(nodes[0], nodes[1], &bs_updates.as_ref().unwrap().commitment_signed, false); @@ -2715,8 +2713,7 @@ fn double_temp_error() { assert_eq!(node_id, nodes[0].node.get_our_node_id()); nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_1); check_added_monitors!(nodes[0], 0); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_sent!(nodes[0], payment_preimage_1, events); + expect_payment_sent!(nodes[0], payment_preimage_1); nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed_b1); check_added_monitors!(nodes[0], 1); nodes[0].node.process_pending_htlc_forwards(); @@ -2759,6 +2756,5 @@ fn double_temp_error() { check_added_monitors!(nodes[0], 0); assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); commitment_signed_dance!(nodes[0], nodes[1], commitment_signed_b2, false); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_sent!(nodes[0], payment_preimage_2, events); + expect_payment_sent!(nodes[0], payment_preimage_2); } diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs index 6ab97c242..734466404 100644 --- a/lightning/src/ln/channelmanager.rs +++ b/lightning/src/ln/channelmanager.rs @@ -5711,8 +5711,7 @@ mod tests { assert!(updates.update_fee.is_none()); nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]); commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, true, true); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, our_payment_hash, true); + expect_payment_failed!(nodes[0], our_payment_hash, true); // Send the second half of the original MPP payment. nodes[0].node.send_payment_along_path(&route.paths[0], &our_payment_hash, &Some(payment_secret), 200_000, cur_height, mpp_id, &None).unwrap(); @@ -5766,7 +5765,6 @@ mod tests { #[test] fn test_keysend_dup_payment_hash() { - // (1): Test that a keysend payment with a duplicate payment hash to an existing pending // outbound regular payment fails as expected. // (2): Test that a regular payment with a duplicate payment hash to an existing keysend payment @@ -5804,8 +5802,7 @@ mod tests { assert!(updates.update_fee.is_none()); nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]); commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, true, true); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, payment_hash, true); + expect_payment_failed!(nodes[0], payment_hash, true); // Finally, claim the original payment. claim_payment(&nodes[0], &expected_route, payment_preimage); @@ -5843,8 +5840,7 @@ mod tests { assert!(updates.update_fee.is_none()); nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]); commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, true, true); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, payment_hash, true); + expect_payment_failed!(nodes[0], payment_hash, true); // Finally, succeed the keysend payment. claim_payment(&nodes[0], &expected_route, payment_preimage); diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs index 1ab91cfb2..a8b91735c 100644 --- a/lightning/src/ln/functional_test_utils.rs +++ b/lightning/src/ln/functional_test_utils.rs @@ -1038,9 +1038,10 @@ macro_rules! expect_payment_received { } macro_rules! expect_payment_sent { - ($node: expr, $expected_payment_preimage: expr, $events: expr) => { - assert_eq!($events.len(), 1); - match $events[0] { + ($node: expr, $expected_payment_preimage: expr) => { + let events = $node.node.get_and_clear_pending_events(); + assert_eq!(events.len(), 1); + match events[0] { Event::PaymentSent { ref payment_preimage } => { assert_eq!($expected_payment_preimage, *payment_preimage); }, @@ -1094,8 +1095,8 @@ macro_rules! expect_payment_failed_with_update { #[cfg(test)] macro_rules! expect_payment_failed { - ($node: expr, $events: expr, $expected_payment_hash: expr, $rejected_by_dest: expr $(, $expected_error_code: expr, $expected_error_data: expr)*) => { - let events: Vec = $events; + ($node: expr, $expected_payment_hash: expr, $rejected_by_dest: expr $(, $expected_error_code: expr, $expected_error_data: expr)*) => { + let events = $node.node.get_and_clear_pending_events(); assert_eq!(events.len(), 1); match events[0] { Event::PaymentFailed { ref payment_hash, rejected_by_dest, network_update: _, ref error_code, ref error_data, .. } => { @@ -1273,8 +1274,7 @@ pub fn claim_payment_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, exp } } if !skip_last { - let events = origin_node.node.get_and_clear_pending_events(); - expect_payment_sent!(origin_node, our_payment_preimage, events); + expect_payment_sent!(origin_node, our_payment_preimage); } } diff --git a/lightning/src/ln/functional_tests.rs b/lightning/src/ln/functional_tests.rs index 3da0f08fe..c6db98176 100644 --- a/lightning/src/ln/functional_tests.rs +++ b/lightning/src/ln/functional_tests.rs @@ -1926,8 +1926,7 @@ fn channel_reserve_in_flight_removes() { nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_removes.commitment_signed); check_added_monitors!(nodes[0], 1); let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id()); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_sent!(nodes[0], payment_preimage_1, events); + expect_payment_sent!(nodes[0], payment_preimage_1); nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_1.msgs[0]); nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &send_1.commitment_msg); @@ -1956,8 +1955,7 @@ fn channel_reserve_in_flight_removes() { nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_cs.commitment_signed); check_added_monitors!(nodes[0], 1); let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id()); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_sent!(nodes[0], payment_preimage_2, events); + expect_payment_sent!(nodes[0], payment_preimage_2); nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa); check_added_monitors!(nodes[1], 1); @@ -2384,8 +2382,7 @@ fn claim_htlc_outputs_shared_tx() { check_added_monitors!(nodes[1], 1); check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxBroadcasted); connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1); - let events = nodes[1].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[1], events, payment_hash_2, true); + expect_payment_failed!(nodes[1], payment_hash_2, true); let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); assert_eq!(node_txn.len(), 2); // ChannelMonitor: penalty tx, ChannelManager: local commitment @@ -2444,13 +2441,12 @@ fn claim_htlc_outputs_single_tx() { let mut events = nodes[0].node.get_and_clear_pending_events(); expect_pending_htlcs_forwardable_from_events!(nodes[0], events[0..1], true); match events[1] { - Event::ChannelClosed { .. } => {} + Event::ChannelClosed { reason: ClosureReason::CommitmentTxBroadcasted, .. } => {} _ => panic!("Unexpected event"), } connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1); - let events = nodes[1].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[1], events, payment_hash_2, true); + expect_payment_failed!(nodes[1], payment_hash_2, true); let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); assert_eq!(node_txn.len(), 9); @@ -3191,8 +3187,14 @@ fn fail_backward_pending_htlc_upon_channel_failure() { nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &update_add_htlc); } let events = nodes[0].node.get_and_clear_pending_events(); + assert_eq!(events.len(), 2); // Check that Alice fails backward the pending HTLC from the second payment. - expect_payment_failed!(nodes[0], events[0..1].to_vec(), failed_payment_hash, true); + match events[0] { + Event::PaymentFailed { payment_hash, .. } => { + assert_eq!(payment_hash, failed_payment_hash); + }, + _ => panic!("Unexpected event"), + } match events[1] { Event::ChannelClosed { .. } => {} _ => panic!("Unexpected event"), @@ -3334,8 +3336,7 @@ fn test_dup_events_on_peer_disconnect() { check_added_monitors!(nodes[1], 1); let claim_msgs = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &claim_msgs.update_fulfill_htlcs[0]); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_sent!(nodes[0], payment_preimage, events); + expect_payment_sent!(nodes[0], payment_preimage); nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false); nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false); @@ -3994,8 +3995,7 @@ fn do_test_htlc_timeout(send_partial_mpp: bool) { // 100_000 msat as u64, followed by the height at which we failed back above let mut expected_failure_data = byte_utils::be64_to_array(100_000).to_vec(); expected_failure_data.extend_from_slice(&byte_utils::be32_to_array(block_count - 1)); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, our_payment_hash, true, 0x4000 | 15, &expected_failure_data[..]); + expect_payment_failed!(nodes[0], our_payment_hash, true, 0x4000 | 15, &expected_failure_data[..]); } #[test] @@ -4068,8 +4068,7 @@ fn do_test_holding_cell_htlc_add_timeouts(forwarded_htlc: bool) { } expect_payment_failed_with_update!(nodes[0], second_payment_hash, false, chan_2.0.contents.short_channel_id, false); } else { - let events = nodes[1].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[1], events, second_payment_hash, true); + expect_payment_failed!(nodes[1], second_payment_hash, true); } } @@ -4246,8 +4245,7 @@ fn test_dup_htlc_onchain_fails_on_reload() { header.prev_blockhash = nodes[0].best_block_hash(); let claim_block = Block { header, txdata: claim_txn}; connect_block(&nodes[0], &claim_block); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_sent!(nodes[0], payment_preimage, events); + expect_payment_sent!(nodes[0], payment_preimage); // ChannelManagers generally get re-serialized after any relevant event(s). Since we just // connected a highly-relevant block, it likely gets serialized out now. @@ -4807,8 +4805,7 @@ fn test_static_spendable_outputs_timeout_tx() { mine_transaction(&nodes[1], &node_txn[1]); check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxBroadcasted); connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1); - let events = nodes[1].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[1], events, our_payment_hash, true); + expect_payment_failed!(nodes[1], our_payment_hash, true); let spend_txn = check_spendable_outputs!(nodes[1], node_cfgs[1].keys_manager); assert_eq!(spend_txn.len(), 3); // SpendableOutput: remote_commitment_tx.to_remote, timeout_tx.output @@ -5447,48 +5444,28 @@ fn do_test_fail_backwards_unrevoked_remote_announce(deliver_last_raa: bool, anno if announce_latest { mine_transaction(&nodes[2], &ds_last_commitment_tx[0]); - let events = nodes[2].node.get_and_clear_pending_events(); - if deliver_last_raa { - assert_eq!(events.len(), 2); - match events[1] { - Event::ChannelClosed { .. } => {} - _ => panic!("Unexpected event"), - } - connect_blocks(&nodes[2], ANTI_REORG_DELAY - 1); - check_closed_broadcast!(nodes[2], true); - expect_pending_htlcs_forwardable_from_events!(nodes[2], events[0..1], true); - } else { - assert_eq!(events.len(), 1); - match events[0] { - Event::ChannelClosed { .. } => {} - _ => panic!("Unexpected event"), - } - connect_blocks(&nodes[2], ANTI_REORG_DELAY - 1); - check_closed_broadcast!(nodes[2], true); - expect_pending_htlcs_forwardable!(nodes[2]); - } } else { mine_transaction(&nodes[2], &ds_prev_commitment_tx[0]); - let events = nodes[2].node.get_and_clear_pending_events(); - if deliver_last_raa { - assert_eq!(events.len(), 2); - match events[1] { - Event::ChannelClosed { .. } => {} - _ => panic!("Unexpected event"), - } - connect_blocks(&nodes[2], ANTI_REORG_DELAY - 1); - check_closed_broadcast!(nodes[2], true); - expect_pending_htlcs_forwardable_from_events!(nodes[2], events[0..1], true); - } else { - assert_eq!(events.len(), 1); - match events[0] { - Event::ChannelClosed { .. } => {} - _ => panic!("Unexpected event"), - } - connect_blocks(&nodes[2], ANTI_REORG_DELAY - 1); - check_closed_broadcast!(nodes[2], true); - expect_pending_htlcs_forwardable!(nodes[2]); - } + } + let events = nodes[2].node.get_and_clear_pending_events(); + let close_event = if deliver_last_raa { + assert_eq!(events.len(), 2); + events[1].clone() + } else { + assert_eq!(events.len(), 1); + events[0].clone() + }; + match close_event { + Event::ChannelClosed { reason: ClosureReason::CommitmentTxBroadcasted, .. } => {} + _ => panic!("Unexpected event"), + } + + connect_blocks(&nodes[2], ANTI_REORG_DELAY - 1); + check_closed_broadcast!(nodes[2], true); + if deliver_last_raa { + expect_pending_htlcs_forwardable_from_events!(nodes[2], events[0..1], true); + } else { + expect_pending_htlcs_forwardable!(nodes[2]); } check_added_monitors!(nodes[2], 3); @@ -5641,8 +5618,7 @@ fn test_dynamic_spendable_outputs_local_htlc_timeout_tx() { mine_transaction(&nodes[0], &htlc_timeout); connect_blocks(&nodes[0], BREAKDOWN_TIMEOUT as u32 - 1); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, our_payment_hash, true); + 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 let spend_txn = check_spendable_outputs!(nodes[0], node_cfgs[0].keys_manager); @@ -5723,8 +5699,7 @@ fn test_key_derivation_params() { mine_transaction(&nodes[0], &htlc_timeout); connect_blocks(&nodes[0], BREAKDOWN_TIMEOUT as u32 - 1); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, our_payment_hash, true); + 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 let new_keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet); @@ -5896,8 +5871,7 @@ fn do_htlc_claim_previous_remote_commitment_only(use_dust: bool, check_revoke_no check_added_monitors!(nodes[0], 1); check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxBroadcasted); } else { - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, our_payment_hash, true); + expect_payment_failed!(nodes[0], our_payment_hash, true); } } @@ -7188,8 +7162,7 @@ fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) { mine_transaction(&nodes[0], &as_commitment_tx[0]); check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxBroadcasted); connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, dust_hash, true); + expect_payment_failed!(nodes[0], dust_hash, true); connect_blocks(&nodes[0], TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS - ANTI_REORG_DELAY); check_closed_broadcast!(nodes[0], true); @@ -7201,8 +7174,7 @@ fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) { assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0); mine_transaction(&nodes[0], &timeout_tx[0]); connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, non_dust_hash, true); + 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 mine_transaction(&nodes[0], &bs_commitment_tx[0]); @@ -7213,15 +7185,13 @@ fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) { connect_blocks(&nodes[0], TEST_FINAL_CLTV - 1); // Confirm blocks until the HTLC expires timeout_tx.push(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap()[1].clone()); if !revoked { - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, dust_hash, true); + 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 mine_transaction(&nodes[0], &timeout_tx[0]); assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0); connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, non_dust_hash, true); + 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 // commitment tx @@ -7486,8 +7456,7 @@ fn test_check_htlc_underpaying() { // 10_000 msat as u64, followed by a height of CHAN_CONFIRM_DEPTH as u32 let mut expected_failure_data = byte_utils::be64_to_array(10_000).to_vec(); expected_failure_data.extend_from_slice(&byte_utils::be32_to_array(CHAN_CONFIRM_DEPTH)); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, our_payment_hash, true, 0x4000|15, &expected_failure_data[..]); + expect_payment_failed!(nodes[0], our_payment_hash, true, 0x4000|15, &expected_failure_data[..]); } #[test] @@ -8426,20 +8395,17 @@ fn test_bad_secret_hash() { // Send a payment with the right payment hash but the wrong payment secret nodes[0].node.send_payment(&route, our_payment_hash, &Some(random_payment_secret)).unwrap(); handle_unknown_invalid_payment_data!(); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, our_payment_hash, true, expected_error_code, expected_error_data); + expect_payment_failed!(nodes[0], our_payment_hash, true, expected_error_code, expected_error_data); // Send a payment with a random payment hash, but the right payment secret nodes[0].node.send_payment(&route, random_payment_hash, &Some(our_payment_secret)).unwrap(); handle_unknown_invalid_payment_data!(); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, random_payment_hash, true, expected_error_code, expected_error_data); + expect_payment_failed!(nodes[0], random_payment_hash, true, expected_error_code, expected_error_data); // Send a payment with a random payment hash and random payment secret nodes[0].node.send_payment(&route, random_payment_hash, &Some(random_payment_secret)).unwrap(); handle_unknown_invalid_payment_data!(); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, random_payment_hash, true, expected_error_code, expected_error_data); + expect_payment_failed!(nodes[0], random_payment_hash, true, expected_error_code, expected_error_data); } #[test] @@ -8710,8 +8676,7 @@ fn test_htlc_no_detection() { let header_201 = 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_201, txdata: vec![htlc_timeout.clone()] }); connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, our_payment_hash, true); + expect_payment_failed!(nodes[0], our_payment_hash, true); } fn do_test_onchain_htlc_settlement_after_close(broadcast_alice: bool, go_onchain_before_fulfill: bool) { diff --git a/lightning/src/ln/monitor_tests.rs b/lightning/src/ln/monitor_tests.rs index 9e8d74b55..98efa9931 100644 --- a/lightning/src/ln/monitor_tests.rs +++ b/lightning/src/ln/monitor_tests.rs @@ -250,8 +250,7 @@ fn do_test_claim_value_force_close(prev_commitment_tx: bool) { if prev_commitment_tx { // To build a previous commitment transaction, deliver one round of commitment messages. nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &b_htlc_msgs.update_fulfill_htlcs[0]); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_sent!(nodes[0], payment_preimage, events); + expect_payment_sent!(nodes[0], payment_preimage); nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &b_htlc_msgs.commitment_signed); check_added_monitors!(nodes[0], 1); let (as_raa, as_cs) = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id()); @@ -363,8 +362,7 @@ fn do_test_claim_value_force_close(prev_commitment_tx: bool) { sorted_vec(nodes[1].chain_monitor.chain_monitor.monitors.read().unwrap().get(&funding_outpoint).unwrap().get_claimable_balances())); connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, dust_payment_hash, true); + expect_payment_failed!(nodes[0], dust_payment_hash, true); connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1); // After ANTI_REORG_DELAY, A will consider its balance fully spendable and generate a @@ -404,8 +402,7 @@ fn do_test_claim_value_force_close(prev_commitment_tx: bool) { // possibly-claimable up to ANTI_REORG_DELAY, at which point it will drop it. mine_transaction(&nodes[0], &b_broadcast_txn[0]); if !prev_commitment_tx { - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_sent!(nodes[0], payment_preimage, events); + expect_payment_sent!(nodes[0], payment_preimage); } assert_eq!(sorted_vec(vec![Balance::MaybeClaimableHTLCAwaitingTimeout { claimable_amount_satoshis: 3_000, @@ -451,8 +448,7 @@ fn do_test_claim_value_force_close(prev_commitment_tx: bool) { connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1); assert_eq!(Vec::::new(), nodes[0].chain_monitor.chain_monitor.monitors.read().unwrap().get(&funding_outpoint).unwrap().get_claimable_balances()); - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_failed!(nodes[0], events, timeout_payment_hash, true); + expect_payment_failed!(nodes[0], timeout_payment_hash, true); let mut node_a_spendable = nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events(); assert_eq!(node_a_spendable.len(), 1); diff --git a/lightning/src/ln/reorg_tests.rs b/lightning/src/ln/reorg_tests.rs index 54ec7b833..834d9ca53 100644 --- a/lightning/src/ln/reorg_tests.rs +++ b/lightning/src/ln/reorg_tests.rs @@ -164,8 +164,7 @@ fn do_test_onchain_htlc_reorg(local_commitment: bool, claim: bool) { } commitment_signed_dance!(nodes[0], nodes[1], htlc_updates.commitment_signed, false, true); if claim { - let events = nodes[0].node.get_and_clear_pending_events(); - expect_payment_sent!(nodes[0], our_payment_preimage, events); + expect_payment_sent!(nodes[0], our_payment_preimage); } else { expect_payment_failed_with_update!(nodes[0], our_payment_hash, false, chan_2.0.contents.short_channel_id, true); }