fix : make the channel_id inside close optional

When there is only one channel open with the given `node_id` we
can just skip the `channel_id` from the `close` request.

lampo-common/src/event/ln.rs

@@ -41,7 +41,7 @@ pub enum LightningEvent {
     CloseChannelEvent {
         channel_id: String,
         message: String,
-        counterparty_node_id: String,
-        funding_utxo: String,
+        counterparty_node_id: Option<String>,
+        funding_utxo: Option<String>,
     },
 }

lampo-common/src/model/close_channel.rs

@@ -37,6 +37,11 @@ pub mod request {
             Ok(ChannelId::from_bytes(result_array))
         }
 
+        /// This converts hex to bytes array.
+        /// Stolen from https://stackoverflow.com/a/52992629
+        /// It takes two values every in each iteration from the hex
+        /// then convert the formed hexdecimal digit to u8, collects it in a vector
+        /// and return it (redix = 16 for hexadecimal)
         fn decode_hex(&self, s: &str) -> Result<Vec<u8>, ParseIntError> {
             (0..s.len())
                 .step_by(2)

lampod/src/actions/handler.rs

@@ -159,16 +159,8 @@ impl Handler for LampoHandler {
                 channel_funding_txo,
                 ..
             } => {
-                let node_id = if let Some(id) = counterparty_node_id {
-                    id.to_string()
-                } else {
-                    "Node_id not found".to_string()
-                };
-                let txo = if let Some(txo) = channel_funding_txo {
-                    txo.to_string()
-                } else {
-                    "Outpoint not found".to_string()
-                };
+                let node_id = counterparty_node_id.map(|id| id.to_string());
+                let txo = channel_funding_txo.map(|txo| txo.to_string());
                 self.emit(Event::Lightning(LightningEvent::CloseChannelEvent { channel_id: channel_id.to_string(), message: reason.to_string(), counterparty_node_id : node_id, funding_utxo : txo}));
                 log::info!("channel `{user_channel_id}` closed with reason: `{reason}`");
                 Ok(())

lampod/src/jsonrpc/channels.rs

@@ -1,10 +1,11 @@
 use lampo_common::event::ln::LightningEvent;
 use lampo_common::event::Event;
+use lampo_common::handler::Handler;
 use lampo_common::json;
 use lampo_common::model::request;
+use lampo_common::model::response;
 use lampo_jsonrpc::errors::Error;
 use lampo_jsonrpc::errors::RpcError;
-use lampo_common::handler::Handler;
 
 use crate::ln::events::ChannelEvents;
 
@@ -18,17 +19,61 @@ pub fn json_list_channels(ctx: &LampoDeamon, request: &json::Value) -> Result<js
 
 pub fn json_close_channel(ctx: &LampoDeamon, request: &json::Value) -> Result<json::Value, Error> {
     log::info!("call for `closechannel` with request {:?}", request);
-    let request: request::CloseChannel = json::from_value(request.clone())?;
+    let mut request: request::CloseChannel = json::from_value(request.clone())?;
     let events = ctx.handler().events();
-    let res = ctx.channel_manager().close_channel(request);
-    let (message, channel_id, node_id, funding_utxo) = loop {
-        let event = events.recv_timeout(std::time::Duration::from_secs(30)).map_err(|err| {
+    let res;
+    // This gives all the channels with associated peer
+    let channels: response::Channels = ctx
+        .handler()
+        .call(
+            "channels",
+            json::json!({
+            "peer_id": request.node_id,
+            }),
+        )
+        .map_err(|err| {
             Error::Rpc(RpcError {
                 code: -1,
                 message: format!("{err}"),
                 data: None,
             })
         })?;
+    if channels.channels.len() > 1 {
+        // check the channel_id if it is not none, if it is return an error
+        // and if it is not none then we need to have the channel_id that needs to be shut
+        if request.channel_id.is_none() {
+            return Err(Error::Rpc(RpcError {
+                code: -1,
+                message: format!("Channels > 1, provide `channel_id`"),
+                data: None,
+            }));
+        } else {
+            res = ctx.channel_manager().close_channel(request.clone());
+        };
+    } else if !channels.channels.is_empty() {
+        // This is the case where channel with the given node_id = 1
+        // SAFETY: it is safe to unwrap because the channels is not empty
+        let channel = channels.channels.first().unwrap();
+        request.channel_id = Some(channel.channel_id.clone());
+        res = ctx.channel_manager().close_channel(request);
+    } else {
+        // No channels with the given peer.
+        return Err(Error::Rpc(RpcError {
+            code: -1,
+            message: format!("No channels with associated peer"),
+            data: None,
+        }));
+    };
+    let (message, channel_id, node_id, funding_utxo) = loop {
+        let event = events
+            .recv_timeout(std::time::Duration::from_secs(30))
+            .map_err(|err| {
+                Error::Rpc(RpcError {
+                    code: -1,
+                    message: format!("{err}"),
+                    data: None,
+                })
+            })?;
         if let Event::Lightning(LightningEvent::CloseChannelEvent {
             message,
             channel_id,
@@ -38,7 +83,7 @@ pub fn json_close_channel(ctx: &LampoDeamon, request: &json::Value) -> Result<js
         {
             break (message, channel_id, counterparty_node_id, funding_utxo);
         }
-        };
+    };
     let resp = match res {
         Ok(_) => Ok(json::json!({
             "message" : message,

lampod/src/ln/channel_manager.rs

@@ -10,7 +10,6 @@ use lampo_common::bitcoin::absolute::Height;
 use lampo_common::bitcoin::{BlockHash, Transaction};
 use lampo_common::conf::{LampoConf, UserConfig};
 use lampo_common::error;
-use lampo_common::event::ln::LightningEvent;
 use lampo_common::event::onchain::OnChainEvent;
 use lampo_common::event::Event;
 use lampo_common::handler::Handler;
@@ -32,7 +31,7 @@ use lampo_common::ldk::util::config::{ChannelHandshakeConfig, ChannelHandshakeLi
 use lampo_common::ldk::util::persist::read_channel_monitors;
 use lampo_common::ldk::util::ser::ReadableArgs;
 use lampo_common::model::request;
-use lampo_common::model::response::{self, Channel, Channels, CloseChannel};
+use lampo_common::model::response::{self, Channel, Channels};
 
 use crate::actions::handler::LampoHandler;
 use crate::chain::{LampoChainManager, WalletManager};
@@ -450,10 +449,7 @@ impl ChannelEvents for LampoChannelManager {
         })
     }
 
-    fn close_channel(
-        &self,
-        channel: request::CloseChannel,
-    ) -> error::Result<()> {
+    fn close_channel(&self, channel: request::CloseChannel) -> error::Result<()> {
         let channel_id = channel.channel_id()?;
         let node_id = channel.counterpart_node_id()?;
 

lampod/src/ln/events.rs

@@ -31,10 +31,7 @@ pub trait ChannelEvents {
     ) -> error::Result<response::OpenChannel>;
 
     /// Close a channel
-    fn close_channel(
-        &self,
-        channel: request::CloseChannel,
-    ) -> error::Result<()>;
+    fn close_channel(&self, channel: request::CloseChannel) -> error::Result<()>;
 
     fn change_state_channel(&self, event: ChangeStateChannelEvent) -> error::Result<()>;
 }

tests/tests/src/lampo_cln_tests.rs

@@ -1,7 +1,6 @@
 use std::str::FromStr;
 use std::time::Duration;
 
-use lampo_common::bitcoin::hashes::hex;
 use lampo_common::error;
 use lampo_common::event::ln::LightningEvent;
 use lampo_common::event::onchain::OnChainEvent;
@@ -549,7 +548,6 @@ fn close_channel() {
         "regtest"
     ))
     .unwrap();
-    std::thread::sleep(Duration::from_secs(2));
     let btc = cln.btc();
     let lampo_manager = LampoTesting::new(btc.clone()).unwrap();
     let lampo = lampo_manager.lampod();
@@ -581,7 +579,19 @@ fn close_channel() {
         )
         .unwrap();
 
-    std::thread::sleep(Duration::from_secs(2));
+    // This would be the second channel
+    let _: json::Value = lampo
+        .call(
+            "fundchannel",
+            request::OpenChannel {
+                node_id: cln.rpc().getinfo().unwrap().id,
+                port: Some(cln.port.into()),
+                amount: 1_000_000_000,
+                public: true,
+                addr: Some("127.0.0.1".to_owned()),
+            },
+        )
+        .unwrap();
 
     // Get the transaction confirmed
     let _ = btc.rpc().generate_to_address(6, &address).unwrap();
@@ -628,12 +638,47 @@ fn close_channel() {
     // This should return the final channel_id as channel_id may differ from the time being in ChannelPending, ChannelClosed state.
     let channels: response::Channels = lampo.call("channels", json::json!({})).unwrap();
 
+    // This should fail as there are two channels with the peer so we need to pass the specific `channel_id`
     let result: Result<response::CloseChannel, _> = lampo.call(
         "close",
         request::CloseChannel {
             node_id: info_cln.id.to_string(),
-            channel_id: Some(channels.channels.first().unwrap().channel_id),
+            channel_id: None,
+        },
+    );
+
+    assert!(result.is_err(), "{:?}", result);
+
+    // Closing the first channel
+    let result: Result<response::CloseChannel, _> = lampo.call(
+        "close",
+        request::CloseChannel {
+            node_id: info_cln.id.to_string(),
+            channel_id: Some(channels.channels.first().unwrap().channel_id.to_string()),
         },
     );
     assert!(result.is_ok(), "{:?}", result);
+    // assert_eq!(&result.unwrap().counterparty_node_id, &info_cln.id.to_string());
+    assert_eq!(&result.unwrap().channel_id, &channels.channels.first().unwrap().channel_id.to_string());
+
+    // Closing the second channel - at this point there is only 1 channel with the peer
+    let result: Result<response::CloseChannel, _> = lampo.call(
+        "close",
+        request::CloseChannel {
+            node_id: info_cln.id.to_string(),
+            channel_id: None,
+        },
+    );
+    assert!(result.is_ok(), "{:?}", result);
+    assert_eq!(result.unwrap().counterparty_node_id, info_cln.id.to_string());
+
+    // Closing the third channel (this channel does not exist)
+    let result: Result<response::CloseChannel, _> = lampo.call(
+        "close",
+        request::CloseChannel {
+            node_id: info_cln.id.to_string(),
+            channel_id: Some(channels.channels.first().unwrap().channel_id.to_string()),
+        },
+    );
+    assert!(result.is_err(), "{:?}", result);
 }