Remove APIs to create static invoice/async offers

Now that we've implemented the static invoice server protocol, these methods
are not intended to ever be called by users. If someone did want to use these
apis, they could use the equivalent methods on the OffersMessageFlow.

Author: valentinewallace

lightning/src/ln/async_payments_tests.rs

@@ -17,6 +17,7 @@ use crate::events::{
 use crate::ln::blinded_payment_tests::{fail_blinded_htlc_backwards, get_blinded_route_parameters};
 use crate::ln::channelmanager::{PaymentId, RecipientOnionFields};
 use crate::ln::functional_test_utils::*;
+use crate::ln::inbound_payment;
 use crate::ln::msgs;
 use crate::ln::msgs::{
 	BaseMessageHandler, ChannelMessageHandler, MessageSendEvent, OnionMessageHandler,
@@ -36,8 +37,11 @@ use crate::offers::flow::{
 };
 use crate::offers::invoice_request::InvoiceRequest;
 use crate::offers::nonce::Nonce;
-use crate::offers::offer::Offer;
-use crate::offers::static_invoice::StaticInvoice;
+use crate::offers::offer::{Amount, Offer};
+use crate::offers::static_invoice::{
+	StaticInvoice, StaticInvoiceBuilder,
+	DEFAULT_RELATIVE_EXPIRY as STATIC_INVOICE_DEFAULT_RELATIVE_EXPIRY,
+};
 use crate::onion_message::async_payments::{AsyncPaymentsMessage, AsyncPaymentsMessageHandler};
 use crate::onion_message::messenger::{
 	Destination, MessageRouter, MessageSendInstructions, PeeledOnion,
@@ -240,10 +244,50 @@ fn pass_async_payments_oms(
 	(held_htlc_available_om_1_2, release_held_htlc)
 }
 
+fn create_static_invoice_builder<'a>(
+	recipient: &Node, offer: &'a Offer, offer_nonce: Nonce, relative_expiry: Option<Duration>,
+) -> StaticInvoiceBuilder<'a> {
+	let entropy = recipient.keys_manager;
+	let amount_msat = offer.amount().and_then(|amount| match amount {
+		Amount::Bitcoin { amount_msats } => Some(amount_msats),
+		Amount::Currency { .. } => None,
+	});
+
+	let relative_expiry = relative_expiry.unwrap_or(STATIC_INVOICE_DEFAULT_RELATIVE_EXPIRY);
+	let relative_expiry_secs: u32 = relative_expiry.as_secs().try_into().unwrap_or(u32::MAX);
+
+	let created_at = recipient.node.duration_since_epoch();
+	let payment_secret = inbound_payment::create_for_spontaneous_payment(
+		&recipient.keys_manager.get_inbound_payment_key(),
+		amount_msat,
+		relative_expiry_secs,
+		created_at.as_secs(),
+		None,
+	)
+	.unwrap();
+
+	recipient
+		.node
+		.flow
+		.create_static_invoice_builder(
+			&recipient.router,
+			entropy,
+			offer,
+			offer_nonce,
+			payment_secret,
+			relative_expiry_secs,
+			recipient.node.list_usable_channels(),
+			recipient.node.test_get_peers_for_blinded_path(),
+		)
+		.unwrap()
+}
+
 fn create_static_invoice<T: secp256k1::Signing + secp256k1::Verification>(
 	always_online_counterparty: &Node, recipient: &Node, relative_expiry: Option<Duration>,
 	secp_ctx: &Secp256k1<T>,
 ) -> (Offer, StaticInvoice) {
+	let entropy_source = recipient.keys_manager;
+
 	let blinded_paths_to_always_online_node = always_online_counterparty
 		.message_router
 		.create_blinded_paths(
@@ -256,15 +300,14 @@ fn create_static_invoice<T: secp256k1::Signing + secp256k1::Verification>(
 		.unwrap();
 	let (offer_builder, offer_nonce) = recipient
 		.node
-		.create_async_receive_offer_builder(blinded_paths_to_always_online_node)
+		.flow
+		.create_async_receive_offer_builder(entropy_source, blinded_paths_to_always_online_node)
 		.unwrap();
 	let offer = offer_builder.build().unwrap();
-	let static_invoice = recipient
-		.node
-		.create_static_invoice_builder(&offer, offer_nonce, relative_expiry)
-		.unwrap()
-		.build_and_sign(&secp_ctx)
-		.unwrap();
+	let static_invoice =
+		create_static_invoice_builder(recipient, &offer, offer_nonce, relative_expiry)
+			.build_and_sign(&secp_ctx)
+			.unwrap();
 	(offer, static_invoice)
 }
 
@@ -377,6 +420,7 @@ fn static_invoice_unknown_required_features() {
 	let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
 	let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
 	let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
+	let entropy_source = nodes[2].keys_manager;
 	create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
 	create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
 
@@ -393,16 +437,15 @@ fn static_invoice_unknown_required_features() {
 		.unwrap();
 	let (offer_builder, nonce) = nodes[2]
 		.node
-		.create_async_receive_offer_builder(blinded_paths_to_always_online_node)
+		.flow
+		.create_async_receive_offer_builder(entropy_source, blinded_paths_to_always_online_node)
 		.unwrap();
 	let offer = offer_builder.build().unwrap();
-	let static_invoice_unknown_req_features = nodes[2]
-		.node
-		.create_static_invoice_builder(&offer, nonce, None)
-		.unwrap()
-		.features_unchecked(Bolt12InvoiceFeatures::unknown())
-		.build_and_sign(&secp_ctx)
-		.unwrap();
+	let static_invoice_unknown_req_features =
+		create_static_invoice_builder(&nodes[2], &offer, nonce, None)
+			.features_unchecked(Bolt12InvoiceFeatures::unknown())
+			.build_and_sign(&secp_ctx)
+			.unwrap();
 
 	// Initiate payment to the offer corresponding to the manually-constructed invoice that has
 	// unknown required features.
@@ -1073,6 +1116,7 @@ fn invalid_async_receive_with_retry<F1, F2>(
 		create_node_chanmgrs(3, &node_cfgs, &[None, Some(allow_priv_chan_fwds_cfg), None]);
 
 	let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
+	let entropy_source = nodes[2].keys_manager;
 	create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
 	create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
 
@@ -1102,7 +1146,8 @@ fn invalid_async_receive_with_retry<F1, F2>(
 		.unwrap();
 	let (offer_builder, offer_nonce) = nodes[2]
 		.node
-		.create_async_receive_offer_builder(blinded_paths_to_always_online_node)
+		.flow
+		.create_async_receive_offer_builder(entropy_source, blinded_paths_to_always_online_node)
 		.unwrap();
 	let offer = offer_builder.build().unwrap();
 	let amt_msat = 5000;
@@ -1112,12 +1157,10 @@ fn invalid_async_receive_with_retry<F1, F2>(
 	// use the same nodes to avoid complicating the test with a bunch of extra nodes.
 	let mut static_invoice_paths = Vec::new();
 	for _ in 0..3 {
-		let static_inv_for_path = nodes[2]
-			.node
-			.create_static_invoice_builder(&offer, offer_nonce, None)
-			.unwrap()
-			.build_and_sign(&secp_ctx)
-			.unwrap();
+		let static_inv_for_path =
+			create_static_invoice_builder(&nodes[2], &offer, offer_nonce, None)
+				.build_and_sign(&secp_ctx)
+				.unwrap();
 		static_invoice_paths.push(static_inv_for_path.payment_paths()[0].clone());
 	}
 	nodes[2].router.expect_blinded_payment_paths(static_invoice_paths);

lightning/src/ln/channelmanager.rs

@@ -138,12 +138,7 @@ use crate::util::wakers::{Future, Notifier};
 use crate::blinded_path::payment::BlindedPaymentPath;
 #[cfg(async_payments)]
 use {
-	crate::blinded_path::message::BlindedMessagePath,
-	crate::offers::offer::Amount,
-	crate::offers::static_invoice::{
-		StaticInvoice, StaticInvoiceBuilder,
-		DEFAULT_RELATIVE_EXPIRY as STATIC_INVOICE_DEFAULT_RELATIVE_EXPIRY,
-	},
+	crate::blinded_path::message::BlindedMessagePath, crate::offers::static_invoice::StaticInvoice,
 };
 
 #[cfg(feature = "dnssec")]
@@ -11900,68 +11895,6 @@ where
 		Ok(offer)
 	}
 
-	/// Create an offer for receiving async payments as an often-offline recipient.
-	///
-	/// Instead of using this method, it is preferable to call
-	/// [`Self::set_paths_to_static_invoice_server`] and retrieve the automatically built offer via
-	/// [`Self::get_async_receive_offer`].
-	///
-	/// If you want to build the [`StaticInvoice`] manually using this method instead, you MUST:
-	/// 1. Provide at least 1 [`BlindedMessagePath`] terminating at an always-online node that will
-	///    serve the [`StaticInvoice`] created from this offer on our behalf.
-	/// 2. Use [`Self::create_static_invoice_builder`] to create a [`StaticInvoice`] from this
-	///    [`Offer`] plus the returned [`Nonce`], and provide the static invoice to the
-	///    aforementioned always-online node.
-	#[cfg(async_payments)]
-	pub fn create_async_receive_offer_builder(
-		&self, message_paths_to_always_online_node: Vec<BlindedMessagePath>,
-	) -> Result<(OfferBuilder<DerivedMetadata, secp256k1::All>, Nonce), Bolt12SemanticError> {
-		let entropy = &*self.entropy_source;
-		self.flow.create_async_receive_offer_builder(entropy, message_paths_to_always_online_node)
-	}
-
-	/// Creates a [`StaticInvoiceBuilder`] from the corresponding [`Offer`] and [`Nonce`] that were
-	/// created via [`Self::create_async_receive_offer_builder`]. If `relative_expiry` is unset, the
-	/// invoice's expiry will default to [`STATIC_INVOICE_DEFAULT_RELATIVE_EXPIRY`].
-	///
-	/// Instead of using this method to manually build the invoice, it is preferable to set
-	/// [`Self::set_paths_to_static_invoice_server`] and retrieve the automatically built offer via
-	/// [`Self::get_async_receive_offer`].
-	#[cfg(async_payments)]
-	pub fn create_static_invoice_builder<'a>(
-		&self, offer: &'a Offer, offer_nonce: Nonce, relative_expiry: Option<Duration>,
-	) -> Result<StaticInvoiceBuilder<'a>, Bolt12SemanticError> {
-		let entropy = &*self.entropy_source;
-		let amount_msat = offer.amount().and_then(|amount| match amount {
-			Amount::Bitcoin { amount_msats } => Some(amount_msats),
-			Amount::Currency { .. } => None,
-		});
-
-		let relative_expiry = relative_expiry.unwrap_or(STATIC_INVOICE_DEFAULT_RELATIVE_EXPIRY);
-		let relative_expiry_secs: u32 = relative_expiry.as_secs().try_into().unwrap_or(u32::MAX);
-
-		let created_at = self.duration_since_epoch();
-		let payment_secret = inbound_payment::create_for_spontaneous_payment(
-			&self.inbound_payment_key,
-			amount_msat,
-			relative_expiry_secs,
-			created_at.as_secs(),
-			None,
-		)
-		.map_err(|()| Bolt12SemanticError::InvalidAmount)?;
-
-		self.flow.create_static_invoice_builder(
-			&self.router,
-			entropy,
-			offer,
-			offer_nonce,
-			payment_secret,
-			relative_expiry_secs,
-			self.list_usable_channels(),
-			self.get_peers_for_blinded_path(),
-		)
-	}
-
 	/// Sets the [`BlindedMessagePath`]s that we will use as an async recipient to interactively build
 	/// [`Offer`]s with a static invoice server, so the server can serve [`StaticInvoice`]s to payers
 	/// on our behalf when we're offline.
@@ -12413,6 +12346,11 @@ where
 			.collect::<Vec<_>>()
 	}
 
+	#[cfg(all(test, async_payments))]
+	pub(super) fn test_get_peers_for_blinded_path(&self) -> Vec<MessageForwardNode> {
+		self.get_peers_for_blinded_path()
+	}
+
 	#[cfg(all(test, async_payments))]
 	/// Creates multi-hop blinded payment paths for the given `amount_msats` by delegating to
 	/// [`Router::create_blinded_payment_paths`].