Drop the amount parameter to claim_funds

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

diff --git a/lightning/src/ln/functional_tests.rs b/lightning/src/ln/functional_tests.rs
index b36cb32f3eeca3828257754611060164a75c8c4c..aea006fe71fbed21def1d079b85386ee01dc1381 100644 (file)
--- a/lightning/src/ln/functional_tests.rs
+++ b/lightning/src/ln/functional_tests.rs
@@ -128,7 +128,7 @@ fn test_async_inbound_update_fee() {
        let channel_id = chan.2;
 
        // balancing
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
 
        // A                                        B
        // update_fee                            ->
@@ -243,7 +243,7 @@ fn test_update_fee_unordered_raa() {
        let logger = test_utils::TestLogger::new();
 
        // balancing
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
 
        // First nodes[0] generates an update_fee
        nodes[0].node.update_fee(channel_id, get_feerate!(nodes[0], channel_id) + 20).unwrap();
@@ -625,7 +625,7 @@ fn test_update_fee_with_fundee_update_add_htlc() {
        let logger = test_utils::TestLogger::new();
 
        // balancing
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
 
        let feerate = get_feerate!(nodes[0], channel_id);
        nodes[0].node.update_fee(channel_id, feerate+20).unwrap();
@@ -705,10 +705,10 @@ fn test_update_fee_with_fundee_update_add_htlc() {
                _ => panic!("Unexpected event"),
        };
 
-       claim_payment(&nodes[1], &vec!(&nodes[0])[..], our_payment_preimage, 800_000);
+       claim_payment(&nodes[1], &vec!(&nodes[0])[..], our_payment_preimage);
 
-       send_payment(&nodes[1], &vec!(&nodes[0])[..], 800000, 800_000);
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 800000, 800_000);
+       send_payment(&nodes[1], &vec!(&nodes[0])[..], 800000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 800000);
        close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true);
 }
 
@@ -874,7 +874,7 @@ fn updates_shutdown_wait() {
        unwrap_send_err!(nodes[0].node.send_payment(&route_1, payment_hash, &Some(payment_secret)), true, APIError::ChannelUnavailable {..}, {});
        unwrap_send_err!(nodes[1].node.send_payment(&route_2, payment_hash, &Some(payment_secret)), true, APIError::ChannelUnavailable {..}, {});
 
-       assert!(nodes[2].node.claim_funds(our_payment_preimage, 100_000));
+       assert!(nodes[2].node.claim_funds(our_payment_preimage));
        check_added_monitors!(nodes[2], 1);
        let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
        assert!(updates.update_add_htlcs.is_empty());
@@ -1047,7 +1047,7 @@ fn do_test_shutdown_rebroadcast(recv_count: u8) {
        assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
        assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 
-       assert!(nodes[2].node.claim_funds(our_payment_preimage, 100_000));
+       assert!(nodes[2].node.claim_funds(our_payment_preimage));
        check_added_monitors!(nodes[2], 1);
        let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
        assert!(updates.update_add_htlcs.is_empty());
@@ -1175,15 +1175,15 @@ fn fake_network_test() {
        let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
 
        // Rebalance the network a bit by relaying one payment through all the channels...
-       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
-       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
-       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
-       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000);
+       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000);
+       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000);
+       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000);
 
        // Send some more payments
-       send_payment(&nodes[1], &vec!(&nodes[2], &nodes[3])[..], 1000000, 1_000_000);
-       send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1], &nodes[0])[..], 1000000, 1_000_000);
-       send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1])[..], 1000000, 1_000_000);
+       send_payment(&nodes[1], &vec!(&nodes[2], &nodes[3])[..], 1000000);
+       send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1], &nodes[0])[..], 1000000);
+       send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1])[..], 1000000);
 
        // Test failure packets
        let payment_hash_1 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 1000000).1;
@@ -1192,13 +1192,13 @@ fn fake_network_test() {
        // Add a new channel that skips 3
        let chan_4 = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known());
 
-       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 1000000, 1_000_000);
-       send_payment(&nodes[2], &vec!(&nodes[3])[..], 1000000, 1_000_000);
-       send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
-       send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
-       send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
-       send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
-       send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 1000000);
+       send_payment(&nodes[2], &vec!(&nodes[3])[..], 1000000);
+       send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
+       send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
+       send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
+       send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
+       send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
 
        // Do some rebalance loop payments, simultaneously
        let mut hops = Vec::with_capacity(3);
