Merge pull request #2441 from arik-so/2023-07-taproot-signer-wrapped

[rust-lightning] / lightning / src / ln / monitor_tests.rs

diff --git a/lightning/src/ln/monitor_tests.rs b/lightning/src/ln/monitor_tests.rs
index af79464801b883a86f0409cc5fe05ed06c0845c4..728752f97c310bc478abc213d165fc347a2db407 100644 (file)
--- a/lightning/src/ln/monitor_tests.rs
+++ b/lightning/src/ln/monitor_tests.rs
@@ -16,7 +16,7 @@ use crate::chain::chaininterface::{LowerBoundedFeeEstimator, compute_feerate_sat
 use crate::events::bump_transaction::{BumpTransactionEvent, WalletSource};
 use crate::events::{Event, MessageSendEvent, MessageSendEventsProvider, ClosureReason, HTLCDestination};
 use crate::ln::channel;
-use crate::ln::channelmanager::{BREAKDOWN_TIMEOUT, ChannelManager, PaymentId, RecipientOnionFields};
+use crate::ln::channelmanager::{BREAKDOWN_TIMEOUT, PaymentId, RecipientOnionFields};
 use crate::ln::msgs::ChannelMessageHandler;
 use crate::util::config::UserConfig;
 use crate::util::crypto::sign;
@@ -95,7 +95,7 @@ fn chanmon_fail_from_stale_commitment() {
 fn test_spendable_output<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, spendable_tx: &Transaction) {
        let mut spendable = node.chain_monitor.chain_monitor.get_and_clear_pending_events();
        assert_eq!(spendable.len(), 1);
-       if let Event::SpendableOutputs { outputs } = spendable.pop().unwrap() {
+       if let Event::SpendableOutputs { outputs, .. } = spendable.pop().unwrap() {
                assert_eq!(outputs.len(), 1);
                let spend_tx = node.keys_manager.backing.spend_spendable_outputs(&[&outputs[0]], Vec::new(),
                        Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(), 253, None, &Secp256k1::new()).unwrap();
@@ -345,7 +345,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]);
-               expect_payment_sent_without_paths!(nodes[0], payment_preimage);
+               expect_payment_sent(&nodes[0], payment_preimage, None, false, false);
                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());
@@ -454,7 +454,7 @@ fn do_test_claim_value_force_close(prev_commitment_tx: bool) {
        if prev_commitment_tx {
                expect_payment_path_successful!(nodes[0]);
        } else {
-               expect_payment_sent!(nodes[0], payment_preimage);
+               expect_payment_sent(&nodes[0], payment_preimage, None, true, false);
        }
        assert_eq!(sorted_vec(vec![sent_htlc_balance.clone(), sent_htlc_timeout_balance.clone()]),
                sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(funding_outpoint).unwrap().get_claimable_balances()));
@@ -681,7 +681,7 @@ fn test_balances_on_local_commitment_htlcs() {
        // Now confirm nodes[1]'s HTLC claim, giving nodes[0] the preimage. Note that the "maybe
        // claimable" balance remains until we see ANTI_REORG_DELAY blocks.
        mine_transaction(&nodes[0], &bs_htlc_claim_txn[0]);
-       expect_payment_sent!(nodes[0], payment_preimage_2);
+       expect_payment_sent(&nodes[0], payment_preimage_2, None, true, false);
        assert_eq!(sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
                        amount_satoshis: 1_000_000 - 10_000 - 20_000 - chan_feerate *
                                (channel::commitment_tx_base_weight(&channel_type_features) + 2 * channel::COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000,
@@ -1538,7 +1538,7 @@ fn test_revoked_counterparty_aggregated_claims() {
        // Confirm A's HTLC-Success tranasction which presumably raced B's claim, causing B to create a
        // new claim.
        mine_transaction(&nodes[1], &as_revoked_txn[1]);
-       expect_payment_sent!(nodes[1], claimed_payment_preimage);
+       expect_payment_sent(&nodes[1], claimed_payment_preimage, None, true, false);
        let mut claim_txn_2: Vec<_> = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
        claim_txn_2.sort_unstable_by_key(|tx| if tx.input.iter().any(|inp| inp.previous_output.txid == as_revoked_txn[0].txid()) { 0 } else { 1 });
        // Once B sees the HTLC-Success transaction it splits its claim transaction into two, though in
@@ -1638,13 +1638,14 @@ fn test_revoked_counterparty_aggregated_claims() {
 
 fn do_test_restored_packages_retry(check_old_monitor_retries_after_upgrade: bool) {
        // Tests that we'll retry packages that were previously timelocked after we've restored them.
+       let chanmon_cfgs = create_chanmon_cfgs(2);
+       let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let persister;
        let new_chain_monitor;
-       let node_deserialized;
 
-       let chanmon_cfgs = create_chanmon_cfgs(2);
-       let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
+       let node_deserialized;
+
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 
        // Open a channel, lock in an HTLC, and immediately broadcast the commitment transaction. This
@@ -1969,19 +1970,15 @@ fn test_anchors_aggregated_revoked_htlc_tx() {
        // Required to sign a revoked commitment transaction
        chanmon_cfgs[1].keys_manager.disable_revocation_policy_check = true;
        let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
+       let bob_persister;
+       let bob_chain_monitor;
+
        let mut anchors_config = UserConfig::default();
        anchors_config.channel_handshake_config.announced_channel = true;
        anchors_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
        anchors_config.manually_accept_inbound_channels = true;
        let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(anchors_config), Some(anchors_config)]);
-
-       let bob_persister: test_utils::TestPersister;
-       let bob_chain_monitor: test_utils::TestChainMonitor;
-       let bob_deserialized: ChannelManager<
-               &test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface,
-               &test_utils::TestKeysInterface, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator,
-               &test_utils::TestRouter, &test_utils::TestLogger,
-       >;
+       let bob_deserialized;
 
        let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 
@@ -2231,8 +2228,9 @@ fn test_anchors_aggregated_revoked_htlc_tx() {
        let spendable_output_events = nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events();
        assert_eq!(spendable_output_events.len(), 2);
        for (idx, event) in spendable_output_events.iter().enumerate() {
-               if let Event::SpendableOutputs { outputs } = event {
+               if let Event::SpendableOutputs { outputs, channel_id } = event {
                        assert_eq!(outputs.len(), 1);
+                       assert!(vec![chan_b.2, chan_a.2].contains(&channel_id.unwrap()));
                        let spend_tx = nodes[0].keys_manager.backing.spend_spendable_outputs(
                                &[&outputs[0]], Vec::new(), Script::new_op_return(&[]), 253, None, &Secp256k1::new(),
                        ).unwrap();