Track historical SCIDs from previous funding

When a splice is locked, the SCID from the previous funding transaction
needs to be remembered so that pending HTLCs can be handled properly.
Additionally, when they need to be cleaned up once they should no longer
be used. Track these SCIDs as splices are locked and clean any up as
blocks are connected.

Author: jkczyz

lightning/src/ln/channel.rs

@@ -2267,6 +2267,10 @@ pub(super) struct ChannelContext<SP: Deref> where SP::Target: SignerProvider {
 	// blinded paths instead of simple scid+node_id aliases.
 	outbound_scid_alias: u64,
 
+	/// Short channel ids used by any prior FundingScope. These are maintained such that
+	/// ChannelManager can look up the channel for any pending HTLCs.
+	pub historical_scids: Vec<u64>,
+
 	// We track whether we already emitted a `ChannelPending` event.
 	channel_pending_event_emitted: bool,
 
@@ -3083,6 +3087,7 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 
 			latest_inbound_scid_alias: None,
 			outbound_scid_alias: 0,
+			historical_scids: Vec::new(),
 
 			channel_pending_event_emitted: false,
 			funding_tx_broadcast_safe_event_emitted: false,
@@ -3317,6 +3322,7 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 
 			latest_inbound_scid_alias: None,
 			outbound_scid_alias,
+			historical_scids: Vec::new(),
 
 			channel_pending_event_emitted: false,
 			funding_tx_broadcast_safe_event_emitted: false,
@@ -5338,6 +5344,9 @@ pub(super) struct FundedChannel<SP: Deref> where SP::Target: SignerProvider {
 #[cfg(splicing)]
 macro_rules! promote_splice_funding {
 	($self: expr, $funding: expr) => {
+		if let Some(scid) = $self.funding.short_channel_id {
+			$self.context.historical_scids.push(scid);
+		}
 		core::mem::swap(&mut $self.funding, $funding);
 		$self.pending_splice = None;
 		$self.pending_funding.clear();
@@ -11448,7 +11457,8 @@ impl<SP: Deref> Writeable for FundedChannel<SP> where SP::Target: SignerProvider
 			(54, self.pending_funding, optional_vec), // Added in 0.2
 			(55, removed_htlc_failure_attribution_data, optional_vec), // Added in 0.2
 			(57, holding_cell_failure_attribution_data, optional_vec), // Added in 0.2
-			(58, self.interactive_tx_signing_session, option) // Added in 0.2
+			(58, self.interactive_tx_signing_session, option), // Added in 0.2
+			(60, self.context.historical_scids, optional_vec), // Added in 0.2
 		});
 
 		Ok(())
@@ -11764,6 +11774,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, &'c Channel
 		let mut is_manual_broadcast = None;
 
 		let mut pending_funding = Some(Vec::new());
+		let mut historical_scids = Some(Vec::new());
 
 		let mut interactive_tx_signing_session: Option<InteractiveTxSigningSession> = None;
 
@@ -11806,6 +11817,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, &'c Channel
 			(55, removed_htlc_failure_attribution_data, optional_vec),
 			(57, holding_cell_failure_attribution_data, optional_vec),
 			(58, interactive_tx_signing_session, option), // Added in 0.2
+			(60, historical_scids, optional_vec), // Added in 0.2
 		});
 
 		let holder_signer = signer_provider.derive_channel_signer(channel_keys_id);
@@ -12078,6 +12090,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, &'c Channel
 				latest_inbound_scid_alias,
 				// Later in the ChannelManager deserialization phase we scan for channels and assign scid aliases if its missing
 				outbound_scid_alias,
+				historical_scids: historical_scids.unwrap(),
 
 				funding_tx_broadcast_safe_event_emitted: funding_tx_broadcast_safe_event_emitted.unwrap_or(false),
 				channel_pending_event_emitted: channel_pending_event_emitted.unwrap_or(true),

lightning/src/ln/channelmanager.rs

