Expose ChannelCounterparty and ReserveType in ChannelDetails

src/lib.rs

@@ -177,7 +177,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;
@@ -1069,7 +1071,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

@@ -16,13 +16,15 @@ use bitcoin_payment_instructions::onion_message_resolver::LDKOnionMessageDNSSECH
 use lightning::chain::chainmonitor;
 use lightning::impl_writeable_tlv_based;
 use lightning::ln::channel_state::ChannelDetails as LdkChannelDetails;
+pub use lightning::ln::channel_state::CounterpartyForwardingInfo;
 use lightning::ln::msgs::{RoutingMessageHandler, SocketAddress};
 use lightning::ln::peer_handler::IgnoringMessageHandler;
 use lightning::ln::types::ChannelId;
 use lightning::routing::gossip;
 use lightning::routing::router::DefaultRouter;
 use lightning::routing::scoring::{CombinedScorer, ProbabilisticScoringFeeParameters};
 use lightning::sign::InMemorySigner;
+use lightning::types::features::InitFeatures;
 use lightning::util::persist::{
 	KVStore, KVStoreSync, MonitorUpdatingPersister, MonitorUpdatingPersisterAsync,
 };
@@ -34,7 +36,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::logger::Logger;
@@ -347,6 +349,97 @@ impl fmt::Display for UserChannelId {
 	}
 }
 
