Have close_channel take a UserChannelId

... which is nice for consistency reasons.

We also fix a minor bug that would have lead us to forget a peer
whenever we'd close a channel, even if it wasn't the last one.

Author: tnull

bindings/kotlin/ldk-node-jvm/lib/src/test/kotlin/org/lightningdevkit/ldknode/LibraryTest.kt

@@ -217,8 +217,8 @@ class LibraryTest {
         assert(channelReadyEvent2 is Event.ChannelReady)
         node2.eventHandled()
 
-        val channelId = when (channelReadyEvent2) {
-            is Event.ChannelReady -> channelReadyEvent2.channelId
+        val userChannelId = when (channelReadyEvent2) {
+            is Event.ChannelReady -> channelReadyEvent2.userChannelId
             else -> return
         }
 
@@ -239,7 +239,7 @@ class LibraryTest {
         assert(node1.listPayments().size == 1)
         assert(node2.listPayments().size == 1)
 
-        node2.closeChannel(channelId, nodeId1)
+        node2.closeChannel(userChannelId, nodeId1)
 
         val channelClosedEvent1 = node1.waitNextEvent()
         println("Got event: $channelClosedEvent1")

bindings/ldk_node.udl

@@ -65,7 +65,7 @@ interface LDKNode {
 	[Throws=NodeError]
 	UserChannelId connect_open_channel(PublicKey node_id, SocketAddress address, u64 channel_amount_sats, u64? push_to_counterparty_msat, ChannelConfig? channel_config, boolean announce_channel);
 	[Throws=NodeError]
-	void close_channel([ByRef]ChannelId channel_id, PublicKey counterparty_node_id);
+	void close_channel([ByRef]UserChannelId user_channel_id, PublicKey counterparty_node_id);
 	[Throws=NodeError]
 	void update_channel_config([ByRef]ChannelId channel_id, PublicKey counterparty_node_id, ChannelConfig channel_config);
 	[Throws=NodeError]

bindings/python/src/ldk_node/test_ldk_node.py

@@ -198,7 +198,7 @@ def test_channel_full_cycle(self):
         print("EVENT:", payment_received_event_2)
         node_2.event_handled()
 
-        node_2.close_channel(channel_ready_event_2.channel_id, node_id_1)
+        node_2.close_channel(channel_ready_event_2.user_channel_id, node_id_1)
 
         channel_closed_event_1 = node_1.wait_next_event()
         assert isinstance(channel_closed_event_1, Event.CHANNEL_CLOSED)

src/lib.rs

@@ -1104,12 +1104,28 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 
 	/// Close a previously opened channel.
 	pub fn close_channel(
-		&self, channel_id: &ChannelId, counterparty_node_id: PublicKey,
+		&self, user_channel_id: &UserChannelId, counterparty_node_id: PublicKey,
 	) -> Result<(), Error> {
-		self.peer_store.remove_peer(&counterparty_node_id)?;
-		match self.channel_manager.close_channel(&channel_id, &counterparty_node_id) {
-			Ok(_) => Ok(()),
-			Err(_) => Err(Error::ChannelClosingFailed),
+		let open_channels =
+			self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
+		if let Some(channel_details) =
+			open_channels.iter().find(|c| c.user_channel_id == user_channel_id.0)
+		{
+			match self
+				.channel_manager
+				.close_channel(&channel_details.channel_id, &counterparty_node_id)
+			{
+				Ok(_) => {
+					// Check if this was the last open channel, if so, forget the peer.
+					if open_channels.len() == 1 {
+						self.peer_store.remove_peer(&counterparty_node_id)?;
+					}
+					Ok(())
+				}
+				Err(_) => Err(Error::ChannelClosingFailed),
+			}
+		} else {
+			Ok(())
 		}
 	}
 

tests/common.rs

@@ -65,11 +65,11 @@ pub(crate) use expect_channel_pending_event;
 macro_rules! expect_channel_ready_event {
 	($node: expr, $counterparty_node_id: expr) => {{
 		match $node.wait_next_event() {
-			ref e @ Event::ChannelReady { channel_id, counterparty_node_id, .. } => {
+			ref e @ Event::ChannelReady { user_channel_id, counterparty_node_id, .. } => {
 				println!("{} got event {:?}", $node.node_id(), e);
 				assert_eq!(counterparty_node_id, Some($counterparty_node_id));
 				$node.event_handled();
-				channel_id
+				user_channel_id
 			}
 			ref e => {
 				panic!("{} got unexpected event!: {:?}", std::stringify!($node), e);
@@ -377,7 +377,7 @@ pub(crate) fn do_channel_full_cycle<K: KVStore + Sync + Send, E: ElectrumApi>(
 
 	expect_channel_ready_event!(node_a, node_b.node_id());
 
-	let channel_id = expect_channel_ready_event!(node_b, node_a.node_id());
+	let user_channel_id = expect_channel_ready_event!(node_b, node_a.node_id());
 
 	println!("\nB receive_payment");
 	let invoice_amount_1_msat = 2500_000;
@@ -520,7 +520,7 @@ pub(crate) fn do_channel_full_cycle<K: KVStore + Sync + Send, E: ElectrumApi>(
 	);
 
 	println!("\nB close_channel");
-	node_b.close_channel(&channel_id, node_a.node_id()).unwrap();
+	node_b.close_channel(&user_channel_id, node_a.node_id()).unwrap();
 	expect_event!(node_a, ChannelClosed);
 	expect_event!(node_b, ChannelClosed);
 

tests/integration_tests_cln.rs

@@ -88,7 +88,7 @@ fn test_cln() {
 	let funding_txo = common::expect_channel_pending_event!(node, cln_node_id);
 	common::wait_for_tx(&electrs_client, funding_txo.txid);
 	common::generate_blocks_and_wait(&bitcoind_client, &electrs_client, 6);
-	let channel_id = common::expect_channel_ready_event!(node, cln_node_id);
+	let user_channel_id = common::expect_channel_ready_event!(node, cln_node_id);
 
 	// Send a payment to CLN
 	let mut rng = thread_rng();
@@ -110,7 +110,7 @@ fn test_cln() {
 	cln_client.pay(&ldk_invoice.to_string(), Default::default()).unwrap();
 	common::expect_event!(node, PaymentReceived);
 
-	node.close_channel(&channel_id, cln_node_id).unwrap();
+	node.close_channel(&user_channel_id, cln_node_id).unwrap();
 	common::expect_event!(node, ChannelClosed);
 	node.stop().unwrap();
 }