Reject FundingCreated before channel accepted test

Author: ViktorTigerstrom

lightning/src/ln/channel.rs

@@ -4526,6 +4526,10 @@ impl<Signer: Sign> Channel<Signer> {
 		self.inbound_awaiting_accept
 	}
 
+	pub fn set_is_awaiting_accept(&mut self) {
+		self.inbound_awaiting_accept = true;
+	}
+
 	pub fn get_accept_channel(&mut self) -> msgs::AcceptChannel {
 		if self.is_outbound() {
 			panic!("Tried to send accept_channel for an outbound channel?");

lightning/src/ln/functional_tests.rs

@@ -8247,6 +8247,80 @@ fn test_manually_reject_inbound_channel_request() {
 	check_closed_event!(nodes[1], 1, ClosureReason::HolderForceClosed);
 }
 
+#[test]
+fn test_reject_funding_before_inbound_channel_accepted() {
+	// This tests that when the util::config::UserConfig.manually_accept_inbound_channels is set to
+	// true, inbound channels must to be manually accepted through the
+	// ln::channelmanager::ChannelManager::accept_inbound_channel function by the node operator
+	// before the counterparty sends a `FundingCreated` message. If a `FundingCreated` message is
+	// received before the channel is accepted, it should be rejected and the channel should be
+	// closed.
+	let mut manually_accept_conf = UserConfig::default();
+	manually_accept_conf.manually_accept_inbound_channels = true;
+	let chanmon_cfgs = create_chanmon_cfgs(2);
+	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
+	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(manually_accept_conf.clone())]);
+	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+
+	nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, Some(manually_accept_conf)).unwrap();
+	let res = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
+	let temp_channel_id = res.temporary_channel_id;
+
+	nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &res);
+
+	// Assert that node[1] has no MessageSendEvent::SendAcceptChannel in the msg_events before rejecting the inbound request
+	assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
+
+	// Clear the Event::OpenChannelRequest event without responding to the request.
+	nodes[1].node.get_and_clear_pending_events();
+
+	// Get the `AcceptChannel` message of nodes[1] without calling the
+	// ChannelManager::accept_inbound_channel function, which generates the
+	// MessageSendEvent::SendAcceptChannel event. This is passed to nodes[0] handle_accept_channel
+	// function, which is required in order for the create_funding_transaction function not to
+	// crash when nodes[0] is passed to it.
+	{
+		let mut channel_state_lock = nodes[1].node.channel_state.lock().unwrap();
+		let channel_state = &mut *channel_state_lock;
+		match channel_state.by_id.entry(temp_channel_id.clone()) {
+			hash_map::Entry::Occupied(mut channel) => {
+				let accept_chan_msg = channel.get_mut().get_accept_channel();
+				// As this test doesn't intend to actually accept the channel by nodes[1], we reset
+				// Channel::inbound_awaiting_accept flag which was mutated by the
+				// get_accept_channel call.
+				channel.get_mut().set_is_awaiting_accept();
+				nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), InitFeatures::known(), &accept_chan_msg);
+			}
+			hash_map::Entry::Vacant(_) => {
+				panic!("Should have found the created channel")
+			}
+		}
+	}
+
+	let (temporary_channel_id, tx, _) = create_funding_transaction(&nodes[0], 100000, 42);
+
+	nodes[0].node.funding_transaction_generated(&temporary_channel_id, tx.clone()).unwrap();
+	let funding_created_msg = get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id());
+
+	// The funding_created_msg should be rejected by nodes[1] as it hasn't accepted the channel.
+	nodes[1].node.handle_funding_created(&nodes[0].node.get_our_node_id(), &funding_created_msg);
+
+	let close_msg_ev = nodes[1].node.get_and_clear_pending_msg_events();
+	assert_eq!(close_msg_ev.len(), 1);
+
+	let expected_err = "FundingCreated message received before the channel was accepted";
+	match close_msg_ev[0] {
+		MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, ref node_id, } => {
+			assert_eq!(msg.channel_id, temp_channel_id);
+			assert_eq!(*node_id, nodes[0].node.get_our_node_id());
+			assert_eq!(msg.data, expected_err);
+		}
+		_ => panic!("Unexpected event"),
+	}
+
+	check_closed_event!(nodes[1], 1, ClosureReason::ProcessingError { err: expected_err.to_string() });
+}
+
 #[test]
 fn test_simple_mpp() {
 	// Simple test of sending a multi-path payment.