Allow to set payer_note on pay_for_offer_from_human_readable_name

Author: elnosh

lightning-dns-resolver/src/lib.rs

@@ -182,6 +182,7 @@ mod test {
 		commitment_signed_dance, expect_payment_claimed, expect_pending_htlcs_forwardable,
 		get_htlc_update_msgs,
 	};
+	use lightning_types::string::UntrustedString;
 
 	use std::ops::Deref;
 	use std::sync::Mutex;
@@ -396,7 +397,7 @@ mod test {
 		// When we get the proof back, override its contents to an offer from nodes[1]
 		let bs_offer = nodes[1].node.create_offer_builder(None).unwrap().build().unwrap();
 		let proof_override = &nodes[0].node.testing_dnssec_proof_offer_resolution_override;
-		proof_override.lock().unwrap().insert(name.clone(), bs_offer);
+		proof_override.lock().unwrap().insert(name.clone(), bs_offer.clone());
 
 		let payment_id = PaymentId([42; 32]);
 		let resolvers = vec![Destination::Node(resolver_id)];
@@ -405,7 +406,86 @@ mod test {
 		let params = RouteParametersConfig::default();
 		nodes[0]
 			.node
-			.pay_for_offer_from_human_readable_name(name, amt, payment_id, retry, params, resolvers)
+			.pay_for_offer_from_human_readable_name(
+				name.clone(),
+				amt,
+				payment_id,
+				None,
+				retry,
+				params,
+				resolvers.clone(),
+			)
+			.unwrap();
+
+		let query = nodes[0].onion_messenger.next_onion_message_for_peer(resolver_id).unwrap();
+		resolver_messenger.get_om().handle_onion_message(payer_id, &query);
+
+		assert!(resolver_messenger.get_om().next_onion_message_for_peer(payer_id).is_none());
+		let start = Instant::now();
+		let response = loop {
+			tokio::time::sleep(Duration::from_millis(10)).await;
+			if let Some(msg) = resolver_messenger.get_om().next_onion_message_for_peer(payer_id) {
+				break msg;
+			}
+			assert!(start.elapsed() < Duration::from_secs(10), "Resolution took too long");
+		};
+
+		nodes[0].onion_messenger.handle_onion_message(resolver_id, &response);
+
+		let invreq = nodes[0].onion_messenger.next_onion_message_for_peer(payee_id).unwrap();
+		nodes[1].onion_messenger.handle_onion_message(payer_id, &invreq);
+
+		let inv = nodes[1].onion_messenger.next_onion_message_for_peer(payer_id).unwrap();
+		nodes[0].onion_messenger.handle_onion_message(payee_id, &inv);
+
+		check_added_monitors(&nodes[0], 1);
+		let updates = get_htlc_update_msgs!(nodes[0], payee_id);
+		nodes[1].node.handle_update_add_htlc(payer_id, &updates.update_add_htlcs[0]);
+		commitment_signed_dance!(nodes[1], nodes[0], updates.commitment_signed, false);
+		expect_pending_htlcs_forwardable!(nodes[1]);
+
+		let claimable_events = nodes[1].node.get_and_clear_pending_events();
+		assert_eq!(claimable_events.len(), 1);
+		let our_payment_preimage;
+		if let Event::PaymentClaimable { purpose, amount_msat, .. } = &claimable_events[0] {
+			assert_eq!(*amount_msat, amt);
+			if let PaymentPurpose::Bolt12OfferPayment {
+				payment_preimage, payment_context, ..
+			} = purpose
+			{
+				our_payment_preimage = payment_preimage.unwrap();
+				nodes[1].node.claim_funds(our_payment_preimage);
+				let payment_hash: PaymentHash = our_payment_preimage.into();
+				expect_payment_claimed!(nodes[1], payment_hash, amt);
+				assert_eq!(payment_context.invoice_request.payer_note_truncated, None);
+			} else {
+				panic!();
+			}
+		} else {
+			panic!();
+		}
+
+		check_added_monitors(&nodes[1], 1);
+		let updates = get_htlc_update_msgs!(nodes[1], payer_id);
+		nodes[0].node.handle_update_fulfill_htlc(payee_id, &updates.update_fulfill_htlcs[0]);
+		commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, false);
+
+		expect_payment_sent(&nodes[0], our_payment_preimage, None, true, true);
+
+		// Pay offer with payer_note
+		let proof_override = &nodes[0].node.testing_dnssec_proof_offer_resolution_override;
+		proof_override.lock().unwrap().insert(name.clone(), bs_offer);
+		nodes[0]
+			.node
+			.pay_for_offer_from_human_readable_name(
+				name,
+				amt,
+				PaymentId([21; 32]),
+				Some("foo".into()),
+				retry,
+				params,
+				resolvers,
+			)
 			.unwrap();
 
 		let query = nodes[0].onion_messenger.next_onion_message_for_peer(resolver_id).unwrap();
@@ -440,11 +520,18 @@ mod test {
 		let our_payment_preimage;
 		if let Event::PaymentClaimable { purpose, amount_msat, .. } = &claimable_events[0] {
 			assert_eq!(*amount_msat, amt);
-			if let PaymentPurpose::Bolt12OfferPayment { payment_preimage, .. } = purpose {
+			if let PaymentPurpose::Bolt12OfferPayment {
+				payment_preimage, payment_context, ..
+			} = purpose
+			{
 				our_payment_preimage = payment_preimage.unwrap();
 				nodes[1].node.claim_funds(our_payment_preimage);
 				let payment_hash: PaymentHash = our_payment_preimage.into();
 				expect_payment_claimed!(nodes[1], payment_hash, amt);
+				assert_eq!(
+					payment_context.invoice_request.payer_note_truncated,
+					Some(UntrustedString("foo".into()))
+				);
 			} else {
 				panic!();
 			}

lightning/src/ln/channelmanager.rs

@@ -10588,15 +10588,15 @@ where
 	/// [Avoiding Duplicate Payments]: #avoiding-duplicate-payments
 	#[cfg(feature = "dnssec")]
 	pub fn pay_for_offer_from_human_readable_name(
-		&self, name: HumanReadableName, amount_msats: u64, payment_id: PaymentId,
+		&self, name: HumanReadableName, amount_msats: u64, payment_id: PaymentId, payer_note: Option<String>,
 		retry_strategy: Retry, route_params_config: RouteParametersConfig,
 		dns_resolvers: Vec<Destination>,
 	) -> Result<(), ()> {
 		let (onion_message, context) =
 			self.flow.hrn_resolver.resolve_name(payment_id, name, &*self.entropy_source)?;
 
 		let expiration = StaleExpiration::TimerTicks(1);
-		self.pending_outbound_payments.add_new_awaiting_offer(payment_id, expiration, retry_strategy, route_params_config, amount_msats)?;
+		self.pending_outbound_payments.add_new_awaiting_offer(payment_id, expiration, retry_strategy, route_params_config, amount_msats, payer_note)?;
 
 		self.flow.enqueue_dns_onion_message(
 			onion_message, context, dns_resolvers,
@@ -12463,9 +12463,9 @@ where
 					// offer, but tests can deal with that.
 					offer = replacement_offer;
 				}
-				if let Ok(amt_msats) = self.pending_outbound_payments.amt_msats_for_payment_awaiting_offer(payment_id) {
+				if let Ok((amt_msats, payer_note)) = self.pending_outbound_payments.params_for_payment_awaiting_offer(payment_id) {
 					let offer_pay_res =
-						self.pay_for_offer_intern(&offer, None, Some(amt_msats), None, payment_id, Some(name),
+						self.pay_for_offer_intern(&offer, None, Some(amt_msats), payer_note, payment_id, Some(name),
 							|invoice_request, nonce| {
 								let retryable_invoice_request = RetryableInvoiceRequest {
 									invoice_request: invoice_request.clone(),

lightning/src/ln/outbound_payment.rs

@@ -67,6 +67,7 @@ pub(crate) enum PendingOutboundPayment {
 		/// Human Readable Names-originated payments should always specify an explicit amount to
 		/// send up-front, which we track here and enforce once we receive the offer.
 		amount_msats: u64,
+		payer_note: Option<String>
 	},
 	AwaitingInvoice {
 		expiration: StaleExpiration,
@@ -1775,7 +1776,7 @@ impl OutboundPayments {
 	#[cfg(feature = "dnssec")]
 	pub(super) fn add_new_awaiting_offer(
 		&self, payment_id: PaymentId, expiration: StaleExpiration, retry_strategy: Retry,
-		route_params_config: RouteParametersConfig, amount_msats: u64,
+		route_params_config: RouteParametersConfig, amount_msats: u64, payer_note: Option<String>
 	) -> Result<(), ()> {
 		let mut pending_outbounds = self.pending_outbound_payments.lock().unwrap();
 		match pending_outbounds.entry(payment_id) {
@@ -1786,6 +1787,7 @@ impl OutboundPayments {
 					retry_strategy,
 					route_params_config,
 					amount_msats,
+					payer_note,
 				});
 
 				Ok(())
@@ -1794,10 +1796,10 @@ impl OutboundPayments {
 	}
 
 	#[cfg(feature = "dnssec")]
-	pub(super) fn amt_msats_for_payment_awaiting_offer(&self, payment_id: PaymentId) -> Result<u64, ()> {
+	pub(super) fn params_for_payment_awaiting_offer(&self, payment_id: PaymentId) -> Result<(u64, Option<String>), ()> {
 		match self.pending_outbound_payments.lock().unwrap().entry(payment_id) {
 			hash_map::Entry::Occupied(entry) => match entry.get() {
-				PendingOutboundPayment::AwaitingOffer { amount_msats, .. } => Ok(*amount_msats),
+				PendingOutboundPayment::AwaitingOffer { amount_msats, payer_note, .. } => Ok((*amount_msats, payer_note.clone())),
 				_ => Err(()),
 			},
 			_ => Err(()),
@@ -2583,6 +2585,7 @@ impl_writeable_tlv_based_enum_upgradable!(PendingOutboundPayment,
 			)
 		))),
 		(6, amount_msats, required),
+		(7, payer_note, option),
 	},
 );