Introduce OffersMessageCommons Trait and Implementation

A new trait, `OffersMessageCommons`, is introduced to encapsulate
functions that are commonly used by both BOLT12-related functionality
and other parts of `ChannelManager`.

This enables a clean transition of BOLT12 code to `OffersMessageFlow`
by moving shared functions into the new trait, ensuring they remain
accessible to both `ChannelManager` and the refactored BOLT12 code.

Author: shaavan

lightning/src/ln/channelmanager.rs

@@ -28,7 +28,7 @@ use bitcoin::hashes::hmac::Hmac;
 use bitcoin::hashes::sha256::Hash as Sha256;
 use bitcoin::hash_types::{BlockHash, Txid};
 
-use bitcoin::secp256k1::{SecretKey,PublicKey};
+use bitcoin::secp256k1::{schnorr, PublicKey, SecretKey};
 use bitcoin::secp256k1::Secp256k1;
 use bitcoin::{secp256k1, Sequence};
 
@@ -47,6 +47,7 @@ use crate::events::{self, Event, EventHandler, EventsProvider, InboundChannelFun
 // construct one themselves.
 use crate::ln::inbound_payment;
 use crate::ln::types::ChannelId;
+use crate::offers::flow::OffersMessageCommons;
 use crate::types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
 use crate::ln::channel::{self, Channel, ChannelError, ChannelUpdateStatus, FundedChannel, ShutdownResult, UpdateFulfillCommitFetch, OutboundV1Channel, ReconnectionMsg, InboundV1Channel, WithChannelContext};
 #[cfg(any(dual_funding, splicing))]
@@ -122,7 +123,7 @@ use core::{cmp, mem};
 use core::borrow::Borrow;
 use core::cell::RefCell;
 use crate::io::Read;
-use crate::sync::{Arc, Mutex, RwLock, RwLockReadGuard, FairRwLock, LockTestExt, LockHeldState};
+use crate::sync::{Arc, FairRwLock, LockHeldState, LockTestExt, Mutex, MutexGuard, RwLock, RwLockReadGuard};
 use core::sync::atomic::{AtomicUsize, AtomicBool, Ordering};
 use core::time::Duration;
 use core::ops::Deref;
@@ -9932,6 +9933,88 @@ macro_rules! create_refund_builder { ($self: ident, $builder: ty) => {
 	}
 } }
 
+impl<M: Deref, T: Deref, ES: Deref, NS: Deref, SP: Deref, F: Deref, R: Deref, MR: Deref, L: Deref> OffersMessageCommons for ChannelManager<M, T, ES, NS, SP, F, R, MR, L>
+where
+	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
+	T::Target: BroadcasterInterface,
+	ES::Target: EntropySource,
+	NS::Target: NodeSigner,
+	SP::Target: SignerProvider,
+	F::Target: FeeEstimator,
+	R::Target: Router,
+	MR::Target: MessageRouter,
+	L::Target: Logger,
+{
+	fn get_current_blocktime(&self) -> Duration {
+		Duration::from_secs(self.highest_seen_timestamp.load(Ordering::Acquire) as u64)
+	}
+	
+	fn get_peer_for_blinded_path(&self) -> Vec<MessageForwardNode> {
+		self.per_peer_state.read().unwrap()
+			.iter()
+			.map(|(node_id, peer_state)| (node_id, peer_state.lock().unwrap()))
+			.filter(|(_, peer)| peer.is_connected)
+			.filter(|(_, peer)| peer.latest_features.supports_onion_messages())
+			.map(|(node_id, peer)| MessageForwardNode {
+				node_id: *node_id,
+				short_channel_id: peer.channel_by_id
+					.iter()
+					.filter(|(_, channel)| channel.context().is_usable())
+					.min_by_key(|(_, channel)| channel.context().channel_creation_height)
+					.and_then(|(_, channel)| channel.context().get_short_channel_id()),
+			})
+			.collect::<Vec<_>>()
+	}
+	
+	fn create_blinded_payment_paths(
+		&self, amount_msats: Option<u64>, payment_secret: PaymentSecret, payment_context: PaymentContext, relative_expiry_time: u32,
+	) -> Result<Vec<BlindedPaymentPath>, ()> {
+		self.create_blinded_payment_paths(amount_msats, payment_secret, payment_context, relative_expiry_time)
+	}
+	
+	fn create_inbound_payment(&self, min_value_msat: Option<u64>, invoice_expiry_delta_secs: u32,
+		min_final_cltv_expiry_delta: Option<u16>) -> Result<(PaymentHash, PaymentSecret), ()> {
+		self.create_inbound_payment(min_value_msat, invoice_expiry_delta_secs, min_final_cltv_expiry_delta)
+	}
+	
+	fn release_invoice_requests_awaiting_invoice(&self) -> Vec<(PaymentId, RetryableInvoiceRequest)> {
+		self.pending_outbound_payments.release_invoice_requests_awaiting_invoice()
+	}
+	
+	fn sign_bolt12_invoice(
+		&self, invoice: &UnsignedBolt12Invoice,
+	) -> Result<schnorr::Signature, ()> {
+		self.node_signer.sign_bolt12_invoice(invoice)
+	}
+	
+	fn send_payment_for_verified_bolt12_invoice(&self, invoice: &Bolt12Invoice, payment_id: PaymentId) -> Result<(), Bolt12PaymentError> {
+		self.send_payment_for_verified_bolt12_invoice(invoice, payment_id)
+	}
+	
+	fn abandon_payment_with_reason(&self, payment_id: PaymentId, reason: PaymentFailureReason) {
+		self.abandon_payment_with_reason(payment_id, reason);
+	}
+	
+	// ----Temporary Functions----
+	// Set of functions temporarily moved to OffersMessageCommons for easier
+	// transition of code from ChannelManager to OffersMessageFlow
+
+	fn get_pending_offers_messages(&self) -> MutexGuard<'_, Vec<(OffersMessage, MessageSendInstructions)>> {
+		self.pending_offers_messages.lock().expect("Mutex is locked by other thread.")
+	}
+	
+	fn enqueue_invoice_request(&self, invoice_request: InvoiceRequest, reply_paths: Vec<BlindedMessagePath>) -> Result<(), Bolt12SemanticError> {
+		self.enqueue_invoice_request(invoice_request, reply_paths)
+	}
+	
+	#[cfg(async_payments)]
+	fn initiate_async_payment(
+		&self, invoice: &StaticInvoice, payment_id: PaymentId
+	) -> Result<(), Bolt12PaymentError> {
+		self.initiate_async_payment(invoice, payment_id)
+	}
+}
+
 /// Defines the maximum number of [`OffersMessage`] including different reply paths to be sent
 /// along different paths.
 /// Sending multiple requests increases the chances of successful delivery in case some

