Add `payment_hash` to `WithChannelMonitor`

diff --git a/lightning/src/chain/chainmonitor.rs b/lightning/src/chain/chainmonitor.rs
index 162482835fc2edd8788cd2bbedc67fd501c6024f..8f68fe043492a2e68da099e594c6ff63f87244e7 100644 (file)
--- a/lightning/src/chain/chainmonitor.rs
+++ b/lightning/src/chain/chainmonitor.rs
@@ -301,7 +301,7 @@ where C::Target: chain::Filter,
                monitor_state: &MonitorHolder<ChannelSigner>
        ) -> Result<(), ()> where FN: Fn(&ChannelMonitor<ChannelSigner>, &TransactionData) -> Vec<TransactionOutputs> {
                let monitor = &monitor_state.monitor;
-               let logger = WithChannelMonitor::from(&self.logger, &monitor);
+               let logger = WithChannelMonitor::from(&self.logger, &monitor, None);
                let mut txn_outputs;
                {
                        txn_outputs = process(monitor, txdata);
@@ -599,7 +599,7 @@ where C::Target: chain::Filter,
        pub fn archive_fully_resolved_channel_monitors(&self) {
                let mut have_monitors_to_prune = false;
                for (_, monitor_holder) in self.monitors.read().unwrap().iter() {
-                       let logger = WithChannelMonitor::from(&self.logger, &monitor_holder.monitor);
+                       let logger = WithChannelMonitor::from(&self.logger, &monitor_holder.monitor, None);
                        if monitor_holder.monitor.is_fully_resolved(&logger) {
                                have_monitors_to_prune = true;
                        }
@@ -607,7 +607,7 @@ where C::Target: chain::Filter,
                if have_monitors_to_prune {
                        let mut monitors = self.monitors.write().unwrap();
                        monitors.retain(|funding_txo, monitor_holder| {
-                               let logger = WithChannelMonitor::from(&self.logger, &monitor_holder.monitor);
+                               let logger = WithChannelMonitor::from(&self.logger, &monitor_holder.monitor, None);
                                if monitor_holder.monitor.is_fully_resolved(&logger) {
                                        log_info!(logger,
                                                "Archiving fully resolved ChannelMonitor for funding txo {}",
@@ -715,7 +715,7 @@ where C::Target: chain::Filter,
            P::Target: Persist<ChannelSigner>,
 {
        fn watch_channel(&self, funding_outpoint: OutPoint, monitor: ChannelMonitor<ChannelSigner>) -> Result<ChannelMonitorUpdateStatus, ()> {
-               let logger = WithChannelMonitor::from(&self.logger, &monitor);
+               let logger = WithChannelMonitor::from(&self.logger, &monitor, None);
                let mut monitors = self.monitors.write().unwrap();
                let entry = match monitors.entry(funding_outpoint) {
                        hash_map::Entry::Occupied(_) => {
@@ -773,7 +773,7 @@ where C::Target: chain::Filter,
                        },
                        Some(monitor_state) => {
                                let monitor = &monitor_state.monitor;
-                               let logger = WithChannelMonitor::from(&self.logger, &monitor);
+                               let logger = WithChannelMonitor::from(&self.logger, &monitor, None);
                                log_trace!(logger, "Updating ChannelMonitor to id {} for channel {}", update.update_id, log_funding_info!(monitor));
                                let update_res = monitor.update_monitor(update, &self.broadcaster, &self.fee_estimator, &self.logger);
 

diff --git a/lightning/src/chain/channelmonitor.rs b/lightning/src/chain/channelmonitor.rs
index b8598eabb972daab40551eb3c7ada7f4b6ace80d..6bb79a73a3297068c5b4dc00b025da32ab5abad0 100644 (file)
--- a/lightning/src/chain/channelmonitor.rs
+++ b/lightning/src/chain/channelmonitor.rs
@@ -1195,26 +1195,28 @@ pub(crate) struct WithChannelMonitor<'a, L: Deref> where L::Target: Logger {
        logger: &'a L,
        peer_id: Option<PublicKey>,
        channel_id: Option<ChannelId>,
+       payment_hash: Option<PaymentHash>,
 }
 
 impl<'a, L: Deref> Logger for WithChannelMonitor<'a, L> where L::Target: Logger {
        fn log(&self, mut record: Record) {
                record.peer_id = self.peer_id;
                record.channel_id = self.channel_id;
+               record.payment_hash = self.payment_hash;
                self.logger.log(record)
        }
 }
 
 impl<'a, L: Deref> WithChannelMonitor<'a, L> where L::Target: Logger {
-       pub(crate) fn from<S: WriteableEcdsaChannelSigner>(logger: &'a L, monitor: &ChannelMonitor<S>) -> Self {
-               Self::from_impl(logger, &*monitor.inner.lock().unwrap())
+       pub(crate) fn from<S: WriteableEcdsaChannelSigner>(logger: &'a L, monitor: &ChannelMonitor<S>, payment_hash: Option<PaymentHash>) -> Self {
+               Self::from_impl(logger, &*monitor.inner.lock().unwrap(), payment_hash)
        }
 
-       pub(crate) fn from_impl<S: WriteableEcdsaChannelSigner>(logger: &'a L, monitor_impl: &ChannelMonitorImpl<S>) -> Self {
+       pub(crate) fn from_impl<S: WriteableEcdsaChannelSigner>(logger: &'a L, monitor_impl: &ChannelMonitorImpl<S>, payment_hash: Option<PaymentHash>) -> Self {
                let peer_id = monitor_impl.counterparty_node_id;
                let channel_id = Some(monitor_impl.channel_id());
                WithChannelMonitor {
-                       logger, peer_id, channel_id,
+                       logger, peer_id, channel_id, payment_hash,
                }
        }
 }
@@ -1356,7 +1358,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
        where L::Target: Logger
        {
                let mut inner = self.inner.lock().unwrap();
-               let logger = WithChannelMonitor::from_impl(logger, &*inner);
+               let logger = WithChannelMonitor::from_impl(logger, &*inner, None);
                inner.provide_initial_counterparty_commitment_tx(txid,
                        htlc_outputs, commitment_number, their_cur_per_commitment_point, feerate_per_kw,
                        to_broadcaster_value_sat, to_countersignatory_value_sat, &logger);
@@ -1376,7 +1378,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
                logger: &L,
        ) where L::Target: Logger {
                let mut inner = self.inner.lock().unwrap();
-               let logger = WithChannelMonitor::from_impl(logger, &*inner);
+               let logger = WithChannelMonitor::from_impl(logger, &*inner, None);
                inner.provide_latest_counterparty_commitment_tx(
                        txid, htlc_outputs, commitment_number, their_per_commitment_point, &logger)
        }
@@ -1404,7 +1406,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
                L::Target: Logger,
        {
                let mut inner = self.inner.lock().unwrap();
-               let logger = WithChannelMonitor::from_impl(logger, &*inner);
+               let logger = WithChannelMonitor::from_impl(logger, &*inner, Some(*payment_hash));
                inner.provide_payment_preimage(
                        payment_hash, payment_preimage, broadcaster, fee_estimator, &logger)
        }
@@ -1426,7 +1428,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
                L::Target: Logger,
        {
                let mut inner = self.inner.lock().unwrap();
-               let logger = WithChannelMonitor::from_impl(logger, &*inner);
+               let logger = WithChannelMonitor::from_impl(logger, &*inner, None);
                inner.update_monitor(updates, broadcaster, fee_estimator, &logger)
        }
 
@@ -1461,7 +1463,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
                F::Target: chain::Filter, L::Target: Logger,
        {
                let lock = self.inner.lock().unwrap();
-               let logger = WithChannelMonitor::from_impl(logger, &*lock);
+               let logger = WithChannelMonitor::from_impl(logger, &*lock, None);
                log_trace!(&logger, "Registering funding outpoint {}", &lock.get_funding_txo().0);
                filter.register_tx(&lock.get_funding_txo().0.txid, &lock.get_funding_txo().1);
                for (txid, outputs) in lock.get_outputs_to_watch().iter() {
@@ -1621,7 +1623,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
        {
                let mut inner = self.inner.lock().unwrap();
                let fee_estimator = LowerBoundedFeeEstimator::new(&**fee_estimator);
-               let logger = WithChannelMonitor::from_impl(logger, &*inner);
+               let logger = WithChannelMonitor::from_impl(logger, &*inner, None);
                inner.queue_latest_holder_commitment_txn_for_broadcast(broadcaster, &fee_estimator, &logger);
        }
 
@@ -1632,7 +1634,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
        pub fn unsafe_get_latest_holder_commitment_txn<L: Deref>(&self, logger: &L) -> Vec<Transaction>
        where L::Target: Logger {
                let mut inner = self.inner.lock().unwrap();
-               let logger = WithChannelMonitor::from_impl(logger, &*inner);
+               let logger = WithChannelMonitor::from_impl(logger, &*inner, None);
                inner.unsafe_get_latest_holder_commitment_txn(&logger)
        }
 
@@ -1662,7 +1664,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
                L::Target: Logger,
        {
                let mut inner = self.inner.lock().unwrap();
-               let logger = WithChannelMonitor::from_impl(logger, &*inner);
+               let logger = WithChannelMonitor::from_impl(logger, &*inner, None);
                inner.block_connected(
                        header, txdata, height, broadcaster, fee_estimator, &logger)
        }
@@ -1682,7 +1684,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
                L::Target: Logger,
        {
                let mut inner = self.inner.lock().unwrap();
-               let logger = WithChannelMonitor::from_impl(logger, &*inner);
+               let logger = WithChannelMonitor::from_impl(logger, &*inner, None);
                inner.block_disconnected(
                        header, height, broadcaster, fee_estimator, &logger)
        }
@@ -1710,7 +1712,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
        {
                let bounded_fee_estimator = LowerBoundedFeeEstimator::new(fee_estimator);
                let mut inner = self.inner.lock().unwrap();
-               let logger = WithChannelMonitor::from_impl(logger, &*inner);
+               let logger = WithChannelMonitor::from_impl(logger, &*inner, None);
                inner.transactions_confirmed(
                        header, txdata, height, broadcaster, &bounded_fee_estimator, &logger)
        }
@@ -1734,7 +1736,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
        {
                let bounded_fee_estimator = LowerBoundedFeeEstimator::new(fee_estimator);
                let mut inner = self.inner.lock().unwrap();
-               let logger = WithChannelMonitor::from_impl(logger, &*inner);
+               let logger = WithChannelMonitor::from_impl(logger, &*inner, None);
                inner.transaction_unconfirmed(
                        txid, broadcaster, &bounded_fee_estimator, &logger
                );
@@ -1762,7 +1764,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
        {
                let bounded_fee_estimator = LowerBoundedFeeEstimator::new(fee_estimator);
                let mut inner = self.inner.lock().unwrap();
-               let logger = WithChannelMonitor::from_impl(logger, &*inner);
+               let logger = WithChannelMonitor::from_impl(logger, &*inner, None);
                inner.best_block_updated(
                        header, height, broadcaster, &bounded_fee_estimator, &logger
                )
@@ -1802,7 +1804,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
        {
                let fee_estimator = LowerBoundedFeeEstimator::new(fee_estimator);
                let mut inner = self.inner.lock().unwrap();
-               let logger = WithChannelMonitor::from_impl(logger, &*inner);
+               let logger = WithChannelMonitor::from_impl(logger, &*inner, None);
                let current_height = inner.best_block.height;
                inner.onchain_tx_handler.rebroadcast_pending_claims(
                        current_height, FeerateStrategy::HighestOfPreviousOrNew, &broadcaster, &fee_estimator, &logger,
@@ -1821,7 +1823,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
        {
                let fee_estimator = LowerBoundedFeeEstimator::new(fee_estimator);
                let mut inner = self.inner.lock().unwrap();
-               let logger = WithChannelMonitor::from_impl(logger, &*inner);
+               let logger = WithChannelMonitor::from_impl(logger, &*inner, None);
                let current_height = inner.best_block.height;
                inner.onchain_tx_handler.rebroadcast_pending_claims(
                        current_height, FeerateStrategy::RetryPrevious, &broadcaster, &fee_estimator, &logger,
@@ -5260,7 +5262,8 @@ mod tests {
                        best_block, dummy_key, channel_id);
 
                let chan_id = monitor.inner.lock().unwrap().channel_id();
-               let context_logger = WithChannelMonitor::from(&logger, &monitor);
+               let payment_hash = PaymentHash([1; 32]);
+               let context_logger = WithChannelMonitor::from(&logger, &monitor, Some(payment_hash));
                log_error!(context_logger, "This is an error");
                log_warn!(context_logger, "This is an error");
                log_debug!(context_logger, "This is an error");

diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
index 7680bd030d5e2cf21acc1a9bc468298ad7cd81b5..c867fdc35107dedb78a2f86611726c376ca2d2ea 100644 (file)
--- a/lightning/src/ln/channelmanager.rs
+++ b/lightning/src/ln/channelmanager.rs
@@ -11633,7 +11633,7 @@ where
 
                for (funding_txo, monitor) in args.channel_monitors.iter() {
                        if !funding_txo_set.contains(funding_txo) {
-                               let logger = WithChannelMonitor::from(&args.logger, monitor);
+                               let logger = WithChannelMonitor::from(&args.logger, monitor, None);
                                let channel_id = monitor.channel_id();
                                log_info!(logger, "Queueing monitor update to ensure missing channel {} is force closed",
                                        &channel_id);
@@ -11940,8 +11940,8 @@ where
                        for (_, monitor) in args.channel_monitors.iter() {
                                let counterparty_opt = outpoint_to_peer.get(&monitor.get_funding_txo().0);
                                if counterparty_opt.is_none() {
-                                       let logger = WithChannelMonitor::from(&args.logger, monitor);
                                        for (htlc_source, (htlc, _)) in monitor.get_pending_or_resolved_outbound_htlcs() {
+                                               let logger = WithChannelMonitor::from(&args.logger, monitor, Some(htlc.payment_hash));
                                                if let HTLCSource::OutboundRoute { payment_id, session_priv, path, .. } = htlc_source {
                                                        if path.hops.is_empty() {
                                                                log_error!(logger, "Got an empty path for a pending payment");
@@ -11982,6 +11982,7 @@ where
                                                }
                                        }
                                        for (htlc_source, (htlc, preimage_opt)) in monitor.get_all_current_outbound_htlcs() {
+                                               let logger = WithChannelMonitor::from(&args.logger, monitor, Some(htlc.payment_hash));
                                                match htlc_source {
                                                        HTLCSource::PreviousHopData(prev_hop_data) => {
                                                                let pending_forward_matches_htlc = |info: &PendingAddHTLCInfo| {