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,
 };
@@ -81,7 +83,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,
+	PaymentStore, PeerManager, PendingChannelStore, PendingPaymentStore,
 };
 use crate::wallet::persist::KVStoreWalletPersister;
 use crate::wallet::Wallet;
@@ -1381,30 +1383,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 {
@@ -1627,6 +1640,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,
@@ -2172,6 +2199,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;
@@ -56,7 +56,7 @@ use crate::payment::PaymentMetadata;
 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,9 +578,10 @@ where
 		output_sweeper: Arc<Sweeper>, network_graph: Arc<Graph>,
 		liquidity_source: Arc<LiquiditySource<Arc<Logger>>>, payment_store: Arc<PaymentStore>,
 		peer_store: Arc<PeerStore<L>>, closed_channel_store: Arc<ClosedChannelStore>,
-		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>,
+		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>,
 	) -> Self {
 		// Seed outbound_channel_ids and announced_channel_ids from currently open channels so we
 		// correctly classify channels that were already open when this node started.
@@ -609,6 +611,7 @@ where
 			payment_store,
 			peer_store,
 			closed_channel_store,
+			pending_channel_store,
 			outbound_channel_ids,
 			announced_channel_ids,
 			keys_manager,
@@ -1386,12 +1389,23 @@ where
 						100
 					);
 				}
+				// 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 {
@@ -1567,13 +1581,13 @@ where
 					},
 				};
 
-				let peer_to_store = {
+				let (pending_info_opt, peer_to_store) = {
 					let network_graph = self.network_graph.read_only();
 					let channels =
 						self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
 					let pending_channel = channels.into_iter().find(|c| c.channel_id == channel_id);
 
-					if let Some(ref ch) = pending_channel {
+					let pending_info_opt = if let Some(ref ch) = pending_channel {
 						if ch.is_outbound {
 							self.outbound_channel_ids
 								.lock()
@@ -1586,9 +1600,16 @@ where
 								.expect("Lock poisoned")
 								.insert(UserChannelId(user_channel_id));
 						}
-					}
+						Some(PendingChannelInfo {
+							user_channel_id: UserChannelId(user_channel_id),
+							is_outbound: ch.is_outbound,
+							is_announced: ch.is_announced,
+						})
+					} else {
+						None
+					};
 
-					pending_channel
+					let peer_to_store = pending_channel
 						.filter(|ch| {
 							!ch.is_outbound
 								&& self.peer_store.get_peer(&counterparty_node_id).is_none()
@@ -1603,8 +1624,23 @@ where
 									node_id: counterparty_node_id,
 									address: address.clone(),
 								})
-						})
-				};
+						});
+
+					(pending_info_opt, peer_to_store)
+				}; // network_graph is dropped here, before any await
+
+				if let Some(pending_info) = pending_info_opt {
+					if let Err(e) = self.pending_channel_store.insert_or_update(pending_info).await
+					{
+						log_error!(
+							self.logger,
+							"Failed to persist pending channel info {}: {}",
+							channel_id,
+							e
+						);
+						return Err(ReplayEvent());
+					}
+				}
 				if let Some(peer) = peer_to_store {
 					self.peer_store.add_peer(peer).await.unwrap_or_else(|e| {
 						log_error!(
@@ -1682,14 +1718,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()
@@ -1737,7 +1779,16 @@ where
 				};
 
 				match self.event_queue.add_event(event).await {
-					Ok(_) => {},
+					Ok(_) => {
+						if let Err(e) = self.pending_channel_store.remove(&user_channel_id).await {
+							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

@@ -33,6 +33,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

@@ -178,8 +178,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, UserChannelId};
 pub use vss_client;
@@ -245,6 +245,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<PersistedNodeMetrics>,
@@ -608,6 +609,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;
@@ -631,3 +631,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>>;