feat: allow self payment

This PR solves issue #2462. If we asked to
pay an invoice that we generated ourselves. We
generate PaymentSent and PaymentClaimable event
and mark the payment as fulfilled in our set
of outbound payments.

This PR is important because we realized users
can easily screw up self payments when they implement
it themselves. See here: https://lists.linuxfoundation.org/pipermail/lightning-dev/2023-June/003983.html

Author: vladimirfomene

lightning/src/ln/outbound_payment.rs

@@ -14,7 +14,7 @@ use bitcoin::hashes::sha256::Hash as Sha256;
 use bitcoin::secp256k1::{self, Secp256k1, SecretKey};
 
 use crate::sign::{EntropySource, NodeSigner, Recipient};
-use crate::events::{self, PaymentFailureReason};
+use crate::events::{self, PaymentFailureReason, Event, PaymentPurpose};
 use crate::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 use crate::ln::channelmanager::{ChannelDetails, EventCompletionAction, HTLCSource, PaymentId};
 use crate::ln::onion_utils::{DecodedOnionFailure, HTLCFailReason};
@@ -902,15 +902,41 @@ impl OutboundPayments {
 			}
 		}
 
-		let mut route = router.find_route_with_id(
-			&node_signer.get_node_id(Recipient::Node).unwrap(), &route_params,
+		let payer = node_signer.get_node_id(Recipient::Node).unwrap();
+		let mut route;
+		match router.find_route_with_id(
+			&payer,&route_params,
 			Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs(),
 			payment_hash, payment_id,
-		).map_err(|_| {
-			log_error!(logger, "Failed to find route for payment with id {} and hash {}",
-				payment_id, payment_hash);
-			RetryableSendFailure::RouteNotFound
-		})?;
+		) {
+			Ok(res) => route = res,
+			Err(error) => {
+				if error.err == "Cannot generate a route to ourselves" {
+					let payment_secret = match recipient_onion.payment_secret {
+						Some(secret) => secret,
+						None => PaymentSecret([0; 32])
+					};
+					let payment_preimage = PaymentPreimage([0; 32]);
+					let payment_purpose = PaymentPurpose::InvoicePayment {
+						payment_preimage: Some(payment_preimage),
+						payment_secret,
+					};
+					let mut pending_outbounds_lock = self.pending_outbound_payments.lock().unwrap();
+					let payment = pending_outbounds_lock.get_mut(&payment_id).unwrap();
+					payment.mark_fulfilled();
+					let mut pending_events_lock = pending_events.lock().unwrap();
+					pending_events_lock.push_back((Event::PaymentSent { payment_id: Some(payment_id), payment_preimage,
+								payment_hash, fee_paid_msat: None }, None));
+					pending_events_lock.push_back((Event::PaymentClaimable { receiver_node_id: Some(payer), payment_hash,
+								onion_fields: Some(recipient_onion), amount_msat: route_params.final_value_msat, counterparty_skimmed_fee_msat: 0,
+								purpose: payment_purpose, via_channel_id: None, via_user_channel_id: None, claim_deadline: None }, None));
+					return Ok(());
+				}
+				log_error!(logger, "Failed to find route for payment with id {} and hash {}",
+						payment_id, payment_hash);
+				return Err(RetryableSendFailure::RouteNotFound);
+			}
+		}
 
 		if route.route_params.as_ref() != Some(&route_params) {
 			debug_assert!(false,