X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fcli.rs;h=e3487421373c74ad6ae862fefe8f53119551edff;hb=b61dae03855accbafcbbc68c69692cbe1797b195;hp=96d5d9d3c137eaabf97358d17d1d676a1dbdef87;hpb=a9b67530dd95bc1d2b0aa5f075efb6fa7c002d5f;p=ldk-sample diff --git a/src/cli.rs b/src/cli.rs index 96d5d9d..e348742 100644 --- a/src/cli.rs +++ b/src/cli.rs @@ -1,32 +1,33 @@ -use crate::disk; +use crate::disk::{self, INBOUND_PAYMENTS_FNAME, OUTBOUND_PAYMENTS_FNAME}; use crate::hex_utils; use crate::{ - ChannelManager, HTLCStatus, MillisatAmount, NetworkGraph, OnionMessenger, PaymentInfo, - PaymentInfoStorage, PeerManager, + ChannelManager, HTLCStatus, InboundPaymentInfoStorage, MillisatAmount, NetworkGraph, + OnionMessenger, OutboundPaymentInfoStorage, PaymentInfo, PeerManager, }; use bitcoin::hashes::sha256::Hash as Sha256; use bitcoin::hashes::Hash; use bitcoin::network::constants::Network; use bitcoin::secp256k1::PublicKey; -use lightning::chain::keysinterface::{EntropySource, KeysManager}; -use lightning::ln::channelmanager::{PaymentId, Retry}; -use lightning::ln::msgs::NetAddress; -use lightning::ln::{PaymentHash, PaymentPreimage}; -use lightning::onion_message::{CustomOnionMessageContents, Destination, OnionMessageContents}; +use lightning::ln::channelmanager::{PaymentId, RecipientOnionFields, Retry}; +use lightning::ln::msgs::SocketAddress; +use lightning::ln::{ChannelId, PaymentHash, PaymentPreimage}; +use lightning::onion_message::messenger::Destination; +use lightning::onion_message::packet::OnionMessageContents; use lightning::routing::gossip::NodeId; use lightning::routing::router::{PaymentParameters, RouteParameters}; +use lightning::sign::{EntropySource, KeysManager}; use lightning::util::config::{ChannelHandshakeConfig, ChannelHandshakeLimits, UserConfig}; +use lightning::util::persist::KVStore; use lightning::util::ser::{Writeable, Writer}; -use lightning_invoice::payment::pay_invoice; -use lightning_invoice::{utils, Currency, Invoice}; +use lightning_invoice::{utils, Bolt11Invoice, Currency}; +use lightning_persister::fs_store::FilesystemStore; use std::env; use std::io; use std::io::Write; use std::net::{SocketAddr, ToSocketAddrs}; -use std::ops::Deref; use std::path::Path; use std::str::FromStr; -use std::sync::Arc; +use std::sync::{Arc, Mutex}; use std::time::Duration; pub(crate) struct LdkUserInfo { @@ -36,17 +37,18 @@ 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: Vec, + pub(crate) ldk_announced_listen_addr: Vec, pub(crate) ldk_announced_node_name: [u8; 32], pub(crate) network: Network, } +#[derive(Debug)] struct UserOnionMessageContents { tlv_type: u64, data: Vec, } -impl CustomOnionMessageContents for UserOnionMessageContents { +impl OnionMessageContents for UserOnionMessageContents { fn tlv_type(&self) -> u64 { self.tlv_type } @@ -58,12 +60,12 @@ impl Writeable for UserOnionMessageContents { } } -pub(crate) async fn poll_for_user_input( +pub(crate) fn poll_for_user_input( peer_manager: Arc, channel_manager: Arc, keys_manager: Arc, network_graph: Arc, - onion_messenger: Arc, inbound_payments: PaymentInfoStorage, - outbound_payments: PaymentInfoStorage, ldk_data_dir: String, network: Network, - logger: Arc, + onion_messenger: Arc, inbound_payments: Arc>, + outbound_payments: Arc>, ldk_data_dir: String, + network: Network, logger: Arc, fs_store: Arc, ) { println!( "LDK startup successful. Enter \"help\" to view available commands. Press Ctrl-D to quit." @@ -91,7 +93,7 @@ pub(crate) async fn poll_for_user_input( let peer_pubkey_and_ip_addr = words.next(); let channel_value_sat = words.next(); if peer_pubkey_and_ip_addr.is_none() || channel_value_sat.is_none() { - println!("ERROR: openchannel has 2 required arguments: `openchannel pubkey@host:port channel_amt_satoshis` [--public]"); + println!("ERROR: openchannel has 2 required arguments: `openchannel pubkey@host:port channel_amt_satoshis` [--public] [--with-anchors]"); continue; } let peer_pubkey_and_ip_addr = peer_pubkey_and_ip_addr.unwrap(); @@ -110,27 +112,36 @@ pub(crate) async fn poll_for_user_input( continue; } - if connect_peer_if_necessary(pubkey, peer_addr, peer_manager.clone()) - .await + if tokio::runtime::Handle::current() + .block_on(connect_peer_if_necessary( + pubkey, + peer_addr, + peer_manager.clone(), + )) .is_err() { continue; }; - let announce_channel = match words.next() { - Some("--public") | Some("--public=true") => true, - Some("--public=false") => false, - Some(_) => { - println!("ERROR: invalid `--public` command format. Valid formats: `--public`, `--public=true` `--public=false`"); - continue; + let (mut announce_channel, mut with_anchors) = (false, false); + while let Some(word) = words.next() { + match word { + "--public" | "--public=true" => announce_channel = true, + "--public=false" => announce_channel = false, + "--with-anchors" | "--with-anchors=true" => with_anchors = true, + "--with-anchors=false" => with_anchors = false, + _ => { + println!("ERROR: invalid boolean flag format. Valid formats: `--option`, `--option=true` `--option=false`"); + continue; + } } - None => false, - }; + } if open_channel( pubkey, chan_amt_sat.unwrap(), announce_channel, + with_anchors, channel_manager.clone(), ) .is_ok() @@ -149,7 +160,7 @@ pub(crate) async fn poll_for_user_input( continue; } - let invoice = match Invoice::from_str(invoice_str.unwrap()) { + let invoice = match Bolt11Invoice::from_str(invoice_str.unwrap()) { Ok(inv) => inv, Err(e) => { println!("ERROR: invalid invoice: {:?}", e); @@ -157,7 +168,12 @@ pub(crate) async fn poll_for_user_input( } }; - send_payment(&*channel_manager, &invoice, outbound_payments.clone()); + send_payment( + &channel_manager, + &invoice, + &mut outbound_payments.lock().unwrap(), + Arc::clone(&fs_store), + ); } "keysend" => { let dest_pubkey = match words.next() { @@ -188,11 +204,12 @@ pub(crate) async fn poll_for_user_input( } }; keysend( - &*channel_manager, + &channel_manager, dest_pubkey, amt_msat, &*keys_manager, - outbound_payments.clone(), + &mut outbound_payments.lock().unwrap(), + Arc::clone(&fs_store), ); } "getinvoice" => { @@ -220,15 +237,19 @@ pub(crate) async fn poll_for_user_input( continue; } + let mut inbound_payments = inbound_payments.lock().unwrap(); get_invoice( amt_msat.unwrap(), - Arc::clone(&inbound_payments), - &*channel_manager, + &mut inbound_payments, + &channel_manager, Arc::clone(&keys_manager), network, expiry_secs.unwrap(), Arc::clone(&logger), ); + fs_store + .write("", "", INBOUND_PAYMENTS_FNAME, &inbound_payments.encode()) + .unwrap(); } "connectpeer" => { let peer_pubkey_and_ip_addr = words.next(); @@ -244,8 +265,12 @@ pub(crate) async fn poll_for_user_input( continue; } }; - if connect_peer_if_necessary(pubkey, peer_addr, peer_manager.clone()) - .await + if tokio::runtime::Handle::current() + .block_on(connect_peer_if_necessary( + pubkey, + peer_addr, + peer_manager.clone(), + )) .is_ok() { println!("SUCCESS: connected to peer {}", pubkey); @@ -278,9 +303,10 @@ pub(crate) async fn poll_for_user_input( } } "listchannels" => list_channels(&channel_manager, &network_graph), - "listpayments" => { - list_payments(inbound_payments.clone(), outbound_payments.clone()) - } + "listpayments" => list_payments( + &inbound_payments.lock().unwrap(), + &outbound_payments.lock().unwrap(), + ), "closechannel" => { let channel_id_str = words.next(); if channel_id_str.is_none() { @@ -357,14 +383,14 @@ pub(crate) async fn poll_for_user_input( "listpeers" => list_peers(peer_manager.clone()), "signmessage" => { const MSG_STARTPOS: usize = "signmessage".len() + 1; - if line.as_bytes().len() <= MSG_STARTPOS { + if line.trim().as_bytes().len() <= MSG_STARTPOS { println!("ERROR: signmsg requires a message"); continue; } println!( "{:?}", lightning::util::message_signing::sign( - &line.as_bytes()[MSG_STARTPOS..], + &line.trim().as_bytes()[MSG_STARTPOS..], &keys_manager.get_node_secret_key() ) ); @@ -377,7 +403,7 @@ pub(crate) async fn poll_for_user_input( ); continue; } - let mut node_pks = Vec::new(); + let mut intermediate_nodes = Vec::new(); let mut errored = false; for pk_str in path_pks_str.unwrap().split(",") { let node_pubkey_vec = match hex_utils::to_vec(pk_str) { @@ -396,7 +422,7 @@ pub(crate) async fn poll_for_user_input( break; } }; - node_pks.push(node_pubkey); + intermediate_nodes.push(node_pubkey); } if errored { continue; @@ -415,14 +441,15 @@ pub(crate) async fn poll_for_user_input( continue; } }; - let destination_pk = node_pks.pop().unwrap(); + let destination = Destination::Node(intermediate_nodes.pop().unwrap()); match onion_messenger.send_onion_message( - &node_pks, - Destination::Node(destination_pk), - OnionMessageContents::Custom(UserOnionMessageContents { tlv_type, data }), + UserOnionMessageContents { tlv_type, data }, + destination, None, ) { - Ok(()) => println!("SUCCESS: forwarded onion message to first hop"), + Ok(success) => { + println!("SUCCESS: forwarded onion message to first hop {:?}", success) + } Err(e) => println!("ERROR: failed to send onion message: {:?}", e), } } @@ -444,7 +471,7 @@ fn help() { println!(" help\tShows a list of commands."); println!(" quit\tClose the application."); println!("\n Channels:"); - println!(" openchannel pubkey@host:port [--public]"); + println!(" openchannel pubkey@host:port [--public] [--with-anchors]"); println!(" closechannel "); println!(" forceclosechannel "); println!(" listchannels"); @@ -491,7 +518,7 @@ fn list_channels(channel_manager: &Arc, network_graph: &Arc, network_graph: &Arc, network_graph: &Arc, ) -> Result<(), ()> { let config = UserConfig { @@ -640,12 +667,13 @@ fn open_channel( }, channel_handshake_config: ChannelHandshakeConfig { announced_channel, + negotiate_anchors_zero_fee_htlc_tx: with_anchors, ..Default::default() }, ..Default::default() }; - match channel_manager.create_channel(peer_pubkey, channel_amt_sat, 0, 0, Some(config)) { + match channel_manager.create_channel(peer_pubkey, channel_amt_sat, 0, 0, None, Some(config)) { Ok(_) => { println!("EVENT: initiated channel with peer {}. ", peer_pubkey); return Ok(()); @@ -658,90 +686,132 @@ fn open_channel( } fn send_payment( - channel_manager: &ChannelManager, invoice: &Invoice, payment_storage: PaymentInfoStorage, + channel_manager: &ChannelManager, invoice: &Bolt11Invoice, + outbound_payments: &mut OutboundPaymentInfoStorage, fs_store: Arc, ) { - let status = - match pay_invoice(invoice, Retry::Timeout(Duration::from_secs(10)), channel_manager) { - Ok(_payment_id) => { - let payee_pubkey = invoice.recover_payee_pub_key(); - let amt_msat = invoice.amount_milli_satoshis().unwrap(); - println!("EVENT: initiated sending {} msats to {}", amt_msat, payee_pubkey); - print!("> "); - HTLCStatus::Pending - } - Err(e) => { - println!("ERROR: failed to send payment: {:?}", e); - print!("> "); - HTLCStatus::Failed - } - }; - let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner()); - let payment_secret = Some(invoice.payment_secret().clone()); - - let mut payments = payment_storage.lock().unwrap(); - payments.insert( - payment_hash, + let payment_id = PaymentId((*invoice.payment_hash()).to_byte_array()); + let payment_hash = PaymentHash((*invoice.payment_hash()).to_byte_array()); + let payment_secret = Some(*invoice.payment_secret()); + outbound_payments.payments.insert( + payment_id, PaymentInfo { preimage: None, secret: payment_secret, - status, + status: HTLCStatus::Pending, amt_msat: MillisatAmount(invoice.amount_milli_satoshis()), }, ); + fs_store.write("", "", OUTBOUND_PAYMENTS_FNAME, &outbound_payments.encode()).unwrap(); + + let mut recipient_onion = RecipientOnionFields::secret_only(*invoice.payment_secret()); + recipient_onion.payment_metadata = invoice.payment_metadata().map(|v| v.clone()); + let mut payment_params = match PaymentParameters::from_node_id( + invoice.recover_payee_pub_key(), + invoice.min_final_cltv_expiry_delta() as u32, + ) + .with_expiry_time( + invoice.duration_since_epoch().as_secs().saturating_add(invoice.expiry_time().as_secs()), + ) + .with_route_hints(invoice.route_hints()) + { + Err(e) => { + println!("ERROR: Could not process invoice to prepare payment parameters, {:?}, invoice: {:?}", e, invoice); + return; + } + Ok(p) => p, + }; + if let Some(features) = invoice.features() { + payment_params = match payment_params.with_bolt11_features(features.clone()) { + Err(e) => { + println!("ERROR: Could not build BOLT11 payment parameters! {:?}", e); + return; + } + Ok(p) => p, + }; + } + let invoice_amount = match invoice.amount_milli_satoshis() { + None => { + println!("ERROR: An invoice with an amount is expected; {:?}", invoice); + return; + } + Some(a) => a, + }; + let route_params = + RouteParameters::from_payment_params_and_value(payment_params, invoice_amount); + + match channel_manager.send_payment( + payment_hash, + recipient_onion, + payment_id, + route_params, + Retry::Timeout(Duration::from_secs(10)), + ) { + Ok(_) => { + let payee_pubkey = invoice.recover_payee_pub_key(); + let amt_msat = invoice.amount_milli_satoshis().unwrap(); + println!("EVENT: initiated sending {} msats to {}", amt_msat, payee_pubkey); + print!("> "); + } + Err(e) => { + println!("ERROR: failed to send payment: {:?}", e); + print!("> "); + outbound_payments.payments.get_mut(&payment_id).unwrap().status = HTLCStatus::Failed; + fs_store.write("", "", OUTBOUND_PAYMENTS_FNAME, &outbound_payments.encode()).unwrap(); + } + }; } fn keysend( channel_manager: &ChannelManager, payee_pubkey: PublicKey, amt_msat: u64, entropy_source: &E, - payment_storage: PaymentInfoStorage, + outbound_payments: &mut OutboundPaymentInfoStorage, fs_store: Arc, ) { let payment_preimage = PaymentPreimage(entropy_source.get_secure_random_bytes()); - let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0[..]).into_inner()); + let payment_id = PaymentId(Sha256::hash(&payment_preimage.0[..]).to_byte_array()); - let route_params = RouteParameters { - payment_params: PaymentParameters::for_keysend(payee_pubkey, 40), - final_value_msat: amt_msat, - }; - let status = match channel_manager.send_spontaneous_payment_with_retry( + let route_params = RouteParameters::from_payment_params_and_value( + PaymentParameters::for_keysend(payee_pubkey, 40, false), + amt_msat, + ); + outbound_payments.payments.insert( + payment_id, + PaymentInfo { + preimage: None, + secret: None, + status: HTLCStatus::Pending, + amt_msat: MillisatAmount(Some(amt_msat)), + }, + ); + fs_store.write("", "", OUTBOUND_PAYMENTS_FNAME, &outbound_payments.encode()).unwrap(); + match channel_manager.send_spontaneous_payment_with_retry( Some(payment_preimage), - PaymentId(payment_hash.0), + RecipientOnionFields::spontaneous_empty(), + payment_id, route_params, Retry::Timeout(Duration::from_secs(10)), ) { Ok(_payment_hash) => { println!("EVENT: initiated sending {} msats to {}", amt_msat, payee_pubkey); print!("> "); - HTLCStatus::Pending } Err(e) => { println!("ERROR: failed to send payment: {:?}", e); print!("> "); - HTLCStatus::Failed + outbound_payments.payments.get_mut(&payment_id).unwrap().status = HTLCStatus::Failed; + fs_store.write("", "", OUTBOUND_PAYMENTS_FNAME, &outbound_payments.encode()).unwrap(); } }; - - let mut payments = payment_storage.lock().unwrap(); - payments.insert( - payment_hash, - PaymentInfo { - preimage: None, - secret: None, - status, - amt_msat: MillisatAmount(Some(amt_msat)), - }, - ); } fn get_invoice( - amt_msat: u64, payment_storage: PaymentInfoStorage, channel_manager: &ChannelManager, - keys_manager: Arc, network: Network, expiry_secs: u32, - logger: Arc, + amt_msat: u64, inbound_payments: &mut InboundPaymentInfoStorage, + channel_manager: &ChannelManager, keys_manager: Arc, network: Network, + expiry_secs: u32, logger: Arc, ) { - let mut payments = payment_storage.lock().unwrap(); let currency = match network { Network::Bitcoin => Currency::Bitcoin, - Network::Testnet => Currency::BitcoinTestnet, Network::Regtest => Currency::Regtest, Network::Signet => Currency::Signet, + Network::Testnet | _ => Currency::BitcoinTestnet, }; let invoice = match utils::create_invoice_from_channelmanager( channel_manager, @@ -763,8 +833,8 @@ fn get_invoice( } }; - let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner()); - payments.insert( + let payment_hash = PaymentHash(invoice.payment_hash().to_byte_array()); + inbound_payments.payments.insert( payment_hash, PaymentInfo { preimage: None, @@ -778,7 +848,7 @@ fn get_invoice( fn close_channel( channel_id: [u8; 32], counterparty_node_id: PublicKey, channel_manager: Arc, ) { - match channel_manager.close_channel(&channel_id, &counterparty_node_id) { + match channel_manager.close_channel(&ChannelId(channel_id), &counterparty_node_id) { Ok(()) => println!("EVENT: initiating channel close"), Err(e) => println!("ERROR: failed to close channel: {:?}", e), } @@ -787,7 +857,9 @@ fn close_channel( fn force_close_channel( channel_id: [u8; 32], counterparty_node_id: PublicKey, channel_manager: Arc, ) { - match channel_manager.force_close_broadcasting_latest_txn(&channel_id, &counterparty_node_id) { + match channel_manager + .force_close_broadcasting_latest_txn(&ChannelId(channel_id), &counterparty_node_id) + { Ok(()) => println!("EVENT: initiating channel force-close"), Err(e) => println!("ERROR: failed to force-close channel: {:?}", e), }