fixup! Add persistent closed channel history and list_closed_channels()

Generalize PendingChannelInfo into ChannelRecord::Funded.
Rather than shipping two separate per-channel stores, introduce a
ChannelRecord enum with a single Funded variant that already carries the
fields the splice PR will need (counterparty_node_id, channel_id) in
addition to is_outbound/is_announced flags. This lets the splice PR add
pending_splice: Option<SpliceIntent> as a new optional TLV field without
touching the store infrastructure.

Author: f3r10

src/builder.rs

@@ -64,11 +64,11 @@ use crate::io::utils::{
 };
 use crate::io::vss_store::VssStoreBuilder;
 use crate::io::{
-	self, CLOSED_CHANNEL_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
+	self, CHANNEL_RECORD_PERSISTENCE_PRIMARY_NAMESPACE,
+	CHANNEL_RECORD_PERSISTENCE_SECONDARY_NAMESPACE,
+	CLOSED_CHANNEL_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 	CLOSED_CHANNEL_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 	PAYMENT_INFO_PERSISTENCE_PRIMARY_NAMESPACE, PAYMENT_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
-	PENDING_CHANNEL_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
-	PENDING_CHANNEL_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 	PENDING_PAYMENT_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
 	PENDING_PAYMENT_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
 };
@@ -83,9 +83,9 @@ use crate::peer_store::PeerStore;
 use crate::runtime::{Runtime, RuntimeSpawner};
 use crate::tx_broadcaster::TransactionBroadcaster;
 use crate::types::{
-	AsyncPersister, ChainMonitor, ChannelManager, ClosedChannelStore, DynStore, DynStoreRef,
-	DynStoreWrapper, GossipSync, Graph, HRNResolver, KeysManager, MessageRouter, OnionMessenger,
-	PaymentStore, PeerManager, PendingChannelStore, PendingPaymentStore, SyncAndAsyncKVStore,
+	AsyncPersister, ChainMonitor, ChannelManager, ChannelRecordStore, ClosedChannelStore, DynStore,
+	DynStoreRef, DynStoreWrapper, GossipSync, Graph, HRNResolver, KeysManager, MessageRouter,
+	OnionMessenger, PaymentStore, PeerManager, PendingPaymentStore, SyncAndAsyncKVStore,
 };
 use crate::wallet::persist::KVStoreWalletPersister;
 use crate::wallet::Wallet;
