f don't feature gate public api methods that were already shipped

Author: dunxen

lightning/src/ln/channelmanager.rs

@@ -9859,23 +9859,31 @@ where
 		});
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_open_channel_v2(&self, counterparty_node_id: &PublicKey, msg: &msgs::OpenChannelV2) {
-		// Note that we never need to persist the updated ChannelManager for an inbound
-		// open_channel message - pre-funded channels are never written so there should be no
-		// change to the contents.
-		let _persistence_guard = PersistenceNotifierGuard::optionally_notify(self, || {
-			let res = self.internal_open_channel(counterparty_node_id, OpenChannelMessage::V2(msg.clone()));
-			let persist = match &res {
-				Err(e) if e.closes_channel() => {
-					debug_assert!(false, "We shouldn't close a new channel");
-					NotifyOption::DoPersist
-				},
-				_ => NotifyOption::SkipPersistHandleEvents,
-			};
-			let _ = handle_error!(self, res, *counterparty_node_id);
-			persist
-		});
+		#[cfg(any(dual_funding, splicing))]
+		{
+			// Note that we never need to persist the updated ChannelManager for an inbound
+			// open_channel message - pre-funded channels are never written so there should be no
+			// change to the contents.
+			let _persistence_guard = PersistenceNotifierGuard::optionally_notify(self, || {
+				let res = self.internal_open_channel(counterparty_node_id, OpenChannelMessage::V2(msg.clone()));
+				let persist = match &res {
+					Err(e) if e.closes_channel() => {
+						debug_assert!(false, "We shouldn't close a new channel");
+						NotifyOption::DoPersist
+					},
+					_ => NotifyOption::SkipPersistHandleEvents,
+				};
+				let _ = handle_error!(self, res, *counterparty_node_id);
+				persist
+			});
+		};
+		#[cfg(not(any(dual_funding, splicing)))]
+		{
+			let _: Result<(), _> = handle_error!(self, Err(MsgHandleErrInternal::send_err_msg_no_close(
+				"Dual-funded channels not supported".to_owned(),
+				 msg.common_fields.temporary_channel_id.clone())), *counterparty_node_id);
+		};
 	}
 
 	fn handle_accept_channel(&self, counterparty_node_id: &PublicKey, msg: &msgs::AcceptChannel) {
@@ -9888,7 +9896,6 @@ where
 		});
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_accept_channel_v2(&self, counterparty_node_id: &PublicKey, msg: &msgs::AcceptChannelV2) {
 		let _: Result<(), _> = handle_error!(self, Err(MsgHandleErrInternal::send_err_msg_no_close(
 			"Dual-funded channels not supported".to_owned(),
@@ -10420,83 +10427,119 @@ where
 		Some(vec![self.chain_hash])
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_add_input(&self, counterparty_node_id: &PublicKey, msg: &msgs::TxAddInput) {
-		// Note that we never need to persist the updated ChannelManager for an inbound
-		// tx_add_input message - interactive transaction construction does not need to
-		// be persisted before any signatures are exchanged.
-		let _persistence_guard = PersistenceNotifierGuard::optionally_notify(self, || {
-			let _ = handle_error!(self, self.internal_tx_add_input(counterparty_node_id, msg), *counterparty_node_id);
-			NotifyOption::SkipPersistHandleEvents
-		});
+		#[cfg(any(dual_funding, splicing))]
+		{
+			// Note that we never need to persist the updated ChannelManager for an inbound
+			// tx_add_input message - interactive transaction construction does not need to
+			// be persisted before any signatures are exchanged.
+			let _persistence_guard = PersistenceNotifierGuard::optionally_notify(self, || {
+				let _ = handle_error!(self, self.internal_tx_add_input(counterparty_node_id, msg), *counterparty_node_id);
+				NotifyOption::SkipPersistHandleEvents
+			});
+		};
+		#[cfg(not(any(dual_funding, splicing)))]
+		{
+			let _: Result<(), _> = handle_error!(self, Err(MsgHandleErrInternal::send_err_msg_no_close(
+				"Dual-funded channels not supported".to_owned(),
+				 msg.channel_id.clone())), *counterparty_node_id);
+		};
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_add_output(&self, counterparty_node_id: &PublicKey, msg: &msgs::TxAddOutput) {
-		// Note that we never need to persist the updated ChannelManager for an inbound
-		// tx_add_input message - interactive transaction construction does not need to
-		// be persisted before any signatures are exchanged.
-		let _persistence_guard = PersistenceNotifierGuard::optionally_notify(self, || {
-			let _ = handle_error!(self, self.internal_tx_add_output(counterparty_node_id, msg), *counterparty_node_id);
-			NotifyOption::SkipPersistHandleEvents
-		});
+		#[cfg(any(dual_funding, splicing))]
+		{
+			// Note that we never need to persist the updated ChannelManager for an inbound
+			// tx_add_input message - interactive transaction construction does not need to
+			// be persisted before any signatures are exchanged.
+			let _persistence_guard = PersistenceNotifierGuard::optionally_notify(self, || {
+				let _ = handle_error!(self, self.internal_tx_add_output(counterparty_node_id, msg), *counterparty_node_id);
+				NotifyOption::SkipPersistHandleEvents
+			});
+		};
+		#[cfg(not(any(dual_funding, splicing)))]
+		{
+			let _: Result<(), _> = handle_error!(self, Err(MsgHandleErrInternal::send_err_msg_no_close(
+				"Dual-funded channels not supported".to_owned(),
+				 msg.channel_id.clone())), *counterparty_node_id);
+		};
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_remove_input(&self, counterparty_node_id: &PublicKey, msg: &msgs::TxRemoveInput) {
-		// Note that we never need to persist the updated ChannelManager for an inbound
-		// tx_add_input message - interactive transaction construction does not need to
-		// be persisted before any signatures are exchanged.
-		let _persistence_guard = PersistenceNotifierGuard::optionally_notify(self, || {
-			let _ = handle_error!(self, self.internal_tx_remove_input(counterparty_node_id, msg), *counterparty_node_id);
-			NotifyOption::SkipPersistHandleEvents
-		});
+		#[cfg(any(dual_funding, splicing))]
+		{
+			// Note that we never need to persist the updated ChannelManager for an inbound
+			// tx_add_input message - interactive transaction construction does not need to
+			// be persisted before any signatures are exchanged.
+			let _persistence_guard = PersistenceNotifierGuard::optionally_notify(self, || {
+				let _ = handle_error!(self, self.internal_tx_remove_input(counterparty_node_id, msg), *counterparty_node_id);
+				NotifyOption::SkipPersistHandleEvents
+			});
+		};
+		#[cfg(not(any(dual_funding, splicing)))]
+		{
+			let _: Result<(), _> = handle_error!(self, Err(MsgHandleErrInternal::send_err_msg_no_close(
+				"Dual-funded channels not supported".to_owned(),
+				 msg.channel_id.clone())), *counterparty_node_id);
+		};
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_remove_output(&self, counterparty_node_id: &PublicKey, msg: &msgs::TxRemoveOutput) {
-		// Note that we never need to persist the updated ChannelManager for an inbound
-		// tx_add_input message - interactive transaction construction does not need to
-		// be persisted before any signatures are exchanged.
-		let _persistence_guard = PersistenceNotifierGuard::optionally_notify(self, || {
-			let _ = handle_error!(self, self.internal_tx_remove_output(counterparty_node_id, msg), *counterparty_node_id);
-			NotifyOption::SkipPersistHandleEvents
-		});
+		#[cfg(any(dual_funding, splicing))]
+		{
+			// Note that we never need to persist the updated ChannelManager for an inbound
+			// tx_add_input message - interactive transaction construction does not need to
+			// be persisted before any signatures are exchanged.
+			let _persistence_guard = PersistenceNotifierGuard::optionally_notify(self, || {
+				let _ = handle_error!(self, self.internal_tx_remove_output(counterparty_node_id, msg), *counterparty_node_id);
+				NotifyOption::SkipPersistHandleEvents
+			});
+		};
+		#[cfg(not(any(dual_funding, splicing)))]
+		{
+			let _: Result<(), _> = handle_error!(self, Err(MsgHandleErrInternal::send_err_msg_no_close(
+				"Dual-funded channels not supported".to_owned(),
+				 msg.channel_id.clone())), *counterparty_node_id);
+		};
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_complete(&self, counterparty_node_id: &PublicKey, msg: &msgs::TxComplete) {
-		// Note that we never need to persist the updated ChannelManager for an inbound
-		// tx_add_input message - interactive transaction construction does not need to
-		// be persisted before any signatures are exchanged.
-		let _persistence_guard = PersistenceNotifierGuard::optionally_notify(self, || {
-			let _ = handle_error!(self, self.internal_tx_complete(counterparty_node_id, msg), *counterparty_node_id);
-			NotifyOption::SkipPersistHandleEvents
-		});
+		#[cfg(any(dual_funding, splicing))]
+		{
+			// Note that we never need to persist the updated ChannelManager for an inbound
+			// tx_add_input message - interactive transaction construction does not need to
+			// be persisted before any signatures are exchanged.
+			let _persistence_guard = PersistenceNotifierGuard::optionally_notify(self, || {
+				let _ = handle_error!(self, self.internal_tx_complete(counterparty_node_id, msg), *counterparty_node_id);
+				NotifyOption::SkipPersistHandleEvents
+			});
+		};
+		#[cfg(not(any(dual_funding, splicing)))]
+		{
+			let _: Result<(), _> = handle_error!(self, Err(MsgHandleErrInternal::send_err_msg_no_close(
+				"Dual-funded channels not supported".to_owned(),
+				 msg.channel_id.clone())), *counterparty_node_id);
+		};
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_signatures(&self, counterparty_node_id: &PublicKey, msg: &msgs::TxSignatures) {
 		let _: Result<(), _> = handle_error!(self, Err(MsgHandleErrInternal::send_err_msg_no_close(
 			"Dual-funded channels not supported".to_owned(),
 			 msg.channel_id.clone())), *counterparty_node_id);
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_init_rbf(&self, counterparty_node_id: &PublicKey, msg: &msgs::TxInitRbf) {
 		let _: Result<(), _> = handle_error!(self, Err(MsgHandleErrInternal::send_err_msg_no_close(
 			"Dual-funded channels not supported".to_owned(),
 			 msg.channel_id.clone())), *counterparty_node_id);
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_ack_rbf(&self, counterparty_node_id: &PublicKey, msg: &msgs::TxAckRbf) {
 		let _: Result<(), _> = handle_error!(self, Err(MsgHandleErrInternal::send_err_msg_no_close(
 			"Dual-funded channels not supported".to_owned(),
 			 msg.channel_id.clone())), *counterparty_node_id);
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_abort(&self, counterparty_node_id: &PublicKey, msg: &msgs::TxAbort) {
 		let _: Result<(), _> = handle_error!(self, Err(MsgHandleErrInternal::send_err_msg_no_close(
 			"Dual-funded channels not supported".to_owned(),

lightning/src/ln/msgs.rs

@@ -1438,12 +1438,10 @@ pub trait ChannelMessageHandler : MessageSendEventsProvider {
 	/// Handle an incoming `open_channel` message from the given peer.
 	fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel);
 	/// Handle an incoming `open_channel2` message from the given peer.
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &OpenChannelV2);
 	/// Handle an incoming `accept_channel` message from the given peer.
 	fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel);
 	/// Handle an incoming `accept_channel2` message from the given peer.
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &AcceptChannelV2);
 	/// Handle an incoming `funding_created` message from the given peer.
 	fn handle_funding_created(&self, their_node_id: &PublicKey, msg: &FundingCreated);
@@ -1475,31 +1473,22 @@ pub trait ChannelMessageHandler : MessageSendEventsProvider {
 
 	// Interactive channel construction
 	/// Handle an incoming `tx_add_input message` from the given peer.
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &TxAddInput);
 	/// Handle an incoming `tx_add_output` message from the given peer.
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &TxAddOutput);
 	/// Handle an incoming `tx_remove_input` message from the given peer.
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &TxRemoveInput);
 	/// Handle an incoming `tx_remove_output` message from the given peer.
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &TxRemoveOutput);
 	/// Handle an incoming `tx_complete message` from the given peer.
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &TxComplete);
 	/// Handle an incoming `tx_signatures` message from the given peer.
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &TxSignatures);
 	/// Handle an incoming `tx_init_rbf` message from the given peer.
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &TxInitRbf);
 	/// Handle an incoming `tx_ack_rbf` message from the given peer.
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &TxAckRbf);
 	/// Handle an incoming `tx_abort message` from the given peer.
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &TxAbort);
 
 	// HTLC handling:

lightning/src/ln/peer_handler.rs

@@ -322,57 +322,46 @@ impl ChannelMessageHandler for ErroringMessageHandler {
 		None
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_open_channel_v2(&self, their_node_id: &PublicKey, msg: &msgs::OpenChannelV2) {
 		ErroringMessageHandler::push_error(self, their_node_id, msg.common_fields.temporary_channel_id);
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_accept_channel_v2(&self, their_node_id: &PublicKey, msg: &msgs::AcceptChannelV2) {
 		ErroringMessageHandler::push_error(self, their_node_id, msg.common_fields.temporary_channel_id);
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_add_input(&self, their_node_id: &PublicKey, msg: &msgs::TxAddInput) {
 		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_add_output(&self, their_node_id: &PublicKey, msg: &msgs::TxAddOutput) {
 		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_remove_input(&self, their_node_id: &PublicKey, msg: &msgs::TxRemoveInput) {
 		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_remove_output(&self, their_node_id: &PublicKey, msg: &msgs::TxRemoveOutput) {
 		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_complete(&self, their_node_id: &PublicKey, msg: &msgs::TxComplete) {
 		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_signatures(&self, their_node_id: &PublicKey, msg: &msgs::TxSignatures) {
 		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_init_rbf(&self, their_node_id: &PublicKey, msg: &msgs::TxInitRbf) {
 		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_ack_rbf(&self, their_node_id: &PublicKey, msg: &msgs::TxAckRbf) {
 		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
 	}
 
-	#[cfg(any(dual_funding, splicing))]
 	fn handle_tx_abort(&self, their_node_id: &PublicKey, msg: &msgs::TxAbort) {
 		ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
 	}
@@ -1772,14 +1761,12 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 			wire::Message::OpenChannel(msg) => {
 				self.message_handler.chan_handler.handle_open_channel(&their_node_id, &msg);
 			},
-			#[cfg(any(dual_funding, splicing))]
 			wire::Message::OpenChannelV2(msg) => {
 				self.message_handler.chan_handler.handle_open_channel_v2(&their_node_id, &msg);
 			},
 			wire::Message::AcceptChannel(msg) => {
 				self.message_handler.chan_handler.handle_accept_channel(&their_node_id, &msg);
 			},
-			#[cfg(any(dual_funding, splicing))]
 			wire::Message::AcceptChannelV2(msg) => {
 				self.message_handler.chan_handler.handle_accept_channel_v2(&their_node_id, &msg);
 			},
@@ -1814,39 +1801,30 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 			}
 
 			// Interactive transaction construction messages:
-			#[cfg(any(dual_funding, splicing))]
 			wire::Message::TxAddInput(msg) => {
 				self.message_handler.chan_handler.handle_tx_add_input(&their_node_id, &msg);
 			},
-			#[cfg(any(dual_funding, splicing))]
 			wire::Message::TxAddOutput(msg) => {
 				self.message_handler.chan_handler.handle_tx_add_output(&their_node_id, &msg);
 			},
-			#[cfg(any(dual_funding, splicing))]
 			wire::Message::TxRemoveInput(msg) => {
 				self.message_handler.chan_handler.handle_tx_remove_input(&their_node_id, &msg);
 			},
-			#[cfg(any(dual_funding, splicing))]
 			wire::Message::TxRemoveOutput(msg) => {
 				self.message_handler.chan_handler.handle_tx_remove_output(&their_node_id, &msg);
 			},
-			#[cfg(any(dual_funding, splicing))]
 			wire::Message::TxComplete(msg) => {
 				self.message_handler.chan_handler.handle_tx_complete(&their_node_id, &msg);
 			},
-			#[cfg(any(dual_funding, splicing))]
 			wire::Message::TxSignatures(msg) => {
 				self.message_handler.chan_handler.handle_tx_signatures(&their_node_id, &msg);
 			},
-			#[cfg(any(dual_funding, splicing))]
 			wire::Message::TxInitRbf(msg) => {
 				self.message_handler.chan_handler.handle_tx_init_rbf(&their_node_id, &msg);
 			},
-			#[cfg(any(dual_funding, splicing))]
 			wire::Message::TxAckRbf(msg) => {
 				self.message_handler.chan_handler.handle_tx_ack_rbf(&their_node_id, &msg);
 			},
-			#[cfg(any(dual_funding, splicing))]
 			wire::Message::TxAbort(msg) => {
 				self.message_handler.chan_handler.handle_tx_abort(&their_node_id, &msg);
 			}