@@ -1261,7 +1261,7 @@ fn fake_network_test() {
 
        // Claim the rebalances...
        fail_payment(&nodes[1], &vec!(&nodes[3], &nodes[2], &nodes[1])[..], payment_hash_2);
-       claim_payment(&nodes[1], &vec!(&nodes[2], &nodes[3], &nodes[1])[..], payment_preimage_1, 1_000_000);
+       claim_payment(&nodes[1], &vec!(&nodes[2], &nodes[3], &nodes[1])[..], payment_preimage_1);
 
        // Add a duplicate new channel from 2 to 4
        let chan_5 = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known());
@@ -1279,9 +1279,9 @@ fn fake_network_test() {
 
        //TODO: Test that routes work again here as we've been notified that the channel is full
 
-       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_3, 3_000_000);
-       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_4, 3_000_000);
-       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_5, 3_000_000);
+       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_3);
+       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_4);
+       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_5);
 
        // Close down the channels...
        close_channel(&nodes[0], &nodes[1], &chan_1.2, chan_1.3, true);
@@ -1415,10 +1415,10 @@ fn holding_cell_htlc_counting() {
        }
 
        for (preimage, _) in payments.drain(..) {
-               claim_payment(&nodes[1], &[&nodes[2]], preimage, 100_000);
+               claim_payment(&nodes[1], &[&nodes[2]], preimage);
        }
 
-       send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000, 1_000_000);
+       send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
 }
 
 #[test]
@@ -1445,9 +1445,9 @@ fn duplicate_htlc_test() {
        *nodes[0].network_payment_count.borrow_mut() -= 1;
        assert_eq!(route_payment(&nodes[2], &vec!(&nodes[3], &nodes[5])[..], 1000000).0, payment_preimage);
 
-       claim_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], payment_preimage, 1_000_000);
+       claim_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], payment_preimage);
        fail_payment(&nodes[2], &vec!(&nodes[3], &nodes[5])[..], payment_hash);
-       claim_payment(&nodes[1], &vec!(&nodes[3])[..], payment_preimage, 1_000_000);
+       claim_payment(&nodes[1], &vec!(&nodes[3])[..], payment_preimage);
 }
 
 #[test]
@@ -1464,7 +1464,7 @@ fn test_duplicate_htlc_different_direction_onchain() {
        let logger = test_utils::TestLogger::new();
 
        // balancing
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
 
        let (payment_preimage, payment_hash, _) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 900_000);
 
@@ -1474,7 +1474,7 @@ fn test_duplicate_htlc_different_direction_onchain() {
        send_along_route_with_secret(&nodes[1], route, &[&[&nodes[0]]], 800_000, payment_hash, node_a_payment_secret);
 
        // Provide preimage to node 0 by claiming payment
-       nodes[0].node.claim_funds(payment_preimage, 800_000);
+       nodes[0].node.claim_funds(payment_preimage);
        check_added_monitors!(nodes[0], 1);
 
        // Broadcast node 1 commitment txn
@@ -1560,7 +1560,7 @@ fn test_basic_channel_reserve() {
        assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
        nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot send value that would put our balance under counterparty-announced channel reserve value".to_string(), 1);
 
-       send_payment(&nodes[0], &vec![&nodes[1]], max_can_send, max_can_send);
+       send_payment(&nodes[0], &vec![&nodes[1]], max_can_send);
 }
 
 #[test]
@@ -1939,7 +1939,7 @@ fn test_channel_reserve_holding_cell_htlcs() {
                if stat01.value_to_self_msat < stat01.channel_reserve_msat + commit_tx_fee_all_htlcs + ensure_htlc_amounts_above_dust_buffer + amt_msat {
                        break;
                }
-               send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_0, recv_value_0);
+               send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_0);
 
                let (stat01_, stat11_, stat12_, stat22_) = (
                        get_channel_value_stat!(nodes[0], chan_1.2),
@@ -2086,13 +2086,13 @@ fn test_channel_reserve_holding_cell_htlcs() {
                _ => panic!("Unexpected event"),
        }
 
-       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_1, recv_value_1);
-       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_21, recv_value_21);
-       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_22, recv_value_22);
+       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_1);
+       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_21);
+       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_22);
 
        let commit_tx_fee_0_htlcs = 2*commit_tx_fee_msat(feerate, 1);
        let recv_value_3 = commit_tx_fee_2_htlcs - commit_tx_fee_0_htlcs - total_fee_msat;
-       send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_3, recv_value_3);
+       send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_3);
 
        let commit_tx_fee_1_htlc = 2*commit_tx_fee_msat(feerate, 1 + 1);
        let expected_value_to_self = stat01.value_to_self_msat - (recv_value_1 + total_fee_msat) - (recv_value_21 + total_fee_msat) - (recv_value_22 + total_fee_msat) - (recv_value_3 + total_fee_msat);
