Expose per-channel features in ChannelDetails

We previously flattened ChannelCounterparty fields
into ChannelDetails as individual counterparty_*
fields, and InitFeatures was entirely omitted.
This made it impossible for consumers to access per-peer
feature flags, and awkward to access counterparty
forwarding information without navigating the flattened
field names.

This commit replaces the flattened fields with a
structured ChannelCounterparty type that mirrors
LDK's ChannelCounterparty, exposing InitFeatures
and CounterpartyForwardingInfo that were previously
inaccessible.

We keep outbound_htlc_minimum_msat optional because
it is unavailable before receiving OpenChannel or
AcceptChannel, and re-export ChannelCounterparty so
Rust consumers can name the type.

Author: enigbe

src/ffi/types.rs

@@ -25,7 +25,7 @@ pub use bitcoin::{Address, BlockHash, Network, OutPoint, ScriptBuf, Txid};
 pub use lightning::chain::channelmonitor::BalanceSource;
 use lightning::events::PaidBolt12Invoice as LdkPaidBolt12Invoice;
 pub use lightning::events::{ClosureReason, PaymentFailureReason};
-use lightning::ln::channel_state::ChannelShutdownState;
+use lightning::ln::channel_state::{ChannelShutdownState, CounterpartyForwardingInfo};
 use lightning::ln::channelmanager::PaymentId;
 use lightning::ln::msgs::DecodeError;
 pub use lightning::ln::types::ChannelId;
@@ -44,7 +44,7 @@ pub use lightning_liquidity::lsps0::ser::LSPSDateTime;
 pub use lightning_liquidity::lsps1::msgs::{
 	LSPS1ChannelInfo, LSPS1OrderId, LSPS1OrderParams, LSPS1PaymentState,
 };
