Merge pull request #1062 from galderz/t_payment_hash_999

diff --git a/lightning/src/ln/chanmon_update_fail_tests.rs b/lightning/src/ln/chanmon_update_fail_tests.rs
index c3262f17374327b42bc40c987350a05a6d8441d9..30088f2eba6815256990d634afa9e7ec1f2c5d53 100644 (file)
--- a/lightning/src/ln/chanmon_update_fail_tests.rs
+++ b/lightning/src/ln/chanmon_update_fail_tests.rs
@@ -310,7 +310,7 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
        let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).2;
        let logger = test_utils::TestLogger::new();
 
-       let (payment_preimage_1, _, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
+       let (payment_preimage_1, payment_hash_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
 
        // Now try to send a second payment which will fail to send
        let (payment_preimage_2, payment_hash_2, payment_secret_2) = get_payment_preimage_hash!(nodes[1]);
@@ -346,8 +346,9 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
                                let events_3 = nodes[0].node.get_and_clear_pending_events();
                                assert_eq!(events_3.len(), 1);
                                match events_3[0] {
-                                       Event::PaymentSent { ref payment_preimage } => {
+                                       Event::PaymentSent { ref payment_preimage, ref payment_hash } => {
                                                assert_eq!(*payment_preimage, payment_preimage_1);
+                                               assert_eq!(*payment_hash, payment_hash_1);
                                        },
                                        _ => panic!("Unexpected event"),
                                }
@@ -438,8 +439,9 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
                        let events_3 = nodes[0].node.get_and_clear_pending_events();
                        assert_eq!(events_3.len(), 1);
                        match events_3[0] {
-                               Event::PaymentSent { ref payment_preimage } => {
+                               Event::PaymentSent { ref payment_preimage, ref payment_hash } => {
                                        assert_eq!(*payment_preimage, payment_preimage_1);
+                                       assert_eq!(*payment_hash, payment_hash_1);
                                },
                                _ => panic!("Unexpected event"),
                        }
@@ -1364,7 +1366,7 @@ fn claim_while_disconnected_monitor_update_fail() {
        let logger = test_utils::TestLogger::new();
 
        // Forward a payment for B to claim
-       let (payment_preimage_1, _, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
+       let (payment_preimage_1, payment_hash_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
 
        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);
@@ -1465,8 +1467,9 @@ fn claim_while_disconnected_monitor_update_fail() {
        let events = nodes[0].node.get_and_clear_pending_events();
        assert_eq!(events.len(), 1);
        match events[0] {
-               Event::PaymentSent { ref payment_preimage } => {
+               Event::PaymentSent { ref payment_preimage, ref payment_hash } => {
                        assert_eq!(*payment_preimage, payment_preimage_1);
+                       assert_eq!(*payment_hash, payment_hash_1);
                },
                _ => panic!("Unexpected event"),
        }
@@ -1847,7 +1850,7 @@ fn monitor_update_claim_fail_no_response() {
        let logger = test_utils::TestLogger::new();
 
        // Forward a payment for B to claim
-       let (payment_preimage_1, _, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
+       let (payment_preimage_1, payment_hash_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
 
        // Now start forwarding a second payment, skipping the last RAA so B is in AwaitingRAA
        let (payment_preimage_2, payment_hash_2, payment_secret_2) = get_payment_preimage_hash!(nodes[1]);
@@ -1889,8 +1892,9 @@ fn monitor_update_claim_fail_no_response() {
        let events = nodes[0].node.get_and_clear_pending_events();
        assert_eq!(events.len(), 1);
        match events[0] {
-               Event::PaymentSent { ref payment_preimage } => {
+               Event::PaymentSent { ref payment_preimage, ref payment_hash } => {
                        assert_eq!(*payment_preimage, payment_preimage_1);
+                       assert_eq!(*payment_hash, payment_hash_1);
                },
                _ => panic!("Unexpected event"),
        }

diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
index 152de61fd8e56719f116393c44f55c9144773b36..1b5813a301851229fdd2967dc22e025042b2cab8 100644 (file)
--- a/lightning/src/ln/channelmanager.rs
+++ b/lightning/src/ln/channelmanager.rs
@@ -3308,8 +3308,12 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
                                        sessions.remove(&session_priv_bytes, path.last().unwrap().fee_msat)
                                } else { false };
                                if found_payment {
+                                       let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0).into_inner());
                                        self.pending_events.lock().unwrap().push(
-                                               events::Event::PaymentSent { payment_preimage }
+                                               events::Event::PaymentSent {
+                                                       payment_preimage,
+                                                       payment_hash: payment_hash
+                                               }
                                        );
                                } else {
                                        log_trace!(self.logger, "Received duplicative fulfill for HTLC with payment_preimage {}", log_bytes!(payment_preimage.0));
@@ -6017,8 +6021,9 @@ mod tests {
                // further events will be generated for subsequence path successes.
                let events = nodes[0].node.get_and_clear_pending_events();
                match events[0] {
-                       Event::PaymentSent { payment_preimage: ref preimage } => {
+                       Event::PaymentSent { payment_preimage: ref preimage, payment_hash: ref hash } => {
                                assert_eq!(payment_preimage, *preimage);
+                               assert_eq!(our_payment_hash, *hash);
                        },
                        _ => panic!("Unexpected event"),
                }

diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs
index 9fbbcfff39c9701306f0c06e0dcc47c0fdd7728b..a95d32476b4d3ead0a94e45bd42c5d6bda56f890 100644 (file)
--- a/lightning/src/ln/functional_test_utils.rs
+++ b/lightning/src/ln/functional_test_utils.rs
@@ -1043,10 +1043,12 @@ macro_rules! expect_payment_received {
 macro_rules! expect_payment_sent {
        ($node: expr, $expected_payment_preimage: expr) => {
                let events = $node.node.get_and_clear_pending_events();
+               let expected_payment_hash = PaymentHash(Sha256::hash(&$expected_payment_preimage.0).into_inner());
                assert_eq!(events.len(), 1);
                match events[0] {
-                       Event::PaymentSent { ref payment_preimage } => {
+                       Event::PaymentSent { ref payment_preimage, ref payment_hash } => {
                                assert_eq!($expected_payment_preimage, *payment_preimage);
+                               assert_eq!(expected_payment_hash, *payment_hash);
                        },
                        _ => panic!("Unexpected event"),
                }

diff --git a/lightning/src/ln/functional_tests.rs b/lightning/src/ln/functional_tests.rs
index 30652e47864963ba91574a146bee0192f28ff250..bb9556fc46a1003e334a990ad66efbcb7c1a4c4b 100644 (file)
--- a/lightning/src/ln/functional_tests.rs
+++ b/lightning/src/ln/functional_tests.rs
@@ -2521,8 +2521,8 @@ fn test_htlc_on_chain_success() {
        send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
        send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
 
-       let (our_payment_preimage, _payment_hash, _payment_secret) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
-       let (our_payment_preimage_2, _payment_hash_2, _payment_secret_2) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
+       let (our_payment_preimage, payment_hash_1, _payment_secret) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
+       let (our_payment_preimage_2, payment_hash_2, _payment_secret_2) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
 
        // Broadcast legit commitment tx from C on B's chain
        // Broadcast HTLC Success transaction by C on received output from C's commitment tx on B's chain
@@ -2682,12 +2682,13 @@ fn test_htlc_on_chain_success() {
        let mut first_claimed = false;
        for event in events {
                match event {
-                       Event::PaymentSent { payment_preimage } => {
-                               if payment_preimage == our_payment_preimage {
+                       Event::PaymentSent { payment_preimage, payment_hash } => {
+                               if payment_preimage == our_payment_preimage && payment_hash == payment_hash_1 {
                                        assert!(!first_claimed);
                                        first_claimed = true;
                                } else {
                                        assert_eq!(payment_preimage, our_payment_preimage_2);
+                                       assert_eq!(payment_hash, payment_hash_2);
                                }
                        },
                        Event::ChannelClosed { reason: ClosureReason::CommitmentTxConfirmed, .. } => {},
@@ -3370,7 +3371,7 @@ fn test_simple_peer_disconnect() {
        nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
        reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
 
-       let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).0;
+       let (payment_preimage_3, payment_hash_3, _) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000);
        let payment_preimage_4 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).0;
        let payment_hash_5 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).1;
        let payment_hash_6 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).1;
@@ -3386,8 +3387,9 @@ fn test_simple_peer_disconnect() {
                let events = nodes[0].node.get_and_clear_pending_events();
                assert_eq!(events.len(), 2);
                match events[0] {
-                       Event::PaymentSent { payment_preimage } => {
+                       Event::PaymentSent { payment_preimage, payment_hash } => {
                                assert_eq!(payment_preimage, payment_preimage_3);
+                               assert_eq!(payment_hash, payment_hash_3);
                        },
                        _ => panic!("Unexpected event"),
                }
@@ -3554,8 +3556,9 @@ fn do_test_drop_messages_peer_disconnect(messages_delivered: u8, simulate_broken
                let events_4 = nodes[0].node.get_and_clear_pending_events();
                assert_eq!(events_4.len(), 1);
                match events_4[0] {
-                       Event::PaymentSent { ref payment_preimage } => {
+                       Event::PaymentSent { ref payment_preimage, ref payment_hash } => {
                                assert_eq!(payment_preimage_1, *payment_preimage);
+                               assert_eq!(payment_hash_1, *payment_hash);
                        },
                        _ => panic!("Unexpected event"),
                }
@@ -3594,8 +3597,9 @@ fn do_test_drop_messages_peer_disconnect(messages_delivered: u8, simulate_broken
                        let events_4 = nodes[0].node.get_and_clear_pending_events();
                        assert_eq!(events_4.len(), 1);
                        match events_4[0] {
-                               Event::PaymentSent { ref payment_preimage } => {
+                               Event::PaymentSent { ref payment_preimage, ref payment_hash } => {
                                        assert_eq!(payment_preimage_1, *payment_preimage);
+                                       assert_eq!(payment_hash_1, *payment_hash);
                                },
                                _ => panic!("Unexpected event"),
                        }
@@ -3800,7 +3804,7 @@ fn test_drop_messages_peer_disconnect_dual_htlc() {
        create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
        let logger = test_utils::TestLogger::new();
 
-       let (payment_preimage_1, _, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
+       let (payment_preimage_1, payment_hash_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
 
        // Now try to send a second payment which will fail to send
        let (payment_preimage_2, payment_hash_2, payment_secret_2) = get_payment_preimage_hash!(nodes[1]);
@@ -3834,8 +3838,9 @@ fn test_drop_messages_peer_disconnect_dual_htlc() {
                        let events_3 = nodes[0].node.get_and_clear_pending_events();
                        assert_eq!(events_3.len(), 1);
                        match events_3[0] {
-                               Event::PaymentSent { ref payment_preimage } => {
+                               Event::PaymentSent { ref payment_preimage, ref payment_hash } => {
                                        assert_eq!(*payment_preimage, payment_preimage_1);
+                                       assert_eq!(*payment_hash, payment_hash_1);
                                },
                                _ => panic!("Unexpected event"),
                        }
@@ -5251,8 +5256,9 @@ fn test_duplicate_payment_hash_one_failure_one_success() {
 
        let events = nodes[0].node.get_and_clear_pending_events();
        match events[0] {
-               Event::PaymentSent { ref payment_preimage } => {
+               Event::PaymentSent { ref payment_preimage, ref payment_hash } => {
                        assert_eq!(*payment_preimage, our_payment_preimage);
+                       assert_eq!(*payment_hash, duplicate_payment_hash);
                }
                _ => panic!("Unexpected event"),
        }
@@ -5754,7 +5760,7 @@ fn do_htlc_claim_local_commitment_only(use_dust: bool) {
        let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
        let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 
-       let (our_payment_preimage, _, _) = route_payment(&nodes[0], &[&nodes[1]], if use_dust { 50000 } else { 3000000 });
+       let (our_payment_preimage, our_payment_hash, _) = route_payment(&nodes[0], &[&nodes[1]], if use_dust { 50000 } else { 3000000 });
 
        // 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.
@@ -5766,8 +5772,9 @@ fn do_htlc_claim_local_commitment_only(use_dust: bool) {
        let events = nodes[0].node.get_and_clear_pending_events();
        assert_eq!(events.len(), 1);
        match events[0] {
-               Event::PaymentSent { payment_preimage } => {
+               Event::PaymentSent { payment_preimage, payment_hash } => {
                        assert_eq!(payment_preimage, our_payment_preimage);
+                       assert_eq!(payment_hash, our_payment_hash);
                },
                _ => panic!("Unexpected event"),
        }
@@ -6201,8 +6208,9 @@ fn test_free_and_fail_holding_cell_htlcs() {
        let events = nodes[0].node.get_and_clear_pending_events();
        assert_eq!(events.len(), 1);
        match events[0] {
-               Event::PaymentSent { ref payment_preimage } => {
+               Event::PaymentSent { ref payment_preimage, ref payment_hash } => {
                        assert_eq!(*payment_preimage, payment_preimage_1);
+                       assert_eq!(*payment_hash, payment_hash_1);
                }
                _ => panic!("Unexpected event"),
        }

diff --git a/lightning/src/ln/reorg_tests.rs b/lightning/src/ln/reorg_tests.rs
index aca67c8f9f0ebe40980777f0c24f14799b742660..0409396db11696310cb4ad1a61b7d83870121970 100644 (file)
--- a/lightning/src/ln/reorg_tests.rs
+++ b/lightning/src/ln/reorg_tests.rs
@@ -12,6 +12,7 @@
 use chain::channelmonitor::{ANTI_REORG_DELAY, ChannelMonitor};
 use chain::transaction::OutPoint;
 use chain::{Confirm, Watch};
+use ln::PaymentHash;
 use ln::channelmanager::{ChannelManager, ChannelManagerReadArgs};
 use ln::features::InitFeatures;
 use ln::msgs::{ChannelMessageHandler, ErrorAction};
@@ -24,6 +25,8 @@ use util::ser::{ReadableArgs, Writeable};
 use bitcoin::blockdata::block::{Block, BlockHeader};
 use bitcoin::blockdata::script::Builder;
 use bitcoin::blockdata::opcodes;
+use bitcoin::hashes::sha256::Hash as Sha256;
+use bitcoin::hashes::Hash;
 use bitcoin::hash_types::BlockHash;
 use bitcoin::secp256k1::Secp256k1;
 

diff --git a/lightning/src/ln/shutdown_tests.rs b/lightning/src/ln/shutdown_tests.rs
index d13b7d2df12fece9a5d78092a21caa73e816451b..c2908e2652ed141cc70d0838e3d976c8709feab8 100644 (file)
--- a/lightning/src/ln/shutdown_tests.rs
+++ b/lightning/src/ln/shutdown_tests.rs
@@ -82,7 +82,7 @@ fn updates_shutdown_wait() {
        let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
        let logger = test_utils::TestLogger::new();
 
-       let (our_payment_preimage, _, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
+       let (our_payment_preimage, our_payment_hash, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
 
        nodes[0].node.close_channel(&chan_1.2).unwrap();
        let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
@@ -127,8 +127,9 @@ fn updates_shutdown_wait() {
        let events = nodes[0].node.get_and_clear_pending_events();
        assert_eq!(events.len(), 1);
        match events[0] {
-               Event::PaymentSent { ref payment_preimage } => {
+               Event::PaymentSent { ref payment_preimage, ref payment_hash } => {
                        assert_eq!(our_payment_preimage, *payment_preimage);
+                       assert_eq!(our_payment_hash, *payment_hash);
                },
                _ => panic!("Unexpected event"),
        }
@@ -242,7 +243,7 @@ fn do_test_shutdown_rebroadcast(recv_count: u8) {
        let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
        let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
 
-       let (our_payment_preimage, _, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
+       let (our_payment_preimage, our_payment_hash, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
 
        nodes[1].node.close_channel(&chan_1.2).unwrap();
        let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
@@ -307,8 +308,9 @@ fn do_test_shutdown_rebroadcast(recv_count: u8) {
        let events = nodes[0].node.get_and_clear_pending_events();
        assert_eq!(events.len(), 1);
        match events[0] {
-               Event::PaymentSent { ref payment_preimage } => {
+               Event::PaymentSent { ref payment_preimage, ref payment_hash } => {
                        assert_eq!(our_payment_preimage, *payment_preimage);
+                       assert_eq!(our_payment_hash, *payment_hash);
                },
                _ => panic!("Unexpected event"),
        }

diff --git a/lightning/src/util/events.rs b/lightning/src/util/events.rs
index 22b2f40020371e98f022082a6798b961c724ad0f..2b6a55bcecc66bb54c87b6d7349efb1aa9c6ef81 100644 (file)
--- a/lightning/src/util/events.rs
+++ b/lightning/src/util/events.rs
@@ -23,7 +23,8 @@ use util::ser::{BigSize, FixedLengthReader, Writeable, Writer, MaybeReadable, Re
 use routing::router::RouteHop;
 
 use bitcoin::blockdata::script::Script;
-
+use bitcoin::hashes::Hash;
+use bitcoin::hashes::sha256::Hash as Sha256;
 use bitcoin::secp256k1::key::PublicKey;
 
 use io;
@@ -177,6 +178,10 @@ pub enum Event {
                /// Note that this serves as a payment receipt, if you wish to have such a thing, you must
                /// store it somehow!
                payment_preimage: PaymentPreimage,
+               /// The hash which was given to [`ChannelManager::send_payment`].
+               ///
+               /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
+               payment_hash: PaymentHash,
        },
        /// Indicates an outbound payment we made failed. Probably some intermediary node dropped
        /// something. You may wish to retry with a different route.
@@ -287,10 +292,11 @@ impl Writeable for Event {
                                        (8, payment_preimage, option),
                                });
                        },
-                       &Event::PaymentSent { ref payment_preimage } => {
+                       &Event::PaymentSent { ref payment_preimage, ref payment_hash} => {
                                2u8.write(writer)?;
                                write_tlv_fields!(writer, {
                                        (0, payment_preimage, required),
+                                       (1, payment_hash, required),
                                });
                        },
                        &Event::PaymentPathFailed { ref payment_hash, ref rejected_by_dest, ref network_update,
@@ -387,11 +393,17 @@ impl MaybeReadable for Event {
                        2u8 => {
                                let f = || {
                                        let mut payment_preimage = PaymentPreimage([0; 32]);
+                                       let mut payment_hash = None;
                                        read_tlv_fields!(reader, {
                                                (0, payment_preimage, required),
+                                               (1, payment_hash, option),
                                        });
+                                       if payment_hash.is_none() {
+                                               payment_hash = Some(PaymentHash(Sha256::hash(&payment_preimage.0[..]).into_inner()));
+                                       }
                                        Ok(Some(Event::PaymentSent {
                                                payment_preimage,
+                                               payment_hash: payment_hash.unwrap(),
                                        }))
                                };
                                f()