@@ -2154,13 +2154,13 @@ fn channel_reserve_in_flight_removes() {
 
        // Now claim both of the first two HTLCs on B's end, putting B in AwaitingRAA and generating an
        // initial fulfill/CS.
-       assert!(nodes[1].node.claim_funds(payment_preimage_1, b_chan_values.channel_reserve_msat - b_chan_values.value_to_self_msat - 10000));
+       assert!(nodes[1].node.claim_funds(payment_preimage_1));
        check_added_monitors!(nodes[1], 1);
        let bs_removes = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 
        // This claim goes in B's holding cell, allowing us to have a pending B->A RAA which does not
        // remove the second HTLC when we send the HTLC back from B to A.
-       assert!(nodes[1].node.claim_funds(payment_preimage_2, 20000));
+       assert!(nodes[1].node.claim_funds(payment_preimage_2));
        check_added_monitors!(nodes[1], 1);
        assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 
@@ -2253,8 +2253,8 @@ fn channel_reserve_in_flight_removes() {
        expect_pending_htlcs_forwardable!(nodes[0]);
        expect_payment_received!(nodes[0], payment_hash_4, payment_secret_4, 10000);
 
-       claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_4, 10_000);
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3, 100_000);
+       claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_4);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3);
 }
 
 #[test]
@@ -2280,10 +2280,10 @@ fn channel_monitor_network_test() {
        connect_blocks(&nodes[4], 4*CHAN_CONFIRM_DEPTH + 1 - nodes[4].best_block_info().1);
 
        // 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);
-       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);
+       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000);
+       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000);
+       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000);
+       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000);
 
        // Simple case with no pending HTLCs:
        nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), true);