+/// Information needed for constructing an invoice route hint for this channel.
+#[cfg(feature = "uniffi")]
+#[uniffi::remote(Record)]
+pub struct CounterpartyForwardingInfo {
+	/// Base routing fee in millisatoshis.
+	pub fee_base_msat: u32,
+	/// Amount in millionths of a satoshi the channel will charge per transferred satoshi.
+	pub fee_proportional_millionths: u32,
+	/// The minimum difference in cltv_expiry between an ingoing HTLC and its outgoing counterpart,
+	/// such that the outgoing HTLC is forwardable to this counterparty.
+	pub cltv_expiry_delta: u16,
+}
+
+#[cfg(feature = "uniffi")]
+uniffi::custom_type!(InitFeatures, Vec<u8>, {
+	remote,
+	try_lift: |val| Ok(InitFeatures::from_le_bytes(val)),
+	lower: |obj| obj.le_flags().to_vec(),
+});
+
+/// Channel parameters which apply to our counterparty. These are split out from [`ChannelDetails`]
+/// to better separate parameters.
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
+pub struct ChannelCounterparty {
+	/// The node_id of our counterparty
+	pub node_id: PublicKey,
+	/// The Features the channel counterparty provided upon last connection.
+	/// Useful for routing as it is the most up-to-date copy of the counterparty's features and
+	/// many routing-relevant features are present in the init context.
+	pub features: InitFeatures,
+	/// The value, in satoshis, that must always be held in the channel for our counterparty. This
+	/// value ensures that if our counterparty broadcasts a revoked state, we can punish them by
+	/// claiming at least this value on chain.
+	///
+	/// This value is not included in [`inbound_capacity_msat`] as it can never be spent.
+	///
+	/// [`inbound_capacity_msat`]: ChannelDetails::inbound_capacity_msat
+	pub unspendable_punishment_reserve: u64,
+	/// Information on the fees and requirements that the counterparty requires when forwarding
+	/// payments to us through this channel.
+	pub forwarding_info: Option<CounterpartyForwardingInfo>,
+	/// The smallest value HTLC (in msat) the remote peer will accept, for this channel. This field
+	/// is only `None` before we have received either the `OpenChannel` or `AcceptChannel` message
+	/// from the remote peer, or for `ChannelCounterparty` objects serialized prior to LDK 0.0.107.
+	pub outbound_htlc_minimum_msat: Option<u64>,
+	/// The largest value HTLC (in msat) the remote peer currently will accept, for this channel.
+	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
@@ -363,8 +456,8 @@ pub struct ChannelDetails {
 	/// Note that this means this value is *not* persistent - it can change once during the
 	/// lifetime of the channel.
 	pub channel_id: ChannelId,
-	/// The node ID of our the channel's counterparty.
-	pub counterparty_node_id: PublicKey,
+	/// Parameters which apply to our counterparty. See individual fields for more information.
+	pub counterparty: ChannelCounterparty,
 	/// The channel's funding transaction output, if we've negotiated the funding transaction with
 	/// our counterparty already.
 	///
@@ -480,28 +573,6 @@ pub struct ChannelDetails {
 	/// The difference in the CLTV value between incoming HTLCs and an outbound HTLC forwarded over
 	/// the channel.
 	pub cltv_expiry_delta: Option<u16>,
-	/// The value, in satoshis, that must always be held in the channel for our counterparty. This
-	/// value ensures that if our counterparty broadcasts a revoked state, we can punish them by
-	/// claiming at least this value on chain.
-	///
-	/// This value is not included in [`inbound_capacity_msat`] as it can never be spent.
-	///
-	/// [`inbound_capacity_msat`]: ChannelDetails::inbound_capacity_msat
-	pub counterparty_unspendable_punishment_reserve: u64,
-	/// The smallest value HTLC (in msat) the remote peer will accept, for this channel.
-	///
-	/// This field is only `None` before we have received either the `OpenChannel` or
-	/// `AcceptChannel` message from the remote peer.
-	pub counterparty_outbound_htlc_minimum_msat: Option<u64>,
-	/// The largest value HTLC (in msat) the remote peer currently will accept, for this channel.
-	pub counterparty_outbound_htlc_maximum_msat: Option<u64>,
-	/// Base routing fee in millisatoshis.
-	pub counterparty_forwarding_info_fee_base_msat: Option<u32>,
-	/// Proportional fee, in millionths of a satoshi the channel will charge per transferred satoshi.
-	pub counterparty_forwarding_info_fee_proportional_millionths: Option<u32>,
-	/// The minimum difference in CLTV expiry between an ingoing HTLC and its outgoing counterpart,
-	/// such that the outgoing HTLC is forwardable to this counterparty.
-	pub counterparty_forwarding_info_cltv_expiry_delta: Option<u16>,
 	/// The available outbound capacity for sending a single HTLC to the remote peer. This is
 	/// similar to [`ChannelDetails::outbound_capacity_msat`] but it may be further restricted by
 	/// the current state and per-HTLC limit(s). This is intended for use when routing, allowing us
@@ -529,13 +600,42 @@ pub struct ChannelDetails {
 	pub inbound_htlc_maximum_msat: Option<u64>,
 	/// Set of configurable parameters that affect channel operation.
 	pub config: ChannelConfig,
+	/// 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 is_anchor_channel =
+			value.channel_type.as_ref().map_or(false, |ct| ct.supports_anchors_zero_fee_htlc_tx());
+
+		let reserve_type = if is_anchor_channel {
+			let is_trusted = anchor_channels_config.map_or(false, |c| {
+				c.trusted_peers_no_reserve.contains(&value.counterparty.node_id)
+			});
+			if is_trusted {
+				ReserveType::TrustedPeersNoReserve
+			} else {
+				ReserveType::Adaptive
+			}
+		} else {
+			ReserveType::Legacy
+		};
+
 		ChannelDetails {
 			channel_id: value.channel_id,
-			counterparty_node_id: value.counterparty.node_id,
+			counterparty: ChannelCounterparty {
+				node_id: value.counterparty.node_id,
+				features: value.counterparty.features,
+				unspendable_punishment_reserve: value.counterparty.unspendable_punishment_reserve,
+				forwarding_info: value.counterparty.forwarding_info,
+				outbound_htlc_minimum_msat: value.counterparty.outbound_htlc_minimum_msat,
+				outbound_htlc_maximum_msat: value.counterparty.outbound_htlc_maximum_msat,
+			},
 			funding_txo: value.funding_txo.map(|o| o.into_bitcoin_outpoint()),
 			funding_redeem_script: value.funding_redeem_script,
 			short_channel_id: value.short_channel_id,
@@ -556,26 +656,6 @@ impl From<LdkChannelDetails> for ChannelDetails {
 			is_usable: value.is_usable,
 			is_announced: value.is_announced,
 			cltv_expiry_delta: value.config.map(|c| c.cltv_expiry_delta),
-			counterparty_unspendable_punishment_reserve: value
-				.counterparty
-				.unspendable_punishment_reserve,
-			counterparty_outbound_htlc_minimum_msat: value.counterparty.outbound_htlc_minimum_msat,
-			counterparty_outbound_htlc_maximum_msat: value.counterparty.outbound_htlc_maximum_msat,
-			counterparty_forwarding_info_fee_base_msat: value
-				.counterparty
-				.forwarding_info
-				.as_ref()
-				.map(|f| f.fee_base_msat),
-			counterparty_forwarding_info_fee_proportional_millionths: value
-				.counterparty
-				.forwarding_info
-				.as_ref()
-				.map(|f| f.fee_proportional_millionths),
-			counterparty_forwarding_info_cltv_expiry_delta: value
-				.counterparty
-				.forwarding_info
-				.as_ref()
-				.map(|f| f.cltv_expiry_delta),
 			next_outbound_htlc_limit_msat: value.next_outbound_htlc_limit_msat,
 			next_outbound_htlc_minimum_msat: value.next_outbound_htlc_minimum_msat,
 			force_close_spend_delay: value.force_close_spend_delay,
@@ -584,6 +664,7 @@ impl From<LdkChannelDetails> for ChannelDetails {
 			inbound_htlc_maximum_msat: value.inbound_htlc_maximum_msat,
 			// unwrap safety: `config` is only `None` for LDK objects serialized prior to 0.0.109.
 			config: value.config.map(|c| c.into()).unwrap(),
+			reserve_type,
 		}
 	}
 }

tests/integration_tests_rust.rs

@@ -2112,7 +2112,7 @@ async fn lsps2_client_trusts_lsp() {
 		client_node
 			.list_channels()
 			.iter()
-			.find(|c| c.counterparty_node_id == service_node_id)
+			.find(|c| c.counterparty.node_id == service_node_id)
 			.unwrap()
 			.confirmations,
 		Some(0)
@@ -2121,7 +2121,7 @@ async fn lsps2_client_trusts_lsp() {
 		service_node
 			.list_channels()
 			.iter()
-			.find(|c| c.counterparty_node_id == client_node_id)
+			.find(|c| c.counterparty.node_id == client_node_id)
 			.unwrap()
 			.confirmations,
 		Some(0)
@@ -2156,7 +2156,7 @@ async fn lsps2_client_trusts_lsp() {
 		client_node
 			.list_channels()
 			.iter()
-			.find(|c| c.counterparty_node_id == service_node_id)
+			.find(|c| c.counterparty.node_id == service_node_id)
 			.unwrap()
 			.confirmations,
 		Some(6)
@@ -2165,7 +2165,7 @@ async fn lsps2_client_trusts_lsp() {
 		service_node
 			.list_channels()
 			.iter()
-			.find(|c| c.counterparty_node_id == client_node_id)
+			.find(|c| c.counterparty.node_id == client_node_id)
 			.unwrap()
 			.confirmations,
 		Some(6)
@@ -2284,7 +2284,7 @@ async fn lsps2_lsp_trusts_client_but_client_does_not_claim() {
 		client_node
 			.list_channels()
 			.iter()
-			.find(|c| c.counterparty_node_id == service_node_id)
+			.find(|c| c.counterparty.node_id == service_node_id)
 			.unwrap()
 			.confirmations,
 		Some(6)
@@ -2293,7 +2293,7 @@ async fn lsps2_lsp_trusts_client_but_client_does_not_claim() {
 		service_node
 			.list_channels()
 			.iter()
-			.find(|c| c.counterparty_node_id == client_node_id)
+			.find(|c| c.counterparty.node_id == client_node_id)
 			.unwrap()
 			.confirmations,
 		Some(6)
@@ -2670,7 +2670,7 @@ async fn open_channel_with_all_with_anchors() {
 	assert_eq!(channels.len(), 1);
 	let channel = &channels[0];
 	assert!(channel.channel_value_sats > premine_amount_sat - anchor_reserve_sat - 500);
-	assert_eq!(channel.counterparty_node_id, node_b.node_id());
+	assert_eq!(channel.counterparty.node_id, node_b.node_id());
 	assert_eq!(channel.funding_txo.unwrap(), funding_txo);
 
 	node_a.stop().unwrap();
@@ -2721,7 +2721,7 @@ async fn open_channel_with_all_without_anchors() {
 	assert_eq!(channels.len(), 1);
 	let channel = &channels[0];
 	assert!(channel.channel_value_sats > premine_amount_sat - 500);
-	assert_eq!(channel.counterparty_node_id, node_b.node_id());
+	assert_eq!(channel.counterparty.node_id, node_b.node_id());
 	assert_eq!(channel.funding_txo.unwrap(), funding_txo);
 
 	node_a.stop().unwrap();