Check expected amount in claim_funds

Require to specify expected amount so that we can claim only
payment for thhe correct amount, and reject payments for incorrect
amounts (which are probably middle nodes probing to break our privacy).

Send back incorrect_or_unknown_payments_details (PERM|15) to avoid
the probe node learning that final node is waiting a payment with
the routed hash.

diff --git a/fuzz/fuzz_targets/chanmon_fail_consistency.rs b/fuzz/fuzz_targets/chanmon_fail_consistency.rs
index 91b639eacc0674ab499c305b6a461e5e6e98b64f..74b1e5d14bf8333d47be5d18d63b744c55e2d480 100644 (file)
--- a/fuzz/fuzz_targets/chanmon_fail_consistency.rs
+++ b/fuzz/fuzz_targets/chanmon_fail_consistency.rs
@@ -609,7 +609,7 @@ pub fn do_test(data: &[u8]) {
                                                                if $fail {
                                                                        assert!(nodes[$node].fail_htlc_backwards(&payment_hash));
                                                                } else {
-                                                                       assert!(nodes[$node].claim_funds(PaymentPreimage(payment_hash.0)));
+                                                                       assert!(nodes[$node].claim_funds(PaymentPreimage(payment_hash.0), 5_000_000));
                                                                }
                                                        }
                                                },

diff --git a/fuzz/fuzz_targets/full_stack_target.rs b/fuzz/fuzz_targets/full_stack_target.rs
index 29220f46846a5d8063ff350cb0943d35d798d37c..41ab473fd61c4877412b1dcf36acfde09f5bb3d2 100644 (file)
--- a/fuzz/fuzz_targets/full_stack_target.rs
+++ b/fuzz/fuzz_targets/full_stack_target.rs
@@ -341,7 +341,7 @@ pub fn do_test(data: &[u8], logger: &Arc<Logger>) {
        }, our_network_key, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0], Arc::clone(&logger)));
 
        let mut should_forward = false;
-       let mut payments_received: Vec<PaymentHash> = Vec::new();
+       let mut payments_received: Vec<(PaymentHash, u64)> = Vec::new();
        let mut payments_sent = 0;
        let mut pending_funding_generation: Vec<([u8; 32], u64, Script)> = Vec::new();
        let mut pending_funding_signatures = HashMap::new();
@@ -426,7 +426,7 @@ pub fn do_test(data: &[u8], logger: &Arc<Logger>) {
                                }
                        },
                        8 => {
-                               for payment in payments_received.drain(..) {
+                               for (payment, amt) in payments_received.drain(..) {
                                        // SHA256 is defined as XOR of all input bytes placed in the first byte, and 0s
                                        // for the remaining bytes. Thus, if not all remaining bytes are 0s we cannot
                                        // fulfill this HTLC, but if they are, we can just take the first byte and
@@ -436,12 +436,12 @@ pub fn do_test(data: &[u8], logger: &Arc<Logger>) {
                                        } else {
                                                let mut payment_preimage = PaymentPreimage([0; 32]);
                                                payment_preimage.0[0] = payment.0[0];
-                                               channelmanager.claim_funds(payment_preimage);
+                                               channelmanager.claim_funds(payment_preimage, amt);
                                        }
                                }
                        },
                        9 => {
-                               for payment in payments_received.drain(..) {
+                               for (payment, _) in payments_received.drain(..) {
                                        channelmanager.fail_htlc_backwards(&payment);
                                }
                        },
@@ -516,8 +516,9 @@ pub fn do_test(data: &[u8], logger: &Arc<Logger>) {
                                Event::FundingBroadcastSafe { funding_txo, .. } => {
                                        pending_funding_relay.push(pending_funding_signatures.remove(&funding_txo).unwrap());
                                },
-                               Event::PaymentReceived { payment_hash, .. } => {
-                                       payments_received.push(payment_hash);
+                               Event::PaymentReceived { payment_hash, amt } => {
+                                       //TODO: enhance by fetching random amounts from fuzz input?
+                                       payments_received.push((payment_hash, amt));
                                },
                                Event::PaymentSent {..} => {},
                                Event::PaymentFailed {..} => {},

diff --git a/src/ln/chanmon_update_fail_tests.rs b/src/ln/chanmon_update_fail_tests.rs
index 4b8490c5b227b8c7b506ae2cc699135ffbe23f46..c1fe6fbdd6d7c54002d31f277481a200f5cb5b7b 100644 (file)
--- a/src/ln/chanmon_update_fail_tests.rs
+++ b/src/ln/chanmon_update_fail_tests.rs
@@ -91,7 +91,7 @@ fn do_test_simple_monitor_temporary_update_fail(disconnect: bool) {
                _ => panic!("Unexpected event"),
        }
 
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
 
        // Now set it to failed again...
        let (_, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
@@ -166,7 +166,7 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
 
        // Claim the previous payment, which will result in a update_fulfill_htlc/CS from nodes[1]
        // but nodes[0] won't respond since it is frozen.
-       assert!(nodes[1].node.claim_funds(payment_preimage_1));
+       assert!(nodes[1].node.claim_funds(payment_preimage_1, 1_000_000));
        check_added_monitors!(nodes[1], 1);
        let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
        assert_eq!(events_2.len(), 1);
@@ -440,7 +440,7 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
                _ => panic!("Unexpected event"),
        }
 
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
 }
 
 #[test]
@@ -544,7 +544,7 @@ fn test_monitor_update_fail_cs() {
                _ => panic!("Unexpected event"),
        };
 
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage, 1_000_000);
 }
 
 #[test]
@@ -587,7 +587,7 @@ fn test_monitor_update_fail_no_rebroadcast() {
                _ => panic!("Unexpected event"),
        }
 
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
 }
 
 #[test]