@@ -2318,9 +2318,9 @@ fn channel_monitor_network_test() {
        assert_eq!(nodes[2].node.list_channels().len(), 1);
 
        macro_rules! claim_funds {
-               ($node: expr, $prev_node: expr, $preimage: expr, $amount: expr) => {
+               ($node: expr, $prev_node: expr, $preimage: expr) => {
                        {
-                               assert!($node.node.claim_funds($preimage, $amount));
+                               assert!($node.node.claim_funds($preimage));
                                check_added_monitors!($node, 1);
 
                                let events = $node.node.get_and_clear_pending_msg_events();
@@ -2348,7 +2348,7 @@ fn channel_monitor_network_test() {
                node2_commitment_txid = node_txn[0].txid();
 
                // Claim the payment on nodes[3], giving it knowledge of the preimage
-               claim_funds!(nodes[3], nodes[2], payment_preimage_1, 3_000_000);
+               claim_funds!(nodes[3], nodes[2], payment_preimage_1);
                mine_transaction(&nodes[3], &node_txn[0]);
                check_added_monitors!(nodes[3], 1);
                check_preimage_claim(&nodes[3], &node_txn);
@@ -2397,7 +2397,7 @@ fn channel_monitor_network_test() {
                let node_txn = test_txn_broadcast(&nodes[3], &chan_4, None, HTLCType::TIMEOUT);
 
                // Claim the payment on nodes[4], giving it knowledge of the preimage
-               claim_funds!(nodes[4], nodes[3], payment_preimage_2, 3_000_000);
+               claim_funds!(nodes[4], nodes[3], payment_preimage_2);
 
                connect_blocks(&nodes[4], TEST_FINAL_CLTV - CLTV_CLAIM_BUFFER + 2);
                let events = nodes[4].node.get_and_clear_pending_msg_events();
@@ -2462,7 +2462,7 @@ fn test_justice_tx() {
        assert_eq!(revoked_local_txn[1].input[0].previous_output.txid, revoked_local_txn[0].txid());
        assert_eq!(revoked_local_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT); // HTLC-Timeout
        // Revoke the old state
-       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3, 3_000_000);
+       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3);
 
        {
                mine_transaction(&nodes[1], &revoked_local_txn[0]);
@@ -2508,7 +2508,7 @@ fn test_justice_tx() {
        assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_6.3.txid());
        assert_eq!(revoked_local_txn[0].output.len(), 2); // Only HTLC and output back to A are present
        // Revoke the old state
-       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_4, 3_000_000);
+       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_4);
        {
                mine_transaction(&nodes[0], &revoked_local_txn[0]);
                {
@@ -2548,7 +2548,7 @@ fn revoked_output_claim() {
        // Only output is the full channel value back to nodes[0]:
        assert_eq!(revoked_local_txn[0].output.len(), 1);
        // Send a payment through, updating everyone's latest commitment txn
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 5000000, 5_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 5000000);
 
        // Inform nodes[1] that nodes[0] broadcast a stale tx
        mine_transaction(&nodes[1], &revoked_local_txn[0]);
@@ -2578,7 +2578,7 @@ fn claim_htlc_outputs_shared_tx() {
        let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 
        // Rebalance the network to generate htlc in the two directions
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
        // node[0] is gonna to revoke an old state thus node[1] should be able to claim both offered/received HTLC outputs on top of commitment tx
        let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
        let (_payment_preimage_2, payment_hash_2, _) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000);
@@ -2594,7 +2594,7 @@ fn claim_htlc_outputs_shared_tx() {
        check_spends!(revoked_local_txn[1], revoked_local_txn[0]);
 
        //Revoke the old state
-       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1, 3_000_000);
+       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1);
 
        {
                mine_transaction(&nodes[0], &revoked_local_txn[0]);
@@ -2647,7 +2647,7 @@ fn claim_htlc_outputs_single_tx() {
        let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 
        // Rebalance the network to generate htlc in the two directions
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
        // node[0] is gonna to revoke an old state thus node[1] should be able to claim both offered/received HTLC outputs on top of commitment tx, but this
        // time as two different claim transactions as we're gonna to timeout htlc with given a high current height
        let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
@@ -2657,7 +2657,7 @@ fn claim_htlc_outputs_single_tx() {
        let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
 
        //Revoke the old state
-       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1, 3_000_000);
+       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1);
 
        {
                confirm_transaction_at(&nodes[0], &revoked_local_txn[0], 100);
@@ -2733,8 +2733,8 @@ fn test_htlc_on_chain_success() {
        let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
 
        // Rebalance the network a bit by relaying one payment through all the channels...
-       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
-       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
+       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
 
        let (our_payment_preimage, _payment_hash, _payment_secret) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
        let (our_payment_preimage_2, _payment_hash_2, _payment_secret_2) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
@@ -2744,8 +2744,8 @@ fn test_htlc_on_chain_success() {
        let commitment_tx = get_local_commitment_txn!(nodes[2], chan_2.2);
        assert_eq!(commitment_tx.len(), 1);
        check_spends!(commitment_tx[0], chan_2.3);
-       nodes[2].node.claim_funds(our_payment_preimage, 3_000_000);
-       nodes[2].node.claim_funds(our_payment_preimage_2, 3_000_000);
+       nodes[2].node.claim_funds(our_payment_preimage);
+       nodes[2].node.claim_funds(our_payment_preimage_2);
        check_added_monitors!(nodes[2], 2);
        let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
        assert!(updates.update_add_htlcs.is_empty());
@@ -2914,8 +2914,8 @@ fn do_test_htlc_on_chain_timeout(connect_style: ConnectStyle) {
        let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
 
        // Rebalance the network a bit by relaying one payment thorugh all the channels...
-       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
-       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
+       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
 
        let (_payment_preimage, payment_hash, _payment_secret) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
 
@@ -3046,7 +3046,7 @@ fn test_simple_commitment_revoked_fail_backward() {
        // Get the will-be-revoked local txn from nodes[2]
        let revoked_local_txn = get_local_commitment_txn!(nodes[2], chan_2.2);
        // Revoke the old state
-       claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage, 3_000_000);
+       claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
 
        let (_, payment_hash, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
 
@@ -3112,7 +3112,7 @@ fn do_test_commitment_revoked_fail_backward_exhaustive(deliver_bs_raa: bool, use
        let revoked_local_txn = get_local_commitment_txn!(nodes[2], chan_2.2);
        assert_eq!(revoked_local_txn[0].output.len(), if no_to_remote { 1 } else { 2 });
        // Revoke the old state
-       claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage, if no_to_remote { 10_000 } else { 3_000_000});
+       claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
 
        let value = if use_dust {
                // The dust limit applied to HTLC outputs considers the fee of the HTLC transaction as
@@ -3510,7 +3510,7 @@ fn test_simple_peer_disconnect() {
        let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).0;
        let payment_hash_2 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).1;
        fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_hash_2);
-       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_1, 1_000_000);
+       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_1);
 
        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);
@@ -3524,7 +3524,7 @@ fn test_simple_peer_disconnect() {
        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);
 
-       claim_payment_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], true, payment_preimage_3, 1_000_000);
+       claim_payment_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], true, payment_preimage_3);
        fail_payment_along_route(&nodes[0], &[&nodes[1], &nodes[2]], true, payment_hash_5);
 
        reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (1, 0), (1, 0), (false, false));
@@ -3546,7 +3546,7 @@ fn test_simple_peer_disconnect() {
                }
        }
 
-       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_4, 1_000_000);
+       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_4);
        fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_hash_6);
 }
 
@@ -3654,7 +3654,7 @@ fn do_test_drop_messages_peer_disconnect(messages_delivered: u8) {
                _ => panic!("Unexpected event"),
        }
 
