Lightning Network Channels

mm2src/coins/Cargo.toml

@@ -43,7 +43,7 @@ jsonrpc-core = "8.0.1"
 keys = { path = "../mm2_bitcoin/keys" }
 lazy_static = "1.4"
 libc = "0.2"
-lightning = "0.0.101"
+lightning = "0.0.103"
 metrics = "0.12"
 mocktopus = "0.7.0"
 num-traits = "0.2"
@@ -78,9 +78,9 @@ web-sys = { version = "0.3.4", features = ["console", "Headers", "Request", "Req
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 dirs = { version = "1" }
-lightning-background-processor = "0.0.101"
-lightning-persister = "0.0.101"
-lightning-net-tokio = "0.0.101"
+lightning-background-processor = "0.0.103"
+lightning-persister = "0.0.103"
+lightning-net-tokio = "0.0.103"
 rusqlite = { version = "0.24.2", features = ["bundled"], optional = true }
 rust-ini = { version = "0.13" }
 rustls = { version = "0.19", features = ["dangerous_configuration"] }

mm2src/coins/lightning.rs

@@ -1,12 +1,23 @@
 #[cfg(not(target_arch = "wasm32"))]
 use crate::utxo::rpc_clients::UtxoRpcClientEnum;
 #[cfg(not(target_arch = "wasm32"))]
+use crate::utxo::utxo_common::big_decimal_from_sat;
+use crate::WithdrawFee;
+#[cfg(not(target_arch = "wasm32"))]
 use common::ip_addr::myipaddr;
 use common::mm_ctx::MmArc;
 use common::mm_error::prelude::*;
-use ln_errors::{EnableLightningError, EnableLightningResult};
 #[cfg(not(target_arch = "wasm32"))]
-use ln_utils::{network_from_string, start_lightning, LightningConf};
+use futures::compat::Future01CompatExt;
+use ln_errors::{ConnectToNodeError, ConnectToNodeResult, EnableLightningError, EnableLightningResult,
+                OpenChannelError, OpenChannelResult};
+#[cfg(not(target_arch = "wasm32"))]
+use ln_utils::{connect_to_node, network_from_string, nodes_data_path, open_ln_channel, parse_node_info,
+               read_nodes_data_from_file, save_node_data_to_file, start_lightning, LightningConf, LightningContext};
+use std::sync::atomic::AtomicU64;
+#[cfg(not(target_arch = "wasm32"))]
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
 
 #[cfg(not(target_arch = "wasm32"))]
 use super::{lp_coinfind_or_err, MmCoinEnum};
@@ -15,6 +26,10 @@ mod ln_errors;
 mod ln_rpc;
 #[cfg(not(target_arch = "wasm32"))] mod ln_utils;
 
+lazy_static! {
+    static ref REQUEST_IDX: Arc<AtomicU64> = Arc::new(AtomicU64::new(0));
+}
+
 #[derive(Deserialize)]
 pub struct EnableLightningRequest {
     pub coin: String,
@@ -54,6 +69,18 @@ pub async fn enable_lightning(ctx: MmArc, req: EnableLightningRequest) -> Enable
         ));
     }
 
