OffersMessageHandler impl for ChannelManager

Define the BOLT 12 message flow in ChannelManager's
OffersMessageHandler implementation.
- An invoice_request message results in responding with an invoice
  message if it can be verified that the request is for a valid offer.
- An invoice is paid if it can be verified to have originated from a
  sent invoice_request or a refund.
- An invoice_error is sent in some failure cases.

Author: jkczyz

lightning/src/ln/channelmanager.rs

@@ -55,6 +55,11 @@ use crate::ln::msgs::{ChannelMessageHandler, DecodeError, LightningError};
 use crate::ln::outbound_payment;
 use crate::ln::outbound_payment::{OutboundPayments, PaymentAttempts, PendingOutboundPayment, SendAlongPathArgs};
 use crate::ln::wire::Encode;
+use crate::offers::invoice::{Bolt12Invoice, DEFAULT_RELATIVE_EXPIRY, DerivedSigningPubkey, InvoiceBuilder};
+use crate::offers::invoice_error::InvoiceError;
+use crate::offers::merkle::SignError;
+use crate::offers::parse::Bolt12SemanticError;
+use crate::onion_message::{OffersMessage, OffersMessageHandler};
 use crate::sign::{EntropySource, KeysManager, NodeSigner, Recipient, SignerProvider, WriteableEcdsaChannelSigner};
 use crate::util::config::{UserConfig, ChannelConfig, ChannelConfigUpdate};
 use crate::util::wakers::{Future, Notifier};
@@ -3404,6 +3409,17 @@ where
 		self.pending_outbound_payments.test_set_payment_metadata(payment_id, new_payment_metadata);
 	}
 
+	pub(super) fn send_payment_for_bolt12_invoice(&self, invoice: &Bolt12Invoice, payment_id: PaymentId) -> Result<(), RetryableSendFailure> {
+		let best_block_height = self.best_block.read().unwrap().height();
+		let _persistence_guard = PersistenceNotifierGuard::notify_on_drop(self);
+		self.pending_outbound_payments
+			.send_payment_for_bolt12_invoice(
+				invoice, payment_id, &self.router, self.list_usable_channels(),
+				|| self.compute_inflight_htlcs(), &self.entropy_source, &self.node_signer,
+				best_block_height, &self.logger, &self.pending_events,
+				|args| self.send_payment_along_path(args)
+			)
+	}
 
 	/// Signals that no further retries for the given payment should occur. Useful if you have a
 	/// pending outbound payment with retries remaining, but wish to stop retrying the payment before
@@ -7734,6 +7750,121 @@ where
 	}
 }
 
