+ Event::PaymentPathFailed {
+ payment_hash,
+ rejected_by_dest,
+ network_update: _,
+ all_paths_failed,
+ path: _,
+ short_channel_id,
+ ..
+ } => {
+ print!(
+ "\nEVENT: Failed to send payment{} to payment hash {:?}",
+ if *all_paths_failed { "" } else { " along MPP path" },
+ hex_utils::hex_str(&payment_hash.0)
+ );
+ if let Some(scid) = short_channel_id {
+ print!(" because of failure at channel {}", scid);
+ }
+ if *rejected_by_dest {
+ println!(": re-attempting the payment will not succeed");
+ } else {
+ println!(": payment may be retried");
+ }
+ print!("> ");
+ io::stdout().flush().unwrap();
+
+ let mut payments = outbound_payments.lock().unwrap();
+ if payments.contains_key(&payment_hash) {
+ let payment = payments.get_mut(&payment_hash).unwrap();
+ payment.status = HTLCStatus::Failed;
+ }
+ }
+ Event::PaymentForwarded { fee_earned_msat, claim_from_onchain_tx } => {
+ let from_onchain_str = if *claim_from_onchain_tx {
+ "from onchain downstream claim"
+ } else {
+ "from HTLC fulfill message"
+ };
+ if let Some(fee_earned) = fee_earned_msat {
+ println!(
+ "\nEVENT: Forwarded payment, earning {} msat {}",
+ fee_earned, from_onchain_str
+ );
+ } else {
+ println!("\nEVENT: Forwarded payment, claiming onchain {}", from_onchain_str);
+ }
+ print!("> ");
+ io::stdout().flush().unwrap();
+ }
+ Event::PendingHTLCsForwardable { time_forwardable } => {
+ let forwarding_channel_manager = channel_manager.clone();
+ let min = time_forwardable.as_millis() as u64;
+ tokio::spawn(async move {
+ let millis_to_sleep = thread_rng().gen_range(min, min * 5) as u64;
+ tokio::time::sleep(Duration::from_millis(millis_to_sleep)).await;
+ forwarding_channel_manager.process_pending_htlc_forwards();
+ });
+ }
+ Event::SpendableOutputs { outputs } => {
+ let destination_address = bitcoind_client.get_new_address().await;
+ let output_descriptors = &outputs.iter().map(|a| a).collect::<Vec<_>>();
+ let tx_feerate =
+ bitcoind_client.get_est_sat_per_1000_weight(ConfirmationTarget::Normal);
+ let spending_tx = keys_manager
+ .spend_spendable_outputs(
+ output_descriptors,
+ Vec::new(),
+ destination_address.script_pubkey(),
+ tx_feerate,
+ &Secp256k1::new(),
+ )
+ .unwrap();
+ bitcoind_client.broadcast_transaction(&spending_tx);
+ }
+ Event::ChannelClosed { channel_id, reason, user_channel_id: _ } => {
+ println!(
+ "\nEVENT: Channel {} closed due to: {:?}",
+ hex_utils::hex_str(channel_id),
+ reason
+ );
+ print!("> ");
+ io::stdout().flush().unwrap();
+ }
+ Event::DiscardFunding { .. } => {
+ // A "real" node should probably "lock" the UTXOs spent in funding transactions until
+ // the funding transaction either confirms, or this event is generated.
+ }