-use lightning_types::features::NodeFeatures as LdkNodeFeatures;
+use lightning_types::features::{InitFeatures as LdkInitFeatures, NodeFeatures as LdkNodeFeatures};
 pub use lightning_types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
 pub use lightning_types::string::UntrustedString;
 use vss_client::headers::{
@@ -1815,6 +1815,246 @@ impl From<LdkNodeFeatures> for NodeFeatures {
 	}
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, uniffi::Object)]
+pub struct InitFeatures {
+	pub(crate) inner: LdkInitFeatures,
+}
+
+impl InitFeatures {
+	/// Constructs init features from big-endian BOLT 9 encoded bytes.
+	#[uniffi::constructor]
+	pub fn from_bytes(bytes: &[u8]) -> Self {
+		Self { inner: LdkInitFeatures::from_be_bytes(bytes.to_vec()).into() }
+	}
+
+	/// Returns the BOLT 9 big-endian encoded representation of these features.
+	pub fn to_bytes(&self) -> Vec<u8> {
+		self.inner.encode()
+	}
+
+	/// Whether the peer supports `option_static_remotekey`.
+	///
+	/// This ensures the non-broadcaster's output pays directly to their specified key,
+	/// simplifying recovery if a channel is force-closed.
+	pub fn supports_static_remote_key(&self) -> bool {
+		self.inner.supports_static_remote_key()
+	}
+
+	/// Whether the peer supports `option_anchors_zero_fee_htlc_tx`.
+	///
+	/// Anchor channels allow fee-bumping commitment transactions after broadcast,
+	/// improving on-chain fee management.
+	pub fn supports_anchors_zero_fee_htlc_tx(&self) -> bool {
+		self.inner.supports_anchors_zero_fee_htlc_tx()
+	}
+
+	/// Whether the peer supports `option_anchors_nonzero_fee_htlc_tx`.
+	///
+	/// The initial version of anchor outputs, which was later found to be
+	/// vulnerable and superseded by `option_anchors_zero_fee_htlc_tx`.
+	pub fn supports_anchors_nonzero_fee_htlc_tx(&self) -> bool {
+		self.inner.supports_anchors_nonzero_fee_htlc_tx()
+	}
+
+	/// Whether the peer supports `option_support_large_channel`.
+	///
+	/// When supported, channels larger than 2^24 satoshis (≈0.168 BTC) may be opened.
+	pub fn supports_wumbo(&self) -> bool {
+		self.inner.supports_wumbo()
+	}
+
+	/// Whether the peer supports `option_route_blinding`.
+	///
+	/// Route blinding allows the recipient to hide their node identity and
+	/// last-hop channel from the sender.
+	pub fn supports_route_blinding(&self) -> bool {
+		self.inner.supports_route_blinding()
+	}
+
+	/// Whether the peer supports `option_onion_messages`.
+	///
+	/// Onion messages enable communication over the Lightning Network without
+	/// requiring a payment, used by BOLT 12 offers and async payments.
+	pub fn supports_onion_messages(&self) -> bool {
+		self.inner.supports_onion_messages()
+	}
+
+	/// Whether the peer supports `option_scid_alias`.
+	///
+	/// When supported, the peer will only forward using short channel ID aliases,
+	/// preventing the real channel UTXO from being revealed during routing.
+	pub fn supports_scid_privacy(&self) -> bool {
+		self.inner.supports_scid_privacy()
+	}
+
+	/// Whether the peer supports `option_zeroconf`.
+	///
+	/// Zero-conf channels can be used immediately without waiting for
+	/// on-chain funding confirmations.
+	pub fn supports_zero_conf(&self) -> bool {
+		self.inner.supports_zero_conf()
+	}
+
+	/// Whether the peer supports `option_dual_fund`.
+	///
+	/// Dual-funded channels allow both parties to contribute funds
+	/// to the channel opening transaction.
+	pub fn supports_dual_fund(&self) -> bool {
+		self.inner.supports_dual_fund()
+	}
+
+	/// Whether the peer supports `option_quiesce`.
+	///
+	/// Quiescence is a prerequisite for splicing, allowing both sides to
+	/// pause HTLC activity before modifying the funding transaction.
+	pub fn supports_quiescence(&self) -> bool {
+		self.inner.supports_quiescence()
+	}
+
+	/// Whether the peer supports `option_data_loss_protect`.
+	///
+	/// Allows a node that has fallen behind (e.g., restored from backup)
+	/// to detect that it is out of date and close the channel safely.
+	pub fn supports_data_loss_protect(&self) -> bool {
+		self.inner.supports_data_loss_protect()
+	}
+
+	/// Whether the peer supports `option_upfront_shutdown_script`.
+	///
+	/// Commits to a shutdown scriptpubkey when opening a channel,
+	/// preventing a compromised key from redirecting closing funds.
+	pub fn supports_upfront_shutdown_script(&self) -> bool {
+		self.inner.supports_upfront_shutdown_script()
+	}
+
+	/// Whether the peer supports `gossip_queries`.
+	///
+	/// Indicates the peer has useful gossip to share and supports
+	/// gossip query messages for synchronization.
+	pub fn supports_gossip_queries(&self) -> bool {
+		self.inner.supports_gossip_queries()
+	}
+
+	/// Whether the peer supports `var_onion_optin`.
+	///
+	/// Requires variable-length routing onion payloads, which is
+	/// assumed to be supported by all modern Lightning nodes.
+	pub fn supports_variable_length_onion(&self) -> bool {
+		self.inner.supports_variable_length_onion()
+	}
+
+	/// Whether the peer supports `payment_secret`.
+	///
+	/// Payment secrets prevent forwarding nodes from probing
+	/// payment recipients. Assumed to be supported by all modern nodes.
+	pub fn supports_payment_secret(&self) -> bool {
+		self.inner.supports_payment_secret()
+	}
+
+	/// Whether the peer supports `basic_mpp`.
+	///
+	/// Multi-part payments allow splitting a payment across multiple
+	/// routes for improved reliability and liquidity utilization.
+	pub fn supports_basic_mpp(&self) -> bool {
+		self.inner.supports_basic_mpp()
+	}
+
+	/// Whether the peer supports `opt_shutdown_anysegwit`.
+	///
+	/// Allows future segwit versions in the shutdown script,
+	/// enabling closing to Taproot or later output types.
+	pub fn supports_shutdown_anysegwit(&self) -> bool {
+		self.inner.supports_shutdown_anysegwit()
+	}
+
+	/// Whether the peer supports `option_channel_type`.
+	///
+	/// Supports explicit channel type negotiation during channel opening.
+	pub fn supports_channel_type(&self) -> bool {
+		self.inner.supports_channel_type()
+	}
+
+	/// Whether the peer supports `option_trampoline`.
+	///
+	/// Trampoline routing allows lightweight nodes to delegate
+	/// pathfinding to an intermediate trampoline node.
+	pub fn supports_trampoline_routing(&self) -> bool {
+		self.inner.supports_trampoline_routing()
+	}
+
+	/// Whether the peer supports `option_simple_close`.
+	///
+	/// Simplified closing negotiation reduces the number of
+	/// round trips needed for a cooperative channel close.
+	pub fn supports_simple_close(&self) -> bool {
+		self.inner.supports_simple_close()
+	}
+
+	/// Whether the peer supports `option_splice`.
+	///
+	/// Splicing allows replacing the funding transaction with a new one,
+	/// enabling on-the-fly capacity changes without closing the channel.
+	pub fn supports_splicing(&self) -> bool {
+		self.inner.supports_splicing()
+	}
+
+	/// Whether the peer supports `option_provide_storage`.
+	///
+	/// Indicates the node offers to store encrypted backup data
+	/// on behalf of its peers.
+	pub fn supports_provide_storage(&self) -> bool {
+		self.inner.supports_provide_storage()
+	}
+
+	/// Whether the peer set `initial_routing_sync`.
+	///
+	/// Indicates the sending node needs a complete routing information dump.
+	/// Per BOLT #9, this feature has no even (required) bit.
+	pub fn initial_routing_sync(&self) -> bool {
+		self.inner.initial_routing_sync()
+	}
+
+	/// Whether the peer supports `option_taproot`.
+	///
+	/// Taproot channels use MuSig2-based multisig for funding outputs,
+	/// improving privacy and efficiency.
+	pub fn supports_taproot(&self) -> bool {
+		self.inner.supports_taproot()
+	}
+
+	/// Whether the peer supports `option_zero_fee_commitments`.
+	///
+	/// A channel type which always uses zero transaction fee on commitment
+	/// transactions, combined with anchor outputs.
+	pub fn supports_anchor_zero_fee_commitments(&self) -> bool {
+		self.inner.supports_anchor_zero_fee_commitments()
+	}
+
+	/// Whether the peer supports HTLC hold.
+	///
+	/// Supports holding HTLCs and forwarding on receipt of an onion message.
+	pub fn supports_htlc_hold(&self) -> bool {
+		self.inner.supports_htlc_hold()
+	}
+}
+
+impl From<LdkInitFeatures> for InitFeatures {
+	fn from(ldk_init: LdkInitFeatures) -> Self {
+		Self { inner: ldk_init }
+	}
+}
+/// Information needed for constructing an invoice route hint for this channel.
+#[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(test)]
 mod tests {
 	use std::num::NonZeroU64;

src/lib.rs

@@ -179,7 +179,7 @@ use types::{
 	HRNResolver, KeysManager, OnionMessenger, PaymentStore, PeerManager, Router, Scorer, Sweeper,
 	Wallet,
 };
-pub use types::{ChannelDetails, CustomTlvRecord, PeerDetails, UserChannelId};
+pub use types::{ChannelCounterparty, ChannelDetails, CustomTlvRecord, PeerDetails, UserChannelId};
 pub use vss_client;
 
 use crate::ffi::maybe_wrap;