Add ReserveType to ChannelDetails

We expose the reserve type of each channel through
a new ReserveType enum on ChannelDetails. This tells
users whether a channel uses adaptive anchor reserves,
has no reserve due to a trusted peer, or is a legacy
pre-anchor channel.

The reserve type is derived at query time in list_channels
by checking the channel's type features against
trusted_peers_no_reserve.

We replace the From<LdkChannelDetails> implementation with
an explicit from_ldk method that takes the anchor channels
config.

Additionally, we document the rationale behind selecting
adaptive reserve type in the unlikely event the anchor
channels config was previously set and then later removed.

Author: enigbe

src/lib.rs

@@ -180,7 +180,9 @@ use types::{
 	HRNResolver, KeysManager, OnionMessenger, PaymentStore, PeerManager, Router, Scorer, Sweeper,
 	Wallet,
 };
-pub use types::{ChannelDetails, CustomTlvRecord, PeerDetails, SyncAndAsyncKVStore, UserChannelId};
+pub use types::{
+	ChannelDetails, CustomTlvRecord, PeerDetails, ReserveType, SyncAndAsyncKVStore, UserChannelId,
+};
 pub use vss_client;
 
 use crate::scoring::setup_background_pathfinding_scores_sync;
@@ -1093,7 +1095,11 @@ impl Node {
 
 	/// Retrieve a list of known channels.
 	pub fn list_channels(&self) -> Vec<ChannelDetails> {
-		self.channel_manager.list_channels().into_iter().map(|c| c.into()).collect()
+		self.channel_manager
+			.list_channels()
+			.into_iter()
+			.map(|c| ChannelDetails::from_ldk(c, self.config.anchor_channels_config.as_ref()))
+			.collect()
 	}
 
 	/// Connect to a node on the peer-to-peer network.

src/types.rs

@@ -40,7 +40,7 @@ use lightning_net_tokio::SocketDescriptor;
 
 use crate::chain::bitcoind::UtxoSourceClient;
 use crate::chain::ChainSource;
-use crate::config::ChannelConfig;
+use crate::config::{AnchorChannelsConfig, ChannelConfig};
 use crate::data_store::DataStore;
 use crate::fee_estimator::OnchainFeeEstimator;
 use crate::ffi::maybe_wrap;
@@ -451,6 +451,47 @@ pub struct ChannelCounterparty {
 	pub outbound_htlc_maximum_msat: Option<u64>,
 }
 
+/// Describes the reserve behavior of a channel based on its type and trust configuration.
+///
+/// This captures the combination of the channel's on-chain construction (anchor outputs vs legacy
+/// static_remote_key) and whether the counterparty is in our trusted peers list. It tells the
+/// user what reserve obligations exist for this channel without exposing internal protocol details.
+///
+/// See [`AnchorChannelsConfig`] for how reserve behavior is configured.
+///
+/// [`AnchorChannelsConfig`]: crate::config::AnchorChannelsConfig
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
+pub enum ReserveType {
+	/// An anchor outputs channel where we maintain a per-channel on-chain reserve for fee
+	/// bumping force-close transactions.
+	///
+	/// Anchor channels allow either party to fee-bump commitment transactions via CPFP
+	/// at broadcast time. Because the pre-signed commitment fee may be insufficient under
+	/// current fee conditions, the broadcaster must supply additional funds (hence adaptive)
+	/// through an anchor output spend. The reserve ensures sufficient on-chain funds are
+	/// available to cover this.
+	///
+	/// This is the default for anchor channels when the counterparty is not in
+	/// [`trusted_peers_no_reserve`].
+	///
+	/// [`trusted_peers_no_reserve`]: crate::config::AnchorChannelsConfig::trusted_peers_no_reserve
+	Adaptive,
+	/// An anchor outputs channel where we do not maintain any reserve, because the counterparty
+	/// is in our [`trusted_peers_no_reserve`] list.
+	///
+	/// In this mode, we trust the counterparty to broadcast a valid commitment transaction on
+	/// our behalf and do not set aside funds for fee bumping.
+	///
+	/// [`trusted_peers_no_reserve`]: crate::config::AnchorChannelsConfig::trusted_peers_no_reserve
+	TrustedPeersNoReserve,
+	/// A legacy (pre-anchor) channel using only `option_static_remotekey`.
+	///
+	/// These channels do not use anchor outputs and therefore do not require an on-chain reserve
+	/// for fee bumping. Commitment transaction fees are pre-committed at channel open time.
+	Legacy,
+}
+
 /// Details of a channel as returned by [`Node::list_channels`].
 ///
 /// When a channel is spliced, most fields continue to refer to the original pre-splice channel
@@ -615,10 +656,39 @@ pub struct ChannelDetails {
 	///
 	/// Will be `None` for objects serialized with LDK Node v0.1 and earlier.
 	pub channel_shutdown_state: Option<ChannelShutdownState>,
+	/// The type of on-chain reserve maintained for this channel.
+	///
+	/// See [`ReserveType`] for details on how reserves differ between anchor and legacy channels.
+	pub reserve_type: ReserveType,
 }
 
-impl From<LdkChannelDetails> for ChannelDetails {
-	fn from(value: LdkChannelDetails) -> Self {
+impl ChannelDetails {
+	pub(crate) fn from_ldk(
+		value: LdkChannelDetails, anchor_channels_config: Option<&AnchorChannelsConfig>,
+	) -> Self {
+		let reserve_type =
+			if value.channel_type.as_ref().is_some_and(|ct| ct.supports_anchors_zero_fee_htlc_tx())
+			{
+				if let Some(config) = anchor_channels_config {
+					if config.trusted_peers_no_reserve.contains(&value.counterparty.node_id) {
+						ReserveType::TrustedPeersNoReserve
+					} else {
+						ReserveType::Adaptive
+					}
+				} else {
+					// Edge case: if `AnchorChannelsConfig` was previously set and later
+					// removed, we can no longer distinguish whether this anchor channel's
+					// reserve was `Adaptive` or `TrustedPeersNoReserve`. We default to
+					// `Adaptive` here, which may incorrectly override a prior
+					// `TrustedPeersNoReserve` designation. This is acceptable since
+					// unsetting `AnchorChannelsConfig` on a node with existing anchor
+					// channels is not an expected operation.
+					ReserveType::Adaptive
+				}
+			} else {
+				ReserveType::Legacy
+			};
+
 		ChannelDetails {
 			channel_id: value.channel_id,
 			counterparty: ChannelCounterparty {
@@ -666,6 +736,7 @@ impl From<LdkChannelDetails> for ChannelDetails {
 				.map(|c| c.into())
 				.expect("value is set for objects serialized with LDK v0.0.109+"),
 			channel_shutdown_state: value.channel_shutdown_state,
+			reserve_type,
 		}
 	}
 }