+impl<M: Deref, T: Deref, ES: Deref, NS: Deref, SP: Deref, F: Deref, R: Deref, L: Deref>
+OffersMessageHandler for ChannelManager<M, T, ES, NS, SP, F, R, L>
+where
+	M::Target: chain::Watch<<SP::Target as SignerProvider>::Signer>,
+	T::Target: BroadcasterInterface,
+	ES::Target: EntropySource,
+	NS::Target: NodeSigner,
+	SP::Target: SignerProvider,
+	F::Target: FeeEstimator,
+	R::Target: Router,
+	L::Target: Logger,
+{
+	fn handle_message(&self, message: OffersMessage) -> Option<OffersMessage> {
+		let secp_ctx = &self.secp_ctx;
+		let expanded_key = &self.inbound_payment_key;
+
+		match message {
+			OffersMessage::InvoiceRequest(invoice_request) => {
+				let amount_msats = match InvoiceBuilder::<DerivedSigningPubkey>::amount_msats(
+					&invoice_request
+				) {
+					Ok(amount_msats) => Some(amount_msats),
+					Err(error) => return Some(OffersMessage::InvoiceError(error.into())),
+				};
+				let invoice_request = match invoice_request.verify(expanded_key, secp_ctx) {
+					Ok(invoice_request) => invoice_request,
+					Err(()) => {
+						let error = Bolt12SemanticError::InvalidMetadata;
+						return Some(OffersMessage::InvoiceError(error.into()));
+					},
+				};
+				let relative_expiry = DEFAULT_RELATIVE_EXPIRY.as_secs() as u32;
+
+				match self.create_inbound_payment(amount_msats, relative_expiry, None) {
+					Ok((payment_hash, _payment_secret)) if invoice_request.keys.is_some() => {
+						// TODO: Include payment_secret in payment_paths.
+						let payment_paths = vec![];
+						#[cfg(not(feature = "no-std"))]
+						let builder = invoice_request.respond_using_derived_keys(
+							payment_paths, payment_hash
+						);
+						#[cfg(feature = "no-std")]
+						let created_at = Duration::from_secs(
+							self.highest_seen_timestamp.load(Ordering::Acquire) as u64
+						);
+						#[cfg(feature = "no-std")]
+						let builder = invoice_request.respond_using_derived_keys_no_std(
+							payment_paths, payment_hash, created_at
+						);
+						match builder.and_then(|b| b.allow_mpp().build_and_sign(secp_ctx)) {
+							Ok(invoice) => Some(OffersMessage::Invoice(invoice)),
+							Err(error) => Some(OffersMessage::InvoiceError(error.into())),
+						}
+					},
+					Ok((payment_hash, _payment_secret)) => {
+						// TODO: Include payment_secret in payment_paths.
+						let payment_paths = vec![];
+						#[cfg(not(feature = "no-std"))]
+						let builder = invoice_request.respond_with(payment_paths, payment_hash);
+						#[cfg(feature = "no-std")]
+						let created_at = Duration::from_secs(
+							self.highest_seen_timestamp.load(Ordering::Acquire) as u64
+						);
+						#[cfg(feature = "no-std")]
+						let builder = invoice_request.respond_with_no_std(
+							payment_paths, payment_hash, created_at
+						);
+						let response = builder.and_then(|builder| builder.allow_mpp().build())
+							.map_err(|e| OffersMessage::InvoiceError(e.into()))
+							.and_then(|invoice|
+								match invoice.sign(|invoice| self.node_signer.sign_bolt12_invoice(invoice)) {
+									Ok(invoice) => Ok(OffersMessage::Invoice(invoice)),
+									Err(SignError::Signing(())) => Err(OffersMessage::InvoiceError(
+											InvoiceError::from_str("Failed signing invoice")
+									)),
+									Err(SignError::Verification(_)) => Err(OffersMessage::InvoiceError(
+											InvoiceError::from_str("Failed invoice signature verification")
+									)),
+								});
+						match response {
+							Ok(invoice) => Some(invoice),
+							Err(error) => Some(error),
+						}
+					},
+					Err(()) => {
+						Some(OffersMessage::InvoiceError(Bolt12SemanticError::InvalidAmount.into()))
+					},
+				}
+			},
+			OffersMessage::Invoice(invoice) => {
+				match invoice.verify(expanded_key, secp_ctx) {
+					Err(()) => {
+						Some(OffersMessage::InvoiceError(InvoiceError::from_str("Unrecognized invoice")))
+					},
+					Ok(_) if invoice.invoice_features().requires_unknown_bits() => {
+						Some(OffersMessage::InvoiceError(Bolt12SemanticError::UnknownRequiredFeatures.into()))
+					},
+					Ok(payment_id) => {
+						if let Err(e) = self.send_payment_for_bolt12_invoice(&invoice, payment_id) {
+							log_error!(self.logger, "Failed paying invoice: {:?}", e);
+							Some(OffersMessage::InvoiceError(InvoiceError::from_str(&format!("{:?}", e))))
+						} else {
+							None
+						}
+					},
+				}
+			},
+			OffersMessage::InvoiceError(invoice_error) => {
+				log_error!(self.logger, "Received invoice_error: {}", invoice_error);
+				None
+			},
+		}
+	}
+}
+
 /// Fetches the set of [`NodeFeatures`] flags which are provided by or required by
 /// [`ChannelManager`].
 pub(crate) fn provided_node_features(config: &UserConfig) -> NodeFeatures {

lightning/src/ln/outbound_payment.rs

@@ -18,6 +18,7 @@ use crate::events::{self, PaymentFailureReason};
 use crate::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 use crate::ln::channelmanager::{ChannelDetails, EventCompletionAction, HTLCSource, IDEMPOTENCY_TIMEOUT_TICKS, INVOICE_REQUEST_TIMEOUT_TICKS, PaymentId};
 use crate::ln::onion_utils::{DecodedOnionFailure, HTLCFailReason};
+use crate::offers::invoice::Bolt12Invoice;
 use crate::routing::router::{InFlightHtlcs, Path, PaymentParameters, Route, RouteParameters, Router};
 use crate::util::errors::APIError;
 use crate::util::logger::Logger;
@@ -356,6 +357,10 @@ pub enum RetryableSendFailure {
 	/// [`Event::PaymentSent`]: crate::events::Event::PaymentSent
 	/// [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
 	DuplicatePayment,
+	/// Indicates that a payment for the provided [`PaymentId`] was unexpected, either because the
+	/// invoice was not explicitly requested (or for a known refund) or the invoice was not received
+	/// in time (or was already paid).
+	UnexpectedPayment,
 }
 
 /// If a payment fails to send with [`ChannelManager::send_payment_with_route`], it can be in one
@@ -565,6 +570,8 @@ pub(super) struct SendAlongPathArgs<'a> {
 	pub session_priv_bytes: [u8; 32],
 }
 