@@ -597,7 +597,7 @@ fn test_monitor_update_raa_while_paused() {
        let mut nodes = create_network(2, &[None, None]);
        create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
 
-       send_payment(&nodes[0], &[&nodes[1]], 5000000);
+       send_payment(&nodes[0], &[&nodes[1]], 5000000, 5_000_000);
 
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
        let (payment_preimage_1, our_payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
@@ -655,8 +655,8 @@ fn test_monitor_update_raa_while_paused() {
        expect_pending_htlcs_forwardable!(nodes[1]);
        expect_payment_received!(nodes[1], our_payment_hash_1, 1000000);
 
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1);
-       claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_2);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
+       claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_2, 1_000_000);
 }
 
 fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) {
@@ -666,7 +666,7 @@ fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) {
        let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, LocalFeatures::new(), LocalFeatures::new());
 
        // Rebalance a bit so that we can send backwards from 2 to 1.
-       send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000);
+       send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000, 5_000_000);
 
        // Route a first payment that we'll fail backwards
        let (_, payment_hash_1) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
@@ -897,10 +897,10 @@ fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) {
                        Event::PaymentReceived { payment_hash, .. } => assert_eq!(payment_hash, payment_hash_4.unwrap()),
                        _ => panic!("Unexpected event"),
                };
-               claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_4.unwrap());
+               claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_4.unwrap(), 1_000_000);
        }
 
-       claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage_2);
+       claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage_2, 1_000_000);
 }
 
 #[test]
@@ -923,7 +923,7 @@ fn test_monitor_update_fail_reestablish() {
        nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
        nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
 
-       assert!(nodes[2].node.claim_funds(our_payment_preimage));
+       assert!(nodes[2].node.claim_funds(our_payment_preimage, 1_000_000));
        check_added_monitors!(nodes[2], 1);
        let mut updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
        assert!(updates.update_add_htlcs.is_empty());
@@ -1092,9 +1092,9 @@ fn raa_no_response_awaiting_raa_state() {
        expect_pending_htlcs_forwardable!(nodes[1]);
        expect_payment_received!(nodes[1], payment_hash_3, 1000000);
 
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1);
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3, 1_000_000);
 }
 
 #[test]
@@ -1114,7 +1114,7 @@ fn claim_while_disconnected_monitor_update_fail() {
        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);
 
-       assert!(nodes[1].node.claim_funds(payment_preimage_1));
+       assert!(nodes[1].node.claim_funds(payment_preimage_1, 1_000_000));
        check_added_monitors!(nodes[1], 1);
 
        nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id());
@@ -1211,7 +1211,7 @@ fn claim_while_disconnected_monitor_update_fail() {
                _ => panic!("Unexpected event"),
        }
 
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
 }
 
 #[test]
@@ -1271,7 +1271,7 @@ fn monitor_failed_no_reestablish_response() {
        expect_pending_htlcs_forwardable!(nodes[1]);
        expect_payment_received!(nodes[1], payment_hash_1, 1000000);
 
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
 }
 
 #[test]
@@ -1360,8 +1360,8 @@ fn first_message_on_recv_ordering() {
        expect_pending_htlcs_forwardable!(nodes[1]);
        expect_payment_received!(nodes[1], payment_hash_2, 1000000);
 
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1);
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
 }
 
 #[test]
@@ -1376,12 +1376,12 @@ fn test_monitor_update_fail_claim() {
        create_announced_chan_between_nodes(&nodes, 1, 2, LocalFeatures::new(), LocalFeatures::new());
 
        // Rebalance a bit so that we can send backwards from 3 to 2.
-       send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000);
+       send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000, 5_000_000);
 
        let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
 
        *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