+    // Channel funding transactions need to spend segwit outputs
+    // and while the witness script can be generated from pubkey and be used
+    // it's better for the coin to be enabled in segwit to check if balance is enough for funding transaction, etc...
+    // TODO: when merging with the "mm2.1-orderbook-ticker-btc-segwit" PR, we should have a different coin called BTC-Lightning
+    // with same ticker as BTC and to open a channel the BTC-Segwit wallet should be used to fund the transaction
+    if !utxo_coin.as_ref().my_address.addr_format.is_segwit() {
+        return MmError::err(EnableLightningError::UnsupportedMode(
+            "Lightning network".into(),
+            "segwit".into(),
+        ));
+    }
+
     let client = match &utxo_coin.as_ref().rpc_client {
         UtxoRpcClientEnum::Electrum(c) => c,
         UtxoRpcClientEnum::Native(_) => {
@@ -94,7 +121,133 @@ pub async fn enable_lightning(ctx: MmArc, req: EnableLightningRequest) -> Enable
     let port = req.port.unwrap_or(9735);
 
     let conf = LightningConf::new(client.clone(), network, listen_addr, port, node_name, node_color);
-    start_lightning(&ctx, conf).await?;
+    start_lightning(ctx, utxo_coin, conf).await?;
 
     Ok("success".into())
 }
+
+#[derive(Deserialize)]
+pub struct ConnectToNodeRequest {
+    pub coin: String,
+    pub node_id: String,
+}
+
+#[cfg(target_arch = "wasm32")]
+pub async fn connect_to_lightning_node(_ctx: MmArc, _req: ConnectToNodeRequest) -> ConnectToNodeResult<String> {
+    MmError::err(ConnectToNodeError::UnsupportedMode(
+        "'connect_to_lightning_node'".into(),
+        "native".into(),
+    ))
+}
+
+/// Connect to a certain node on the lightning network.
+#[cfg(not(target_arch = "wasm32"))]
+pub async fn connect_to_lightning_node(ctx: MmArc, req: ConnectToNodeRequest) -> ConnectToNodeResult<String> {
+    let lightning_ctx = LightningContext::from_ctx(&ctx).unwrap();
+
+    {
+        let background_processor = lightning_ctx.background_processors.lock().await;
+        if !background_processor.contains_key(&req.coin) {
+            return MmError::err(ConnectToNodeError::LightningNotEnabled(req.coin));
+        }
+    }
+
+    let (node_pubkey, node_addr) = parse_node_info(req.node_id.clone())?;
+
+    let peer_managers = lightning_ctx.peer_managers.lock().await;
+    let peer_manager = peer_managers
+        .get(&req.coin)
+        .ok_or(ConnectToNodeError::LightningNotEnabled(req.coin))?;
+    let res = connect_to_node(node_pubkey, node_addr, peer_manager.clone()).await?;
+
+    Ok(res.to_string())
+}
+
+fn get_true() -> bool { true }
+
+#[allow(dead_code)]
+#[derive(Deserialize)]
+pub struct OpenChannelRequest {
+    pub coin: String,
+    pub node_id: String,
+    #[serde(default)]
+    pub amount_in_sat: u64,
+    #[serde(default)]
+    max: bool,
+    fee: Option<WithdrawFee>,
+    #[serde(default = "get_true")]
+    pub announce_channel: bool,
+}
+
+#[cfg(target_arch = "wasm32")]
+pub async fn open_channel(_ctx: MmArc, _req: OpenChannelRequest) -> OpenChannelResult<String> {
+    MmError::err(OpenChannelError::UnsupportedMode(
+        "'open_channel'".into(),
+        "native".into(),
+    ))
+}
+
+/// Opens a channel on the lightning network.
+#[cfg(not(target_arch = "wasm32"))]
+pub async fn open_channel(ctx: MmArc, req: OpenChannelRequest) -> OpenChannelResult<String> {
+    let coin = lp_coinfind_or_err(&ctx, &req.coin).await?;
+
+    let balance = coin.my_spendable_balance().compat().await?;
+    if balance < big_decimal_from_sat(req.amount_in_sat as i64, coin.decimals()) {
+        return MmError::err(OpenChannelError::BalanceError(format!(
+            "Not enough balance to open channel, Current balance: {}",
+            balance
+        )));
+    }
+
+    let lightning_ctx = LightningContext::from_ctx(&ctx).unwrap();
+
+    {
+        let background_processor = lightning_ctx.background_processors.lock().await;
+        if !background_processor.contains_key(&req.coin) {
+            return MmError::err(OpenChannelError::LightningNotEnabled(req.coin));
+        }
+    }
+
+    let (node_pubkey, node_addr) = parse_node_info(req.node_id.clone())?;
+
+    {
+        let peer_managers = lightning_ctx.peer_managers.lock().await;
+        let peer_manager = peer_managers
+            .get(&req.coin)
+            .ok_or_else(|| ConnectToNodeError::LightningNotEnabled(req.coin.clone()))?;
+        connect_to_node(node_pubkey, node_addr, peer_manager.clone()).await?;
+    }
+
+    let nodes_data = read_nodes_data_from_file(&nodes_data_path(&ctx))?;
+    if !nodes_data.contains_key(&node_pubkey) {
+        save_node_data_to_file(&nodes_data_path(&ctx), &req.node_id)?;
+    }
+
+    // Helps in tracking which FundingGenerationReady events corresponds to which open_channel call
+    let request_id = REQUEST_IDX.fetch_add(1, Ordering::Relaxed);
+
+    {
+        let mut funding_tx_params = lightning_ctx.funding_tx_params.lock().await;
+        funding_tx_params.insert(request_id, (req.fee, req.max));
+    }
+
+    let temporary_channel_id = {
+        let channel_managers = lightning_ctx.channel_managers.lock().await;
+        let channel_manager = channel_managers
+            .get(&req.coin)
+            .ok_or(ConnectToNodeError::LightningNotEnabled(req.coin))?;
+        open_ln_channel(
+            node_pubkey,
+            req.amount_in_sat,
+            request_id,
+            req.announce_channel,
+            channel_manager.clone(),
+        )?
+    };
+
+    Ok(format!(
+        "Initiated opening channel with temporary ID {:?} with node {} and request id {}",
+        temporary_channel_id, req.node_id, request_id
+    ))
+}