-       nodes[1].node.claim_funds(payment_preimage_1, 1_000_000);
+       nodes[1].node.claim_funds(payment_preimage_1);
        check_added_monitors!(nodes[1], 1);
 
        let events_3 = nodes[1].node.get_and_clear_pending_msg_events();
@@ -3749,7 +3749,7 @@ fn do_test_drop_messages_peer_disconnect(messages_delivered: u8) {
                &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), Some(&nodes[0].node.list_usable_channels().iter().collect::<Vec<_>>()),
                &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
        let payment_preimage_2 = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000).0;
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
 }
 
 #[test]
@@ -3850,7 +3850,7 @@ fn test_funding_peer_disconnect() {
        let logger = test_utils::TestLogger::new();
        let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
        let (payment_preimage, _, _) = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000);
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage, 1_000_000);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
 }
 
 #[test]
@@ -3880,7 +3880,7 @@ fn test_drop_messages_peer_disconnect_dual_htlc() {
                _ => panic!("Unexpected event"),
        }
 
-       assert!(nodes[1].node.claim_funds(payment_preimage_1, 1_000_000));
+       assert!(nodes[1].node.claim_funds(payment_preimage_1));
        check_added_monitors!(nodes[1], 1);
 
        let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
@@ -3994,7 +3994,7 @@ fn test_drop_messages_peer_disconnect_dual_htlc() {
        assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
        check_added_monitors!(nodes[0], 1);
 
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
 }
 
 fn do_test_htlc_timeout(send_partial_mpp: bool) {
@@ -4293,7 +4293,7 @@ fn test_no_txn_manager_serialize_deserialize() {
                node.net_graph_msg_handler.handle_channel_update(&bs_update).unwrap();
        }
 
-       send_payment(&nodes[0], &[&nodes[1]], 1000000, 1_000_000);
+       send_payment(&nodes[0], &[&nodes[1]], 1000000);
 }
 
 #[test]
@@ -4412,7 +4412,7 @@ fn test_manager_serialize_deserialize_events() {
                node.net_graph_msg_handler.handle_channel_update(&bs_update).unwrap();
        }
 
-       send_payment(&nodes[0], &[&nodes[1]], 1000000, 1_000_000);
+       send_payment(&nodes[0], &[&nodes[1]], 1000000);
 }
 
 #[test]
@@ -4472,7 +4472,7 @@ fn test_simple_manager_serialize_deserialize() {
        reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
 
        fail_payment(&nodes[0], &[&nodes[1]], our_payment_hash);
-       claim_payment(&nodes[0], &[&nodes[1]], our_payment_preimage, 1_000_000);
+       claim_payment(&nodes[0], &[&nodes[1]], our_payment_preimage);
 }
 
 #[test]