-       assert!(nodes[1].node.claim_funds(payment_preimage_1));
+       assert!(nodes[1].node.claim_funds(payment_preimage_1, 1_000_000));
        check_added_monitors!(nodes[1], 1);
 
        let route = nodes[2].router.get_route(&nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
@@ -1446,7 +1446,7 @@ fn test_monitor_update_on_pending_forwards() {
        create_announced_chan_between_nodes(&nodes, 1, 2, LocalFeatures::new(), LocalFeatures::new());
 
        // Rebalance a bit so that we can send backwards from 3 to 1.
-       send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000);
+       send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000, 5_000_000);
 
        let (_, payment_hash_1) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
        assert!(nodes[2].node.fail_htlc_backwards(&payment_hash_1));
@@ -1496,7 +1496,7 @@ fn test_monitor_update_on_pending_forwards() {
        nodes[0].node.process_pending_htlc_forwards();
        expect_payment_received!(nodes[0], payment_hash_2, 1000000);
 
-       claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_2);
+       claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_2, 1_000_000);
 }
 
 #[test]
@@ -1524,7 +1524,7 @@ fn monitor_update_claim_fail_no_response() {
        let as_raa = commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false, true, false, true);
 
        *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
-       assert!(nodes[1].node.claim_funds(payment_preimage_1));
+       assert!(nodes[1].node.claim_funds(payment_preimage_1, 1_000_000));
        check_added_monitors!(nodes[1], 1);
        assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 
@@ -1551,7 +1551,7 @@ fn monitor_update_claim_fail_no_response() {
                _ => panic!("Unexpected event"),
        }
 
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
 }
 
 // Note that restore_between_fails with !fail_on_generate is useless
@@ -1671,7 +1671,7 @@ fn do_during_funding_monitor_fail(fail_on_generate: bool, restore_between_fails:
                node.router.handle_channel_update(&bs_update).unwrap();
        }
 
-       send_payment(&nodes[0], &[&nodes[1]], 8000000);
+       send_payment(&nodes[0], &[&nodes[1]], 8000000, 8_000_000);
        close_channel(&nodes[0], &nodes[1], &channel_id, funding_tx, true);
 }
 

