Add configuration knob to enable 0FC channels

In upcoming commits we will read this knob to determine whether to
negotiate 0FC channels.

For now, we make a best-effort attempt to make sure the configured chain
source supports 0FC channels if this knob is set.

Do this roundtrip at the same time we make a roundtrip to retrieve the
feerates to keep startup as fast as possible.

Author: tankyleo

bindings/ldk_node.udl

@@ -246,6 +246,7 @@ enum NodeError {
 	"LnurlAuthFailed",
 	"LnurlAuthTimeout",
 	"InvalidLnurl",
+	"ChainSourceNotSupported",
 };
 
 typedef dictionary NodeStatus;

src/chain/bitcoind.rs

@@ -119,6 +119,30 @@ impl BitcoindChainSource {
 		self.api_client.utxo_source()
 	}
 
+	pub(super) async fn validate_zero_fee_commitments_support(&self) -> Result<(), Error> {
+		let node_version_result = tokio::time::timeout(
+			Duration::from_secs(CHAIN_POLLING_TIMEOUT_SECS),
+			self.api_client.get_node_version(),
+		)
+		.await
+		.map_err(|e| {
+			log_error!(self.logger, "Failed to get node version: {:?}", e);
+			Error::ConnectionFailed
+		})?;
+
+		let node_version = node_version_result.map_err(|e| {
+			log_error!(self.logger, "Failed to get node version: {:?}", e);
+			Error::ConnectionFailed
+		})?;
+
+		// v26 first shipped the `submitpackage` RPC, but we need v29 to relay ephemeral dust
+		if node_version < 290000 {
+			log_error!(self.logger, "Bitcoin backend MUST be greater than or equal to v29");
+			return Err(Error::ChainSourceNotSupported);
+		}
+		Ok(())
+	}
+
 	pub(super) async fn continuously_sync_wallets(
 		&self, mut stop_sync_receiver: tokio::sync::watch::Receiver<()>,
 		onchain_wallet: Arc<Wallet>, channel_manager: Arc<ChannelManager>,
@@ -748,6 +772,31 @@ impl BitcoindClient {
 		}
 	}
 
+	pub(crate) async fn get_node_version(&self) -> Result<u64, BitcoindClientError> {
+		match self {
+			BitcoindClient::Rpc { rpc_client, .. } => {
+				Self::get_node_version_inner(Arc::clone(rpc_client))
+					.await
+					.map_err(BitcoindClientError::Rpc)
+			},
+			BitcoindClient::Rest { rpc_client, .. } => {
+				// Bitcoin Core's REST interface does not support `getnetworkinfo`
+				// so we use the RPC client.
+				Self::get_node_version_inner(Arc::clone(rpc_client))
+					.await
+					.map_err(BitcoindClientError::Rpc)
+			},
+		}
+	}
+
+	async fn get_node_version_inner(rpc_client: Arc<RpcClient>) -> Result<u64, RpcClientError> {
+		rpc_client.call_method::<serde_json::Value>("getnetworkinfo", &[]).await.and_then(|value| {
+			value["version"].as_u64().ok_or(RpcClientError::InvalidData(String::from(
+				"The version field in the `getnetworkinfo` response should be a u64",
+			)))
+		})
+	}
+
 	/// Broadcasts the provided transaction.
 	pub(crate) async fn broadcast_transaction(
 		&self, tx: &Transaction,

src/chain/electrum.rs

@@ -306,6 +306,53 @@ impl ElectrumChainSource {
 		Ok(())
 	}
 
+	pub(crate) async fn validate_zero_fee_commitments_support(&self) -> Result<(), Error> {
+		let electrum_client: Arc<ElectrumRuntimeClient> = if let Some(client) =
+			self.electrum_runtime_status.read().expect("lock").client().as_ref()
+		{
+			Arc::clone(client)
+		} else {
+			debug_assert!(
+				false,
+				"We should have started the chain source before checking submitpackage support"
+			);
+			return Err(Error::ConnectionFailed);
+		};
+
+		// TODO: Use `protocol_version` API once shipped in
+		// https://github.com/bitcoindevkit/rust-electrum-client/pull/213.
+		//
+		// This could still accept an Electrum server running against Bitcoin Core v26
+		// through v28, which does not relay ephemeral dust.
+		let spawn_fut = electrum_client.runtime.spawn_blocking({
+			let electrum_client = Arc::clone(&electrum_client.electrum_client);
+			move || electrum_client.transaction_broadcast_package(&super::dummy_package())
+		});
+		let timeout_fut = tokio::time::timeout(
+			Duration::from_secs(self.sync_config.timeouts_config.tx_broadcast_timeout_secs),
+			spawn_fut,
+		);
+
+		match timeout_fut.await {
+			Ok(Ok(Ok(_))) => Ok(()),
+			Ok(Ok(Err(
+				e @ (electrum_client::Error::Protocol(_)
+				| electrum_client::Error::AllAttemptsErrored(_)),
+			))) => {
+				log_error!(self.logger, "Electrum server does not support submitpackage: {:?}", e);
+				Err(Error::ChainSourceNotSupported)
+			},
+			e => {
+				log_error!(
+					self.logger,
+					"Failed to check support for submitpackage on the Electrum server: {:?}",
+					e
+				);
+				Err(Error::ConnectionFailed)
+			},
+		}
+	}
+
 	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
 		let electrum_client: Arc<ElectrumRuntimeClient> = if let Some(client) =
 			self.electrum_runtime_status.read().expect("lock").client().as_ref()

src/chain/esplora.rs

@@ -83,6 +83,31 @@ impl EsploraChainSource {
 		})
 	}
 
