X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Fevents.rs;h=8ddd762e97036bac77fee08c2be7819ec707388e;hb=2f4a1f7f79e55d28b289f4907e019e66a251a19e;hp=47e0c88f549f6f882f310c220d5cc94736dc4f41;hpb=c57bb42204a569fce5fb90d7f1b1367320124ae1;p=rust-lightning

diff --git a/lightning/src/util/events.rs b/lightning/src/util/events.rs
index 47e0c88f..8ddd762e 100644
--- a/lightning/src/util/events.rs
+++ b/lightning/src/util/events.rs
@@ -1002,7 +1002,7 @@ impl MaybeReadable for Event {
 						(4, path, vec_type),
 						(6, short_channel_id, option),
 					});
-					Ok(Some(Event::ProbeFailed{
+					Ok(Some(Event::ProbeFailed {
 						payment_id,
 						payment_hash,
 						path: path.unwrap(),
@@ -1011,6 +1011,28 @@ impl MaybeReadable for Event {
 				};
 				f()
 			},
+			25u8 => {
+				let f = || {
+					let mut prev_channel_id = [0; 32];
+					let mut failed_next_destination_opt = None;
+					read_tlv_fields!(reader, {
+						(0, prev_channel_id, required),
+						(2, failed_next_destination_opt, ignorable),
+					});
+					if let Some(failed_next_destination) = failed_next_destination_opt {
+						Ok(Some(Event::HTLCHandlingFailed {
+							prev_channel_id,
+							failed_next_destination,
+						}))
+					} else {
+						// If we fail to read a `failed_next_destination` assume it's because
+						// `MaybeReadable::read` returned `Ok(None)`, though it's also possible we
+						// were simply missing the field.
+						Ok(None)
+					}
+				};
+				f()
+			},
 			// Versions prior to 0.0.100 did not ignore odd types, instead returning InvalidValue.
 			// Version 0.0.100 failed to properly ignore odd types, possibly resulting in corrupt
 			// reads.
@@ -1115,25 +1137,32 @@ pub enum MessageSendEvent {
 		/// The message which should be sent.
 		msg: msgs::ChannelReestablish,
 	},
+	/// Used to send a channel_announcement and channel_update to a specific peer, likely on
+	/// initial connection to ensure our peers know about our channels.
+	SendChannelAnnouncement {
+		/// The node_id of the node which should receive this message
+		node_id: PublicKey,
+		/// The channel_announcement which should be sent.
+		msg: msgs::ChannelAnnouncement,
+		/// The followup channel_update which should be sent.
+		update_msg: msgs::ChannelUpdate,
+	},
 	/// Used to indicate that a channel_announcement and channel_update should be broadcast to all
 	/// peers (except the peer with node_id either msg.contents.node_id_1 or msg.contents.node_id_2).
 	///
-	/// Note that after doing so, you very likely (unless you did so very recently) want to call
-	/// ChannelManager::broadcast_node_announcement to trigger a BroadcastNodeAnnouncement event.
-	/// This ensures that any nodes which see our channel_announcement also have a relevant
+	/// Note that after doing so, you very likely (unless you did so very recently) want to
+	/// broadcast a node_announcement (e.g. via [`PeerManager::broadcast_node_announcement`]). This
+	/// ensures that any nodes which see our channel_announcement also have a relevant
 	/// node_announcement, including relevant feature flags which may be important for routing
 	/// through or to us.
+	///
+	/// [`PeerManager::broadcast_node_announcement`]: crate::ln::peer_handler::PeerManager::broadcast_node_announcement
 	BroadcastChannelAnnouncement {
 		/// The channel_announcement which should be sent.
 		msg: msgs::ChannelAnnouncement,
 		/// The followup channel_update which should be sent.
 		update_msg: msgs::ChannelUpdate,
 	},
-	/// Used to indicate that a node_announcement should be broadcast to all peers.
-	BroadcastNodeAnnouncement {
-		/// The node_announcement which should be sent.
-		msg: msgs::NodeAnnouncement,
-	},
 	/// Used to indicate that a channel_update should be broadcast to all peers.
 	BroadcastChannelUpdate {
 		/// The channel_update which should be sent.
@@ -1207,11 +1236,17 @@ pub trait OnionMessageProvider {
 ///
 /// # Requirements
 ///
-/// See [`process_pending_events`] for requirements around event processing.
-///
 /// When using this trait, [`process_pending_events`] will call [`handle_event`] for each pending
-/// event since the last invocation. The handler must either act upon the event immediately
-/// or preserve it for later handling.
+/// event since the last invocation.
+///
+/// In order to ensure no [`Event`]s are lost, implementors of this trait will persist [`Event`]s
+/// and replay any unhandled events on startup. An [`Event`] is considered handled when
+/// [`process_pending_events`] returns, thus handlers MUST fully handle [`Event`]s and persist any
+/// relevant changes to disk *before* returning.
+///
+/// Further, because an application may crash between an [`Event`] being handled and the
+/// implementor of this trait being re-serialized, [`Event`] handling must be idempotent - in
+/// effect, [`Event`]s may be replayed.
 ///
 /// Note, handlers may call back into the provider and thus deadlocking must be avoided. Be sure to
 /// consult the provider's documentation on the implication of processing events and how a handler
@@ -1228,9 +1263,7 @@ pub trait OnionMessageProvider {
 pub trait EventsProvider {
 	/// Processes any events generated since the last call using the given event handler.
 	///
-	/// Subsequent calls must only process new events. However, handlers must be capable of handling
-	/// duplicate events across process restarts. This may occur if the provider was recovered from
-	/// an old state (i.e., it hadn't been successfully persisted after processing pending events).
+	/// See the trait-level documentation for requirements.
 	fn process_pending_events<H: Deref>(&self, handler: H) where H::Target: EventHandler;
 }