diff --git a/src/ln/channelmanager.rs b/src/ln/channelmanager.rs
index fad5b30b3a5648b680c441a22099515028db1398..c863f46b613c77c27198d85e8f3121d9a2eb5c20 100644 (file)
--- a/src/ln/channelmanager.rs
+++ b/src/ln/channelmanager.rs
@@ -1606,8 +1606,15 @@ impl ChannelManager {
        /// generating message events for the net layer to claim the payment, if possible. Thus, you
        /// should probably kick the net layer to go send messages if this returns true!
        ///
+       /// You must specify the expected amounts for this HTLC, and we will only claim HTLCs
+       /// available within a few percent of the expected amount. This is critical for several
+       /// reasons : a) it avoids providing senders with `proof-of-payment` (in the form of the
+       /// payment_preimage without having provided the full value and b) it avoids certain
+       /// privacy-breaking recipient-probing attacks which may reveal payment activity to
+       /// motivated attackers.
+       ///
        /// May panic if called except in response to a PaymentReceived event.
-       pub fn claim_funds(&self, payment_preimage: PaymentPreimage) -> bool {
+       pub fn claim_funds(&self, payment_preimage: PaymentPreimage, expected_amount: u64) -> bool {
                let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0).into_inner());
 
                let _ = self.total_consistency_lock.read().unwrap();
@@ -1615,12 +1622,18 @@ impl ChannelManager {
                let mut channel_state = Some(self.channel_state.lock().unwrap());
                let removed_source = channel_state.as_mut().unwrap().claimable_htlcs.remove(&payment_hash);
                if let Some(mut sources) = removed_source {
-                       // TODO: We should require the user specify the expected amount so that we can claim
-                       // only payments for the correct amount, and reject payments for incorrect amounts
-                       // (which are probably middle nodes probing to break our privacy).
-                       for (_, htlc_with_hash) in sources.drain(..) {
+                       for (received_amount, htlc_with_hash) in sources.drain(..) {
                                if channel_state.is_none() { channel_state = Some(self.channel_state.lock().unwrap()); }
-                               self.claim_funds_internal(channel_state.take().unwrap(), HTLCSource::PreviousHopData(htlc_with_hash), payment_preimage);
+                               if received_amount < expected_amount || received_amount > expected_amount * 2 {
+                                       let mut htlc_msat_data = byte_utils::be64_to_array(received_amount).to_vec();
+                                       let mut height_data = byte_utils::be32_to_array(self.latest_block_height.load(Ordering::Acquire) as u32).to_vec();
+                                       htlc_msat_data.append(&mut height_data);
+                                       self.fail_htlc_backwards_internal(channel_state.take().unwrap(),
+                                                                        HTLCSource::PreviousHopData(htlc_with_hash), &payment_hash,
+                                                                        HTLCFailReason::Reason { failure_code: 0x4000|15, data: htlc_msat_data });
+                               } else {
+                                       self.claim_funds_internal(channel_state.take().unwrap(), HTLCSource::PreviousHopData(htlc_with_hash), payment_preimage);
+                               }
                        }
                        true
                } else { false }

diff --git a/src/ln/functional_test_utils.rs b/src/ln/functional_test_utils.rs
index ba30330719e1fd0bd7a2ad66f943b7b7d44f3b00..7e776227aeef3871294d3726b8606bf6feacc0f7 100644 (file)
--- a/src/ln/functional_test_utils.rs
+++ b/src/ln/functional_test_utils.rs
@@ -636,8 +636,8 @@ pub fn send_along_route(origin_node: &Node, route: Route, expected_route: &[&Nod
        (our_payment_preimage, our_payment_hash)
 }
 
-pub fn claim_payment_along_route(origin_node: &Node, expected_route: &[&Node], skip_last: bool, our_payment_preimage: PaymentPreimage) {
-       assert!(expected_route.last().unwrap().node.claim_funds(our_payment_preimage));
+pub fn claim_payment_along_route(origin_node: &Node, expected_route: &[&Node], skip_last: bool, our_payment_preimage: PaymentPreimage, expected_amount: u64) {
+       assert!(expected_route.last().unwrap().node.claim_funds(our_payment_preimage, expected_amount));
        check_added_monitors!(expected_route.last().unwrap(), 1);
 
        let mut next_msgs: Option<(msgs::UpdateFulfillHTLC, msgs::CommitmentSigned)> = None;
@@ -714,8 +714,8 @@ pub fn claim_payment_along_route(origin_node: &Node, expected_route: &[&Node], s
        }
 }
 
-pub fn claim_payment(origin_node: &Node, expected_route: &[&Node], our_payment_preimage: PaymentPreimage) {
-       claim_payment_along_route(origin_node, expected_route, false, our_payment_preimage);
+pub fn claim_payment(origin_node: &Node, expected_route: &[&Node], our_payment_preimage: PaymentPreimage, expected_amount: u64) {
+       claim_payment_along_route(origin_node, expected_route, false, our_payment_preimage, expected_amount);
 }
 
 pub const TEST_FINAL_CLTV: u32 = 32;
@@ -746,9 +746,9 @@ pub fn route_over_limit(origin_node: &Node, expected_route: &[&Node], recv_value
        };
 }
 
-pub fn send_payment(origin: &Node, expected_route: &[&Node], recv_value: u64) {
+pub fn send_payment(origin: &Node, expected_route: &[&Node], recv_value: u64, expected_value: u64) {
        let our_payment_preimage = route_payment(&origin, expected_route, recv_value).0;
-       claim_payment(&origin, expected_route, our_payment_preimage);
+       claim_payment(&origin, expected_route, our_payment_preimage, expected_value);
 }
 
 pub fn fail_payment_along_route(origin_node: &Node, expected_route: &[&Node], skip_last: bool, our_payment_hash: PaymentHash) {

diff --git a/src/ln/functional_tests.rs b/src/ln/functional_tests.rs
index 5bb98bb613f6dd67fbc271146780b99037378dd3..1548b50b2f737a367089d6805b761aaca8393d2c 100644 (file)
--- a/src/ln/functional_tests.rs
+++ b/src/ln/functional_tests.rs
@@ -108,7 +108,7 @@ fn test_async_inbound_update_fee() {
        let channel_id = chan.2;
 
        // balancing
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 
        // A                                        B
        // update_fee                            ->
@@ -218,7 +218,7 @@ fn test_update_fee_unordered_raa() {
        let channel_id = chan.2;
 
        // balancing
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 
        // First nodes[0] generates an update_fee
        nodes[0].node.update_fee(channel_id, get_feerate!(nodes[0], channel_id) + 20).unwrap();
@@ -463,7 +463,7 @@ fn test_update_fee_with_fundee_update_add_htlc() {
        let channel_id = chan.2;
 
        // balancing
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 
        let feerate = get_feerate!(nodes[0], channel_id);
        nodes[0].node.update_fee(channel_id, feerate+20).unwrap();
@@ -543,10 +543,10 @@ fn test_update_fee_with_fundee_update_add_htlc() {
                _ => panic!("Unexpected event"),
        };
 
-       claim_payment(&nodes[1], &vec!(&nodes[0])[..], our_payment_preimage);
+       claim_payment(&nodes[1], &vec!(&nodes[0])[..], our_payment_preimage, 800_000);
 
-       send_payment(&nodes[1], &vec!(&nodes[0])[..], 800000);
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 800000);
+       send_payment(&nodes[1], &vec!(&nodes[0])[..], 800000, 800_000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 800000, 800_000);
        close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true);
 }
 
@@ -702,7 +702,7 @@ fn updates_shutdown_wait() {
        if let Err(APIError::ChannelUnavailable {..}) = nodes[1].node.send_payment(route_2, payment_hash) {}
        else { panic!("New sends should fail!") };
 
-       assert!(nodes[2].node.claim_funds(our_payment_preimage));
+       assert!(nodes[2].node.claim_funds(our_payment_preimage, 100_000));
        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());
@@ -875,7 +875,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));
+       assert!(nodes[2].node.claim_funds(our_payment_preimage, 100_000));
        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());
@@ -993,15 +993,15 @@ fn fake_network_test() {
        let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3, LocalFeatures::new(), LocalFeatures::new());
 
        // 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);
-       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, 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 some more payments
-       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);
+       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);
 
        // Test failure packets
        let payment_hash_1 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 1000000).1;
@@ -1010,13 +1010,13 @@ fn fake_network_test() {
        // Add a new channel that skips 3
        let chan_4 = create_announced_chan_between_nodes(&nodes, 1, 3, LocalFeatures::new(), LocalFeatures::new());
 
-       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);
+       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);
 
        // Do some rebalance loop payments, simultaneously
        let mut hops = Vec::with_capacity(3);
