Follow-ups to #660

.github/workflows/0fc-integration.yml

@@ -46,4 +46,4 @@ jobs:
           echo "ELECTRS_EXE=$( pwd )/bin/electrs-${{ runner.os }}-${{ runner.arch }}" >> "$GITHUB_ENV"
       - name: Test with 0FC enabled
         run: |
-          RUSTFLAGS="--cfg no_download --cfg cycle_tests --cfg tokio_unstable --cfg zero_fee_commitment_tests" cargo test -- --test-threads=1
+          RUSTFLAGS="--cfg no_download --cfg cycle_tests --cfg tokio_unstable --cfg zero_fee_commitment_tests" cargo test -- --test-threads=1 --no-capture

.github/workflows/eclair-integration.yml

@@ -8,8 +8,18 @@ concurrency:
 
 jobs:
   check-eclair:
+    name: check-eclair (${{ matrix.name }})
     timeout-minutes: 60
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - name: standard
+            eclair_extra_java_opts: ""
+            rustflags: "--cfg eclair_test"
+          - name: zero-fee-commitments
+            eclair_extra_java_opts: "-Declair.features.zero_fee_commitments=optional"
+            rustflags: "--cfg eclair_test --cfg zero_fee_commitment_tests"
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -37,6 +47,8 @@ jobs:
           docker compose -p ldk-node -f tests/docker/docker-compose-eclair.yml exec bitcoin bitcoin-cli -regtest -rpcuser=user -rpcpassword=pass createwallet ldk_node_test
 
       - name: Start Eclair
+        env:
+          ECLAIR_EXTRA_JAVA_OPTS: ${{ matrix.eclair_extra_java_opts }}
         run: docker compose -p ldk-node -f tests/docker/docker-compose-eclair.yml up -d eclair
 
       - name: Wait for Eclair to be ready
@@ -54,4 +66,5 @@ jobs:
           exit 1
 
       - name: Run Eclair integration tests
-        run: RUSTFLAGS="--cfg eclair_test" cargo test --test integration_tests_eclair -- --show-output --test-threads=1
+        run: |
+          RUSTFLAGS="${{ matrix.rustflags }}" cargo test --test integration_tests_eclair -- --show-output --test-threads=1

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/lib.rs

@@ -292,6 +292,16 @@ impl Node {
 			return Err(Error::AlreadyRunning);
 		}
 
+		match self.start_inner(&mut is_running_lock) {
+			Ok(()) => Ok(()),
+			Err(e) => {
+				self.chain_source.stop();
+				Err(e)
+			},
+		}
+	}
+
+	fn start_inner(&self, is_running_lock: &mut bool) -> Result<(), Error> {
 		log_info!(
 			self.logger,
 			"Starting up LDK Node with node ID {} on network: {}",

src/tx_broadcaster.rs

@@ -18,7 +18,7 @@ use crate::logger::{log_error, LdkLogger};
 use crate::types::Wallet;
 use crate::Error;
 
-const BCAST_PACKAGE_QUEUE_SIZE: usize = 50;
+const BCAST_PACKAGE_QUEUE_SIZE: usize = 256;
 
 /// A package of transactions that LDK handed to the broadcaster in one `broadcast_transactions`
 /// call, along with each transaction's type. Queued until the background task classifies and

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/common/scenarios/channel.rs

@@ -9,6 +9,8 @@ use std::time::Duration;
 
 use electrsd::corepc_node::Client as BitcoindClient;
 use electrsd::electrum_client::ElectrumApi;
+#[cfg(all(eclair_test, zero_fee_commitment_tests))]
+use ldk_node::ReserveType;
 use ldk_node::{Event, Node};
 
 use super::super::external_node::ExternalNode;
@@ -41,6 +43,21 @@ pub(crate) async fn open_channel_to_external<E: ElectrumApi>(
 		.map(|ch| ch.channel_id.clone())
 		.unwrap_or_else(|| panic!("Could not find channel on external node {}", peer.name()));
 
+	#[cfg(all(eclair_test, zero_fee_commitment_tests))]
+	{
+		let channel = node
+			.list_channels()
+			.into_iter()
+			.find(|channel| channel.user_channel_id == user_channel_id)
+			.expect("opened channel should be listed");
+		let channel_type = channel.channel_type.as_ref().expect("channel type should be set");
+		assert_eq!(channel.counterparty.node_id, ext_node_id);
+		assert!(channel.counterparty.features.supports_anchor_zero_fee_commitments());
+		assert!(channel_type.requires_anchor_zero_fee_commitments());
+		assert_eq!(channel.feerate_sat_per_1000_weight, 0);
+		assert_eq!(channel.reserve_type, Some(ReserveType::Adaptive));
+	}
+
 	(user_channel_id, ext_channel_id)
 }
 

tests/common/scenarios/mod.rs

@@ -87,15 +87,15 @@ pub(crate) async fn wait_for_htlcs_settled(
 	panic!("HTLCs did not settle on {} channel {} within 15s", peer.name(), ext_channel_id);
 }
 
-/// Build a fresh LDK node configured for interop tests. Uses electrum at the
+/// Build a fresh LDK node configured for interop tests. Uses esplora at the
 /// docker-compose default port and bumps sync timeouts for combo stress.
 pub(crate) fn setup_ldk_node() -> Node {
 	let config = crate::common::random_config();
 	let mut builder = ldk_node::Builder::from_config(config.node_config);
-	let mut sync_config = ldk_node::config::ElectrumSyncConfig::default();
+	let mut sync_config = ldk_node::config::EsploraSyncConfig::default();
 	sync_config.timeouts_config.onchain_wallet_sync_timeout_secs = 180;
 	sync_config.timeouts_config.lightning_wallet_sync_timeout_secs = 120;
-	builder.set_chain_source_electrum("tcp://127.0.0.1:50001".to_string(), Some(sync_config));
+	builder.set_chain_source_esplora("http://127.0.0.1:3002".to_string(), Some(sync_config));
 	let node = builder.build(config.node_entropy).unwrap();
 	node.start().unwrap();
 	node

tests/docker/docker-compose-eclair.yml

@@ -77,4 +77,5 @@ services:
         -Declair.bitcoind.zmqtx=tcp://127.0.0.1:28333
         -Declair.features.keysend=optional
         -Declair.on-chain-fees.confirmation-priority.funding=slow
+        ${ECLAIR_EXTRA_JAVA_OPTS:-}
         -Declair.printToConsole

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 };