use crate::disk;
use crate::hex_utils;
use crate::{
- ChannelManager, FilesystemLogger, HTLCDirection, HTLCStatus, PaymentInfoStorage, PeerManager,
- SatoshiAmount,
+ ChannelManager, FilesystemLogger, HTLCStatus, MillisatAmount, PaymentInfo, PaymentInfoStorage,
+ PeerManager,
};
use bitcoin::hashes::sha256::Hash as Sha256Hash;
use bitcoin::hashes::Hash;
use lightning::chain;
use lightning::ln::channelmanager::{PaymentHash, PaymentPreimage, PaymentSecret};
use lightning::ln::features::InvoiceFeatures;
-use lightning::routing::network_graph::NetGraphMsgHandler;
+use lightning::routing::network_graph::{NetGraphMsgHandler, RoutingFees};
use lightning::routing::router;
+use lightning::routing::router::RouteHint;
use lightning::util::config::UserConfig;
use rand;
use rand::Rng;
use std::str::FromStr;
use std::sync::Arc;
use std::time::Duration;
-use tokio::runtime::Handle;
use tokio::sync::mpsc;
pub(crate) struct LdkUserInfo {
})
}
-pub(crate) fn poll_for_user_input(
+pub(crate) async fn poll_for_user_input(
peer_manager: Arc<PeerManager>, channel_manager: Arc<ChannelManager>,
router: Arc<NetGraphMsgHandler<Arc<dyn chain::Access>, Arc<FilesystemLogger>>>,
- payment_storage: PaymentInfoStorage, node_privkey: SecretKey, event_notifier: mpsc::Sender<()>,
- ldk_data_dir: String, logger: Arc<FilesystemLogger>, runtime_handle: Handle, network: Network,
+ inbound_payments: PaymentInfoStorage, outbound_payments: PaymentInfoStorage,
+ node_privkey: SecretKey, event_notifier: mpsc::Sender<()>, ldk_data_dir: String,
+ logger: Arc<FilesystemLogger>, network: Network,
) {
println!("LDK startup successful. To view available commands: \"help\".\nLDK logs are available at <your-supplied-ldk-data-dir-path>/.ldk/logs");
let stdin = io::stdin();
peer_addr,
peer_manager.clone(),
event_notifier.clone(),
- runtime_handle.clone(),
)
.is_err()
{
continue;
};
- // let private_channel = match words.next().as_ref().map(String::as_str) {
let announce_channel = match words.next() {
- Some("--public") | Some("--public=true") | Some("--public true") => true,
- Some("--public=false") | Some("--public false") => false,
+ Some("--public") | Some("--public=true") => true,
+ Some("--public=false") => false,
Some(_) => {
- println!("ERROR: invalid `--public` command format");
+ println!("ERROR: invalid `--public` command format. Valid formats: `--public`, `--public=true` `--public=false`");
print!("> ");
io::stdout().flush().unwrap();
continue;
continue;
}
let invoice = invoice_res.unwrap();
+ let route_hints: Vec<lightning_invoice::Route> =
+ invoice.routes().iter().map(|&route| route.clone()).collect();
let amt_pico_btc = invoice.amount_pico_btc();
if amt_pico_btc.is_none() {
payment_hash,
payment_secret,
invoice_features_opt,
+ route_hints,
router.clone(),
channel_manager.clone(),
- payment_storage.clone(),
+ outbound_payments.clone(),
logger.clone(),
);
}
"getinvoice" => {
let amt_str = words.next();
if amt_str.is_none() {
- println!("ERROR: getinvoice requires an amount in satoshis");
+ println!("ERROR: getinvoice requires an amount in millisatoshis");
print!("> ");
io::stdout().flush().unwrap();
continue;
}
- let amt_sat: Result<u64, _> = amt_str.unwrap().parse();
- if amt_sat.is_err() {
+ let amt_msat: Result<u64, _> = amt_str.unwrap().parse();
+ if amt_msat.is_err() {
println!("ERROR: getinvoice provided payment amount was not a number");
print!("> ");
io::stdout().flush().unwrap();
continue;
}
get_invoice(
- amt_sat.unwrap(),
- payment_storage.clone(),
+ amt_msat.unwrap(),
+ inbound_payments.clone(),
node_privkey.clone(),
channel_manager.clone(),
network,
peer_addr,
peer_manager.clone(),
event_notifier.clone(),
- runtime_handle.clone(),
)
.is_ok()
{
}
}
"listchannels" => list_channels(channel_manager.clone()),
- "listpayments" => list_payments(payment_storage.clone()),
+ "listpayments" => {
+ list_payments(inbound_payments.clone(), outbound_payments.clone())
+ }
"closechannel" => {
let channel_id_str = words.next();
if channel_id_str.is_none() {
fn help() {
println!("openchannel pubkey@host:port <channel_amt_satoshis>");
println!("sendpayment <invoice>");
- println!("getinvoice <amt_in_satoshis>");
+ println!("getinvoice <amt_in_millisatoshis>");
println!("connectpeer pubkey@host:port");
println!("listchannels");
println!("listpayments");
println!("]");
}
-fn list_payments(payment_storage: PaymentInfoStorage) {
- let payments = payment_storage.lock().unwrap();
+fn list_payments(inbound_payments: PaymentInfoStorage, outbound_payments: PaymentInfoStorage) {
+ let inbound = inbound_payments.lock().unwrap();
+ let outbound = outbound_payments.lock().unwrap();
print!("[");
- for (payment_hash, payment_info) in payments.deref() {
- let direction_str = match payment_info.1 {
- HTLCDirection::Inbound => "inbound",
- HTLCDirection::Outbound => "outbound",
- };
+ for (payment_hash, payment_info) in inbound.deref() {
+ println!("");
+ println!("\t{{");
+ println!("\t\tamount_millisatoshis: {},", payment_info.amt_msat);
+ println!("\t\tpayment_hash: {},", hex_utils::hex_str(&payment_hash.0));
+ println!("\t\thtlc_direction: inbound,");
+ println!(
+ "\t\thtlc_status: {},",
+ match payment_info.status {
+ HTLCStatus::Pending => "pending",
+ HTLCStatus::Succeeded => "succeeded",
+ HTLCStatus::Failed => "failed",
+ }
+ );
+
+ println!("\t}},");
+ }
+
+ for (payment_hash, payment_info) in outbound.deref() {
println!("");
println!("\t{{");
- println!("\t\tamount_satoshis: {},", payment_info.3);
+ println!("\t\tamount_millisatoshis: {},", payment_info.amt_msat);
println!("\t\tpayment_hash: {},", hex_utils::hex_str(&payment_hash.0));
- println!("\t\thtlc_direction: {},", direction_str);
+ println!("\t\thtlc_direction: outbound,");
println!(
"\t\thtlc_status: {},",
- match payment_info.2 {
+ match payment_info.status {
HTLCStatus::Pending => "pending",
HTLCStatus::Succeeded => "succeeded",
HTLCStatus::Failed => "failed",
pub(crate) fn connect_peer_if_necessary(
pubkey: PublicKey, peer_addr: SocketAddr, peer_manager: Arc<PeerManager>,
- event_notifier: mpsc::Sender<()>, runtime: Handle,
+ event_notifier: mpsc::Sender<()>,
) -> Result<(), ()> {
for node_pubkey in peer_manager.get_peer_node_ids() {
if node_pubkey == pubkey {
Ok(stream) => {
let peer_mgr = peer_manager.clone();
let event_ntfns = event_notifier.clone();
- runtime.spawn(async move {
+ tokio::spawn(async move {
lightning_net_tokio::setup_outbound(peer_mgr, event_ntfns, pubkey, stream).await;
});
let mut peer_connected = false;
fn send_payment(
payee: PublicKey, amt_msat: u64, final_cltv: u32, payment_hash: PaymentHash,
payment_secret: Option<PaymentSecret>, payee_features: Option<InvoiceFeatures>,
+ mut route_hints: Vec<lightning_invoice::Route>,
router: Arc<NetGraphMsgHandler<Arc<dyn chain::Access>, Arc<FilesystemLogger>>>,
channel_manager: Arc<ChannelManager>, payment_storage: PaymentInfoStorage,
logger: Arc<FilesystemLogger>,
let first_hops = channel_manager.list_usable_channels();
let payer_pubkey = channel_manager.get_our_node_id();
+ let mut hints: Vec<RouteHint> = Vec::new();
+ for route in route_hints.drain(..) {
+ let route_hops = route.into_inner();
+ let last_hop = &route_hops[route_hops.len() - 1];
+ hints.push(RouteHint {
+ src_node_id: last_hop.pubkey,
+ short_channel_id: u64::from_be_bytes(last_hop.short_channel_id),
+ fees: RoutingFees {
+ base_msat: last_hop.fee_base_msat,
+ proportional_millionths: last_hop.fee_proportional_millionths,
+ },
+ cltv_expiry_delta: last_hop.cltv_expiry_delta,
+ htlc_minimum_msat: None,
+ htlc_maximum_msat: None,
+ })
+ }
let route = router::get_route(
&payer_pubkey,
&network_graph,
&payee,
payee_features,
Some(&first_hops.iter().collect::<Vec<_>>()),
- &vec![],
+ &hints.iter().collect::<Vec<_>>(),
amt_msat,
final_cltv,
logger,
let mut payments = payment_storage.lock().unwrap();
payments.insert(
payment_hash,
- (None, HTLCDirection::Outbound, status, SatoshiAmount(Some(amt_msat / 1000))),
+ PaymentInfo {
+ preimage: None,
+ secret: payment_secret,
+ status,
+ amt_msat: MillisatAmount(Some(amt_msat)),
+ },
);
}
fn get_invoice(
- amt_sat: u64, payment_storage: PaymentInfoStorage, our_node_privkey: SecretKey,
+ amt_msat: u64, payment_storage: PaymentInfoStorage, our_node_privkey: SecretKey,
channel_manager: Arc<ChannelManager>, network: Network,
) {
let mut payments = payment_storage.lock().unwrap();
})
.payment_hash(payment_hash)
.description("rust-lightning-bitcoinrpc invoice".to_string())
- .amount_pico_btc(amt_sat * 10_000)
+ .amount_pico_btc(amt_msat * 10)
.current_timestamp()
.payee_pub_key(our_node_pubkey);
// Add route hints to the invoice.
let our_channels = channel_manager.list_usable_channels();
+ let mut min_final_cltv_expiry = 9;
for channel in our_channels {
let short_channel_id = match channel.short_channel_id {
Some(id) => id.to_be_bytes(),
Some(info) => info,
None => continue,
};
- println!("VMW: adding routehop, info.fee base: {}", forwarding_info.fee_base_msat);
+ if forwarding_info.cltv_expiry_delta > min_final_cltv_expiry {
+ min_final_cltv_expiry = forwarding_info.cltv_expiry_delta;
+ }
invoice = invoice.route(vec![lightning_invoice::RouteHop {
pubkey: channel.remote_network_id,
short_channel_id,
cltv_expiry_delta: forwarding_info.cltv_expiry_delta,
}]);
}
+ invoice = invoice.min_final_cltv_expiry(min_final_cltv_expiry.into());
// Sign the invoice.
let invoice =
payments.insert(
PaymentHash(payment_hash.into_inner()),
- (
- Some(PaymentPreimage(preimage)),
- HTLCDirection::Inbound,
- HTLCStatus::Pending,
- SatoshiAmount(Some(amt_sat)),
- ),
+ PaymentInfo {
+ preimage: Some(PaymentPreimage(preimage)),
+ // We can't add payment secrets to invoices until we support features in invoices.
+ // Otherwise lnd errors with "destination hop doesn't understand payment addresses"
+ // (for context, lnd calls payment secrets "payment addresses").
+ secret: None,
+ status: HTLCStatus::Pending,
+ amt_msat: MillisatAmount(Some(amt_msat)),
+ },
);
}