@@ -1067,7 +1067,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);
+       claim_payment(&nodes[1], &vec!(&nodes[2], &nodes[3], &nodes[1])[..], payment_preimage_1, 1_000_000);
 
        // Add a duplicate new channel from 2 to 4
        let chan_5 = create_announced_chan_between_nodes(&nodes, 1, 3, LocalFeatures::new(), LocalFeatures::new());
@@ -1081,9 +1081,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);
-       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_4);
-       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_5);
+       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);
 
        // Close down the channels...
        close_channel(&nodes[0], &nodes[1], &chan_1.2, chan_1.3, true);
@@ -1213,10 +1213,10 @@ fn holding_cell_htlc_counting() {
        }
 
        for (preimage, _) in payments.drain(..) {
-               claim_payment(&nodes[1], &[&nodes[2]], preimage);
+               claim_payment(&nodes[1], &[&nodes[2]], preimage, 100_000);
        }
 
-       send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
+       send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000, 1_000_000);
 }
 
 #[test]
@@ -1240,9 +1240,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);
+       claim_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], payment_preimage, 1_000_000);
        fail_payment(&nodes[2], &vec!(&nodes[3], &nodes[5])[..], payment_hash);
-       claim_payment(&nodes[1], &vec!(&nodes[3])[..], payment_preimage);
+       claim_payment(&nodes[1], &vec!(&nodes[3])[..], payment_preimage, 1_000_000);
 }
 
 #[test]
@@ -1255,7 +1255,7 @@ fn test_duplicate_htlc_different_direction_onchain() {
        let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
 
        // balancing
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 
        let (payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 900_000);
 
@@ -1263,7 +1263,7 @@ fn test_duplicate_htlc_different_direction_onchain() {
        send_along_route_with_hash(&nodes[1], route, &vec!(&nodes[0])[..], 800_000, payment_hash);
 
        // Provide preimage to node 0 by claiming payment
-       nodes[0].node.claim_funds(payment_preimage);
+       nodes[0].node.claim_funds(payment_preimage, 800_000);
        check_added_monitors!(nodes[0], 1);
 
        // Broadcast node 1 commitment txn
@@ -1367,7 +1367,7 @@ fn do_channel_reserve_test(test_recv: bool) {
                if stat01.value_to_self_msat - amt_msat < stat01.channel_reserve_msat {
                        break;
                }
-               send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_0);
+               send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_0, recv_value_0);
                htlc_id += 1;
 
                let (stat01_, stat11_, stat12_, stat22_) = (
@@ -1550,9 +1550,9 @@ fn do_channel_reserve_test(test_recv: bool) {
                _ => panic!("Unexpected event"),
        }
 
-       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);
+       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);
 
        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);
        let stat0 = get_channel_value_stat!(nodes[0], chan_1.2);
