Expose ChannelTypeFeatures in ChannelDetails

Add a UniFFI wrapper so bindings can inspect channel type flags.

Update anchor accounting tests to use channel type features instead
of inferring zero-fee commitments from the commitment feerate.

Co-Authored-By: HAL 9000

Author: tankyleo

CHANGELOG.md

@@ -18,6 +18,8 @@
 - `EsploraSyncConfig` and `ElectrumSyncConfig` now support `force_wallet_full_scan`. When set,
   the on-chain wallet keeps using BDK `full_scan` instead of incremental sync until a full scan
   succeeds, allowing restored wallets to rediscover funds sent to previously-unknown addresses.
+- The `ChannelDetails` returned by `Node::list_channels` now exposes the negotiated
+  `ChannelTypeFeatures`.
 - `Config::anchor_channels_config` is no longer optional, hence anchor channels can no longer be
   disabled. We still negotiate legacy channels if the peer does not support anchor channels.
 

src/ffi/types.rs

@@ -44,7 +44,10 @@ pub use lightning_liquidity::lsps0::ser::LSPSDateTime;
 pub use lightning_liquidity::lsps1::msgs::{
 	LSPS1ChannelInfo, LSPS1OrderId, LSPS1OrderParams, LSPS1PaymentState,
 };
-use lightning_types::features::{InitFeatures as LdkInitFeatures, NodeFeatures as LdkNodeFeatures};
+use lightning_types::features::{
+	ChannelTypeFeatures as LdkChannelTypeFeatures, InitFeatures as LdkInitFeatures,
+	NodeFeatures as LdkNodeFeatures,
+};
 pub use lightning_types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
 pub use lightning_types::string::UntrustedString;
 use vss_client::headers::{
@@ -1817,6 +1820,102 @@ impl From<LdkNodeFeatures> for NodeFeatures {
 	}
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, uniffi::Object)]
+#[uniffi::export(Debug, Eq)]
+pub struct ChannelTypeFeatures {
+	pub(crate) inner: LdkChannelTypeFeatures,
+}
+
+#[uniffi::export]
+impl ChannelTypeFeatures {
+	/// Constructs channel type features from big-endian BOLT 9 encoded bytes.
+	#[uniffi::constructor]
+	pub fn from_bytes(bytes: &[u8]) -> Self {
+		Self { inner: LdkChannelTypeFeatures::from_be_bytes(bytes.to_vec()) }
+	}
+
+	/// Returns the BOLT 9 big-endian encoded representation of these features.
+	pub fn to_bytes(&self) -> Vec<u8> {
+		self.inner.encode()
+	}
+
+	/// Whether this channel type advertises support for `option_static_remotekey`.
+	pub fn supports_static_remote_key(&self) -> bool {
+		self.inner.supports_static_remote_key()
+	}
+
+	/// Whether this channel type requires `option_static_remotekey`.
+	pub fn requires_static_remote_key(&self) -> bool {
+		self.inner.requires_static_remote_key()
+	}
+
+	/// Whether this channel type advertises support for `option_anchors_zero_fee_htlc_tx`.
+	pub fn supports_anchors_zero_fee_htlc_tx(&self) -> bool {
+		self.inner.supports_anchors_zero_fee_htlc_tx()
+	}
+
+	/// Whether this channel type requires `option_anchors_zero_fee_htlc_tx`.
+	pub fn requires_anchors_zero_fee_htlc_tx(&self) -> bool {
+		self.inner.requires_anchors_zero_fee_htlc_tx()
+	}
+
+	/// Whether this channel type advertises support for `option_anchors_nonzero_fee_htlc_tx`.
+	pub fn supports_anchors_nonzero_fee_htlc_tx(&self) -> bool {
+		self.inner.supports_anchors_nonzero_fee_htlc_tx()
+	}
+
+	/// Whether this channel type requires `option_anchors_nonzero_fee_htlc_tx`.
+	pub fn requires_anchors_nonzero_fee_htlc_tx(&self) -> bool {
+		self.inner.requires_anchors_nonzero_fee_htlc_tx()
+	}
+
+	/// Whether this channel type advertises support for `option_taproot`.
+	pub fn supports_taproot(&self) -> bool {
+		self.inner.supports_taproot()
+	}
+
+	/// Whether this channel type requires `option_taproot`.
+	pub fn requires_taproot(&self) -> bool {
+		self.inner.requires_taproot()
+	}
+
+	/// Whether this channel type advertises support for `option_scid_alias`.
+	pub fn supports_scid_privacy(&self) -> bool {
+		self.inner.supports_scid_privacy()
+	}
+
+	/// Whether this channel type requires `option_scid_alias`.
+	pub fn requires_scid_privacy(&self) -> bool {
+		self.inner.requires_scid_privacy()
+	}
+
+	/// Whether this channel type advertises support for `option_zeroconf`.
+	pub fn supports_zero_conf(&self) -> bool {
+		self.inner.supports_zero_conf()
+	}
+
+	/// Whether this channel type requires `option_zeroconf`.
+	pub fn requires_zero_conf(&self) -> bool {
+		self.inner.requires_zero_conf()
+	}
+
+	/// Whether this channel type advertises support for `option_zero_fee_commitments`.
+	pub fn supports_anchor_zero_fee_commitments(&self) -> bool {
+		self.inner.supports_anchor_zero_fee_commitments()
+	}
+
+	/// Whether this channel type requires `option_zero_fee_commitments`.
+	pub fn requires_anchor_zero_fee_commitments(&self) -> bool {
+		self.inner.requires_anchor_zero_fee_commitments()
+	}
+}
+
+impl From<LdkChannelTypeFeatures> for ChannelTypeFeatures {
+	fn from(features: LdkChannelTypeFeatures) -> Self {
+		Self { inner: features }
+	}
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, uniffi::Object)]
 #[uniffi::export(Debug, Eq)]
 pub struct InitFeatures {
@@ -2191,6 +2290,27 @@ mod tests {
 		(ldk_invoice, wrapped_invoice)
 	}
 
+	#[test]
+	fn test_channel_type_feature_accessors() {
+		let mut optional = LdkChannelTypeFeatures::empty();
+		optional.set_scid_privacy_optional();
+		optional.set_zero_conf_optional();
+		let optional = ChannelTypeFeatures::from(optional);
+		assert!(optional.supports_scid_privacy());
+		assert!(!optional.requires_scid_privacy());
+		assert!(optional.supports_zero_conf());
+		assert!(!optional.requires_zero_conf());
+
+		let mut required = LdkChannelTypeFeatures::empty();
+		required.set_scid_privacy_required();
+		required.set_zero_conf_required();
+		let required = ChannelTypeFeatures::from(required);
+		assert!(required.supports_scid_privacy());
+		assert!(required.requires_scid_privacy());
+		assert!(required.supports_zero_conf());
+		assert!(required.requires_zero_conf());
+	}
+
 	#[test]
 	fn test_invoice_description_conversion() {
 		let hash = "09d08d4865e8af9266f6cc7c0ae23a1d6bf868207cf8f7c5979b9f6ed850dfb0".to_string();

src/types.rs

@@ -39,6 +39,8 @@ use lightning::util::sweep::OutputSweeper;
 use lightning_block_sync::gossip::GossipVerifier;
 use lightning_liquidity::utils::time::DefaultTimeProvider;
 use lightning_net_tokio::SocketDescriptor;
+#[cfg(not(feature = "uniffi"))]
+use lightning_types::features::ChannelTypeFeatures;
 
 use crate::chain::bitcoind::UtxoSourceClient;
 use crate::chain::ChainSource;
@@ -51,6 +53,8 @@ use crate::message_handler::NodeCustomMessageHandler;
 use crate::payment::{PaymentDetails, PendingPaymentDetails};
 use crate::runtime::RuntimeSpawner;
 
+#[cfg(feature = "uniffi")]
+type ChannelTypeFeatures = Arc<crate::ffi::ChannelTypeFeatures>;
 #[cfg(not(feature = "uniffi"))]
 type InitFeatures = lightning::types::features::InitFeatures;
 #[cfg(feature = "uniffi")]
@@ -642,6 +646,11 @@ pub struct ChannelDetails {
 	///
 	/// See [`ReserveType`] for details on how reserves differ between anchor and legacy channels.
 	pub reserve_type: Option<ReserveType>,
+	/// The negotiated channel type features.
+	///
+	/// Will be `None` until channel negotiation has completed and the channel type has been
+	/// determined.
+	pub channel_type: Option<ChannelTypeFeatures>,
 }
 
 impl ChannelDetails {
@@ -706,6 +715,7 @@ impl ChannelDetails {
 				.expect("value is set for objects serialized with LDK v0.0.109+"),
 			channel_shutdown_state: value.channel_shutdown_state,
 			reserve_type,
+			channel_type: value.channel_type.map(maybe_wrap),
 		}
 	}
 }

tests/common/mod.rs

@@ -1578,12 +1578,15 @@ pub(crate) async fn do_channel_full_cycle<E: ElectrumApi>(
 	);
 
 	if disable_node_b_reserve {
-		let node_a_outbound_capacity_msat = node_a.list_channels()[0].outbound_capacity_msat;
-		let node_a_reserve_msat =
-			node_a.list_channels()[0].unspendable_punishment_reserve.unwrap() * 1000;
-		let zero_fee_commitments = node_a.list_channels()[0].feerate_sat_per_1000_weight == 0;
+		let node_a_channel = node_a.list_channels().into_iter().next().unwrap();
+		let node_a_outbound_capacity_msat = node_a_channel.outbound_capacity_msat;
+		let node_a_reserve_msat = node_a_channel.unspendable_punishment_reserve.unwrap() * 1000;
+		let zero_fee_commitments = node_a_channel
+			.channel_type
+			.as_ref()
+			.map_or(false, |c| c.requires_anchor_zero_fee_commitments());
 		let node_a_anchors_msat = if zero_fee_commitments { 0 } else { 2 * 330 * 1000 };
-		let funding_amount_msat = node_a.list_channels()[0].channel_value_sats * 1000;
+		let funding_amount_msat = node_a_channel.channel_value_sats * 1000;
 		// Node B does not have any reserve, so we only subtract a few items on node A's
 		// side to arrive at node B's capacity
 		let node_b_capacity_msat = funding_amount_msat

tests/integration_tests_rust.rs

@@ -1706,7 +1706,9 @@ async fn splice_channel() {
 	let user_channel_id_b = expect_channel_ready_event!(node_b, node_a.node_id());
 
 	let opening_transaction_fee_sat = 156;
-	let zero_fee_commitments = node_a.list_channels()[0].feerate_sat_per_1000_weight == 0;
+	let channel = node_a.list_channels().into_iter().next().unwrap();
+	let zero_fee_commitments =
+		channel.channel_type.as_ref().map_or(false, |c| c.requires_anchor_zero_fee_commitments());
 	let closing_transaction_fee_sat = if zero_fee_commitments { 0 } else { 614 };
 	let anchor_output_sat = if zero_fee_commitments { 0 } else { 330 };