X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fcli.rs;h=9bc2ef1584d80acaea947d42c9223c63cc1f09a7;hb=68a95c0646810ed7afe5022ac211c1f214d950c5;hp=b69f9af20c210638d9e9dedfcebc3d52eb6c4015;hpb=2ce4eb6de2eb3d550ddbee3134ac902199eb052f;p=ldk-sample diff --git a/src/cli.rs b/src/cli.rs index b69f9af..9bc2ef1 100644 --- a/src/cli.rs +++ b/src/cli.rs @@ -8,13 +8,14 @@ use bitcoin::hashes::Hash; use bitcoin::network::constants::Network; use bitcoin::secp256k1::key::PublicKey; use lightning::chain; -use lightning::chain::keysinterface::KeysManager; +use lightning::chain::keysinterface::{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::RouteHint; +use lightning::routing::scorer::Scorer; use lightning::util::config::{ChannelConfig, ChannelHandshakeLimits, UserConfig}; use lightning_invoice::{utils, Currency, Invoice}; use std::env; @@ -34,14 +35,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_listen_addr: Vec, 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] [announced-listen-addr announced-node-name]`"); + println!("ldk-tutorial-node requires 3 arguments: `cargo run :@: ldk_storage_directory_path [] [bitcoin-network] [announced-node-name announced-listen-addr*]`"); return Err(()); } let bitcoind_rpc_info = env::args().skip(1).next().unwrap(); @@ -70,42 +71,35 @@ pub(crate) fn parse_startup_args() -> Result { let mut ldk_peer_port_set = true; let ldk_peer_listening_port: u16 = match env::args().skip(3).next().map(|p| p.parse()) { Some(Ok(p)) => p, - Some(Err(e)) => panic!("{}", e), + Some(Err(_)) => { + ldk_peer_port_set = false; + 9735 + } None => { ldk_peer_port_set = false; 9735 } }; - let arg_idx = match ldk_peer_port_set { + let mut arg_idx = match ldk_peer_port_set { true => 4, false => 3, }; let network: Network = match env::args().skip(arg_idx).next().as_ref().map(String::as_str) { Some("testnet") => Network::Testnet, Some("regtest") => Network::Regtest, - Some(_) => panic!("Unsupported network provided. Options are: `regtest`, `testnet`"), + Some(net) => { + panic!("Unsupported network provided. Options are: `regtest`, `testnet`. Got {}", net); + } 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() { + let ldk_announced_node_name = match env::args().skip(arg_idx + 1).next().as_ref() { Some(s) => { if s.len() > 32 { panic!("Node Alias can not be longer than 32 bytes"); } + arg_idx += 1; let mut bytes = [0; 32]; bytes[..s.len()].copy_from_slice(s.as_bytes()); bytes @@ -113,6 +107,26 @@ pub(crate) fn parse_startup_args() -> Result { None => [0; 32], }; + let mut ldk_announced_listen_addr = Vec::new(); + loop { + match env::args().skip(arg_idx + 1).next().as_ref() { + Some(s) => match IpAddr::from_str(s) { + Ok(IpAddr::V4(a)) => { + ldk_announced_listen_addr + .push(NetAddress::IPv4 { addr: a.octets(), port: ldk_peer_listening_port }); + arg_idx += 1; + } + Ok(IpAddr::V6(a)) => { + ldk_announced_listen_addr + .push(NetAddress::IPv6 { addr: a.octets(), port: ldk_peer_listening_port }); + arg_idx += 1; + } + Err(_) => panic!("Failed to parse announced-listen-addr into an IP address"), + }, + None => break, + } + } + Ok(LdkUserInfo { bitcoind_rpc_username, bitcoind_rpc_password, @@ -242,7 +256,7 @@ pub(crate) async fn poll_for_user_input( let payee_pubkey = invoice.recover_payee_pub_key(); let final_cltv = invoice.min_final_cltv_expiry() as u32; let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner()); - let payment_secret = invoice.payment_secret().cloned(); + let payment_secret = Some(invoice.payment_secret().clone()); let invoice_features = invoice.features().cloned(); send_payment( @@ -259,6 +273,52 @@ pub(crate) async fn poll_for_user_input( logger.clone(), ); } + "keysend" => { + let dest_pubkey = match words.next() { + Some(dest) => match hex_utils::to_compressed_pubkey(dest) { + Some(pk) => pk, + None => { + println!("ERROR: couldn't parse destination pubkey"); + print!("> "); + io::stdout().flush().unwrap(); + continue; + } + }, + None => { + println!("ERROR: keysend requires a destination pubkey: `keysend `"); + print!("> "); + io::stdout().flush().unwrap(); + continue; + } + }; + let amt_msat_str = match words.next() { + Some(amt) => amt, + None => { + println!("ERROR: keysend requires an amount in millisatoshis: `keysend `"); + + print!("> "); + io::stdout().flush().unwrap(); + continue; + } + }; + let amt_msat: u64 = match amt_msat_str.parse() { + Ok(amt) => amt, + Err(e) => { + println!("ERROR: couldn't parse amount_msat: {}", e); + print!("> "); + io::stdout().flush().unwrap(); + continue; + } + }; + keysend( + dest_pubkey, + amt_msat, + router.clone(), + channel_manager.clone(), + outbound_payments.clone(), + logger.clone(), + ); + } "getinvoice" => { let amt_str = words.next(); if amt_str.is_none() { @@ -352,6 +412,24 @@ pub(crate) async fn poll_for_user_input( } "nodeinfo" => node_info(channel_manager.clone(), peer_manager.clone()), "listpeers" => list_peers(peer_manager.clone()), + "signmessage" => { + const MSG_STARTPOS: usize = "signmsg".len() + 1; + if line.as_bytes().len() <= MSG_STARTPOS { + println!("ERROR: signmsg requires a message"); + print!("> "); + io::stdout().flush().unwrap(); + continue; + } + println!( + "{:?}", + lightning::util::message_signing::sign( + &line.as_bytes()[MSG_STARTPOS..], + &keys_manager.get_node_secret() + ) + ); + print!("> "); + io::stdout().flush().unwrap(); + } _ => println!("Unknown command. See `\"help\" for available commands."), } } @@ -371,6 +449,7 @@ fn help() { println!("forceclosechannel "); println!("nodeinfo"); println!("listpeers"); + println!("signmessage "); } fn node_info(channel_manager: Arc, peer_manager: Arc) { @@ -401,13 +480,18 @@ fn list_channels(channel_manager: Arc) { } println!( "\t\tpeer_pubkey: {},", - hex_utils::hex_str(&chan_info.remote_network_id.serialize()) + hex_utils::hex_str(&chan_info.counterparty.node_id.serialize()) ); if let Some(id) = chan_info.short_channel_id { println!("\t\tshort_channel_id: {},", id); } println!("\t\tis_confirmed_onchain: {},", chan_info.is_funding_locked); println!("\t\tchannel_value_satoshis: {},", chan_info.channel_value_satoshis); + println!( + "\t\tlocal_balance_msat: {},", + chan_info.outbound_capacity_msat + + chan_info.unspendable_punishment_reserve.unwrap_or(0) * 1000 + ); 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); @@ -530,7 +614,7 @@ fn send_payment( channel_manager: Arc, payment_storage: PaymentInfoStorage, logger: Arc, ) { - let network_graph = router.network_graph.read().unwrap(); + let network_graph = &router.network_graph; let first_hops = channel_manager.list_usable_channels(); let payer_pubkey = channel_manager.get_our_node_id(); @@ -544,6 +628,7 @@ fn send_payment( amt_msat, final_cltv, logger, + &Scorer::default(), ); if let Err(e) = route { println!("ERROR: failed to find route: {}", e.err); @@ -551,7 +636,7 @@ fn send_payment( } let status = match channel_manager.send_payment(&route.unwrap(), payment_hash, &payment_secret) { - Ok(()) => { + Ok(_payment_id) => { println!("EVENT: initiated sending {} msats to {}", amt_msat, payee); HTLCStatus::Pending } @@ -572,6 +657,47 @@ fn send_payment( ); } +fn keysend( + payee: PublicKey, amt_msat: u64, + router: Arc, Arc>>, + channel_manager: Arc, payment_storage: PaymentInfoStorage, + logger: Arc, +) { + let network_graph = &router.network_graph; + let first_hops = channel_manager.list_usable_channels(); + let payer_pubkey = channel_manager.get_our_node_id(); + + let route = match router::get_keysend_route( + &payer_pubkey, + &network_graph, + &payee, + Some(&first_hops.iter().collect::>()), + &vec![], + amt_msat, + 40, + logger, + &Scorer::default(), + ) { + Ok(r) => r, + Err(e) => { + println!("ERROR: failed to find route: {}", e.err); + return; + } + }; + + let mut payments = payment_storage.lock().unwrap(); + let payment_hash = channel_manager.send_spontaneous_payment(&route, None).unwrap().0; + payments.insert( + payment_hash, + PaymentInfo { + preimage: None, + secret: None, + status: HTLCStatus::Pending, + amt_msat: MillisatAmount(Some(amt_msat)), + }, + ); +} + fn get_invoice( amt_msat: u64, payment_storage: PaymentInfoStorage, channel_manager: Arc, keys_manager: Arc, network: Network, @@ -605,7 +731,7 @@ fn get_invoice( payment_hash, PaymentInfo { preimage: None, - secret: invoice.payment_secret().cloned(), + secret: Some(invoice.payment_secret().clone()), status: HTLCStatus::Pending, amt_msat: MillisatAmount(Some(amt_msat)), },