@@ -1297,7 +1297,7 @@ fn build_with_store_internal(
 		node_metris_res,
 		pending_payment_store_res,
 		closed_channel_store_res,
-		pending_channel_store_res,
+		channel_record_store_res,
 	) = runtime.block_on(async move {
 		tokio::join!(
 			read_all_objects(
@@ -1321,8 +1321,8 @@ fn build_with_store_internal(
 			),
 			read_all_objects(
 				&*kv_store_ref,
-				PENDING_CHANNEL_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
-				PENDING_CHANNEL_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
+				CHANNEL_RECORD_PERSISTENCE_PRIMARY_NAMESPACE,
+				CHANNEL_RECORD_PERSISTENCE_SECONDARY_NAMESPACE,
 				Arc::clone(&logger_ref),
 			),
 		)
@@ -1541,16 +1541,16 @@ fn build_with_store_internal(
 		},
 	};
 
-	let pending_channel_store = match pending_channel_store_res {
-		Ok(pending_channels) => Arc::new(PendingChannelStore::new(
-			pending_channels,
-			PENDING_CHANNEL_INFO_PERSISTENCE_PRIMARY_NAMESPACE.to_string(),
-			PENDING_CHANNEL_INFO_PERSISTENCE_SECONDARY_NAMESPACE.to_string(),
+	let channel_record_store = match channel_record_store_res {
+		Ok(channel_records) => Arc::new(ChannelRecordStore::new(
+			channel_records,
+			CHANNEL_RECORD_PERSISTENCE_PRIMARY_NAMESPACE.to_string(),
+			CHANNEL_RECORD_PERSISTENCE_SECONDARY_NAMESPACE.to_string(),
 			Arc::clone(&kv_store),
 			Arc::clone(&logger),
 		)),
 		Err(e) => {
-			log_error!(logger, "Failed to read pending channel data from store: {}", e);
+			log_error!(logger, "Failed to read channel record data from store: {}", e);
 			return Err(BuildError::ReadFailed);
 		},
 	};
@@ -2113,7 +2113,7 @@ fn build_with_store_internal(
 		peer_store,
 		payment_store,
 		closed_channel_store,
-		pending_channel_store,
+		channel_record_store,
 		lnurl_auth,
 		is_running,
 		node_metrics,

src/channel/mod.rs

@@ -0,0 +1,10 @@
+// This file is Copyright its original authors, visible in version control history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. You may not use this file except in
+// accordance with one or both of these licenses.
+
+//! Per-channel state tracking.
+
+pub(crate) mod store;

src/channel/store.rs

@@ -0,0 +1,130 @@
+// This file is Copyright its original authors, visible in version control history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. You may not use this file except in
+// accordance with one or both of these licenses.
+
+use bitcoin::secp256k1::PublicKey;
+use lightning::impl_writeable_tlv_based_enum;
+use lightning::ln::types::ChannelId;
+
+use crate::data_store::{StorableObject, StorableObjectId, StorableObjectUpdate};
+use crate::hex_utils;
+use crate::types::UserChannelId;
+
+/// Persistent per-channel state tracked by LDK Node, keyed by [`UserChannelId`].
+///
+/// Durably stores channel flags at `ChannelPending` time so they remain accessible when the
+/// channel closes, even after a restart or a [`ReplayEvent`]. The `Funded` variant is designed
+/// to be extended with a `pending_splice` field in a future PR to support splice retry across
+/// restarts and peer disconnects.
+///
+/// [`ReplayEvent`]: lightning::events::ReplayEvent
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum ChannelRecord {
+	/// State for a live channel whose funding transaction exists.
+	Funded {
+		user_channel_id: UserChannelId,
+		/// The node ID of the channel counterparty.
+		counterparty_node_id: PublicKey,
+		/// The channel's ID at the time the `ChannelPending` event fired.
+		channel_id: ChannelId,
+		/// Whether we opened the channel (outbound) or the counterparty did (inbound).
+		is_outbound: bool,
+		/// Whether the channel was publicly announced.
+		is_announced: bool,
+	},
+}
+
+impl_writeable_tlv_based_enum!(ChannelRecord,
+	(0, Funded) => {
+		(0, user_channel_id, required),
+		(2, counterparty_node_id, required),
+		(4, channel_id, required),
+		(6, is_outbound, required),
+		(8, is_announced, required),
+	},
+);
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct ChannelRecordUpdate {
+	pub user_channel_id: UserChannelId,
+}
+
+impl StorableObjectUpdate<ChannelRecord> for ChannelRecordUpdate {
+	fn id(&self) -> UserChannelId {
+		self.user_channel_id
+	}
+}
+
+impl StorableObject for ChannelRecord {
+	type Id = UserChannelId;
+	type Update = ChannelRecordUpdate;
+
+	fn id(&self) -> UserChannelId {
+		match self {
+			ChannelRecord::Funded { user_channel_id, .. } => *user_channel_id,
+		}
+	}
+
+	fn update(&mut self, _update: Self::Update) -> bool {
+		// ChannelRecord fields are immutable once written in this version. Returning false
+		// makes insert_or_update a no-op when the record already exists, ensuring idempotency
+		// on ChannelPending replay.
+		false
+	}
+
+	fn to_update(&self) -> Self::Update {
+		ChannelRecordUpdate { user_channel_id: self.id() }
+	}
+}
+
+impl StorableObjectId for UserChannelId {
+	fn encode_to_hex_str(&self) -> String {
+		hex_utils::to_string(&self.0.to_be_bytes())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use lightning::ln::types::ChannelId;
+	use lightning::util::ser::{Readable, Writeable};
+
+	use super::*;
+
+	fn make_record(is_outbound: bool, is_announced: bool) -> ChannelRecord {
+		let user_channel_id = UserChannelId(42);
+		// A valid compressed public key: prefix 0x02 followed by 32 bytes.
+		let counterparty_node_id = PublicKey::from_slice(&[2u8; 33]).expect("valid pubkey");
+		let channel_id = ChannelId([3u8; 32]);
+		ChannelRecord::Funded {
+			user_channel_id,
+			counterparty_node_id,
+			channel_id,
+			is_outbound,
+			is_announced,
+		}
+	}
+
+	#[test]
+	fn channel_record_roundtrips() {
+		for (is_outbound, is_announced) in
+			[(true, false), (false, true), (true, true), (false, false)]
+		{
+			let record = make_record(is_outbound, is_announced);
+			let encoded = record.encode();
+			let decoded = ChannelRecord::read(&mut &encoded[..]).expect("decode succeeds");
+			assert_eq!(record, decoded);
+			assert_eq!(decoded.id(), UserChannelId(42));
+			assert!(matches!(
+				decoded,
+				ChannelRecord::Funded {
+					is_outbound: dec_out,
+					is_announced: dec_ann,
+					..
+				} if dec_out == is_outbound && dec_ann == is_announced
+			));
+		}
+	}
+}

src/closed_channel.rs

@@ -13,8 +13,7 @@ use lightning::events::ClosureReason;
 use lightning::impl_writeable_tlv_based;
 use lightning::ln::types::ChannelId;
 
-use crate::data_store::{StorableObject, StorableObjectId, StorableObjectUpdate};
-use crate::hex_utils;
+use crate::data_store::{StorableObject, StorableObjectUpdate};
 use crate::types::UserChannelId;
 
 /// Details of a closed channel.
@@ -77,48 +76,6 @@ impl_writeable_tlv_based!(ClosedChannelDetails, {
 	(18, is_announced, required),
 });
 
-/// Channel flags persisted at channel-pending time so they remain accessible when the channel
-/// closes, even after a restart or when `handle_event` returns [`ReplayEvent`].
-///
-/// [`ReplayEvent`]: lightning::events::ReplayEvent
-#[derive(Clone, Debug)]
-pub(crate) struct PendingChannelInfo {
-	pub user_channel_id: UserChannelId,
-	pub is_outbound: bool,
-	pub is_announced: bool,
-}
-
-impl_writeable_tlv_based!(PendingChannelInfo, {
-	(0, user_channel_id, required),
-	(2, is_outbound, required),
-	(4, is_announced, required),
-});
-
-pub(crate) struct PendingChannelInfoUpdate(pub UserChannelId);
-
-impl StorableObjectUpdate<PendingChannelInfo> for PendingChannelInfoUpdate {
-	fn id(&self) -> UserChannelId {
-		self.0
-	}
-}
-
-impl StorableObject for PendingChannelInfo {
-	type Id = UserChannelId;
-	type Update = PendingChannelInfoUpdate;
-
-	fn id(&self) -> UserChannelId {
-		self.user_channel_id
-	}
-
-	fn update(&mut self, _update: Self::Update) -> bool {
-		false
-	}
-
-	fn to_update(&self) -> Self::Update {
-		PendingChannelInfoUpdate(self.user_channel_id)
-	}
-}
-
 pub(crate) struct ClosedChannelDetailsUpdate(pub UserChannelId);
 
 impl StorableObjectUpdate<ClosedChannelDetails> for ClosedChannelDetailsUpdate {
@@ -144,9 +101,3 @@ impl StorableObject for ClosedChannelDetails {
 		ClosedChannelDetailsUpdate(self.user_channel_id)
 	}
 }
-
-impl StorableObjectId for UserChannelId {
-	fn encode_to_hex_str(&self) -> String {
-		hex_utils::to_string(&self.0.to_be_bytes())
-	}
-}

src/event.rs

@@ -34,7 +34,8 @@ use lightning::{impl_writeable_tlv_based, impl_writeable_tlv_based_enum};
 use lightning_liquidity::lsps2::utils::compute_opening_fee;
 use lightning_types::payment::{PaymentHash, PaymentPreimage};
 
-use crate::closed_channel::{ClosedChannelDetails, PendingChannelInfo};
+use crate::channel::store::ChannelRecord;
+use crate::closed_channel::ClosedChannelDetails;
 use crate::config::{may_announce_channel, Config};
 use crate::connection::ConnectionManager;
 use crate::data_store::DataStoreUpdateResult;
@@ -54,8 +55,8 @@ use crate::payment::store::{
 };
 use crate::runtime::Runtime;
 use crate::types::{
-	ClosedChannelStore, CustomTlvRecord, DynStore, KeysManager, OnionMessenger, PaymentStore,
-	PendingChannelStore, Sweeper, Wallet,
+	ChannelRecordStore, ClosedChannelStore, CustomTlvRecord, DynStore, KeysManager, OnionMessenger,
+	PaymentStore, Sweeper, Wallet,
 };
 use crate::{
 	hex_utils, BumpTransactionEventHandler, ChannelManager, Error, Graph, PeerInfo, PeerStore,
@@ -551,7 +552,7 @@ where
 	payment_store: Arc<PaymentStore>,
 	peer_store: Arc<PeerStore<L>>,
 	closed_channel_store: Arc<ClosedChannelStore>,
-	pending_channel_store: Arc<PendingChannelStore>,
+	channel_record_store: Arc<ChannelRecordStore>,
 	// Tracks which user_channel_ids correspond to outbound channels. Populated at startup from
 	// list_channels() and updated on ChannelPending events. Consumed on ChannelClosed events.
 	outbound_channel_ids: Mutex<HashSet<UserChannelId>>,
@@ -579,7 +580,7 @@ where
 		liquidity_source: Option<Arc<LiquiditySource<Arc<Logger>>>>,
 		payment_store: Arc<PaymentStore>, peer_store: Arc<PeerStore<L>>,
 		closed_channel_store: Arc<ClosedChannelStore>,
-		pending_channel_store: Arc<PendingChannelStore>, keys_manager: Arc<KeysManager>,
+		channel_record_store: Arc<ChannelRecordStore>, keys_manager: Arc<KeysManager>,
 		static_invoice_store: Option<StaticInvoiceStore>, onion_messenger: Arc<OnionMessenger>,
 		om_mailbox: Option<Arc<OnionMessageMailbox>>, runtime: Arc<Runtime>, logger: L,
 		config: Arc<Config>,
@@ -612,7 +613,7 @@ where
 			payment_store,
 			peer_store,
 			closed_channel_store,
-			pending_channel_store,
+			channel_record_store,
 			outbound_channel_ids,
 			announced_channel_ids,
 			keys_manager,
@@ -1575,15 +1576,17 @@ where
 							.insert(UserChannelId(user_channel_id));
 					}
 
-					let pending_info = PendingChannelInfo {
+					let record = ChannelRecord::Funded {
 						user_channel_id: UserChannelId(user_channel_id),
+						counterparty_node_id,
+						channel_id,
 						is_outbound: pending_channel.is_outbound,
 						is_announced: pending_channel.is_announced,
 					};
-					if let Err(e) = self.pending_channel_store.insert_or_update(pending_info) {
+					if let Err(e) = self.channel_record_store.insert_or_update(record) {
 						log_error!(
 							self.logger,
-							"Failed to persist pending channel info {}: {}",
+							"Failed to persist channel record for {}: {}",
 							channel_id,
 							e
 						);
@@ -1683,15 +1686,19 @@ where
 					.expect("Lock poisoned")
 					.remove(&user_channel_id);
 
-				// Primary: use the durably-persisted PendingChannelInfo written at
-				// ChannelPending time. Falls back to in-memory sets (populated at startup
-				// or on ChannelPending), then to any already-persisted ClosedChannelDetails
-				// record (for the replay case where insert_or_update already succeeded but
-				// add_event failed and PendingChannelInfo was already cleaned up).
+				// Primary: use the durably-persisted ChannelRecord written at ChannelPending
+				// time. Falls back to in-memory sets (populated at startup or on
+				// ChannelPending), then to any already-persisted ClosedChannelDetails record
+				// (for the replay case where insert_or_update already succeeded but
+				// add_event failed and the ChannelRecord was already cleaned up).
 				let (is_outbound, is_announced) = self
-					.pending_channel_store
+					.channel_record_store
 					.get(&user_channel_id)
-					.map(|info| (info.is_outbound, info.is_announced))
+					.and_then(|record| match record {
+						ChannelRecord::Funded { is_outbound, is_announced, .. } => {
+							Some((is_outbound, is_announced))
+						},
+					})
 					.or_else(|| {
 						self.closed_channel_store
 							.get(&user_channel_id)
@@ -1745,10 +1752,10 @@ where
 
 				match self.event_queue.add_event(event).await {
 					Ok(_) => {
-						if let Err(e) = self.pending_channel_store.remove(&user_channel_id) {
+						if let Err(e) = self.channel_record_store.remove(&user_channel_id) {
 							log_error!(
 								self.logger,
-								"Failed to remove pending channel info for {}: {}",
+								"Failed to remove channel record for {}: {}",
 								channel_id,
 								e
 							);