Remove the ability to disable anchor channels

tankyleo · tankyleo · commit fac8a1f5d888 · 2026-07-16T06:37:50.000Z
We previously allowed users to disable anchor channels and drain their
anchor reserve while still having anchor channels open or pending
resolution. This was acceptable for keyed anchor channels, as the
commitment transaction therein still contained some fees, and had some
chance of getting mined into a block without any anchor bumps.

In upcoming commits, we will add support for 0FC channels, and their
commitment transactions have zero fees and depend entirely on the anchor
reserve to reach miners and get confirmed in a block. It is thus
dangerous to disable anchor channels and drain the reserve after 0FC
channels have been opened. Therefore, we make `AnchorChannelsConfig`
required, and prevent this case from ever happening.
diff --git a/CHANGELOG.md b/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.
+- `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.
 
 ## Bug Fixes and Improvements
 - Building a fresh node against a Bitcoin Core RPC or REST chain source that fails to return the
diff --git a/benches/payments.rs b/benches/payments.rs
@@ -121,13 +121,8 @@ fn payment_benchmark(c: &mut Criterion) {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = random_chain_source(&bitcoind, &electrsd);
 
-	let (node_a, node_b) = setup_two_nodes_with_store(
-		&chain_source,
-		false,
-		true,
-		false,
-		common::TestStoreType::Sqlite,
-	);
+	let (node_a, node_b) =
+		setup_two_nodes_with_store(&chain_source, false, false, common::TestStoreType::Sqlite);
 
 	let runtime =
 		tokio::runtime::Builder::new_multi_thread().worker_threads(4).enable_all().build().unwrap();
diff --git a/src/config.rs b/src/config.rs
@@ -143,7 +143,7 @@ pub(crate) const LNURL_AUTH_TIMEOUT_SECS: u64 = 15;
 /// | `node_alias`                           | None                                 |
 /// | `trusted_peers_0conf`                  | []                                   |
 /// | `probing_liquidity_limit_multiplier`   | 3                                    |
-/// | `anchor_channels_config`               | Some(..)                             |
+/// | `anchor_channels_config`               | AnchorChannelsConfig::default()      |
 /// | `route_parameters`                     | None                                 |
 /// | `tor_config`                           | None                                 |
 /// | `hrn_config`                           | HumanReadableNamesConfig::default()  |
@@ -190,19 +190,7 @@ pub struct Config {
 	/// `option_anchors_zero_fee_htlc_tx` channel type is negotiated.
 	///
 	/// Please refer to [`AnchorChannelsConfig`] for further information on Anchor channels.
-	///
-	/// If set to `Some`, we'll try to open new channels with Anchors enabled, i.e., new channels
-	/// will be negotiated with the `option_anchors_zero_fee_htlc_tx` channel type if supported by
-	/// the counterparty. Note that this won't prevent us from opening non-Anchor channels if the
-	/// counterparty doesn't support `option_anchors_zero_fee_htlc_tx`. If set to `None`, new
-	/// channels will be negotiated with the legacy `option_static_remotekey` channel type only.
-	///
-	/// **Note:** If set to `None` *after* some Anchor channels have already been
-	/// opened, no dedicated emergency on-chain reserve will be maintained for these channels,
-	/// which can be dangerous if only insufficient funds are available at the time of channel
-	/// closure. We *will* however still try to get the Anchor spending transactions confirmed
-	/// on-chain with the funds available.
-	pub anchor_channels_config: Option<AnchorChannelsConfig>,
+	pub anchor_channels_config: AnchorChannelsConfig,
 	/// Configuration options for payment routing and pathfinding.
 	///
 	/// Setting the [`RouteParametersConfig`] provides flexibility to customize how payments are routed,
@@ -233,7 +221,7 @@ impl Default for Config {
 			announcement_addresses: None,
 			trusted_peers_0conf: Vec::new(),
 			probing_liquidity_limit_multiplier: DEFAULT_PROBING_LIQUIDITY_LIMIT_MULTIPLIER,
-			anchor_channels_config: Some(AnchorChannelsConfig::default()),
+			anchor_channels_config: AnchorChannelsConfig::default(),
 			tor_config: None,
 			route_parameters: None,
 			node_alias: None,
@@ -418,8 +406,6 @@ pub(crate) fn default_user_config(config: &Config) -> UserConfig {
 	// will mostly be relevant for inbound channels.
 	let mut user_config = UserConfig::default();
 	user_config.channel_handshake_limits.force_announced_channel_preference = false;
-	user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx =
-		config.anchor_channels_config.is_some();
 	user_config.reject_inbound_splices = false;
 
 	if may_announce_channel(config).is_err() {
diff --git a/src/event.rs b/src/event.rs
@@ -1267,24 +1267,6 @@ where
 				}
 
 				let anchor_channel = channel_type.requires_anchors_zero_fee_htlc_tx();
-				if anchor_channel && self.config.anchor_channels_config.is_none() {
-					log_error!(
-						self.logger,
-						"Rejecting inbound channel from peer {} due to Anchor channels being disabled.",
-						counterparty_node_id,
-					);
-					self.channel_manager
-						.force_close_broadcasting_latest_txn(
-							&temporary_channel_id,
-							&counterparty_node_id,
-							"Channel request rejected".to_string(),
-						)
-						.unwrap_or_else(|e| {
-							log_error!(self.logger, "Failed to reject channel: {:?}", e)
-						});
-					return Ok(());
-				}
-
 				let required_reserve_sats = crate::new_channel_anchor_reserve_sats(
 					&self.config,
 					&counterparty_node_id,
@@ -1750,19 +1732,17 @@ where
 						..
 					} => {
 						// Skip bumping channel closes if our counterparty is trusted.
-						if let Some(anchor_channels_config) =
-							self.config.anchor_channels_config.as_ref()
+						if self
+							.config
+							.anchor_channels_config
+							.trusted_peers_no_reserve
+							.contains(counterparty_node_id)
 						{
-							if anchor_channels_config
-								.trusted_peers_no_reserve
-								.contains(counterparty_node_id)
-							{
-								log_debug!(self.logger,
-									"Ignoring BumpTransactionEvent::ChannelClose for channel {} due to trusted counterparty {}",
-									channel_id, counterparty_node_id
-								);
-								return Ok(());
-							}
+							log_debug!(self.logger,
+								"Ignoring BumpTransactionEvent::ChannelClose for channel {} due to trusted counterparty {}",
+								channel_id, counterparty_node_id
+							);
+							return Ok(());
 						}
 					},
 					BumpTransactionEvent::HTLCResolution { .. } => {},
diff --git a/src/lib.rs b/src/lib.rs
@@ -1169,7 +1169,7 @@ impl Node {
 		self.channel_manager
 			.list_channels()
 			.into_iter()
-			.map(|c| ChannelDetails::from_ldk(c, self.config.anchor_channels_config.as_ref()))
+			.map(|c| ChannelDetails::from_ldk(c, &self.config.anchor_channels_config))
 			.collect()
 	}
 
@@ -2406,21 +2406,20 @@ impl_writeable_tlv_based!(NodeMetrics, {
 pub(crate) fn total_anchor_channels_reserve_sats(
 	channel_manager: &ChannelManager, config: &Config,
 ) -> u64 {
-	config.anchor_channels_config.as_ref().map_or(0, |anchor_channels_config| {
-		channel_manager
-			.list_channels()
-			.into_iter()
-			.filter(|c| {
-				!anchor_channels_config.trusted_peers_no_reserve.contains(&c.counterparty.node_id)
-					&& c.channel_shutdown_state
-						.map_or(true, |s| s != ChannelShutdownState::ShutdownComplete)
-					&& c.channel_type
-						.as_ref()
-						.map_or(false, |t| t.requires_anchors_zero_fee_htlc_tx())
-			})
-			.count() as u64
-			* anchor_channels_config.per_channel_reserve_sats
-	})
+	channel_manager
+		.list_channels()
+		.into_iter()
+		.filter(|c| {
+			!config
+				.anchor_channels_config
+				.trusted_peers_no_reserve
+				.contains(&c.counterparty.node_id)
+				&& c.channel_shutdown_state
+					.map_or(true, |s| s != ChannelShutdownState::ShutdownComplete)
+				&& c.channel_type.as_ref().map_or(false, |t| t.requires_anchors_zero_fee_htlc_tx())
+		})
+		.count() as u64
+		* config.anchor_channels_config.per_channel_reserve_sats
 }
 
 pub(crate) fn new_channel_anchor_reserve_sats(
@@ -2430,13 +2429,11 @@ pub(crate) fn new_channel_anchor_reserve_sats(
 		return 0;
 	}
 
-	config.anchor_channels_config.as_ref().map_or(0, |c| {
-		if c.trusted_peers_no_reserve.contains(peer_node_id) {
-			0
-		} else {
-			c.per_channel_reserve_sats
-		}
-	})
+	if config.anchor_channels_config.trusted_peers_no_reserve.contains(peer_node_id) {
+		0
+	} else {
+		config.anchor_channels_config.per_channel_reserve_sats
+	}
 }
 
 #[cfg(test)]
diff --git a/src/liquidity/service/lsps2.rs b/src/liquidity/service/lsps2.rs
@@ -453,15 +453,17 @@ where
 				let spendable_amount_sats =
 					self.wallet.get_spendable_amount_sats(cur_anchor_reserve_sats).unwrap_or(0);
 				let required_funds_sats = channel_amount_sats
-					+ self.config.anchor_channels_config.as_ref().map_or(0, |c| {
-						if init_features.supports_anchors_zero_fee_htlc_tx()
-							&& !c.trusted_peers_no_reserve.contains(&their_network_key)
-						{
-							c.per_channel_reserve_sats
-						} else {
-							0
-						}
-					});
+					+ if init_features.supports_anchors_zero_fee_htlc_tx()
+						&& !self
+							.config
+							.anchor_channels_config
+							.trusted_peers_no_reserve
+							.contains(&their_network_key)
+					{
+						self.config.anchor_channels_config.per_channel_reserve_sats
+					} else {
+						0
+					};
 				if spendable_amount_sats < required_funds_sats {
 					log_error!(self.logger,
 						"Unable to create channel due to insufficient funds. Available: {}sats, Required: {}sats",
diff --git a/src/types.rs b/src/types.rs
@@ -646,24 +646,16 @@ pub struct ChannelDetails {
 
 impl ChannelDetails {
 	pub(crate) fn from_ldk(
-		value: LdkChannelDetails, anchor_channels_config: Option<&AnchorChannelsConfig>,
+		value: LdkChannelDetails, anchor_channels_config: &AnchorChannelsConfig,
 	) -> Self {
 		let reserve_type = value.channel_type.as_ref().map(|channel_type| {
 			if channel_type.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
-					}
+				if anchor_channels_config
+					.trusted_peers_no_reserve
+					.contains(&value.counterparty.node_id)
+				{
+					ReserveType::TrustedPeersNoReserve
 				} 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 {
diff --git a/tests/common/mod.rs b/tests/common/mod.rs
@@ -379,13 +379,9 @@ pub(crate) fn random_node_alias() -> Option<NodeAlias> {
 	Some(NodeAlias(bytes))
 }
 
-pub(crate) fn random_config(anchor_channels: bool) -> TestConfig {
+pub(crate) fn random_config() -> TestConfig {
 	let mut node_config = Config::default();
 
-	if !anchor_channels {
-		node_config.anchor_channels_config = None;
-	}
-
 	node_config.network = Network::Regtest;
 	println!("Setting network: {}", node_config.network);
 
@@ -594,24 +590,22 @@ pub(crate) use setup_builder;
 pub(crate) mod scenarios;
 
 pub(crate) fn setup_two_nodes(
-	chain_source: &TestChainSource, allow_0conf: bool, anchor_channels: bool,
-	anchors_trusted_no_reserve: bool,
+	chain_source: &TestChainSource, allow_0conf: bool, anchors_trusted_no_reserve: bool,
 ) -> (TestNode, TestNode) {
 	setup_two_nodes_with_store(
 		chain_source,
 		allow_0conf,
-		anchor_channels,
 		anchors_trusted_no_reserve,
 		TestStoreType::TestSyncStore,
 	)
 }
 
 pub(crate) fn setup_two_nodes_with_store(
-	chain_source: &TestChainSource, allow_0conf: bool, anchor_channels: bool,
-	anchors_trusted_no_reserve: bool, store_type: TestStoreType,
+	chain_source: &TestChainSource, allow_0conf: bool, anchors_trusted_no_reserve: bool,
+	store_type: TestStoreType,
 ) -> (TestNode, TestNode) {
 	println!("== Node A ==");
-	let mut config_a = random_config(anchor_channels);
+	let mut config_a = random_config();
 	config_a.store_type = store_type;
 
 	if cfg!(hrn_tests) {
@@ -622,7 +616,7 @@ pub(crate) fn setup_two_nodes_with_store(
 	let node_a = setup_node(chain_source, config_a);
 
 	println!("\n== Node B ==");
-	let mut config_b = random_config(anchor_channels);
+	let mut config_b = random_config();
 	config_b.store_type = store_type;
 
 	if cfg!(hrn_tests) {
@@ -637,14 +631,8 @@ pub(crate) fn setup_two_nodes_with_store(
 	if allow_0conf {
 		config_b.node_config.trusted_peers_0conf.push(node_a.node_id());
 	}
-	if anchor_channels && anchors_trusted_no_reserve {
-		config_b
-			.node_config
-			.anchor_channels_config
-			.as_mut()
-			.unwrap()
-			.trusted_peers_no_reserve
-			.push(node_a.node_id());
+	if anchors_trusted_no_reserve {
+		config_b.node_config.anchor_channels_config.trusted_peers_no_reserve.push(node_a.node_id());
 	}
 	let node_b = setup_node(chain_source, config_b);
 	(node_a, node_b)
@@ -1199,7 +1187,8 @@ pub(crate) async fn do_channel_full_cycle<E: ElectrumApi>(
 	let node_b_anchor_reserve_sat = if node_b
 		.config()
 		.anchor_channels_config
-		.map_or(true, |acc| acc.trusted_peers_no_reserve.contains(&node_a.node_id()))
+		.trusted_peers_no_reserve
+		.contains(&node_a.node_id())
 	{
 		0
 	} else {
diff --git a/tests/common/scenarios/mod.rs b/tests/common/scenarios/mod.rs
@@ -90,7 +90,7 @@ pub(crate) async fn wait_for_htlcs_settled(
 /// Build a fresh LDK node configured for interop tests. Uses electrum 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(true);
+	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();
 	sync_config.timeouts_config.onchain_wallet_sync_timeout_secs = 180;
diff --git a/tests/integration_tests_hrn.rs b/tests/integration_tests_hrn.rs
@@ -24,7 +24,7 @@ async fn unified_send_to_hrn() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = random_chain_source(&bitcoind, &electrsd);
 
-	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false);
+	let (node_a, node_b) = setup_two_nodes(&chain_source, false, false);
 
 	let address_a = node_a.onchain_payment().new_address().unwrap();
 	let premined_sats = 5_000_000;
diff --git a/tests/integration_tests_migration.rs b/tests/integration_tests_migration.rs
@@ -148,7 +148,7 @@ async fn migrate_node_across_all_backends() {
 	let connection_string = test_connection_string();
 
 	// Set up node B, the Lightning counterparty.
-	let config_b = common::random_config(false);
+	let config_b = common::random_config();
 	let node_b_instance = BackendInstance::new(
 		MigrationBackend::Postgres,
 		&config_b.node_config.storage_dir_path,
@@ -167,7 +167,7 @@ async fn migrate_node_across_all_backends() {
 	// Spin up the node we'll migrate on the first backend. The same node config (storage dir,
 	// listening addresses, identity) is reused across every hop — only the backend changes — so
 	// each backend's store lives in its own subdirectory of the one storage dir.
-	let config = common::random_config(false);
+	let config = common::random_config();
 	let node_entropy = config.node_entropy;
 	let node_config = config.node_config;
 	let base_dir = node_config.storage_dir_path.clone();
diff --git a/tests/integration_tests_postgres.rs b/tests/integration_tests_postgres.rs
@@ -22,7 +22,7 @@ async fn channel_full_cycle_with_postgres_store() {
 	let (bitcoind, electrsd) = common::setup_bitcoind_and_electrsd();
 	println!("== Node A ==");
 	let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap());
-	let config_a = common::random_config(true);
+	let config_a = common::random_config();
 	let mut builder_a = Builder::from_config(config_a.node_config);
 	builder_a.set_chain_source_esplora(esplora_url.clone(), None);
 	let node_a = builder_a
@@ -37,7 +37,7 @@ async fn channel_full_cycle_with_postgres_store() {
 	node_a.start().unwrap();
 
 	println!("\n== Node B ==");
-	let config_b = common::random_config(true);
+	let config_b = common::random_config();
 	let mut builder_b = Builder::from_config(config_b.node_config);
 	builder_b.set_chain_source_esplora(esplora_url.clone(), None);
 	let node_b = builder_b
diff --git a/tests/integration_tests_rust.rs b/tests/integration_tests_rust.rs
diff --git a/tests/integration_tests_vss.rs b/tests/integration_tests_vss.rs
diff --git a/tests/probing_tests.rs b/tests/probing_tests.rs
diff --git a/tests/reorg_test.rs b/tests/reorg_test.rs
