X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fcli.rs;h=603e6a9ad117e5ec5218143ec58a4a799f300b67;hb=fed8e61327521ff288be20787d89665d475e09b8;hp=c5dda5fc33e11f19cad785bb5e042855e7babf68;hpb=a73d564d2b7f0733578747ed1c2604bd880efcd9;p=ldk-sample diff --git a/src/cli.rs b/src/cli.rs index c5dda5f..603e6a9 100644 --- a/src/cli.rs +++ b/src/cli.rs @@ -9,22 +9,22 @@ use bitcoin::secp256k1::key::PublicKey; use lightning::chain; use lightning::chain::keysinterface::KeysManager; use lightning::ln::features::InvoiceFeatures; +use lightning::ln::msgs::NetAddress; use lightning::ln::{PaymentHash, PaymentSecret}; use lightning::routing::network_graph::NetGraphMsgHandler; use lightning::routing::router; -use lightning::routing::router::RouteHintHop; -use lightning::util::config::UserConfig; +use lightning::routing::router::RouteHint; +use lightning::util::config::{ChannelConfig, ChannelHandshakeLimits, UserConfig}; use lightning_invoice::{utils, Currency, Invoice}; use std::env; use std::io; use std::io::{BufRead, Write}; -use std::net::{SocketAddr, TcpStream}; +use std::net::{IpAddr, SocketAddr, ToSocketAddrs}; use std::ops::Deref; use std::path::Path; use std::str::FromStr; use std::sync::Arc; use std::time::Duration; -use tokio::sync::mpsc; pub(crate) struct LdkUserInfo { pub(crate) bitcoind_rpc_username: String, @@ -33,12 +33,14 @@ pub(crate) struct LdkUserInfo { pub(crate) bitcoind_rpc_host: String, pub(crate) ldk_storage_dir_path: String, pub(crate) ldk_peer_listening_port: u16, + pub(crate) ldk_announced_listen_addr: Option, + pub(crate) ldk_announced_node_name: [u8; 32], pub(crate) network: Network, } pub(crate) fn parse_startup_args() -> Result { if env::args().len() < 3 { - println!("ldk-tutorial-node requires 3 arguments: `cargo run :@: ldk_storage_directory_path [] [bitcoin-network]`"); + println!("ldk-tutorial-node requires 3 arguments: `cargo run :@: ldk_storage_directory_path [] [bitcoin-network] [announced-listen-addr announced-node-name]`"); return Err(()); } let bitcoind_rpc_info = env::args().skip(1).next().unwrap(); @@ -84,6 +86,32 @@ pub(crate) fn parse_startup_args() -> Result { Some(_) => panic!("Unsupported network provided. Options are: `regtest`, `testnet`"), None => Network::Testnet, }; + + let ldk_announced_listen_addr = match env::args().skip(arg_idx + 1).next().as_ref() { + Some(s) => match IpAddr::from_str(s) { + Ok(IpAddr::V4(a)) => { + Some(NetAddress::IPv4 { addr: a.octets(), port: ldk_peer_listening_port }) + } + Ok(IpAddr::V6(a)) => { + Some(NetAddress::IPv6 { addr: a.octets(), port: ldk_peer_listening_port }) + } + Err(_) => panic!("Failed to parse announced-listen-addr into an IP address"), + }, + None => None, + }; + + let ldk_announced_node_name = match env::args().skip(arg_idx + 2).next().as_ref() { + Some(s) => { + if s.len() > 32 { + panic!("Node Alias can not be longer than 32 bytes"); + } + let mut bytes = [0; 32]; + bytes[..s.len()].copy_from_slice(s.as_bytes()); + bytes + } + None => [0; 32], + }; + Ok(LdkUserInfo { bitcoind_rpc_username, bitcoind_rpc_password, @@ -91,6 +119,8 @@ pub(crate) fn parse_startup_args() -> Result { bitcoind_rpc_port, ldk_storage_dir_path, ldk_peer_listening_port, + ldk_announced_listen_addr, + ldk_announced_node_name, network, }) } @@ -100,15 +130,15 @@ pub(crate) async fn poll_for_user_input( keys_manager: Arc, router: Arc, Arc>>, inbound_payments: PaymentInfoStorage, outbound_payments: PaymentInfoStorage, - event_notifier: mpsc::Sender<()>, ldk_data_dir: String, logger: Arc, - network: Network, + ldk_data_dir: String, logger: Arc, network: Network, ) { - println!("LDK startup successful. To view available commands: \"help\".\nLDK logs are available at /.ldk/logs"); + println!("LDK startup successful. To view available commands: \"help\"."); + println!("LDK logs are available at /.ldk/logs"); + println!("Local Node ID is {}.", channel_manager.get_our_node_id()); let stdin = io::stdin(); print!("> "); io::stdout().flush().unwrap(); // Without flushing, the `>` doesn't print for line in stdin.lock().lines() { - let _ = event_notifier.try_send(()); let line = line.unwrap(); let mut words = line.split_whitespace(); if let Some(word) = words.next() { @@ -143,13 +173,9 @@ pub(crate) async fn poll_for_user_input( continue; } - if connect_peer_if_necessary( - pubkey, - peer_addr, - peer_manager.clone(), - event_notifier.clone(), - ) - .is_err() + if connect_peer_if_necessary(pubkey, peer_addr, peer_manager.clone()) + .await + .is_err() { print!("> "); io::stdout().flush().unwrap(); @@ -201,11 +227,7 @@ pub(crate) async fn poll_for_user_input( continue; } }; - let mut route_hints = invoice.routes().clone(); - let mut last_hops = Vec::new(); - for hint in route_hints.drain(..) { - last_hops.push(hint[hint.len() - 1].clone()); - } + let last_hops = invoice.route_hints(); let amt_pico_btc = invoice.amount_pico_btc(); if amt_pico_btc.is_none() { @@ -292,13 +314,9 @@ pub(crate) async fn poll_for_user_input( continue; } }; - if connect_peer_if_necessary( - pubkey, - peer_addr, - peer_manager.clone(), - event_notifier.clone(), - ) - .is_ok() + if connect_peer_if_necessary(pubkey, peer_addr, peer_manager.clone()) + .await + .is_ok() { println!("SUCCESS: connected to peer {}", pubkey); } @@ -356,14 +374,16 @@ pub(crate) async fn poll_for_user_input( } fn help() { - println!("openchannel pubkey@host:port "); + println!("openchannel pubkey@host:port "); println!("sendpayment "); - println!("getinvoice "); + println!("getinvoice "); println!("connectpeer pubkey@host:port"); println!("listchannels"); println!("listpayments"); println!("closechannel "); println!("forceclosechannel "); + println!("nodeinfo"); + println!("listpeers"); } fn node_info(channel_manager: Arc, peer_manager: Arc) { @@ -389,20 +409,24 @@ fn list_channels(channel_manager: Arc) { println!(""); println!("\t{{"); println!("\t\tchannel_id: {},", hex_utils::hex_str(&chan_info.channel_id[..])); + if let Some(funding_txo) = chan_info.funding_txo { + println!("\t\tfunding_txid: {},", funding_txo.txid); + } println!( "\t\tpeer_pubkey: {},", hex_utils::hex_str(&chan_info.remote_network_id.serialize()) ); - let mut pending_channel = false; - match chan_info.short_channel_id { - Some(id) => println!("\t\tshort_channel_id: {},", id), - None => { - pending_channel = true; - } + if let Some(id) = chan_info.short_channel_id { + println!("\t\tshort_channel_id: {},", id); } - println!("\t\tpending_open: {},", pending_channel); + println!("\t\tis_confirmed_onchain: {},", chan_info.is_funding_locked); println!("\t\tchannel_value_satoshis: {},", chan_info.channel_value_satoshis); - println!("\t\tchannel_can_send_payments: {},", chan_info.is_live); + if chan_info.is_usable { + println!("\t\tavailable_balance_for_send_msat: {},", chan_info.outbound_capacity_msat); + println!("\t\tavailable_balance_for_recv_msat: {},", chan_info.inbound_capacity_msat); + } + println!("\t\tchannel_can_send_payments: {},", chan_info.is_usable); + println!("\t\tpublic: {},", chan_info.is_public); println!("\t}},"); } println!("]"); @@ -450,33 +474,38 @@ fn list_payments(inbound_payments: PaymentInfoStorage, outbound_payments: Paymen println!("]"); } -pub(crate) fn connect_peer_if_necessary( +pub(crate) async fn connect_peer_if_necessary( pubkey: PublicKey, peer_addr: SocketAddr, peer_manager: Arc, - event_notifier: mpsc::Sender<()>, ) -> Result<(), ()> { for node_pubkey in peer_manager.get_peer_node_ids() { if node_pubkey == pubkey { return Ok(()); } } - match TcpStream::connect_timeout(&peer_addr, Duration::from_secs(10)) { - Ok(stream) => { - let peer_mgr = peer_manager.clone(); - let event_ntfns = event_notifier.clone(); - tokio::spawn(async move { - lightning_net_tokio::setup_outbound(peer_mgr, event_ntfns, pubkey, stream).await; - }); + match lightning_net_tokio::connect_outbound(Arc::clone(&peer_manager), pubkey, peer_addr).await + { + Some(conn_closed_fut) => { + let mut closed_fut_box = Box::pin(conn_closed_fut); let mut peer_connected = false; while !peer_connected { + match futures::poll!(&mut closed_fut_box) { + std::task::Poll::Ready(_) => { + println!("ERROR: Peer disconnected before we finished the handshake"); + return Err(()); + } + std::task::Poll::Pending => {} + } for node_pubkey in peer_manager.get_peer_node_ids() { if node_pubkey == pubkey { peer_connected = true; } } + // Avoid blocking the tokio context by sleeping a bit + tokio::time::sleep(Duration::from_millis(10)).await; } } - Err(e) => { - println!("ERROR: failed to connect to peer: {:?}", e); + None => { + println!("ERROR: failed to connect to peer"); return Err(()); } } @@ -484,16 +513,20 @@ pub(crate) fn connect_peer_if_necessary( } fn open_channel( - peer_pubkey: PublicKey, channel_amt_sat: u64, announce_channel: bool, + peer_pubkey: PublicKey, channel_amt_sat: u64, announced_channel: bool, channel_manager: Arc, ) -> Result<(), ()> { - let mut config = UserConfig::default(); - if announce_channel { - config.channel_options.announced_channel = true; - } - // lnd's max to_self_delay is 2016, so we want to be compatible. - config.peer_channel_config_limits.their_to_self_delay = 2016; - match channel_manager.create_channel(peer_pubkey, channel_amt_sat, 0, 0, None) { + let config = UserConfig { + peer_channel_config_limits: ChannelHandshakeLimits { + // lnd's max to_self_delay is 2016, so we want to be compatible. + their_to_self_delay: 2016, + ..Default::default() + }, + channel_options: ChannelConfig { announced_channel, ..Default::default() }, + ..Default::default() + }; + + match channel_manager.create_channel(peer_pubkey, channel_amt_sat, 0, 0, Some(config)) { Ok(_) => { println!("EVENT: initiated channel with peer {}. ", peer_pubkey); return Ok(()); @@ -508,7 +541,7 @@ fn open_channel( fn send_payment( payee: PublicKey, amt_msat: u64, final_cltv: u32, payment_hash: PaymentHash, payment_secret: Option, payee_features: Option, - route_hints: Vec, + route_hints: Vec<&RouteHint>, router: Arc, Arc>>, channel_manager: Arc, payment_storage: PaymentInfoStorage, logger: Arc, @@ -523,7 +556,7 @@ fn send_payment( &payee, payee_features, Some(&first_hops.iter().collect::>()), - &route_hints.iter().collect::>(), + &route_hints, amt_msat, final_cltv, logger, @@ -622,13 +655,12 @@ pub(crate) fn parse_peer_info( if peer_addr_str.is_none() || peer_addr_str.is_none() { return Err(std::io::Error::new( std::io::ErrorKind::Other, - "ERROR: incorrectly formatted peer - info. Should be formatted as: `pubkey@host:port`", + "ERROR: incorrectly formatted peer info. Should be formatted as: `pubkey@host:port`", )); } - let peer_addr: Result = peer_addr_str.unwrap().parse(); - if peer_addr.is_err() { + let peer_addr = peer_addr_str.unwrap().to_socket_addrs().map(|mut r| r.next()); + if peer_addr.is_err() || peer_addr.as_ref().unwrap().is_none() { return Err(std::io::Error::new( std::io::ErrorKind::Other, "ERROR: couldn't parse pubkey@host:port into a socket address", @@ -643,5 +675,5 @@ pub(crate) fn parse_peer_info( )); } - Ok((pubkey.unwrap(), peer_addr.unwrap())) + Ok((pubkey.unwrap(), peer_addr.unwrap().unwrap())) }