@@ -1614,13 +1614,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));
+       assert!(nodes[1].node.claim_funds(payment_preimage_1, b_chan_values.channel_reserve_msat - b_chan_values.value_to_self_msat - 10000));
        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));
+       assert!(nodes[1].node.claim_funds(payment_preimage_2, 20000));
        check_added_monitors!(nodes[1], 1);
        assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 
@@ -1712,8 +1712,8 @@ fn channel_reserve_in_flight_removes() {
        expect_pending_htlcs_forwardable!(nodes[0]);
        expect_payment_received!(nodes[0], payment_hash_4, 10000);
 
-       claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_4);
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3);
+       claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_4, 10_000);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3, 100_000);
 }
 
 #[test]
@@ -1729,10 +1729,10 @@ fn channel_monitor_network_test() {
        let chan_4 = create_announced_chan_between_nodes(&nodes, 3, 4, LocalFeatures::new(), LocalFeatures::new());
 
        // 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);
-       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, 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);
 
        // Simple case with no pending HTLCs:
        nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), true);
@@ -1762,9 +1762,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) => {
+               ($node: expr, $prev_node: expr, $preimage: expr, $amount: expr) => {
                        {
-                               assert!($node.node.claim_funds($preimage));
+                               assert!($node.node.claim_funds($preimage, $amount));
                                check_added_monitors!($node, 1);
 
                                let events = $node.node.get_and_clear_pending_msg_events();
@@ -1788,7 +1788,7 @@ fn channel_monitor_network_test() {
                let node_txn = test_txn_broadcast(&nodes[2], &chan_3, None, HTLCType::TIMEOUT);
 
                // Claim the payment on nodes[3], giving it knowledge of the preimage
-               claim_funds!(nodes[3], nodes[2], payment_preimage_1);
+               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 };
                nodes[3].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![node_txn[0].clone()] }, 1);
@@ -1822,7 +1822,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);
+               claim_funds!(nodes[4], nodes[3], payment_preimage_2, 3_000_000);
 
                header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
                nodes[4].chain_monitor.block_connected_checked(&header, 2, &Vec::new()[..], &[0; 0]);
@@ -1871,7 +1871,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);
+       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 };
@@ -1911,7 +1911,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);
+       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 };
                nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
@@ -1949,7 +1949,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);
+       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 };
@@ -1976,7 +1976,7 @@ fn claim_htlc_outputs_shared_tx() {
        let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
 
        // Rebalance the network to generate htlc in the two directions
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
        // 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);
@@ -1992,7 +1992,7 @@ fn claim_htlc_outputs_shared_tx() {
        check_spends!(revoked_local_txn[1], revoked_local_txn[0].clone());
 
        //Revoke the old state
-       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1);
+       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 };
@@ -2050,7 +2050,7 @@ fn claim_htlc_outputs_single_tx() {
        let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
 
        // Rebalance the network to generate htlc in the two directions
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
        // 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;
@@ -2060,7 +2060,7 @@ fn claim_htlc_outputs_single_tx() {
        let revoked_local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan_1.2).unwrap().last_local_commitment_txn.clone();
 
        //Revoke the old state
-       claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1);
+       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 };
@@ -2154,8 +2154,8 @@ fn test_htlc_on_chain_success() {
        let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, LocalFeatures::new(), LocalFeatures::new());
 
        // Rebalance the network a bit by relaying one payment through all the channels...
-       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
-       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
+       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);
 
        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);
@@ -2166,8 +2166,8 @@ fn test_htlc_on_chain_success() {
        let commitment_tx = nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().last_local_commitment_txn.clone();
        assert_eq!(commitment_tx.len(), 1);
        check_spends!(commitment_tx[0], chan_2.3.clone());
-       nodes[2].node.claim_funds(our_payment_preimage);
-       nodes[2].node.claim_funds(our_payment_preimage_2);
+       nodes[2].node.claim_funds(our_payment_preimage, 3_000_000);
+       nodes[2].node.claim_funds(our_payment_preimage_2, 3_000_000);
        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());
@@ -2315,8 +2315,8 @@ fn test_htlc_on_chain_timeout() {
        let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, LocalFeatures::new(), LocalFeatures::new());
 
        // Rebalance the network a bit by relaying one payment thorugh all the channels...
-       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
-       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
+       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);
 
        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};
@@ -2426,7 +2426,7 @@ fn test_simple_commitment_revoked_fail_backward() {
        // Get the will-be-revoked local txn from nodes[2]
        let revoked_local_txn = nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().last_local_commitment_txn.clone();
        // Revoke the old state
-       claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
+       claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage, 3_000_000);
 
        route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
 