@@ -84,7 +84,7 @@ use crate::sign::{EntropySource, NodeSigner, Recipient, SignerProvider};
 use crate::sign::ecdsa::EcdsaChannelSigner;
 use crate::util::config::{ChannelConfig, ChannelConfigUpdate, ChannelConfigOverrides, UserConfig};
 use crate::util::wakers::{Future, Notifier};
-use crate::util::scid_utils::fake_scid;
+use crate::util::scid_utils::{block_from_scid, fake_scid};
 use crate::util::string::UntrustedString;
 use crate::util::ser::{BigSize, FixedLengthReader, LengthReadable, Readable, ReadableArgs, MaybeReadable, Writeable, Writer, VecWriter};
 use crate::util::logger::{Level, Logger, WithContext};
@@ -2912,6 +2912,11 @@ const MAX_NO_CHANNEL_PEERS: usize = 250;
 /// become invalid over time as channels are closed. Thus, they are only suitable for short-term use.
 pub const MAX_SHORT_LIVED_RELATIVE_EXPIRY: Duration = Duration::from_secs(60 * 60 * 24);
 
+/// The number of blocks to wait for a channel_announcement to propagate such that payments using an
+/// older SCID can still be relayed. Once the spend of the previous funding transaction has reached
+/// this number of confirmations, the corresponding SCID will be forgotten.
+const CHANNEL_ANNOUNCEMENT_PROPAGATION_DELAY: u32 = 12;
+
 /// Used by [`ChannelManager::list_recent_payments`] to express the status of recent payments.
 /// These include payments that have yet to find a successful path, or have unresolved HTLCs.
 #[derive(Debug, PartialEq)]
@@ -3070,6 +3075,9 @@ macro_rules! locked_close_channel {
 			debug_assert!(alias_removed);
 		}
 		short_to_chan_info.remove(&$channel_context.outbound_scid_alias());
+		for scid in &$channel_context.historical_scids {
+			short_to_chan_info.remove(scid);
+		}
 	}}
 }
 
@@ -11696,6 +11704,29 @@ where
 					channel.check_for_stale_feerate(&logger, feerate)?;
 				}
 			}
+
+			// Remove any scids used by older funding transactions
+			if let Some(current_scid) = channel.funding.get_short_channel_id() {
+				let historical_scids = &mut channel.context.historical_scids;
+				if !historical_scids.is_empty() {
+					let mut short_to_chan_info = self.short_to_chan_info.write().unwrap();
+
+					// Remove an older SCID if the next funding has enough confirmations
+					for (scid, next_scid) in historical_scids
+						.iter()
+						.zip(historical_scids.iter().skip(1).chain(core::iter::once(&current_scid)))
+					{
+						let funding_height = block_from_scid(*next_scid);
+						let retain_scid = funding_height + CHANNEL_ANNOUNCEMENT_PROPAGATION_DELAY > height;
+						if !retain_scid {
+							short_to_chan_info.remove(scid);
+						}
+					}
+
+					historical_scids.retain(|scid| short_to_chan_info.contains_key(scid));
+				}
+			}
+
 			channel.best_block_updated(height, header.time, self.chain_hash, &self.node_signer, &self.default_configuration, &&WithChannelContext::from(&self.logger, &channel.context, None))
 		});
 
@@ -13994,6 +14025,11 @@ where
 					if let Some(short_channel_id) = channel.funding.get_short_channel_id() {
 						short_to_chan_info.insert(short_channel_id, (channel.context.get_counterparty_node_id(), channel.context.channel_id()));
 					}
+
+					for short_channel_id in &channel.context.historical_scids {
+						short_to_chan_info.insert(*short_channel_id, (channel.context.get_counterparty_node_id(), channel.context.channel_id()));
+					}
+
 					per_peer_state.entry(channel.context.get_counterparty_node_id())
 						.or_insert_with(|| Mutex::new(empty_peer_state()))
 						.get_mut().unwrap()