@@ -4586,7 +4586,7 @@ fn test_manager_serialize_deserialize_inconsistent_monitor() {
        reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
        reconnect_nodes(&nodes[0], &nodes[2], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
        //... and we can even still claim the payment!
-       claim_payment(&nodes[2], &[&nodes[0], &nodes[1]], our_payment_preimage, 1_000_000);
+       claim_payment(&nodes[2], &[&nodes[0], &nodes[1]], our_payment_preimage);
 
        nodes[3].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
        let reestablish = get_event_msg!(nodes[3], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
@@ -4702,7 +4702,7 @@ fn test_claim_on_remote_revoked_sizeable_push_msat() {
        assert_eq!(revoked_local_txn[0].input.len(), 1);
        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);
+       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
        mine_transaction(&nodes[1], &revoked_local_txn[0]);
        check_closed_broadcast!(nodes[1], true);
        check_added_monitors!(nodes[1], 1);
@@ -4735,7 +4735,7 @@ 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
-       assert!(nodes[1].node.claim_funds(payment_preimage, 3_000_000));
+       assert!(nodes[1].node.claim_funds(payment_preimage));
        check_added_monitors!(nodes[1], 1);
        mine_transaction(&nodes[1], &commitment_tx[0]);
        check_added_monitors!(nodes[1], 1);
@@ -4776,7 +4776,7 @@ fn test_static_spendable_outputs_timeout_tx() {
        let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 
        // Rebalance the network a bit by relaying one payment through all the channels ...
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
 
        let (_, our_payment_hash, _) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000);
 
@@ -4827,7 +4827,7 @@ fn test_static_spendable_outputs_justice_tx_revoked_commitment_tx() {
        assert_eq!(revoked_local_txn[0].input.len(), 1);
        assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
 
-       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
+       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
 
        mine_transaction(&nodes[1], &revoked_local_txn[0]);
        check_closed_broadcast!(nodes[1], true);
@@ -4862,7 +4862,7 @@ fn test_static_spendable_outputs_justice_tx_revoked_htlc_timeout_tx() {
        assert_eq!(revoked_local_txn[0].input.len(), 1);
        assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
 
-       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
+       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
 
        // A will generate HTLC-Timeout from revoked commitment tx
        mine_transaction(&nodes[0], &revoked_local_txn[0]);
@@ -4931,7 +4931,7 @@ fn test_static_spendable_outputs_justice_tx_revoked_htlc_success_tx() {
        // The to-be-revoked commitment tx should have one HTLC and one to_remote output
        assert_eq!(revoked_local_txn[0].output.len(), 2);
 
-       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
+       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
 
        // B will generate HTLC-Success from revoked commitment tx
        mine_transaction(&nodes[1], &revoked_local_txn[0]);
@@ -5010,13 +5010,13 @@ fn test_onchain_to_onchain_claim() {
        let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
 
        // Rebalance the network a bit by relaying one payment through all the channels ...
-       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
-       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
+       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
 
        let (payment_preimage, _payment_hash, _payment_secret) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
        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, 3_000_000);
+       nodes[2].node.claim_funds(payment_preimage);
        check_added_monitors!(nodes[2], 1);
        let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
        assert!(updates.update_add_htlcs.is_empty());
@@ -5144,7 +5144,7 @@ fn test_duplicate_payment_hash_one_failure_one_success() {
                htlc_timeout_tx = node_txn[1].clone();
        }
 
-       nodes[2].node.claim_funds(our_payment_preimage, 900_000);
+       nodes[2].node.claim_funds(our_payment_preimage);
        mine_transaction(&nodes[2], &commitment_txn[0]);
        check_added_monitors!(nodes[2], 2);
        let events = nodes[2].node.get_and_clear_pending_msg_events();
@@ -5235,7 +5235,7 @@ fn test_dynamic_spendable_outputs_local_htlc_success_tx() {
        check_spends!(local_txn[0], chan_1.3);
 
        // Give B knowledge of preimage to be able to generate a local HTLC-Success Tx
-       nodes[1].node.claim_funds(payment_preimage, 9_000_000);
+       nodes[1].node.claim_funds(payment_preimage);
        check_added_monitors!(nodes[1], 1);
        mine_transaction(&nodes[1], &local_txn[0]);
        check_added_monitors!(nodes[1], 1);
@@ -5294,8 +5294,8 @@ fn do_test_fail_backwards_unrevoked_remote_announce(deliver_last_raa: bool, anno
        create_announced_chan_between_nodes(&nodes, 3, 5, InitFeatures::known(), InitFeatures::known());
 
        // Rebalance and check output sanity...
-       send_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 500000, 500_000);
-       send_payment(&nodes[1], &[&nodes[2], &nodes[3], &nodes[5]], 500000, 500_000);
+       send_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 500000);
+       send_payment(&nodes[1], &[&nodes[2], &nodes[3], &nodes[5]], 500000);
        assert_eq!(get_local_commitment_txn!(nodes[3], chan.2)[0].output.len(), 2);
 
        let ds_dust_limit = nodes[3].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().holder_dust_limit_satoshis;
@@ -5641,7 +5641,7 @@ fn test_static_output_closing_tx() {
 
        let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
        let closing_tx = close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true).2;
 
        mine_transaction(&nodes[0], &closing_tx);
@@ -5670,7 +5670,7 @@ fn do_htlc_claim_local_commitment_only(use_dust: bool) {
 
        // Claim the payment, but don't deliver A's commitment_signed, resulting in the HTLC only being
        // present in B's local commitment transaction, but none of A's commitment transactions.
-       assert!(nodes[1].node.claim_funds(our_payment_preimage, if use_dust { 50_000 } else { 3_000_000 }));
+       assert!(nodes[1].node.claim_funds(our_payment_preimage));
        check_added_monitors!(nodes[1], 1);
 
        let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
@@ -6063,7 +6063,7 @@ fn test_free_and_fail_holding_cell_htlcs() {
                Event::PaymentReceived { .. } => {},
                _ => panic!("Unexpected event"),
        }
-       nodes[1].node.claim_funds(payment_preimage_1, amt_1);
+       nodes[1].node.claim_funds(payment_preimage_1);
        check_added_monitors!(nodes[1], 1);
        let update_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(), &update_msgs.update_fulfill_htlcs[0]);
@@ -6366,7 +6366,7 @@ fn test_update_add_htlc_bolt2_sender_exceed_max_htlc_value_in_flight() {
        let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, channel_value, 0, InitFeatures::known(), InitFeatures::known());
        let max_in_flight = get_channel_value_stat!(nodes[0], chan.2).counterparty_max_htlc_value_in_flight_msat;
 
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], max_in_flight, max_in_flight);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], max_in_flight);
 
        let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(nodes[1]);
        // Manually create a route over our max in flight (which our router normally automatically
@@ -6382,7 +6382,7 @@ fn test_update_add_htlc_bolt2_sender_exceed_max_htlc_value_in_flight() {
        assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
        nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot send value that would put us over the max HTLC value in flight our peer will accept".to_string(), 1);
 
-       send_payment(&nodes[0], &[&nodes[1]], max_in_flight, max_in_flight);
+       send_payment(&nodes[0], &[&nodes[1]], max_in_flight);
 }
 
 // BOLT 2 Requirements for the Receiver when handling an update_add_htlc message.
@@ -6706,7 +6706,7 @@ fn test_update_fulfill_htlc_bolt2_incorrect_htlc_id() {
 
        let our_payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 100000).0;
 
-       nodes[1].node.claim_funds(our_payment_preimage, 100_000);
+       nodes[1].node.claim_funds(our_payment_preimage);
        check_added_monitors!(nodes[1], 1);
 
        let events = nodes[1].node.get_and_clear_pending_msg_events();
@@ -6747,7 +6747,7 @@ fn test_update_fulfill_htlc_bolt2_wrong_preimage() {
 
        let our_payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 100000).0;
 
-       nodes[1].node.claim_funds(our_payment_preimage, 100_000);
+       nodes[1].node.claim_funds(our_payment_preimage);
        check_added_monitors!(nodes[1], 1);
 
        let events = nodes[1].node.get_and_clear_pending_msg_events();
@@ -7017,7 +7017,7 @@ fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) {
        // We revoked bs_commitment_tx
        if revoked {
                let (payment_preimage_3, _, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
-               claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3, 1_000_000);
+               claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3);
        }
 
        let mut timeout_tx = Vec::new();
@@ -7390,8 +7390,8 @@ fn test_data_loss_protect() {
        let mut previous_chain_monitor_state = test_utils::TestVecWriter(Vec::new());
        nodes[0].chain_monitor.chain_monitor.monitors.read().unwrap().iter().next().unwrap().1.write(&mut previous_chain_monitor_state).unwrap();
 
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
 
        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);
@@ -7483,16 +7483,30 @@ fn test_check_htlc_underpaying() {
        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 nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+       let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 
        // Create some initial channels
        create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 
-       let (payment_preimage, payment_hash, _) = route_payment(&nodes[0], &[&nodes[1]], 10_000);
+       let route = get_route(&nodes[0].node.get_our_node_id(), &nodes[0].net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(InvoiceFeatures::known()), None, &Vec::new(), 10_000, TEST_FINAL_CLTV, nodes[0].logger).unwrap();
+       let (_, our_payment_hash, _) = get_payment_preimage_hash!(nodes[0]);
+       let our_payment_secret = nodes[1].node.create_inbound_payment_for_hash(our_payment_hash, Some(100_000), 7200, 0).unwrap();
+       nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
+       check_added_monitors!(nodes[0], 1);
 
-       // Node 3 is expecting payment of 100_000 but receive 10_000,
-       // fail htlc like we didn't know the preimage.
-       nodes[1].node.claim_funds(payment_preimage, 100_000);
+       let mut events = nodes[0].node.get_and_clear_pending_msg_events();
+       assert_eq!(events.len(), 1);
+       let mut payment_event = SendEvent::from_event(events.pop().unwrap());
+       nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
+       commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
+
+       // Note that we first have to wait a random delay before processing the receipt of the HTLC,
+       // and then will wait a second random delay before failing the HTLC back:
+       expect_pending_htlcs_forwardable!(nodes[1]);
+       expect_pending_htlcs_forwardable!(nodes[1]);
+
+       // Node 3 is expecting payment of 100_000 but received 10_000,
+       // it should fail htlc like we didn't know the preimage.
        nodes[1].node.process_pending_htlc_forwards();
 
        let events = nodes[1].node.get_and_clear_pending_msg_events();
@@ -7516,8 +7530,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));
-       expect_payment_failed!(nodes[0], payment_hash, true, 0x4000|15, &expected_failure_data[..]);
-       nodes[1].node.get_and_clear_pending_events();
+       expect_payment_failed!(nodes[0], our_payment_hash, true, 0x4000|15, &expected_failure_data[..]);
 }
 
 #[test]
