Add a method to prune stale channels from NetworkGraph

We define "stale" as "haven't heard an updated channel_update in
two weeks", as described in BOLT 7.

We also filter out stale channels at write-time for `std` users, as
we can look up the current time.

Author: TheBlueMatt

lightning/src/routing/network_graph.rs

@@ -730,6 +730,11 @@ const MIN_SERIALIZATION_VERSION: u8 = 1;
 
 impl Writeable for NetworkGraph {
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
+		#[cfg(feature = "std")]
+		{
+			self.remove_stale_channels();
+		}
+
 		write_ver_prefix!(writer, SERIALIZATION_VERSION, MIN_SERIALIZATION_VERSION);
 
 		self.genesis_hash.write(writer)?;
@@ -1040,6 +1045,63 @@ impl NetworkGraph {
 		}
 	}
 
+	#[cfg(feature = "std")]
+	/// Removes information about channels which we haven't heard any updates about in some time.
+	/// This can be used regularly to prune the network graph from channels which likely no longer
+	/// exist.
+	///
+	/// While there is no formal requirement that nodes regularly re-broadcast their channel
+	/// updates every two weeks, the non-normative section of BOLT 7 currently suggests that
+	/// pruning occurrs for updates which are at least two weeks old, which we implement here.
+	///
+	/// This method is automatically called immediately before writing the network graph via
+	/// [`Writeable::write`].
+	///
+	/// This method is only available with the `std` feature. See
+	/// [`NetworkGraph::remove_stale_channels_with_time`] for `no-std` use.
+	pub fn remove_stale_channels(&self) {
+		use std::time::{SystemTime, UNIX_EPOCH};
+		let time = SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs();
+		self.remove_stale_channels_with_time(time);
+	}
+
+	/// Removes information about channels which we haven't heard any updates about in some time.
+	/// This can be used regularly to prune the network graph from channels which likely no longer
+	/// exist.
+	///
+	/// While there is no formal requirement that nodes regularly re-broadcast their channel
+	/// updates every two weeks, the non-normative section of BOLT 7 currently suggests that
+	/// pruning occurrs for updates which are at least two weeks old, which we implement here.
+	///
+	/// This function takes the current unix time as an argument. For users with the `std` feature
+	/// enabled, [`NetworkGraph::remove_stale_channels`] may be preferrable.
+	pub fn remove_stale_channels_with_time(&self, current_time_unix: u64) {
+		let mut channels = self.channels.write().unwrap();
+		// Time out if we haven't received an update in at least 14 days.
+		let min_time_unix: u32 = (current_time_unix - 60 * 60 * 14) as u32;
+		// Sadly BTreeMap::retain was only stabilized in 1.53 so we can't switch to it for some
+		// time.
+		let mut scids_to_remove = Vec::new();
+		for (scid, info) in channels.iter_mut() {
+			if info.one_to_two.is_some() && info.one_to_two.as_ref().unwrap().last_update < min_time_unix {
+				info.one_to_two = None;
+			}
+			if info.two_to_one.is_some() && info.two_to_one.as_ref().unwrap().last_update < min_time_unix {
+				info.two_to_one = None;
+			}
+			if info.one_to_two.is_none() && info.two_to_one.is_none() {
+				scids_to_remove.push(*scid);
+			}
+		}
+		if !scids_to_remove.is_empty() {
+			let mut nodes = self.nodes.write().unwrap();
+			for scid in scids_to_remove {
+				let info = channels.remove(&scid).expect("We just accessed this scid, it should be present");
+				Self::remove_channel_in_nodes(&mut nodes, &info, scid);
+			}
+		}
+	}
+
 	/// For an already known (from announcement) channel, update info about one of the directions
 	/// of the channel.
 	///
@@ -1639,8 +1701,7 @@ mod tests {
 		};
 	}
 
-	#[test]
-	fn handling_network_update() {
+	fn do_handling_network_update(remove_by_timeout: bool) {
 		let logger = test_utils::TestLogger::new();
 		let chain_source = Arc::new(test_utils::TestChainSource::new(Network::Testnet));
 		let genesis_hash = genesis_block(Network::Testnet).header.block_hash();
@@ -1719,8 +1780,13 @@ mod tests {
 			};
 		}
 
-		// Permanent closing deletes a channel
-		{
+		if remove_by_timeout {
+			network_graph.remove_stale_channels_with_time(100 + 60 * 60 * 14);
+			assert_eq!(network_graph.read_only().channels().len(), 1);
+			assert_eq!(network_graph.read_only().nodes().len(), 2);
+			network_graph.remove_stale_channels_with_time(101 + 60 * 60 * 14);
+		} else {
+			// Permanent closing deletes a channel
 			net_graph_msg_handler.handle_event(&Event::PaymentPathFailed {
 				payment_id: None,
 				payment_hash: PaymentHash([0; 32]),
@@ -1736,14 +1802,20 @@ mod tests {
 				error_code: None,
 				error_data: None,
 			});
-
-			assert_eq!(network_graph.read_only().channels().len(), 0);
-			// Nodes are also deleted because there are no associated channels anymore
-			assert_eq!(network_graph.read_only().nodes().len(), 0);
 		}
+
+		assert_eq!(network_graph.read_only().channels().len(), 0);
+		// Nodes are also deleted because there are no associated channels anymore
+		assert_eq!(network_graph.read_only().nodes().len(), 0);
 		// TODO: Test NetworkUpdate::NodeFailure, which is not implemented yet.
 	}
 
+	#[test]
+	fn handling_network_update() {
+		do_handling_network_update(true);
+		do_handling_network_update(false);
+	}
+
 	#[test]
 	fn getting_next_channel_announcements() {
 		let network_graph = create_network_graph();