Update to latest upstream rust-lightning, bumping deps

[ldk-sample] / src / cli.rs

diff --git a/src/cli.rs b/src/cli.rs
index b45de4221b95da49c5e9021b37f94728ded5ea57..d4d7e9ed4263079d84f3e3e42d1efc269f8f5404 100644 (file)
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -267,6 +267,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 <dest_pubkey> <amt_msat>`");
+                                                       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 <dest_pubkey> <amt_msat>`");
+
+                                                       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() {
@@ -416,6 +462,11 @@ fn list_channels(channel_manager: Arc<ChannelManager>) {
                }
                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);
@@ -580,6 +631,46 @@ fn send_payment(
        );
 }
 
+fn keysend(
+       payee: PublicKey, amt_msat: u64,
+       router: Arc<NetGraphMsgHandler<Arc<dyn chain::Access + Send + Sync>, Arc<FilesystemLogger>>>,
+       channel_manager: Arc<ChannelManager>, payment_storage: PaymentInfoStorage,
+       logger: Arc<FilesystemLogger>,
+) {
+       let network_graph = router.network_graph.read().unwrap();
+       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<_>>()),
+               &vec![],
+               amt_msat,
+               40,
+               logger,
+       ) {
+               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();
+       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<ChannelManager>,
        keys_manager: Arc<KeysManager>, network: Network,