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

@@ -66,7 +66,7 @@ use crate::util::ser::{Readable, ReadableArgs, RequiredWrapper, TransactionU16Le
 use crate::util::logger::{Logger, Record, WithContext};
 use crate::util::errors::APIError;
 use crate::util::config::{UserConfig, ChannelConfig, LegacyChannelConfig, ChannelHandshakeConfig, ChannelHandshakeLimits, MaxDustHTLCExposure};
-use crate::util::scid_utils::scid_from_parts;
+use crate::util::scid_utils::{block_from_scid, scid_from_parts};
 
 use alloc::collections::{btree_map, BTreeMap};
 
@@ -1303,6 +1303,11 @@ pub(crate) const UNFUNDED_CHANNEL_AGE_LIMIT_TICKS: usize = 60;
 /// Number of blocks needed for an output from a coinbase transaction to be spendable.
 pub(crate) const COINBASE_MATURITY: u32 = 100;
 
+/// 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;
+
 struct PendingChannelMonitorUpdate {
 	update: ChannelMonitorUpdate,
 }
@@ -2280,6 +2285,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.
+	historical_scids: Vec<u64>,
+
 	// We track whether we already emitted a `ChannelPending` event.
 	channel_pending_event_emitted: bool,
 
@@ -3097,6 +3106,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,
@@ -3338,6 +3348,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,
@@ -5392,6 +5403,11 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 
 		Ok(())
 	}
+
+	/// Returns SCIDs that have been associated with the channel's funding transactions.
+	pub fn historical_scids(&self) -> &[u64] {
+		&self.historical_scids[..]
+	}
 }
 
 // Internal utility functions for channels
@@ -5579,6 +5595,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();
@@ -10279,6 +10298,28 @@ impl<SP: Deref> FundedChannel<SP> where
 	pub fn has_pending_splice(&self) -> bool {
 		self.pending_splice.is_some()
 	}
+
+	pub fn remove_legacy_scids_before_block(&mut self, height: u32) -> alloc::vec::Drain<u64> {
+		let end = self.funding
+			.get_short_channel_id()
+			.and_then(|current_scid| {
+				let historical_scids = &self.context.historical_scids;
+				historical_scids
+					.iter()
+					.zip(historical_scids.iter().skip(1).chain(core::iter::once(&current_scid)))
+					.map(|(_, next_scid)| {
+						let funding_height = block_from_scid(*next_scid);
+						let retain_scid = funding_height + CHANNEL_ANNOUNCEMENT_PROPAGATION_DELAY - 1 > height;
+						retain_scid
+					})
+					.position(|retain_scid| retain_scid)
+			})
+			.unwrap_or(0);
+
+		// Drains the oldest historical SCIDs until reaching one without
+		// CHANNEL_ANNOUNCEMENT_PROPAGATION_DELAY confirmations.
+		self.context.historical_scids.drain(0..end)
+	}
 }
 
 /// A not-yet-funded outbound (from holder) channel using V1 channel establishment.
@@ -11657,6 +11698,7 @@ impl<SP: Deref> Writeable for FundedChannel<SP> where SP::Target: SignerProvider
 			(57, holding_cell_failure_attribution_data, optional_vec), // Added in 0.2
 			(58, self.interactive_tx_signing_session, option), // Added in 0.2
 			(59, self.funding.minimum_depth_override, option), // Added in 0.2
+			(60, self.context.historical_scids, optional_vec), // Added in 0.2
 		});
 
 		Ok(())
@@ -11972,6 +12014,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;
 
@@ -12017,6 +12060,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, &'c Channel
 			(57, holding_cell_failure_attribution_data, optional_vec),
 			(58, interactive_tx_signing_session, option), // Added in 0.2
 			(59, minimum_depth_override, 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);
@@ -12290,6 +12334,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

@@ -3172,6 +3172,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);
+		}
 	}}
 }
 
@@ -11957,6 +11960,18 @@ where
 					channel.check_for_stale_feerate(&logger, feerate)?;
 				}
 			}
+
+			// Remove any SCIDs used by older funding transactions
+			{
+				let legacy_scids = channel.remove_legacy_scids_before_block(height);
+				if !legacy_scids.as_slice().is_empty() {
+					let mut short_to_chan_info = self.short_to_chan_info.write().unwrap();
+					for scid in legacy_scids {
+						short_to_chan_info.remove(&scid);
+					}
+				}
+			}
+
 			channel.best_block_updated(height, header.time, self.chain_hash, &self.node_signer, &self.default_configuration, &&WithChannelContext::from(&self.logger, &channel.context, None))
 		});
 
@@ -14332,6 +14347,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()