@@ -2495,7 +2495,7 @@ fn do_test_commitment_revoked_fail_backward_exhaustive(deliver_bs_raa: bool, use
        let revoked_local_txn = nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().last_local_commitment_txn.clone();
        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);
+       claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage, if no_to_remote { 10_000 } else { 3_000_000});
 
        let value = if use_dust {
                // The dust limit applied to HTLC outputs considers the fee of the HTLC transaction as
@@ -2831,7 +2831,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);
+       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_1, 1_000_000);
 
        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);
@@ -2845,7 +2845,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], &vec!(&nodes[1], &nodes[2]), true, payment_preimage_3);
+       claim_payment_along_route(&nodes[0], &vec!(&nodes[1], &nodes[2]), true, payment_preimage_3, 1_000_000);
        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));
@@ -2867,7 +2867,7 @@ fn test_simple_peer_disconnect() {
                }
        }
 
-       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_4);
+       claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_4, 1_000_000);
        fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_hash_6);
 }
 
@@ -2967,7 +2967,7 @@ fn do_test_drop_messages_peer_disconnect(messages_delivered: u8) {
                _ => panic!("Unexpected event"),
        }
 
-       nodes[1].node.claim_funds(payment_preimage_1);
+       nodes[1].node.claim_funds(payment_preimage_1, 1_000_000);
        check_added_monitors!(nodes[1], 1);
 
        let events_3 = nodes[1].node.get_and_clear_pending_msg_events();
@@ -3058,7 +3058,7 @@ fn do_test_drop_messages_peer_disconnect(messages_delivered: u8) {
 
        // Channel should still work fine...
        let payment_preimage_2 = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000).0;
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
 }
 
 #[test]
@@ -3123,7 +3123,7 @@ fn test_funding_peer_disconnect() {
 
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), Some(&nodes[0].node.list_usable_channels()), &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
        let (payment_preimage, _) = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000);
-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage, 1_000_000);
 }
 
 #[test]
@@ -3149,7 +3149,7 @@ fn test_drop_messages_peer_disconnect_dual_htlc() {
                _ => panic!("Unexpected event"),
        }
 
-       assert!(nodes[1].node.claim_funds(payment_preimage_1));
+       assert!(nodes[1].node.claim_funds(payment_preimage_1, 1_000_000));
        check_added_monitors!(nodes[1], 1);
 
        let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
@@ -3262,7 +3262,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);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
 }
 
 #[test]
@@ -3400,7 +3400,7 @@ fn test_no_txn_manager_serialize_deserialize() {
                node.router.handle_channel_update(&bs_update).unwrap();
        }
 
-       send_payment(&nodes[0], &[&nodes[1]], 1000000);
+       send_payment(&nodes[0], &[&nodes[1]], 1000000, 1_000_000);
 }
 
 #[test]
@@ -3447,7 +3447,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);
+       claim_payment(&nodes[0], &[&nodes[1]], our_payment_preimage, 1_000_000);
 }
 
 #[test]
@@ -3517,7 +3517,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);
+       claim_payment(&nodes[2], &[&nodes[0], &nodes[1]], our_payment_preimage, 1_000_000);
 
        nodes[3].node.peer_connected(&nodes[0].node.get_our_node_id());
        let reestablish = get_event_msg!(nodes[3], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
@@ -3697,7 +3697,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);
+       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 };
        nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
        check_closed_broadcast!(nodes[1]);
@@ -3726,7 +3726,7 @@ fn test_static_spendable_outputs_preimage_tx() {
 
        // 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));
+       assert!(nodes[1].node.claim_funds(payment_preimage, 3_000_000));
        check_added_monitors!(nodes[1], 1);
        nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_tx[0].clone()] }, 1);
        let events = nodes[1].node.get_and_clear_pending_msg_events();
@@ -3764,7 +3764,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);
+       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 };
        nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
@@ -3794,7 +3794,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);
+       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
@@ -3838,7 +3838,7 @@ fn test_static_spendable_outputs_justice_tx_revoked_htlc_success_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);
+       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
@@ -3888,14 +3888,14 @@ fn test_onchain_to_onchain_claim() {
        let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, LocalFeatures::new(), LocalFeatures::new());
 
        // Rebalance the network a bit by relaying one payment through all the channels ...
-       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
-       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
+       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);
 
        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 = nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().last_local_commitment_txn.clone();
        check_spends!(commitment_tx[0], chan_2.3.clone());
-       nodes[2].node.claim_funds(payment_preimage);
+       nodes[2].node.claim_funds(payment_preimage, 3_000_000);
        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());
