add rough logic for self payment

Author: Prabhat1308

lightning/src/ln/channelmanager.rs

@@ -123,7 +123,7 @@ use crate::types::string::UntrustedString;
 use crate::util::config::{ChannelConfig, ChannelConfigOverrides, ChannelConfigUpdate, UserConfig};
 use crate::util::errors::APIError;
 use crate::util::logger::{Level, Logger, WithContext};
-use crate::util::scid_utils::fake_scid;
+use crate::util::scid_utils::{fake_scid, SCID_SELF_PAYMENT};
 use crate::util::ser::{
 	BigSize, FixedLengthReader, LengthReadable, MaybeReadable, Readable, ReadableArgs, VecWriter,
 	Writeable, Writer,
@@ -4906,6 +4906,11 @@ where
 			path, payment_hash, recipient_onion, total_value, cur_height, payment_id, keysend_preimage,
 			invoice_request, bolt12_invoice, session_priv_bytes
 		} = args;
+
+		if path.hops.first().unwrap().short_channel_id == SCID_SELF_PAYMENT {
+			return self.handle_self_payment(&payment_hash, &recipient_onion, total_value, payment_id, &keysend_preimage);
+		}
+
 		// The top-level caller should hold the total_consistency_lock read lock.
 		debug_assert!(self.total_consistency_lock.try_write().is_err());
 		let prng_seed = self.entropy_source.get_secure_random_bytes();
@@ -5078,6 +5083,88 @@ where
 			|args| self.send_payment_along_path(args),
 		)
 	}