@@ -7618,7 +7631,7 @@ fn test_bump_penalty_txn_on_revoked_commitment() {
        let header_114 = connect_blocks(&nodes[1], 14);
 
        // Actually revoke tx by claiming a HTLC
-       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
+       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
        let header = BlockHeader { version: 0x20000000, prev_blockhash: header_114, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
        connect_block(&nodes[1], &Block { header, txdata: vec![revoked_txn[0].clone()] });
        check_added_monitors!(nodes[1], 1);
@@ -7709,7 +7722,7 @@ fn test_bump_penalty_txn_on_revoked_htlcs() {
        assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
 
        // Revoke local commitment tx
-       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
+       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
 
        let header = BlockHeader { version: 0x20000000, prev_blockhash: nodes[1].best_block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
        // B will generate both revoked HTLC-timeout/HTLC-preimage txn from revoked commitment tx
@@ -7875,7 +7888,7 @@ fn test_bump_penalty_txn_on_remote_commitment() {
        assert_eq!(remote_txn[0].input[0].previous_output.txid, chan.3.txid());
 
        // Claim a HTLC without revocation (provide B monitor with preimage)
-       nodes[1].node.claim_funds(payment_preimage, 3_000_000);
+       nodes[1].node.claim_funds(payment_preimage);
        mine_transaction(&nodes[1], &remote_txn[0]);
        check_added_monitors!(nodes[1], 2);
 
@@ -8012,7 +8025,7 @@ fn test_bump_txn_sanitize_tracking_maps() {
        assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
 
        // Revoke local commitment tx
-       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 9_000_000);
+       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
 
        // Broadcast set of revoked txn on A
        connect_blocks(&nodes[0], 52 - CHAN_CONFIRM_DEPTH);
@@ -8107,7 +8120,7 @@ fn test_simple_mpp() {
        route.paths[1][0].short_channel_id = chan_2_id;
        route.paths[1][1].short_channel_id = chan_4_id;
        send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], 200_000, payment_hash, payment_secret);
-       claim_payment_along_route(&nodes[0], &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], false, payment_preimage, 200_000);
+       claim_payment_along_route(&nodes[0], &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], false, payment_preimage);
 }
 
 #[test]
@@ -8130,7 +8143,7 @@ fn test_update_err_monitor_lockdown() {
        let outpoint = OutPoint { txid: chan_1.3.txid(), index: 0 };
 
        // Rebalance the network to generate htlc in the two directions
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 10_000_000, 10_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 10_000_000);
 
        // Route a HTLC from node 0 to node 1 (but don't settle)
        let preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9_000_000).0;
