X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Fevents.rs;h=2e54e2f3f15b7a6f0162dcd3ac0492a466024b27;hb=eab9b3452657cef788eb54e3f46eda4fb06f9197;hp=bf1bd074314f701bcfc41e628c24a291e955522a;hpb=8f1763159e8b2902f2952388967f8c67d11219ad;p=rust-lightning

diff --git a/lightning/src/util/events.rs b/lightning/src/util/events.rs
index bf1bd074..2e54e2f3 100644
--- 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)