fixup! Add support for sending to human-readable names that resolve to Bolt12 Offers

Author: chuksys

bindings/ldk_node.udl

@@ -200,7 +200,7 @@ interface Bolt12Payment {
 	[Throws=NodeError]
 	PaymentId send_using_amount([ByRef]Offer offer, u64 amount_msat, u64? quantity, string? payer_note);
 	[Throws=NodeError]
-	PaymentId send_to_human_readable_name([ByRef]string name, u64 amount_msat);
+	PaymentId send_to_human_readable_name(HumanReadableName hrn, u64 amount_msat);
 	[Throws=NodeError]
 	Offer receive(u64 amount_msat, [ByRef]string description, u32? expiry_secs, u64? quantity);
 	[Throws=NodeError]
@@ -253,6 +253,13 @@ interface LSPS1Liquidity {
 	LSPS1OrderStatus check_order_status(OrderId order_id);
 };
 
+interface HumanReadableName {
+	[Name=from_encoded]
+	constructor([ByRef] string encoded);
+	string user();
+	string domain();
+};
+
 [Error]
 enum NodeError {
 	"AlreadyRunning",

src/event.rs

@@ -1417,8 +1417,20 @@ where
 					);
 				}
 			},
-			LdkEvent::InvoiceReceived { .. } => {
-				debug_assert!(false, "We currently don't handle BOLT12 invoices manually, so this event should never be emitted.");
+			LdkEvent::InvoiceReceived { payment_id, invoice, context: _, responder: _ } => {
+				let update = PaymentDetailsUpdate {
+					hash: Some(Some(invoice.payment_hash())),
+					quantity: invoice.quantity(),
+					..PaymentDetailsUpdate::new(payment_id)
+				};
+
+				match self.payment_store.update(&update) {
+					Ok(_) => {},
+					Err(e) => {
+						log_error!(self.logger, "Failed to access payment store: {}", e);
+						return Err(ReplayEvent());
+					},
+				};
 			},
 			LdkEvent::ConnectionNeeded { node_id, addresses } => {
 				let runtime_lock = self.runtime.read().unwrap();

src/payment/bolt12.rs

@@ -20,7 +20,7 @@ use lightning::ln::channelmanager::{PaymentId, Retry};
 use lightning::offers::offer::{Amount, Offer as LdkOffer, Quantity};
 use lightning::offers::parse::Bolt12SemanticError;
 use lightning::offers::refund::Refund;
-use lightning::onion_message::dns_resolution::HumanReadableName;
+use lightning::onion_message::dns_resolution::HumanReadableName as LdkHumanReadableName;
 use lightning::onion_message::messenger::Destination;
 use lightning::util::string::UntrustedString;
 
@@ -44,6 +44,18 @@ type Offer = Arc<crate::ffi::Offer>;
 type Refund = lightning::offers::refund::Refund;
 #[cfg(feature = "uniffi")]
 type Refund = Arc<crate::ffi::Refund>;
+type HumanReadableName = LdkHumanReadableName;
+#[cfg(feature = "uniffi")]
+type HumanReadableName = Arc<crate::uniffi_types::HumanReadableName>;
+
+#[cfg(not(feature = "uniffi"))]
+pub fn maybe_convert_hrn(hrn: HumanReadableName) -> LdkHumanReadableName {
+	hrn
+}
+#[cfg(feature = "uniffi")]
+pub fn maybe_convert_hrn(hrn: HumanReadableName) -> LdkHumanReadableName {
+	hrn.inner.clone()
+}
 
 /// A payment handler allowing to create and pay [BOLT 12] offers and refunds.
 ///
@@ -282,30 +294,30 @@ impl Bolt12Payment {
 	/// This can be used to pay so-called "zero-amount" offers, i.e., an offer that leaves the
 	/// amount paid to be determined by the user.
 	///
-	/// If `dns_resolvers_node_ids` in Config is set to `None`, this operation will fail.
+	/// If `dns_resolvers_node_ids` in [`Config.hrn_config`] is empty, this operation will fail.
 	pub fn send_to_human_readable_name(
-		&self, name: &str, amount_msat: u64,
+		&self, hrn: HumanReadableName, amount_msat: u64,
 	) -> Result<PaymentId, Error> {
 		let rt_lock = self.runtime.read().unwrap();
 		if rt_lock.is_none() {
 			return Err(Error::NotRunning);
 		}
 
-		let hrn = HumanReadableName::from_encoded(&name).map_err(|_| Error::HrnParsingFailed)?;
-
 		let mut random_bytes = [0u8; 32];
 		rand::thread_rng().fill_bytes(&mut random_bytes);
 		let payment_id = PaymentId(random_bytes);
 		let retry_strategy = Retry::Timeout(LDK_PAYMENT_RETRY_TIMEOUT);
 		let max_total_routing_fee_msat = None;
 
-		let dns_resolvers = match &self.config.dns_resolvers_node_ids {
-			Some(dns_resolvers) => Ok(dns_resolvers.clone()),
-			None => Err(Error::DnsResolversNotConfigured),
-		}?;
+		let destinations: Vec<Destination> = self
+			.config
+			.hrn_config
+			.dns_resolvers_node_ids
+			.iter()
+			.map(|node_id| Destination::Node(*node_id))
+			.collect();
 
-		let destinations: Vec<Destination> =
-			dns_resolvers.into_iter().map(|public_key| Destination::Node(public_key)).collect();
+		let hrn = maybe_convert_hrn(hrn);
 
 		match self.channel_manager.pay_for_offer_from_human_readable_name(
 			hrn.clone(),
@@ -316,7 +328,7 @@ impl Bolt12Payment {
 			destinations,
 		) {
 			Ok(()) => {
-				log_info!(self.logger, "Initiated sending {} msats to {}", amount_msat, name);
+				log_info!(self.logger, "Initiated sending {} msats to {:?}", amount_msat, hrn);
 				let kind = PaymentKind::Bolt12Offer {
 					hash: None,
 					preimage: None,
@@ -337,7 +349,7 @@ impl Bolt12Payment {
 				Ok(payment_id)
 			},
 			Err(()) => {
-				log_error!(self.logger, "Failed to send payment to {}", name);
+				log_error!(self.logger, "Failed to send payment to {:?}", hrn);
 				let kind = PaymentKind::Bolt12Offer {
 					hash: None,
 					preimage: None,
@@ -352,7 +364,7 @@ impl Bolt12Payment {
 					Some(amount_msat),
 					None,
 					PaymentDirection::Outbound,
-					PaymentStatus::Pending,
+					PaymentStatus::Failed,
 				);
 				self.payment_store.insert(payment)?;
 				Err(Error::PaymentSendingFailed)

src/payment/store.rs

@@ -470,7 +470,7 @@ impl_writeable_tlv_based_enum!(PaymentKind,
 		(2, preimage, option),
 		(3, quantity, option),
 		(4, secret, option),
-		(6, offer_id, required),
+		(6, offer_id, option),
 	},
 	(8, Spontaneous) => {
 		(0, hash, required),
@@ -542,6 +542,7 @@ pub(crate) struct PaymentDetailsUpdate {
 	pub direction: Option<PaymentDirection>,
 	pub status: Option<PaymentStatus>,
 	pub confirmation_status: Option<ConfirmationStatus>,
+	pub quantity: Option<u64>,
 }
 
 impl PaymentDetailsUpdate {
@@ -557,6 +558,7 @@ impl PaymentDetailsUpdate {
 			direction: None,
 			status: None,
 			confirmation_status: None,
+			quantity: None,
 		}
 	}
 }
@@ -584,6 +586,11 @@ impl From<&PaymentDetails> for PaymentDetailsUpdate {
 			_ => None,
 		};
 
+		let quantity = match value.kind {
+			PaymentKind::Bolt12Offer { quantity, .. } => quantity,
+			_ => None,
+		};
+
 		Self {
 			id: value.id,
 			hash: Some(hash),
@@ -595,6 +602,7 @@ impl From<&PaymentDetails> for PaymentDetailsUpdate {
 			direction: Some(value.direction),
 			status: Some(value.status),
 			confirmation_status,
+			quantity,
 		}
 	}
 }

src/uniffi_types.rs

@@ -28,6 +28,7 @@ pub use lightning::ln::types::ChannelId;
 pub use lightning::offers::invoice::Bolt12Invoice;
 pub use lightning::offers::offer::{Offer, OfferId};
 pub use lightning::offers::refund::Refund;
+pub use lightning::onion_message::dns_resolution::HumanReadableName as LdkHumanReadableName;
 pub use lightning::routing::gossip::{NodeAlias, NodeId, RoutingFees};
 pub use lightning::util::string::UntrustedString;
 
@@ -656,6 +657,46 @@ impl UniffiCustomTypeConverter for DateTime {
 	}
 }
 
+pub struct HumanReadableName {
+	pub inner: LdkHumanReadableName,
+}
+
+impl HumanReadableName {
+	/// Returns the underlying HumanReadableName [`LdkHumanReadableName`]
+	pub fn into_inner(&self) -> LdkHumanReadableName {
+		self.inner.clone()
+	}
+
+	pub fn from_encoded(encoded: &str) -> Self {
+		let hrn = match LdkHumanReadableName::from_encoded(encoded) {
+			Ok(hrn) => Ok(hrn),
+			Err(e) => Err(format!("Error creating HRN {:?}", e)),
+		};
+
+		Self { inner: hrn.expect("Error creating HRN") }
+	}
+
+	pub fn user(&self) -> String {
+		self.inner.user().to_string()
+	}
+
+	pub fn domain(&self) -> String {
+		self.inner.domain().to_string()
+	}
+}
+
+impl From<LdkHumanReadableName> for HumanReadableName {
+	fn from(ldk_hrn: LdkHumanReadableName) -> Self {
+		HumanReadableName { inner: ldk_hrn }
+	}
+}
+
+impl From<HumanReadableName> for LdkHumanReadableName {
+	fn from(wrapper: HumanReadableName) -> Self {
+		wrapper.into_inner()
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use super::*;