@@ -8155,7 +8168,7 @@ fn test_update_err_monitor_lockdown() {
        watchtower.chain_monitor.block_connected(&Block { header, txdata: vec![] }, 200);
 
        // Try to update ChannelMonitor
-       assert!(nodes[1].node.claim_funds(preimage, 9_000_000));
+       assert!(nodes[1].node.claim_funds(preimage));
        check_added_monitors!(nodes[1], 1);
        let updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
        assert_eq!(updates.update_fulfill_htlcs.len(), 1);
@@ -8189,7 +8202,7 @@ fn test_concurrent_monitor_claim() {
        let outpoint = OutPoint { txid: chan_1.3.txid(), index: 0 };
 
        // Rebalance the network to generate htlc in the two directions
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 10_000_000, 10_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 10_000_000);
 
        // Route a HTLC from node 0 to node 1 (but don't settle)
        route_payment(&nodes[0], &vec!(&nodes[1])[..], 9_000_000).0;
@@ -8342,7 +8355,7 @@ fn test_htlc_no_detection() {
        // Create some initial channels
        let chan_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001, InitFeatures::known(), InitFeatures::known());
 
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 1_000_000, 1_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 1_000_000);
        let (_, our_payment_hash, _) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 2_000_000);
        let local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
        assert_eq!(local_txn[0].input.len(), 1);
@@ -8434,7 +8447,7 @@ fn do_test_onchain_htlc_settlement_after_close(broadcast_alice: bool, go_onchain
        // Step (5):
        // Carol then claims the funds and sends an update_fulfill message to Bob, and they go through the
        // process of removing the HTLC from their commitment transactions.
-       assert!(nodes[2].node.claim_funds(payment_preimage, 3_000_000));
+       assert!(nodes[2].node.claim_funds(payment_preimage));
        check_added_monitors!(nodes[2], 1);
        let carol_updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
        assert!(carol_updates.update_add_htlcs.is_empty());
@@ -8688,7 +8701,7 @@ fn test_duplicate_chan_id() {
        let (funding_locked, _) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
        let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked);
        update_nodes_with_chan_announce(&nodes, 0, 1, &announcement, &as_update, &bs_update);
-       send_payment(&nodes[0], &[&nodes[1]], 8000000, 8_000_000);
+       send_payment(&nodes[0], &[&nodes[1]], 8000000);
 }
 
 #[test]