+const BOLT_12_INVOICE_RETRY_STRATEGY: Retry = Retry::Attempts(3);
+
 pub(super) struct OutboundPayments {
 	pub(super) pending_outbound_payments: Mutex<HashMap<PaymentId, PendingOutboundPayment>>,
 	pub(super) retry_lock: Mutex<()>,
@@ -598,6 +605,84 @@ impl OutboundPayments {
 			best_block_height, logger, pending_events, &send_payment_along_path)
 	}
 
+	pub(super) fn send_payment_for_bolt12_invoice<R: Deref, ES: Deref, NS: Deref, IH, SP, L: Deref>(
+		&self, invoice: &Bolt12Invoice, payment_id: PaymentId, router: &R,
+		first_hops: Vec<ChannelDetails>, inflight_htlcs: IH, entropy_source: &ES, node_signer: &NS,
+		best_block_height: u32, logger: &L,
+		pending_events: &Mutex<VecDeque<(events::Event, Option<EventCompletionAction>)>>,
+		send_payment_along_path: SP,
+	) -> Result<(), RetryableSendFailure>
+	where
+		R::Target: Router,
+		ES::Target: EntropySource,
+		NS::Target: NodeSigner,
+		L::Target: Logger,
+		IH: Fn() -> InFlightHtlcs,
+		SP: Fn(SendAlongPathArgs) -> Result<(), APIError>,
+	{
+		let payment_hash = invoice.payment_hash();
+		match self.pending_outbound_payments.lock().unwrap().entry(payment_id) {
+			hash_map::Entry::Occupied(entry) if entry.get().is_awaiting_invoice() => {
+				*entry.into_mut() = PendingOutboundPayment::InvoiceReceived { payment_hash };
+			},
+			hash_map::Entry::Occupied(_) => return Err(RetryableSendFailure::DuplicatePayment),
+			hash_map::Entry::Vacant(_) => return Err(RetryableSendFailure::UnexpectedPayment),
+		};
+
+		#[cfg(feature = "std")] {
+			if invoice.is_expired() {
+				log_error!(logger, "Invoice expired, abandoning payment {}", &payment_id);
+				self.abandon_payment(payment_id, PaymentFailureReason::PaymentExpired, pending_events);
+				return Err(RetryableSendFailure::PaymentExpired);
+			}
+		}
+
+		let recipient_onion = RecipientOnionFields {
+			payment_secret: None,
+			payment_metadata: None,
+			custom_tlvs: vec![],
+		};
+		let route_params = RouteParameters {
+			payment_params: PaymentParameters::from_bolt12_invoice(&invoice),
+			final_value_msat: invoice.amount_msats(),
+		};
+
+		let route = match router.find_route_with_id(
+			&node_signer.get_node_id(Recipient::Node).unwrap(), &route_params,
+			Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs(), payment_hash, payment_id
+		) {
+			Ok(route) => route,
+			Err(e) => {
+				log_error!(
+					logger, "Failed to find a route when sending, abandoning payment {}: {:#?}",
+					&payment_id, e
+				);
+				self.abandon_payment(payment_id, PaymentFailureReason::RouteNotFound, pending_events);
+				return Err(RetryableSendFailure::RouteNotFound);
+			}
+		};
+
+		let onion_session_privs = self.add_new_pending_bolt12_payment(
+			recipient_onion.clone(), payment_id, None, &route, Some(BOLT_12_INVOICE_RETRY_STRATEGY),
+			Some(route_params.payment_params.clone()), entropy_source, best_block_height
+		)?;
+		let pay_result = self.pay_route_internal(
+			&route, payment_hash, recipient_onion, None, payment_id, None, onion_session_privs,
+			node_signer, best_block_height, &send_payment_along_path
+		);
+		log_info!(logger, "Result sending payment with id {}: {:?}", &payment_id, pay_result);
+
+		if let Err(e) = pay_result {
+			self.handle_pay_route_err(
+				e, payment_id, payment_hash, route, route_params, router, first_hops,
+				&inflight_htlcs, entropy_source, node_signer, best_block_height, logger,
+				pending_events, &send_payment_along_path
+			);
+		}
+
+		Ok(())
+	}
+
 	pub(super) fn send_payment_with_route<ES: Deref, NS: Deref, F>(
 		&self, route: &Route, payment_hash: PaymentHash, recipient_onion: RecipientOnionFields,
 		payment_id: PaymentId, entropy_source: &ES, node_signer: &NS, best_block_height: u32,
@@ -1051,40 +1136,78 @@ impl OutboundPayments {
 		keysend_preimage: Option<PaymentPreimage>, route: &Route, retry_strategy: Option<Retry>,
 		payment_params: Option<PaymentParameters>, entropy_source: &ES, best_block_height: u32
 	) -> Result<Vec<[u8; 32]>, PaymentSendFailure> where ES::Target: EntropySource {
-		let mut onion_session_privs = Vec::with_capacity(route.paths.len());
-		for _ in 0..route.paths.len() {
-			onion_session_privs.push(entropy_source.get_secure_random_bytes());
-		}
-
 		let mut pending_outbounds = self.pending_outbound_payments.lock().unwrap();
 		match pending_outbounds.entry(payment_id) {
 			hash_map::Entry::Occupied(_) => Err(PaymentSendFailure::DuplicatePayment),
 			hash_map::Entry::Vacant(entry) => {
-				let payment = entry.insert(PendingOutboundPayment::Retryable {
-					retry_strategy,
-					attempts: PaymentAttempts::new(),
-					payment_params,
-					session_privs: HashSet::new(),
-					pending_amt_msat: 0,
-					pending_fee_msat: Some(0),
-					payment_hash,
-					payment_secret: recipient_onion.payment_secret,
-					payment_metadata: recipient_onion.payment_metadata,
-					keysend_preimage,
-					custom_tlvs: recipient_onion.custom_tlvs,
-					starting_block_height: best_block_height,
-					total_msat: route.get_total_amount(),
-				});
-
-				for (path, session_priv_bytes) in route.paths.iter().zip(onion_session_privs.iter()) {
-					assert!(payment.insert(*session_priv_bytes, path));
-				}
-
+				let (payment, onion_session_privs) = self.create_pending_payment(
+					payment_hash, recipient_onion, keysend_preimage, route, retry_strategy,
+					payment_params, entropy_source, best_block_height
+				);
+				entry.insert(payment);
 				Ok(onion_session_privs)
 			},
 		}
 	}
 
+	pub(super) fn add_new_pending_bolt12_payment<ES: Deref>(
+		&self, recipient_onion: RecipientOnionFields, payment_id: PaymentId,
+		keysend_preimage: Option<PaymentPreimage>, route: &Route, retry_strategy: Option<Retry>,
+		payment_params: Option<PaymentParameters>, entropy_source: &ES, best_block_height: u32
+	) -> Result<Vec<[u8; 32]>, RetryableSendFailure> where ES::Target: EntropySource {
+		let mut pending_outbounds = self.pending_outbound_payments.lock().unwrap();
+		match pending_outbounds.entry(payment_id) {
+			hash_map::Entry::Occupied(entry) => match entry.get() {
+				PendingOutboundPayment::InvoiceReceived { payment_hash } => {
+					let (payment, onion_session_privs) = self.create_pending_payment(
+						*payment_hash, recipient_onion, keysend_preimage, route, retry_strategy,
+						payment_params, entropy_source, best_block_height
+					);
+					*entry.into_mut() = payment;
+					Ok(onion_session_privs)
+				},
+				_ => Err(RetryableSendFailure::DuplicatePayment),
+			},
+			hash_map::Entry::Vacant(_) => Err(RetryableSendFailure::UnexpectedPayment),
+		}
+	}
+
+	fn create_pending_payment<ES: Deref>(
+		&self, payment_hash: PaymentHash, recipient_onion: RecipientOnionFields,
+		keysend_preimage: Option<PaymentPreimage>, route: &Route, retry_strategy: Option<Retry>,
+		payment_params: Option<PaymentParameters>, entropy_source: &ES, best_block_height: u32
+	) -> (PendingOutboundPayment, Vec<[u8; 32]>)
+	where
+		ES::Target: EntropySource,
+	{
+		let mut onion_session_privs = Vec::with_capacity(route.paths.len());
+		for _ in 0..route.paths.len() {
+			onion_session_privs.push(entropy_source.get_secure_random_bytes());
+		}
+
+		let mut payment = PendingOutboundPayment::Retryable {
+			retry_strategy,
+			attempts: PaymentAttempts::new(),
+			payment_params,
+			session_privs: HashSet::new(),
+			pending_amt_msat: 0,
+			pending_fee_msat: Some(0),
+			payment_hash,
+			payment_secret: recipient_onion.payment_secret,
+			payment_metadata: recipient_onion.payment_metadata,
+			keysend_preimage,
+			custom_tlvs: recipient_onion.custom_tlvs,
+			starting_block_height: best_block_height,
+			total_msat: route.get_total_amount(),
+		};
+
+		for (path, session_priv_bytes) in route.paths.iter().zip(onion_session_privs.iter()) {
+			assert!(payment.insert(*session_priv_bytes, path));
+		}
+
+		(payment, onion_session_privs)
+	}
+
 	#[allow(unused)]
 	pub(super) fn add_new_awaiting_invoice(&self, payment_id: PaymentId) -> Result<(), ()> {
 		let mut pending_outbounds = self.pending_outbound_payments.lock().unwrap();