fixup! Add persistent closed channel history and list_closed_channels()

Replace the in-memory set + `insert_or_update` fallback approach with a
fully durable solution for tracking `is_outbound`/`is_announced` flags.

The previous approach stored these flags in ephemeral `HashSet`s that were
seeded from `list_channels()` at startup and consumed on `ChannelClosed`.
A fallback to any existing `ClosedChannelDetails` record was added to
handle `ReplayEvent`, but a gap remained: if `insert_or_update` failed
(returning `ReplayEvent`) and the node restarted before the retry, the
in-memory sets would be empty (closed channels don't appear in
`list_channels()`) and no persisted record would exist yet, causing both
flags to silently default to `falsee`.

Fix this by persisting a `PendingChannelInfo` record (containing
`is_outbound` and `is_announced`) to the KV store at `ChannelPending`
time under a new `pending_channels/` namespace. The `ChannelClosed`
handler now resolves the flags with the following priority:

  1. `pending_channel_store` — durable, survives restarts and replays
  2. In-memory sets — covers channels opened before this version
  3. Existing `ClosedChannelDetails` record — idempotency guard

The `PendingChannelInfo` record is deleted after `event_queue.add_event`
succeeds. It is intentionally kept alive until that point so that any
replay of `ChannelClosed` (e.g. due to a failed `insert_or_update` or
`add_event`) still finds the correct flags in the store.

Author: f3r10

src/builder.rs