@@ -4003,7 +4003,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);
+       nodes[2].node.claim_funds(our_payment_preimage, 900_000);
        nodes[2].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_txn[0].clone()] }, 1);
        check_added_monitors!(nodes[2], 2);
        let events = nodes[2].node.get_and_clear_pending_msg_events();
@@ -4094,7 +4094,7 @@ fn test_dynamic_spendable_outputs_local_htlc_success_tx() {
        check_spends!(local_txn[0], chan_1.3.clone());
 
        // Give B knowledge of preimage to be able to generate a local HTLC-Success Tx
-       nodes[1].node.claim_funds(payment_preimage);
+       nodes[1].node.claim_funds(payment_preimage, 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 };
        nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![local_txn[0].clone()] }, 1);
@@ -4141,8 +4141,8 @@ fn do_test_fail_backwards_unrevoked_remote_announce(deliver_last_raa: bool, anno
        create_announced_chan_between_nodes(&nodes, 3, 5, LocalFeatures::new(), LocalFeatures::new());
 
        // Rebalance and check output sanity...
-       send_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 500000);
-       send_payment(&nodes[1], &[&nodes[2], &nodes[3], &nodes[5]], 500000);
+       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);
        assert_eq!(nodes[3].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().last_local_commitment_txn[0].output.len(), 2);
 
        let ds_dust_limit = nodes[3].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
@@ -4410,7 +4410,7 @@ fn test_static_output_closing_tx() {
 
        let chan = create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
 
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
+       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 };
@@ -4433,7 +4433,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));
+       assert!(nodes[1].node.claim_funds(our_payment_preimage, if use_dust { 50_000 } else { 3_000_000 }));
        check_added_monitors!(nodes[1], 1);
 
        let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
@@ -4778,7 +4778,7 @@ fn test_onion_failure() {
        let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
        let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &Vec::new(), 40000, TEST_FINAL_CLTV).unwrap();
        // positve case
-       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 40000);
+       send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 40000, 40_000);
 
        // intermediate node failure
        run_onion_failure_test("invalid_realm", 0, &nodes, &route, &payment_hash, |msg| {
@@ -5134,7 +5134,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, LocalFeatures::new(), LocalFeatures::new());
        let max_in_flight = get_channel_value_stat!(nodes[0], chan.2).their_max_htlc_value_in_flight_msat;
 
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], max_in_flight);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], max_in_flight, max_in_flight);
 
        let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &[], max_in_flight+1, TEST_FINAL_CLTV).unwrap();
        let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
@@ -5146,7 +5146,7 @@ fn test_update_add_htlc_bolt2_sender_exceed_max_htlc_value_in_flight() {
                assert!(false);
        }
 
-       send_payment(&nodes[0], &[&nodes[1]], max_in_flight);
+       send_payment(&nodes[0], &[&nodes[1]], max_in_flight, max_in_flight);
 }
 
 // BOLT 2 Requirements for the Receiver when handling an update_add_htlc message.
@@ -5449,7 +5449,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);
+       nodes[1].node.claim_funds(our_payment_preimage, 100_000);
        check_added_monitors!(nodes[1], 1);
 
        let events = nodes[1].node.get_and_clear_pending_msg_events();
@@ -5490,7 +5490,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);
+       nodes[1].node.claim_funds(our_payment_preimage, 100_000);
        check_added_monitors!(nodes[1], 1);
 
        let events = nodes[1].node.get_and_clear_pending_msg_events();
@@ -5741,7 +5741,7 @@ fn test_no_failure_dust_htlc_local_commitment() {
        let chan = create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
 
        // Rebalance a bit
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 
        let as_dust_limit = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
        let bs_dust_limit = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
@@ -5779,8 +5779,8 @@ fn test_no_failure_dust_htlc_local_commitment() {
        assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
        assert_eq!(nodes[0].node.get_and_clear_pending_msg_events().len(), 0);
 
-       claim_payment(&nodes[0], &vec!(&nodes[1])[..], preimage_1);
-       claim_payment(&nodes[1], &vec!(&nodes[0])[..], preimage_2);
+       claim_payment(&nodes[0], &vec!(&nodes[1])[..], preimage_1, bs_dust_limit*1000);
+       claim_payment(&nodes[1], &vec!(&nodes[0])[..], preimage_2, as_dust_limit*1000);
 }
 
 fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) {
@@ -5805,7 +5805,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);
+               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 };
@@ -6081,8 +6081,8 @@ fn test_data_loss_protect() {
        let mut previous_chan_monitor_state = test_utils::TestVecWriter(Vec::new());
        nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter().next().unwrap().1.write_for_disk(&mut previous_chan_monitor_state).unwrap();
 
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
-       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
+       send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 
        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);