+    
+    /// Send a payment to ourselves (self-payment).
+    ///
+    /// This method creates a payment route from the node to itself, enabling testing
+    /// of payment functionality and providing a way to generate payment events locally.
+    ///
+    /// # Arguments
+    /// * `payment_preimage` - The preimage for the payment hash
+    /// * `recipient_onion` - The recipient onion fields for the payment
+    /// * `payment_id` - A unique identifier for this payment
+    ///
+    /// # Returns
+    /// Returns the payment hash on success, or an APIError on failure.
+    pub fn send_self_payment(
+		&self, payment_preimage: PaymentPreimage, recipient_onion: RecipientOnionFields,
+		payment_id: PaymentId, final_value_msat: u64
+	) -> Result<PaymentHash, APIError> {
+		// Create route parameters for self-payment
+		let payment_params = PaymentParameters::from_node_id(
+			self.get_our_node_id(), 
+			MIN_FINAL_CLTV_EXPIRY_DELTA as u32
+		);
+		let route_params = RouteParameters::from_payment_params_and_value(
+			payment_params, 
+			final_value_msat// Amount in msat
+		);
+		
+		// Use existing spontaneous payment infrastructure
+		self.send_spontaneous_payment(
+			Some(payment_preimage),
+			recipient_onion,
+			payment_id,
+			route_params,
+			Retry::Attempts(0)
+		).map_err(|e| APIError::APIMisuseError { 
+			err: format!("Self-payment failed: {:?}", e) 
+		})
+	}
+    
+	fn handle_self_payment(
+		&self, payment_hash: &PaymentHash, recipient_onion: &RecipientOnionFields,
+		total_value: u64, payment_id: PaymentId, keysend_preimage: &Option<PaymentPreimage>
+	) -> Result<(), APIError> {
+		// For self-payments, we need to:
+		// 1. Validate the payment secret/preimage
+		// 2. Generate a PaymentClaimable event
+		// 3. The user can then claim_funds() to complete the payment
+		
+		let payment_preimage = if let Some(preimage) = keysend_preimage {
+			*preimage
+		} else {
+			// For non-keysend self-payments, try to find the preimage
+			// This would require looking up the payment in inbound_payment_key
+			return Err(APIError::APIMisuseError {
+				err: "Self-payment without keysend preimage not yet supported".to_owned()
+			});
+		};
+		
+		// Validate payment hash matches preimage
+		if PaymentHash(Sha256::hash(&payment_preimage.0).to_byte_array()) != *payment_hash {
+			return Err(APIError::APIMisuseError {
+				err: "Payment hash does not match preimage".to_owned()
+			});
+		}
+		
+		// Create payment claimable event
+		let purpose = events::PaymentPurpose::SpontaneousPayment(payment_preimage);
+		let payment_claimable = events::Event::PaymentClaimable {
+			receiver_node_id: Some(self.get_our_node_id()),
+			payment_hash: *payment_hash,
+			onion_fields: Some(recipient_onion.clone()),
+			amount_msat: total_value,
+			counterparty_skimmed_fee_msat: 0,
+			purpose,
+			via_channel_ids: vec![],
+			claim_deadline: None,
+			payment_id: Some(payment_id),
+		};
+		
+		self.pending_events.lock().unwrap().push_back((payment_claimable, None));
+		Ok(())
+	}
 
 	#[cfg(any(test, feature = "_externalize_tests"))]
 	pub(super) fn test_send_payment_internal(

lightning/src/routing/router.rs

@@ -37,7 +37,7 @@ use crate::types::features::{
 use crate::types::payment::{PaymentHash, PaymentPreimage};
 use crate::util::logger::Logger;
 use crate::util::ser::{Readable, ReadableArgs, Writeable, Writer};
-
+use crate::util::scid_utils::SCID_SELF_PAYMENT;
 use crate::io;
 use crate::prelude::*;
 use alloc::collections::BinaryHeap;
@@ -2453,7 +2453,7 @@ where L::Target: Logger {
 	let our_node_id = NodeId::from_pubkey(&our_node_pubkey);
 
 	if payee_node_id_opt.map_or(false, |payee| payee == our_node_id) {
-		return Err("Cannot generate a route to ourselves");
+		return create_self_payment_route(our_node_pubkey, route_params);
 	}
 	if our_node_id == maybe_dummy_payee_node_id {
 		return Err("Invalid origin node id provided, use a different one");
@@ -3727,6 +3727,25 @@ where L::Target: Logger {
 	Ok(route)
 }
 
+fn create_self_payment_route(our_node_pubkey: &PublicKey, route_params: &RouteParameters) -> Result<Route, &'static str> {
+	let path = Path {
+        hops: vec![RouteHop {
+            pubkey: our_node_pubkey.clone(),
+            short_channel_id: SCID_SELF_PAYMENT, // Dummy short_channel_id specifying self payment
+            fee_msat: 0, // Zero fees
+            cltv_expiry_delta: MIN_FINAL_CLTV_EXPIRY_DELTA.into(),
+            node_features: NodeFeatures::empty(),
+            channel_features: ChannelFeatures::empty(),
+            maybe_announced_channel: false,
+        }],
+        blinded_tail: None,
+    };
+    Ok(Route {
+        paths: vec![path],
+        route_params: Some(route_params.clone()),
+    })
+}
+
 // When an adversarial intermediary node observes a payment, it may be able to infer its
 // destination, if the remaining CLTV expiry delta exactly matches a feasible path in the network
 // graph. In order to improve privacy, this method obfuscates the CLTV expiry deltas along the

lightning/src/util/scid_utils.rs

@@ -21,6 +21,11 @@ pub const MAX_SCID_TX_INDEX: u64 = 0x00ffffff;
 /// value is based on the 2-bytes available for the vout index.
 pub const MAX_SCID_VOUT_INDEX: u64 = 0xffff;
 
+// Self payment scid is 0 to avoid confusion with real channels
+/// A special short channel ID (0) used to indicate a self-payment.
+/// When routing a payment to ourselves, the first hop will have this SCID.
+pub const SCID_SELF_PAYMENT: u64 = 0;
+
 /// A `short_channel_id` construction error
 #[derive(Debug, PartialEq, Eq)]
 pub enum ShortChannelIdError {