@@ -67,6 +67,8 @@ use crate::io::{
 	self, 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,7 +85,7 @@ use crate::tx_broadcaster::TransactionBroadcaster;
 use crate::types::{
 	AsyncPersister, ChainMonitor, ChannelManager, ClosedChannelStore, DynStore, DynStoreRef,
 	DynStoreWrapper, GossipSync, Graph, HRNResolver, KeysManager, MessageRouter, OnionMessenger,
-	PaymentStore, PeerManager, PendingPaymentStore, SyncAndAsyncKVStore,
+	PaymentStore, PeerManager, PendingChannelStore, PendingPaymentStore, SyncAndAsyncKVStore,
 };
 use crate::wallet::persist::KVStoreWalletPersister;
 use crate::wallet::Wallet;
@@ -1290,30 +1292,41 @@ fn build_with_store_internal(
 
 	let kv_store_ref = Arc::clone(&kv_store);
 	let logger_ref = Arc::clone(&logger);
-	let (payment_store_res, node_metris_res, pending_payment_store_res, closed_channel_store_res) =
-		runtime.block_on(async move {
-			tokio::join!(
-				read_all_objects(
-					&*kv_store_ref,
-					PAYMENT_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
-					PAYMENT_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
-					Arc::clone(&logger_ref),
-				),
-				read_node_metrics(&*kv_store_ref, Arc::clone(&logger_ref)),
-				read_all_objects(
-					&*kv_store_ref,
-					PENDING_PAYMENT_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
-					PENDING_PAYMENT_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
-					Arc::clone(&logger_ref),
-				),
-				read_all_objects(
-					&*kv_store_ref,
-					CLOSED_CHANNEL_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
-					CLOSED_CHANNEL_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
-					Arc::clone(&logger_ref),
-				)
-			)
-		});
+	let (
+		payment_store_res,
+		node_metris_res,
+		pending_payment_store_res,
+		closed_channel_store_res,
+		pending_channel_store_res,
+	) = runtime.block_on(async move {
+		tokio::join!(
+			read_all_objects(
+				&*kv_store_ref,
+				PAYMENT_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
+				PAYMENT_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
+				Arc::clone(&logger_ref),
+			),
+			read_node_metrics(&*kv_store_ref, Arc::clone(&logger_ref)),
+			read_all_objects(
+				&*kv_store_ref,
+				PENDING_PAYMENT_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
+				PENDING_PAYMENT_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
+				Arc::clone(&logger_ref),
+			),
+			read_all_objects(
+				&*kv_store_ref,
+				CLOSED_CHANNEL_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
+				CLOSED_CHANNEL_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
+				Arc::clone(&logger_ref),
+			),
+			read_all_objects(
+				&*kv_store_ref,
+				PENDING_CHANNEL_INFO_PERSISTENCE_PRIMARY_NAMESPACE,
+				PENDING_CHANNEL_INFO_PERSISTENCE_SECONDARY_NAMESPACE,
+				Arc::clone(&logger_ref),
+			),
+		)
+	});
 
 	// Initialize the status fields.
 	let node_metrics = match node_metris_res {
@@ -1528,6 +1541,20 @@ 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(),
+			Arc::clone(&kv_store),
+			Arc::clone(&logger),
+		)),
+		Err(e) => {
+			log_error!(logger, "Failed to read pending channel data from store: {}", e);
+			return Err(BuildError::ReadFailed);
+		},
+	};
+
 	let wallet = Arc::new(Wallet::new(
 		bdk_wallet,
 		wallet_persister,
@@ -2086,6 +2113,7 @@ fn build_with_store_internal(
 		peer_store,
 		payment_store,
 		closed_channel_store,
+		pending_channel_store,
 		lnurl_auth,
 		is_running,
 		node_metrics,

src/closed_channel.rs

@@ -77,6 +77,48 @@ 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 {

src/event.rs

@@ -34,7 +34,7 @@ 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;
+use crate::closed_channel::{ClosedChannelDetails, PendingChannelInfo};
 use crate::config::{may_announce_channel, Config};
 use crate::connection::ConnectionManager;
 use crate::data_store::DataStoreUpdateResult;
@@ -55,7 +55,7 @@ use crate::payment::store::{
 use crate::runtime::Runtime;
 use crate::types::{
 	ClosedChannelStore, CustomTlvRecord, DynStore, KeysManager, OnionMessenger, PaymentStore,
-	Sweeper, Wallet,
+	PendingChannelStore, Sweeper, Wallet,
 };
 use crate::{
 	hex_utils, BumpTransactionEventHandler, ChannelManager, Error, Graph, PeerInfo, PeerStore,
@@ -551,6 +551,7 @@ where
 	payment_store: Arc<PaymentStore>,
 	peer_store: Arc<PeerStore<L>>,
 	closed_channel_store: Arc<ClosedChannelStore>,
+	pending_channel_store: Arc<PendingChannelStore>,
 	// 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>>,
@@ -577,7 +578,8 @@ where
 		output_sweeper: Arc<Sweeper>, network_graph: Arc<Graph>,
 		liquidity_source: Option<Arc<LiquiditySource<Arc<Logger>>>>,
 		payment_store: Arc<PaymentStore>, peer_store: Arc<PeerStore<L>>,
-		closed_channel_store: Arc<ClosedChannelStore>, keys_manager: Arc<KeysManager>,
+		closed_channel_store: Arc<ClosedChannelStore>,
+		pending_channel_store: Arc<PendingChannelStore>, 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>,
@@ -610,6 +612,7 @@ where
 			payment_store,
 			peer_store,
 			closed_channel_store,
+			pending_channel_store,
 			outbound_channel_ids,
 			announced_channel_ids,
 			keys_manager,
@@ -1362,12 +1365,23 @@ where
 						);
 					}
 				}
+				// For LSPS2 JIT channels (channel_override_config is Some iff the counterparty
+				// is our configured LSP), accept with ZeroConfZeroReserve so the LSP is not
+				// forced to keep 1000 sats locked as reserve. Without this, the hard
+				// MIN_THEIR_CHAN_RESERVE_SATOSHIS = 1000 floor in LDK reduces the usable
+				// outbound capacity enough that the initial HTLC forward fails on small channels.
+				let is_lsps2_channel = channel_override_config.is_some();
 				let res = if allow_0conf {
+					let trusted_features = if is_lsps2_channel {
+						TrustedChannelFeatures::ZeroConfZeroReserve
+					} else {
+						TrustedChannelFeatures::ZeroConf
+					};
 					self.channel_manager.accept_inbound_channel_from_trusted_peer(
 						&temporary_channel_id,
 						&counterparty_node_id,
 						user_channel_id,
-						TrustedChannelFeatures::ZeroConf,
+						trusted_features,
 						channel_override_config,
 					)
 				} else {
@@ -1561,6 +1575,21 @@ where
 							.insert(UserChannelId(user_channel_id));
 					}
 
+					let pending_info = PendingChannelInfo {
+						user_channel_id: UserChannelId(user_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) {
+						log_error!(
+							self.logger,
+							"Failed to persist pending channel info {}: {}",
+							channel_id,
+							e
+						);
+						return Err(ReplayEvent());
+					}
+
 					if !pending_channel.is_outbound
 						&& self.peer_store.get_peer(&counterparty_node_id).is_none()
 					{
@@ -1654,14 +1683,20 @@ where
 					.expect("Lock poisoned")
 					.remove(&user_channel_id);
 
-				// On replay (after a restart or after handle_event returns ReplayEvent),
-				// the channel is no longer in list_channels() and the in-memory sets are
-				// not repopulated for it, so .remove() returns false. Fall back to any
-				// already-persisted record so we don't overwrite correct values with false.
+				// 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).
 				let (is_outbound, is_announced) = self
-					.closed_channel_store
+					.pending_channel_store
 					.get(&user_channel_id)
-					.map(|existing| (existing.is_outbound, existing.is_announced))
+					.map(|info| (info.is_outbound, info.is_announced))
+					.or_else(|| {
+						self.closed_channel_store
+							.get(&user_channel_id)
+							.map(|existing| (existing.is_outbound, existing.is_announced))
+					})
 					.unwrap_or((is_outbound_from_set, is_announced_from_set));
 
 				let closed_at = SystemTime::now()
@@ -1709,7 +1744,16 @@ where
 				};
 
 				match self.event_queue.add_event(event).await {
-					Ok(_) => {},
+					Ok(_) => {
+						if let Err(e) = self.pending_channel_store.remove(&user_channel_id) {
+							log_error!(
+								self.logger,
+								"Failed to remove pending channel info for {}: {}",
+								channel_id,
+								e
+							);
+						}
+					},
 					Err(e) => {
 						log_error!(self.logger, "Failed to push to event queue: {}", e);
 						return Err(ReplayEvent());

src/io/mod.rs

@@ -31,6 +31,10 @@ pub(crate) const PAYMENT_INFO_PERSISTENCE_SECONDARY_NAMESPACE: &str = "";
 pub(crate) const CLOSED_CHANNEL_INFO_PERSISTENCE_PRIMARY_NAMESPACE: &str = "closed_channels";
 pub(crate) const CLOSED_CHANNEL_INFO_PERSISTENCE_SECONDARY_NAMESPACE: &str = "";
 
+/// The pending channel information will be persisted under this prefix.
+pub(crate) const PENDING_CHANNEL_INFO_PERSISTENCE_PRIMARY_NAMESPACE: &str = "pending_channels";
+pub(crate) const PENDING_CHANNEL_INFO_PERSISTENCE_SECONDARY_NAMESPACE: &str = "";
+
 /// The node metrics will be persisted under this key.
 pub(crate) const NODE_METRICS_PRIMARY_NAMESPACE: &str = "";
 pub(crate) const NODE_METRICS_SECONDARY_NAMESPACE: &str = "";

src/lib.rs

@@ -176,8 +176,8 @@ use runtime::Runtime;
 pub use tokio;
 use types::{
 	Broadcaster, BumpTransactionEventHandler, ChainMonitor, ChannelManager, ClosedChannelStore,
-	DynStore, Graph, HRNResolver, KeysManager, OnionMessenger, PaymentStore, PeerManager, Router,
-	Scorer, Sweeper, Wallet,
+	DynStore, Graph, HRNResolver, KeysManager, OnionMessenger, PaymentStore, PeerManager,
+	PendingChannelStore, Router, Scorer, Sweeper, Wallet,
 };
 pub use types::{ChannelDetails, CustomTlvRecord, PeerDetails, SyncAndAsyncKVStore, UserChannelId};
 pub use vss_client;
@@ -236,6 +236,7 @@ pub struct Node {
 	peer_store: Arc<PeerStore<Arc<Logger>>>,
 	payment_store: Arc<PaymentStore>,
 	closed_channel_store: Arc<ClosedChannelStore>,
+	pending_channel_store: Arc<PendingChannelStore>,
 	lnurl_auth: Arc<LnurlAuth>,
 	is_running: Arc<RwLock<bool>>,
 	node_metrics: Arc<RwLock<NodeMetrics>>,
@@ -596,6 +597,7 @@ impl Node {
 			Arc::clone(&self.payment_store),
 			Arc::clone(&self.peer_store),
 			Arc::clone(&self.closed_channel_store),
+			Arc::clone(&self.pending_channel_store),
 			Arc::clone(&self.keys_manager),
 			static_invoice_store,
 			Arc::clone(&self.onion_messenger),

src/types.rs

@@ -38,7 +38,7 @@ use lightning_net_tokio::SocketDescriptor;
 
 use crate::chain::bitcoind::UtxoSourceClient;
 use crate::chain::ChainSource;
-use crate::closed_channel::ClosedChannelDetails;
+use crate::closed_channel::{ClosedChannelDetails, PendingChannelInfo};
 use crate::config::ChannelConfig;
 use crate::data_store::DataStore;
 use crate::fee_estimator::OnchainFeeEstimator;
@@ -705,3 +705,5 @@ impl From<&(u64, Vec<u8>)> for CustomTlvRecord {
 pub(crate) type PendingPaymentStore = DataStore<PendingPaymentDetails, Arc<Logger>>;
 
 pub(crate) type ClosedChannelStore = DataStore<ClosedChannelDetails, Arc<Logger>>;
+
+pub(crate) type PendingChannelStore = DataStore<PendingChannelInfo, Arc<Logger>>;