lightning/src/ln/mod.rs

@@ -41,7 +41,7 @@ pub mod channel;
 pub(crate) mod channel;
 
 pub(crate) mod onion_utils;
-mod outbound_payment;
+pub(crate) mod outbound_payment;
 pub mod wire;
 
 #[allow(dead_code)] // TODO(dual_funding): Remove once contribution to V2 channels is enabled.

lightning/src/ln/outbound_payment.rs

@@ -140,7 +140,7 @@ pub(crate) enum PendingOutboundPayment {
 }
 
 #[derive(Clone)]
-pub(crate) struct RetryableInvoiceRequest {
+pub struct RetryableInvoiceRequest {
 	pub(crate) invoice_request: InvoiceRequest,
 	pub(crate) nonce: Nonce,
 	pub(super) needs_retry: bool,

lightning/src/offers/flow.rs

@@ -17,10 +17,29 @@ use crate::ln::inbound_payment;
 use crate::prelude::*;
 use crate::sign::EntropySource;
 use core::ops::Deref;
+use core::time::Duration;
 
+use bitcoin::secp256k1::schnorr;
+use lightning_invoice::PaymentSecret;
+use types::payment::PaymentHash;
+
+use crate::blinded_path::message::{BlindedMessagePath, MessageForwardNode};
+use crate::blinded_path::payment::{BlindedPaymentPath, PaymentContext};
+use crate::events::PaymentFailureReason;
+use crate::ln::channelmanager::{Bolt12PaymentError, PaymentId};
+use crate::ln::outbound_payment::RetryableInvoiceRequest;
+use crate::offers::invoice::{Bolt12Invoice, UnsignedBolt12Invoice};
+use crate::offers::invoice_request::InvoiceRequest;
+use crate::offers::parse::Bolt12SemanticError;
+use crate::onion_message::messenger::MessageSendInstructions;
+use crate::onion_message::offers::OffersMessage;
+use crate::sync::MutexGuard;
 use crate::onion_message::messenger::MessageRouter;
 use crate::util::logger::Logger;
 
+#[cfg(async_payments)]
+use crate::offers::static_invoice::StaticInvoice;
+
 #[cfg(not(c_bindings))]
 use {
 	crate::ln::channelmanager::{SimpleArcChannelManager, SimpleRefChannelManager},
@@ -30,10 +49,98 @@ use {
 	crate::sync::Arc,
 };
 
-/// Functions commonly shared in usage between [`ChannelManager`] & [`OffersMessageFlow`]
+/// Functions commonly shared in usage between [`ChannelManager`] & `OffersMessageFlow`
 ///
 /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
-pub trait OffersMessageCommons {}
+pub trait OffersMessageCommons {
+	/// Get the current time determined by highest seen timestamp
+	fn get_current_blocktime(&self) -> Duration;
+
+	/// Get the vector of peers that can be used for a blinded path
+	fn get_peer_for_blinded_path(&self) -> Vec<MessageForwardNode>;
+
+	/// Creates multi-hop blinded payment paths for the given `amount_msats` by delegating to
+	/// [`Router::create_blinded_payment_paths`].
+	///
+	/// [`Router::create_blinded_payment_paths`]: crate::routing::router::Router::create_blinded_payment_paths
+	fn create_blinded_payment_paths(
+		&self, amount_msats: Option<u64>, payment_secret: PaymentSecret, payment_context: PaymentContext, relative_expiry_time: u32,
+	) -> Result<Vec<BlindedPaymentPath>, ()>;
+
+	/// Gets a payment secret and payment hash for use in an invoice given to a third party wishing
+	/// to pay us.
+	///
+	/// This differs from [`create_inbound_payment_for_hash`] only in that it generates the
+	/// [`PaymentHash`] and [`PaymentPreimage`] for you.
+	///
+	/// The [`PaymentPreimage`] will ultimately be returned to you in the [`PaymentClaimable`] event, which
+	/// will have the [`PaymentClaimable::purpose`] return `Some` for [`PaymentPurpose::preimage`]. That
+	/// should then be passed directly to [`claim_funds`].
+	///
+	/// See [`create_inbound_payment_for_hash`] for detailed documentation on behavior and requirements.
+	///
+	/// Note that a malicious eavesdropper can intuit whether an inbound payment was created by
+	/// `create_inbound_payment` or `create_inbound_payment_for_hash` based on runtime.
+	///
+	/// # Note
+	///
+	/// If you register an inbound payment with this method, then serialize the `ChannelManager`, then
+	/// deserialize it with a node running 0.0.103 and earlier, the payment will fail to be received.
+	///
+	/// Errors if `min_value_msat` is greater than total bitcoin supply.
+	///
+	/// If `min_final_cltv_expiry_delta` is set to some value, then the payment will not be receivable
+	/// on versions of LDK prior to 0.0.114.
+	///
+	/// [`claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds
+	/// [`PaymentClaimable`]: crate::events::Event::PaymentClaimable
+	/// [`PaymentClaimable::purpose`]: crate::events::Event::PaymentClaimable::purpose
+	/// [`PaymentPurpose::preimage`]: crate::events::PaymentPurpose::preimage
+	/// [`create_inbound_payment_for_hash`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash
+	/// [`PaymentPreimage`]: crate::types::payment::PaymentPreimage
+	fn create_inbound_payment(&self, min_value_msat: Option<u64>, invoice_expiry_delta_secs: u32,
+		min_final_cltv_expiry_delta: Option<u16>) -> Result<(PaymentHash, PaymentSecret), ()>;
+
+	/// Release invoice requests awaiting invoice
+	fn release_invoice_requests_awaiting_invoice(&self) -> Vec<(PaymentId, RetryableInvoiceRequest)>;
+
+	/// Signs the [`TaggedHash`] of a BOLT 12 invoice.
+	///
+	/// May be called by a function passed to [`UnsignedBolt12Invoice::sign`] where `invoice` is the
+	/// callee.
+	///
+	/// Implementors may check that the `invoice` is expected rather than blindly signing the tagged
+	/// hash. An `Ok` result should sign `invoice.tagged_hash().as_digest()` with the node's signing
+	/// key or an ephemeral key to preserve privacy, whichever is associated with
+	/// [`UnsignedBolt12Invoice::signing_pubkey`].
+	///
+	/// [`TaggedHash`]: crate::offers::merkle::TaggedHash
+	fn sign_bolt12_invoice(
+		&self, invoice: &UnsignedBolt12Invoice,
+	) -> Result<schnorr::Signature, ()>;
+
+	/// Send payment for verified bolt12 invoice
+	fn send_payment_for_verified_bolt12_invoice(&self, invoice: &Bolt12Invoice, payment_id: PaymentId) -> Result<(), Bolt12PaymentError>;
+
+	/// Abandon Payment with Reason
+	fn abandon_payment_with_reason(&self, payment_id: PaymentId, reason: PaymentFailureReason);
+
+	// ----Temporary Functions----
+	// Set of functions temporarily moved to OffersMessageCommons for easier
+	// transition of code from ChannelManager to OffersMessageFlow
+
+	/// Get pending offers messages
+	fn get_pending_offers_messages(&self) -> MutexGuard<'_, Vec<(OffersMessage, MessageSendInstructions)>>;
+
+	/// Enqueue invoice request
+	fn enqueue_invoice_request(&self, invoice_request: InvoiceRequest, reply_paths: Vec<BlindedMessagePath>) -> Result<(), Bolt12SemanticError>;
+
+	/// Initiate a new async payment
+	#[cfg(async_payments)]
+	fn initiate_async_payment(
+		&self, invoice: &StaticInvoice, payment_id: PaymentId
+	) -> Result<(), Bolt12PaymentError>;
+}
 
 /// [`SimpleArcOffersMessageFlow`] is useful when you need a [`OffersMessageFlow`] with a static lifetime, e.g.
 /// when you're using `lightning-net-tokio` (since `tokio::spawn` requires parameters with static