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

@@ -5,16 +5,13 @@
 // 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 std::time::{Duration, SystemTime, UNIX_EPOCH};
-
 use bitcoin::secp256k1::PublicKey;
 use bitcoin::OutPoint;
 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.
@@ -30,10 +27,7 @@ pub struct ClosedChannelDetails {
 	/// The local identifier of the channel.
 	pub user_channel_id: UserChannelId,
 	/// The node ID of the channel's counterparty.
-	///
-	/// Will be `None` if the channel was closed before the counterparty's node ID could be
-	/// determined (e.g., very early in the channel negotiation process).
-	pub counterparty_node_id: Option<PublicKey>,
+	pub counterparty_node_id: PublicKey,
 	/// The channel's funding transaction outpoint.
 	///
 	/// Will be `None` if the channel was closed before a funding transaction was established.
@@ -67,58 +61,16 @@ pub struct ClosedChannelDetails {
 impl_writeable_tlv_based!(ClosedChannelDetails, {
 	(0, channel_id, required),
 	(2, user_channel_id, required),
-	(4, counterparty_node_id, option),
+	(4, counterparty_node_id, required),
 	(6, funding_txo, option),
 	(8, channel_capacity_sats, option),
 	(10, last_local_balance_msat, option),
 	(12, is_outbound, required),
 	(14, closure_reason, upgradable_option),
-	(16, closed_at, (default_value, SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or(Duration::from_secs(0)).as_secs())),
+	(16, closed_at, required),
 	(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 +96,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())
-	}
-}