-f fix new Matt's comments

[rust-lightning] / lightning / src / util / events.rs

diff --git a/lightning/src/util/events.rs b/lightning/src/util/events.rs
index bf1bd074314f701bcfc41e628c24a291e955522a..2e54e2f3f15b7a6f0162dcd3ac0492a466024b27 100644 (file)
--- a/lightning/src/util/events.rs
+++ b/lightning/src/util/events.rs
@@ -16,6 +16,7 @@
 
 use chain::keysinterface::SpendableOutputDescriptor;
 use ln::msgs;
+use ln::msgs::DecodeError;
 use ln::{PaymentPreimage, PaymentHash, PaymentSecret};
 use routing::network_graph::NetworkUpdate;
 use util::ser::{Writeable, Writer, MaybeReadable, Readable, VecReadWrapper, VecWriteWrapper};
@@ -68,6 +69,38 @@ pub enum PaymentPurpose {
        SpontaneousPayment(PaymentPreimage),
 }
 
+#[derive(Clone, Debug)]
+/// Some information provided on the closure source of the channel halting.
+pub enum ClosureReason {
+       /// Closure generated from receiving a peer error message by ChannelManager::handle_error
+       CounterpartyForceClosed {
+               /// The error is coming from the peer, there *might* be a human-readable msg
+               peer_msg: Option<String>,
+       },
+       /// Closure generated from ChannelManager::force_close_channel
+       HolderForceClosed,
+       /// Closure generated from receiving a peer's ClosingSigned message. Note the shutdown
+       /// sequence might have been initially initiated by us.
+       CooperativeClosure,
+       /// Closure generated from receiving chain::Watch's CommitmentTxBroadcast event.
+       CommitmentTxBroadcasted,
+       /// Closure generated from processing an event, likely a HTLC forward/relay/reception.
+       ProcessingError {
+               err: String,
+       },
+       /// Closure generated from ChannelManager::peer_disconnected.
+       DisconnectedPeer,
+}
+
+impl_writeable_tlv_based_enum_upgradable!(ClosureReason,
+       (0, CounterpartyForceClosed) => { (1, peer_msg, option) },
+       (2, HolderForceClosed) => {},
+       (6, CommitmentTxBroadcasted) => {},
+       (4, CooperativeClosure) => {},
+       (8, ProcessingError) => { (1, err, required) },
+       (10, DisconnectedPeer) => {},
+);
+
 /// An Event which you should probably take some action in response to.
 ///
 /// Note that while Writeable and Readable are implemented for Event, you probably shouldn't use
@@ -141,6 +174,10 @@ pub enum Event {
                /// [`NetworkGraph`]: crate::routing::network_graph::NetworkGraph
                /// [`NetGraphMsgHandler`]: crate::routing::network_graph::NetGraphMsgHandler
                network_update: Option<NetworkUpdate>,
+               /// For both single-path and multi-path payments, this is set if all paths of the payment have
+               /// failed. This will be set to false if (1) this is an MPP payment and (2) other parts of the
+               /// larger MPP payment were still in flight when this event was generated.
+               all_paths_failed: bool,
 #[cfg(test)]
                error_code: Option<u16>,
 #[cfg(test)]
@@ -185,6 +222,14 @@ pub enum Event {
                /// transaction.
                claim_from_onchain_tx: bool,
        },
+       /// Used to indicate that a channel with the given `channel_id` is in the process of closure.
+       ChannelClosed  {
+               /// The channel_id which has been barren from further off-chain updates but
+               /// funding output might still be not resolved yet.
+               channel_id: [u8; 32],
+               /// A machine-readable error message
+               err: ClosureReason
+       }
 }
 
 impl Writeable for Event {
@@ -224,7 +269,7 @@ impl Writeable for Event {
                                        (0, payment_preimage, required),
                                });
                        },
-                       &Event::PaymentFailed { ref payment_hash, ref rejected_by_dest, ref network_update,
+                       &Event::PaymentFailed { ref payment_hash, ref rejected_by_dest, ref network_update, ref all_paths_failed,
                                #[cfg(test)]
                                ref error_code,
                                #[cfg(test)]
@@ -239,6 +284,7 @@ impl Writeable for Event {
                                        (0, payment_hash, required),
                                        (1, network_update, option),
                                        (2, rejected_by_dest, required),
+                                       (3, all_paths_failed, required),
                                });
                        },
                        &Event::PendingHTLCsForwardable { time_forwardable: _ } => {
@@ -260,6 +306,12 @@ impl Writeable for Event {
                                        (2, claim_from_onchain_tx, required),
                                });
                        },
+                       &Event::ChannelClosed { ref channel_id, ref err } => {
+                               8u8.write(writer)?;
+                               channel_id.write(writer)?;
+                               err.write(writer)?;
+                               write_tlv_fields!(writer, {});
+                       },
                }
                Ok(())
        }
@@ -322,15 +374,18 @@ impl MaybeReadable for Event {
                                        let mut payment_hash = PaymentHash([0; 32]);
                                        let mut rejected_by_dest = false;
                                        let mut network_update = None;
+                                       let mut all_paths_failed = Some(true);
                                        read_tlv_fields!(reader, {
                                                (0, payment_hash, required),
                                                (1, network_update, ignorable),
                                                (2, rejected_by_dest, required),
+                                               (3, all_paths_failed, option),
                                        });
                                        Ok(Some(Event::PaymentFailed {
                                                payment_hash,
                                                rejected_by_dest,
                                                network_update,
+                                               all_paths_failed: all_paths_failed.unwrap(),
                                                #[cfg(test)]
                                                error_code,
                                                #[cfg(test)]
@@ -370,6 +425,13 @@ impl MaybeReadable for Event {
                                };
                                f()
                        },
+                       8u8 => {
+                               let channel_id = Readable::read(reader)?;
+                               let err = MaybeReadable::read(reader)?;
+                               read_tlv_fields!(reader, {});
+                               if err.is_none() { return Ok(None); }
+                               Ok(Some(Event::ChannelClosed { channel_id, err: err.unwrap() }))
+                       },
                        // Versions prior to 0.0.100 did not ignore odd types, instead returning InvalidValue.
                        x if x % 2 == 1 => Ok(None),
                        _ => Err(msgs::DecodeError::InvalidValue)