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 {
                                                                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;
        }, 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();
        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 => {
                                }
                        },
                        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
                                        // 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];
                                        } 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 => {
                                        }
                                }
                        },
                        9 => {

-                               for payment in payments_received.drain(..) {
+                               for (payment, _) in payments_received.drain(..) {

                                        channelmanager.fail_htlc_backwards(&payment);
                                }
                        },
                                        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::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 {..} => {},
                                },
                                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"),
        }
 
                _ => 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]);
 
        // 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.
 
        // 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);
        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"),
        }
 
                _ => 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]
 }
 
 #[test]


@@ -544,7 +544,7 @@ fn test_monitor_update_fail_cs() {
                _ => panic!("Unexpected event"),
        };
 
                _ => panic!("Unexpected event"),
        };
 

-       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
+       claim_payment(&nodes[0], &[&nodes[1]], payment_preimage, 1_000_000);

 }
 
 #[test]
 }
 
 #[test]


@@ -587,7 +587,7 @@ fn test_monitor_update_fail_no_rebroadcast() {
                _ => panic!("Unexpected event"),
        }
 
                _ => 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]
 }
 
 #[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());
 
        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]);
 
        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);
 
        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) {
 }
 
 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.
        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);
 
        // 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"),
                };
                        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]
 }
 
 #[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);
 
        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());
        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);
 
        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]
 }
 
 #[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);
 
        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());
        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"),
        }
 
                _ => 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]
 }
 
 #[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);
 
        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]
 }
 
 #[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);
 
        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]
 }
 
 #[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.
        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);
 
        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();
        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.
        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));
 
        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);
 
        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]
 }
 
 #[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);
        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());
 
        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"),
        }
 
                _ => 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
 }
 
 // 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();
        }
 
                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);
 }
 
        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!
        ///
        /// 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.
        /// 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();
                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 {
                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()); }
                                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 }
                        }
                        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)
 }
 
        (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;
        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;
 }
 
 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;
        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) {
 }
 
 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
        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                            ->
 
        // A                                        B
        // update_fee                            ->


@@ -218,7 +218,7 @@ fn test_update_fee_unordered_raa() {
        let channel_id = chan.2;
 
        // balancing
        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();
 
        // 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
        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();
 
        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"),
        };
 
                _ => 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);
 }
 
        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!") };
 
        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());
        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[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());
        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...
        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 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;
 
        // 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());
 
        // 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);
 
        // 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 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());
 
        // 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
 
 
        //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);
 
        // 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(..) {
        }
 
        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]
 }
 
 #[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);
 
        *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);
        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]
 }
 
 #[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
        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);
 
 
        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
        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
        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;
                }
                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_) = (
                htlc_id += 1;
 
                let (stat01_, stat11_, stat12_, stat22_) = (


@@ -1550,9 +1550,9 @@ fn do_channel_reserve_test(test_recv: bool) {
                _ => panic!("Unexpected event"),
        }
 
                _ => 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);
 
        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.
 
        // 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.
        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());
 
        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);
 
        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]
 }
 
 #[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...
        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);
 
        // 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 {
        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();
                                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
                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);
 
                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
                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]);
 
                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
        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 };
 
        {
                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
        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);
        {
                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
        // 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 };
 
        // 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
        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);
        // 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
        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 };
 
        {
                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
        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;
        // 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
        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 };
 
        {
                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...
        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);
 
        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());
        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());
        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...
        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};
 
        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
        // 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);
 
 
        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
        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
 
        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);
        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);
 
        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);
 
        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));
        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);
 }
 
        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"),
        }
 
                _ => 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();
        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;
 
        // 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]
 }
 
 #[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);
 
        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]
 }
 
 #[test]


@@ -3149,7 +3149,7 @@ fn test_drop_messages_peer_disconnect_dual_htlc() {
                _ => panic!("Unexpected event"),
        }
 
                _ => 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();
        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);
 
        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]
 }
 
 #[test]


@@ -3400,7 +3400,7 @@ fn test_no_txn_manager_serialize_deserialize() {
                node.router.handle_channel_update(&bs_update).unwrap();
        }
 
                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]
 }
 
 #[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);
        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]
 }
 
 #[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!
        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());
 
        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());
 
        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]);
        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 };
 
        // 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();
        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());
 
        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);
 
        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());
 
        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
 
        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());
 
        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
 
        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 ...
        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());
 
        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());
        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();
        }
 
                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();
        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
        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);
        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...
        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;
        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());
 
 
        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 };
        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.
 
        // 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());
        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
        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| {
 
        // 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;
 
        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]);
 
        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);
        }
 
                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.
 }
 
 // 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;
 
 
        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();
        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;
 
 
        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();
        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
        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;
 
        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);
 
        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) {
 }
 
 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);
        // 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 };
        }
 
        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();
 
        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);
 
        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);