+	pub(super) async fn validate_zero_fee_commitments_support(&self) -> Result<(), Error> {
+		// This could still accept an Esplora server running against Bitcoin Core v26
+		// through v28, which does not relay ephemeral dust.
+		self.esplora_client.submit_package(&super::dummy_package(), None, None).await.map_err(
+			|e| {
+				if let esplora_client::Error::HttpResponse { status: 404, message } = e {
+					log_error!(
+						self.logger,
+						"Esplora server does not support submitpackage: {}",
+						message
+					);
+					Error::ChainSourceNotSupported
+				} else {
+					log_error!(
+						self.logger,
+						"Failed to check support for submitpackage on the Esplora server: {}",
+						e
+					);
+					Error::ConnectionFailed
+				}
+			},
+		)?;
+		Ok(())
+	}
+
 	pub(super) async fn sync_onchain_wallet(
 		&self, onchain_wallet: Arc<Wallet>,
 	) -> Result<(), Error> {

src/chain/mod.rs

@@ -29,6 +29,37 @@ use crate::runtime::Runtime;
 use crate::types::{Broadcaster, ChainMonitor, ChannelManager, DynStore, Sweeper, Wallet};
 use crate::{Error, PersistedNodeMetrics};
 
+/// We use this parent-child TRUC package to make sure the configured chain source supports
+/// broadcasting packages via the `submitpackage` Bitcoin Core RPC.
+const PARENT_TXID: &str = "9a015f93fac6cb203c2b994e18b85176eb0354a22a468255516f3c6002d3f696";
+const PARENT_HEX: &str =
+	"0300000000010160d0cdb72f2ddf719f40ca32f44614c67577fc75996140544003915683c34a310000000000fd\
+	ffffff0201000000000000000451024e73876100000000000022512042731375894dad3b25092cd0f713dc5bee4\
+	a71e30a95e1db3d880906d7eba1fa01409327942924218e4eb1635a7cce6706fcb37b8bbb61a2f0b86357356681\
+	4e09419a3501e02252043bb237d479304632282fe9159db9e9a6ae6ec5bedea9f0f115a97b0e00";
+const CHILD_TXID: &str = "d011b3ff78cdfb8b93822639ea87771847936b04bb83afc8763a7c02a386ae26";
+const CHILD_HEX: &str =
+	"0300000000010296f6d302603c6f515582462aa25403eb7651b8184e992b3c20cbc6fa935f019a0000000000ff\
+	ffffff96f6d302603c6f515582462aa25403eb7651b8184e992b3c20cbc6fa935f019a0100000000fdffffff015\
+	660000000000000225120ac18cd599a1be003595854e2eeec18dbe1c92d04b0ba05812d04445e3fcf16bc000140\
+	1462a35808d77a164f0a23a84c4721d1545befd09ad19945bb8aa0ea5576953a9699038725f944b1bc429942ef4\
+	7e6504a554babf022cb15db53be2d8c1dbfe5a97b0e00";
+
+fn dummy_package() -> [bitcoin::Transaction; 2] {
+	use bitcoin::consensus::Decodable;
+	use bitcoin::hex::FromHex;
+	use bitcoin::Transaction;
+	let parent_tx_bytes = Vec::from_hex(PARENT_HEX).expect("read from a constant");
+	let child_tx_bytes = Vec::from_hex(CHILD_HEX).expect("read from a constant");
+	let parent =
+		Transaction::consensus_decode(&mut &parent_tx_bytes[..]).expect("read from a constant");
+	let child =
+		Transaction::consensus_decode(&mut &child_tx_bytes[..]).expect("read from a constant");
+	assert_eq!(parent.compute_txid().to_string(), PARENT_TXID);
+	assert_eq!(child.compute_txid().to_string(), CHILD_TXID);
+	[parent, child]
+}
+
 pub(crate) enum WalletSyncStatus {
 	Completed,
 	InProgress { subscribers: tokio::sync::broadcast::Sender<Result<(), Error>> },
@@ -438,6 +469,26 @@ impl ChainSource {
 		}
 	}
 
+	pub(crate) async fn validate_zero_fee_commitments_support_if_required(
+		&self, zero_fee_commitments_support_required: bool,
+	) -> Result<(), Error> {
+		if !zero_fee_commitments_support_required {
+			return Ok(());
+		}
+
+		match &self.kind {
+			ChainSourceKind::Esplora(esplora_chain_source) => {
+				esplora_chain_source.validate_zero_fee_commitments_support().await
+			},
+			ChainSourceKind::Electrum(electrum_chain_source) => {
+				electrum_chain_source.validate_zero_fee_commitments_support().await
+			},
+			ChainSourceKind::Bitcoind(bitcoind_chain_source) => {
+				bitcoind_chain_source.validate_zero_fee_commitments_support().await
+			},
+		}
+	}
+
 	pub(crate) async fn continuously_process_broadcast_queue(
 		&self, mut stop_tx_bcast_receiver: tokio::sync::watch::Receiver<()>,
 	) {

src/config.rs

@@ -60,7 +60,8 @@ pub const DEFAULT_LOG_FILENAME: &'static str = "ldk_node.log";
 /// The default storage directory.
 pub const DEFAULT_STORAGE_DIR_PATH: &str = "/tmp/ldk_node";
 
-// The default Esplora server we're using.
+// The default Esplora server we're using. It supports `submitpackage`, check using POST on the
+// `/txs/package` endpoint.
 pub(crate) const DEFAULT_ESPLORA_SERVER_URL: &str = "https://blockstream.info/api";
 
 /// The default stop gap used for BDK full scans of the on-chain wallet.
@@ -305,10 +306,11 @@ impl Default for HumanReadableNamesConfig {
 ///
 /// ### Defaults
 ///
-/// | Parameter                  | Value  |
-/// |----------------------------|--------|
-/// | `trusted_peers_no_reserve` | []     |
-/// | `per_channel_reserve_sats` | 25000  |
+/// | Parameter                     | Value  |
+/// |-------------------------------|--------|
+/// | `trusted_peers_no_reserve`    | []     |
+/// | `per_channel_reserve_sats`    | 25000  |
+/// | `enable_zero_fee_commitments` | false  |
 ///
 ///
 /// [BOLT 3]: https://github.com/lightning/bolts/blob/master/03-transactions.md#htlc-timeout-and-htlc-success-transactions
@@ -344,13 +346,29 @@ pub struct AnchorChannelsConfig {
 	/// might not suffice to successfully spend the Anchor output and have the HTLC transactions
 	/// confirmed on-chain, i.e., you may want to adjust this value accordingly.
 	pub per_channel_reserve_sats: u64,
+	/// If set, we will first attempt to negotiate `option_zero_fee_commitments` before falling
+	/// back to `option_anchors_zero_fee_htlc_tx` and `option_static_remotekey`, as supported by
+	/// the peer. Zero-fee commitment channels remove all commitment feerate negotiation from
+	/// the channel, which eliminates a very common source of channel force-closures. These
+	/// channels instead source *all* the fees required to confirm the commitment from the
+	/// anchor reserve of the channel closer at the time of force-close. If set, your chain
+	/// source *must* support the `submitpackage` Bitcoin Core RPC, and relay [TRUC], [P2A],
+	/// and [Ephemeral Dust].
+	/// See [BOLT 3] for more technical details.
+	///
+	/// [TRUC]: https://github.com/bitcoin/bips/blob/master/bip-0431.mediawiki
+	/// [P2A]: https://github.com/bitcoin/bips/blob/master/bip-0433.mediawiki
+	/// [Ephemeral Dust]: https://bitcoincore.org/en/releases/29.0
+	/// [BOLT 3]: https://github.com/lightning/bolts/blob/master/03-transactions.md#shared_anchor-output-zero_fee_commitments
+	pub enable_zero_fee_commitments: bool,
 }
 
 impl Default for AnchorChannelsConfig {
 	fn default() -> Self {
 		Self {
 			trusted_peers_no_reserve: Vec::new(),
 			per_channel_reserve_sats: DEFAULT_ANCHOR_PER_CHANNEL_RESERVE_SATS,
+			enable_zero_fee_commitments: false,
 		}
 	}
 }

src/error.rs

@@ -137,6 +137,8 @@ pub enum Error {
 	LnurlAuthTimeout,
 	/// The provided lnurl is invalid.
 	InvalidLnurl,
+	/// The configured chain source is not supported.
+	ChainSourceNotSupported,
 }
 
 impl fmt::Display for Error {
@@ -222,6 +224,9 @@ impl fmt::Display for Error {
 			Self::LnurlAuthFailed => write!(f, "LNURL-auth authentication failed."),
 			Self::LnurlAuthTimeout => write!(f, "LNURL-auth authentication timed out."),
 			Self::InvalidLnurl => write!(f, "The provided lnurl is invalid."),
+			Self::ChainSourceNotSupported => {
+				write!(f, "The configured chain source is not supported.")
+			},
 		}
 	}
 }

src/lib.rs

@@ -291,9 +291,43 @@ impl Node {
 			e
 		})?;
 
-		// Block to ensure we update our fee rate cache once on startup
+		let manager_owns_any_0fc_channels =
+			self.channel_manager.list_channels().into_iter().any(|channel| {
+				channel
+					.channel_shutdown_state
+					.map_or(true, |s| s != ChannelShutdownState::ShutdownComplete)
+					&& channel
+						.channel_type
+						.as_ref()
+						.map_or(false, |c| c.requires_anchor_zero_fee_commitments())
+			});
+		let monitor_owns_any_0fc_channels =
+			self.chain_monitor.list_monitors().into_iter().any(|channel_id| {
+				self.chain_monitor
+					.get_monitor(channel_id)
+					.map(|monitor| {
+						monitor.channel_type_features().requires_anchor_zero_fee_commitments()
+					})
+					.unwrap_or(false)
+			});
+		let zero_fee_commitments_support_required = manager_owns_any_0fc_channels
+			|| monitor_owns_any_0fc_channels
+			|| self.config.anchor_channels_config.enable_zero_fee_commitments;
+
+		// Block to ensure we update our fee rate cache once on startup.
+		// Also take this opportunity to make sure our chain source supports 0FC channels
+		// if they are enabled.
+		//
+		// TODO: drop 0FC chain source validation when support is ubiquitous
 		let chain_source = Arc::clone(&self.chain_source);
-		self.runtime.block_on(async move { chain_source.update_fee_rate_estimates().await })?;
+		self.runtime.block_on(async move {
+			tokio::try_join!(
+				chain_source.update_fee_rate_estimates(),
+				chain_source.validate_zero_fee_commitments_support_if_required(
+					zero_fee_commitments_support_required
+				)
+			)
+		})?;
 
 		// Spawn background task continuously syncing onchain, lightning, and fee rate cache.
 		let stop_sync_receiver = self.stop_sender.subscribe();