support for passing preimage for spontaneous payment

- integration test for passing preimage for spontaneous payment
- bindings for passing preimage for spontaneous payment
- refactor: move preimage from method parameter to SendingParameters
- revert to parameter-based approach
- verify node_b recieved payment for end-to-end verification
- expose a proper newtype wrapper for the PaymentPreimage bindings
- trigger CI

Author: aagbotemi

bindings/ldk_node.udl

@@ -212,6 +212,10 @@ interface SpontaneousPayment {
 	[Throws=NodeError]
 	PaymentId send_with_custom_tlvs(u64 amount_msat, PublicKey node_id, SendingParameters? sending_parameters, sequence<CustomTlvRecord> custom_tlvs);
 	[Throws=NodeError]
+	PaymentId send_with_preimage(u64 amount_msat, PublicKey node_id, PaymentPreimage preimage, SendingParameters? sending_parameters);
+	[Throws=NodeError]
+	PaymentId send_with_preimage_and_custom_tlvs(u64 amount_msat, PublicKey node_id, sequence<CustomTlvRecord> custom_tlvs, PaymentPreimage preimage, SendingParameters? sending_parameters);
+	[Throws=NodeError]
 	void send_probes(u64 amount_msat, PublicKey node_id);
 };
 
@@ -446,6 +450,10 @@ dictionary PaymentDetails {
 	u64 latest_update_timestamp;
 };
 
+dictionary PaymentPreimage {
+	bytes inner;
+};
+
 dictionary SendingParameters {
 	MaxTotalRoutingFeeLimit? max_total_routing_fee_msat;
 	u32? max_total_cltv_expiry_delta;
@@ -829,9 +837,6 @@ typedef string PaymentId;
 [Custom]
 typedef string PaymentHash;
 
-[Custom]
-typedef string PaymentPreimage;
-
 [Custom]
 typedef string PaymentSecret;
 

src/balance.rs

@@ -5,14 +5,16 @@
 // http://opensource.org/licenses/MIT>, at your option. You may not use this file except in
 // accordance with one or both of these licenses.
 
+use crate::ffi::maybe_wrap;
+use crate::payment::PaymentPreimage;
 use crate::sweep::value_from_descriptor;
 
 use lightning::chain::channelmonitor::Balance as LdkBalance;
 use lightning::chain::channelmonitor::BalanceSource;
 use lightning::ln::types::ChannelId;
 use lightning::util::sweep::{OutputSpendStatus, TrackedSpendableOutput};
 
-use lightning_types::payment::{PaymentHash, PaymentPreimage};
+use lightning_types::payment::PaymentHash;
 
 use bitcoin::secp256k1::PublicKey;
 use bitcoin::{BlockHash, Txid};
@@ -263,7 +265,7 @@ impl LightningBalance {
 				amount_satoshis,
 				timeout_height,
 				payment_hash,
-				payment_preimage,
+				payment_preimage: maybe_wrap(payment_preimage),
 			},
 			LdkBalance::MaybeTimeoutClaimableHTLC {
 				amount_satoshis,

src/event.rs

@@ -5,6 +5,7 @@
 // http://opensource.org/licenses/MIT>, at your option. You may not use this file except in
 // accordance with one or both of these licenses.
 
+use crate::ffi::maybe_wrap;
 use crate::types::{CustomTlvRecord, DynStore, PaymentStore, Sweeper, Wallet};
 
 use crate::{
@@ -22,6 +23,7 @@ use crate::logger::Logger;
 use crate::payment::store::{
 	PaymentDetails, PaymentDetailsUpdate, PaymentDirection, PaymentKind, PaymentStatus,
 };
+use crate::payment::PaymentPreimage;
 
 use crate::io::{
 	EVENT_QUEUE_PERSISTENCE_KEY, EVENT_QUEUE_PERSISTENCE_PRIMARY_NAMESPACE,
@@ -39,7 +41,7 @@ use lightning::routing::gossip::NodeId;
 use lightning::util::errors::APIError;
 use lightning::util::ser::{Readable, ReadableArgs, Writeable, Writer};
 
-use lightning_types::payment::{PaymentHash, PaymentPreimage};
+use lightning_types::payment::PaymentHash;
 
 use lightning_liquidity::lsps2::utils::compute_opening_fee;
 
@@ -740,7 +742,7 @@ where
 						let quantity = payment_context.invoice_request.quantity;
 						let kind = PaymentKind::Bolt12Offer {
 							hash: Some(payment_hash),
-							preimage: payment_preimage,
+							preimage: payment_preimage.map(|preimage| maybe_wrap(preimage)),
 							secret: Some(payment_secret),
 							offer_id,
 							payer_note,
@@ -785,7 +787,7 @@ where
 						// Since it's spontaneous, we insert it now into our store.
 						let kind = PaymentKind::Spontaneous {
 							hash: payment_hash,
-							preimage: Some(preimage),
+							preimage: Some(maybe_wrap(preimage)),
 						};
 
 						let payment = PaymentDetails::new(
@@ -871,7 +873,7 @@ where
 						payment_secret,
 						..
 					} => PaymentDetailsUpdate {
-						preimage: Some(payment_preimage),
+						preimage: Some(payment_preimage.map(|preimage| maybe_wrap(preimage))),
 						secret: Some(Some(payment_secret)),
 						amount_msat: Some(Some(amount_msat)),
 						status: Some(PaymentStatus::Succeeded),
@@ -880,7 +882,7 @@ where
 					PaymentPurpose::Bolt12OfferPayment {
 						payment_preimage, payment_secret, ..
 					} => PaymentDetailsUpdate {
-						preimage: Some(payment_preimage),
+						preimage: Some(payment_preimage.map(|preimage| maybe_wrap(preimage))),
 						secret: Some(Some(payment_secret)),
 						amount_msat: Some(Some(amount_msat)),
 						status: Some(PaymentStatus::Succeeded),
@@ -891,14 +893,14 @@ where
 						payment_secret,
 						..
 					} => PaymentDetailsUpdate {
-						preimage: Some(payment_preimage),
+						preimage: Some(payment_preimage.map(|preimage| maybe_wrap(preimage))),
 						secret: Some(Some(payment_secret)),
 						amount_msat: Some(Some(amount_msat)),
 						status: Some(PaymentStatus::Succeeded),
 						..PaymentDetailsUpdate::new(payment_id)
 					},
 					PaymentPurpose::SpontaneousPayment(preimage) => PaymentDetailsUpdate {
-						preimage: Some(Some(preimage)),
+						preimage: Some(Some(maybe_wrap(preimage))),
 						amount_msat: Some(Some(amount_msat)),
 						status: Some(PaymentStatus::Succeeded),
 						..PaymentDetailsUpdate::new(payment_id)
@@ -960,7 +962,7 @@ where
 
 				let update = PaymentDetailsUpdate {
 					hash: Some(Some(payment_hash)),
-					preimage: Some(Some(payment_preimage)),
+					preimage: Some(Some(maybe_wrap(payment_preimage))),
 					fee_paid_msat: Some(fee_paid_msat),
 					status: Some(PaymentStatus::Succeeded),
 					..PaymentDetailsUpdate::new(payment_id)
@@ -992,7 +994,7 @@ where
 				let event = Event::PaymentSuccessful {
 					payment_id: Some(payment_id),
 					payment_hash,
-					payment_preimage: Some(payment_preimage),
+					payment_preimage: Some(maybe_wrap(payment_preimage)),
 					fee_paid_msat,
 				};
 

src/ffi/mod.rs

@@ -18,6 +18,14 @@ where
 	wrapped_type.as_ref().as_ref()
 }
 
+#[cfg(feature = "uniffi")]
+pub fn maybe_extract<T, R>(wrapped_type: T) -> Result<R, crate::error::Error>
+where
+	R: TryFrom<T, Error = crate::error::Error>,
+{
+	R::try_from(wrapped_type)
+}
+
 #[cfg(feature = "uniffi")]
 pub fn maybe_try_convert_enum<T, R>(wrapped_type: &T) -> Result<R, crate::error::Error>
 where
@@ -27,10 +35,15 @@ where
 }
 
 #[cfg(feature = "uniffi")]
-pub fn maybe_wrap<T>(ldk_type: impl Into<T>) -> std::sync::Arc<T> {
+pub fn maybe_wrap_arc<T>(ldk_type: impl Into<T>) -> std::sync::Arc<T> {
 	std::sync::Arc::new(ldk_type.into())
 }
 
+#[cfg(feature = "uniffi")]
+pub fn maybe_wrap<T>(ldk_type: impl Into<T>) -> T {
+	ldk_type.into()
+}
+
 #[cfg(not(feature = "uniffi"))]
 pub fn maybe_deref<T>(value: &T) -> &T {
 	value
@@ -41,7 +54,19 @@ pub fn maybe_try_convert_enum<T>(value: &T) -> Result<&T, crate::error::Error> {
 	Ok(value)
 }
 
+#[cfg(not(feature = "uniffi"))]
+pub fn maybe_wrap_arc<T>(value: T) -> T {
+	value
+}
+
 #[cfg(not(feature = "uniffi"))]
 pub fn maybe_wrap<T>(value: T) -> T {
 	value
 }
+
+#[cfg(not(feature = "uniffi"))]
+pub fn maybe_extract<T>(wrapped_type: T) -> Result<T, crate::error::Error>
+where
+{
+	Ok(wrapped_type)
+}

src/ffi/types.rs

@@ -22,14 +22,18 @@ pub use crate::payment::store::{
 };
 pub use crate::payment::{MaxTotalRoutingFeeLimit, QrPaymentResult, SendingParameters};
 
+use bitcoin::io::Read;
 pub use lightning::chain::channelmonitor::BalanceSource;
 pub use lightning::events::{ClosureReason, PaymentFailureReason};
+use lightning::ln::msgs::DecodeError;
 pub use lightning::ln::types::ChannelId;
 pub use lightning::offers::offer::OfferId;
 pub use lightning::routing::gossip::{NodeAlias, NodeId, RoutingFees};
 pub use lightning::util::string::UntrustedString;
 
-pub use lightning_types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
+pub use lightning_types::payment::{
+	PaymentHash, PaymentPreimage as LdkPaymentPreimage, PaymentSecret,
+};
 
 pub use lightning_invoice::{Description, SignedRawBolt11Invoice};
 
@@ -58,7 +62,7 @@ use lightning::ln::channelmanager::PaymentId;
 use lightning::offers::invoice::Bolt12Invoice as LdkBolt12Invoice;
 use lightning::offers::offer::{Amount as LdkAmount, Offer as LdkOffer};
 use lightning::offers::refund::Refund as LdkRefund;
-use lightning::util::ser::Writeable;
+use lightning::util::ser::{Readable, Writeable};
 use lightning_invoice::{Bolt11Invoice as LdkBolt11Invoice, Bolt11InvoiceDescriptionRef};
 
 use std::convert::TryInto;
@@ -665,21 +669,64 @@ impl UniffiCustomTypeConverter for PaymentHash {
 	}
 }
 
-impl UniffiCustomTypeConverter for PaymentPreimage {
-	type Builtin = String;
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PaymentPreimage {
+	pub(crate) inner: Vec<u8>,
+}
 
-	fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
-		if let Some(bytes_vec) = hex_utils::to_vec(&val) {
-			let bytes_res = bytes_vec.try_into();
-			if let Ok(bytes) = bytes_res {
-				return Ok(PaymentPreimage(bytes));
+impl From<LdkPaymentPreimage> for PaymentPreimage {
+	fn from(ldk_value: LdkPaymentPreimage) -> Self {
+		PaymentPreimage { inner: ldk_value.0.to_vec() }
+	}
+}
+
+impl TryFrom<PaymentPreimage> for LdkPaymentPreimage {
+	type Error = Error;
+
+	fn try_from(preimage: PaymentPreimage) -> Result<Self, Self::Error> {
+		if preimage.inner.len() != 32 {
+			return Err(Error::InvalidPaymentPreimage);
+		}
+
+		let mut array = [0u8; 32];
+		array.copy_from_slice(&preimage.inner);
+		Ok(LdkPaymentPreimage(array))
+	}
+}
+
+impl FromStr for PaymentPreimage {
+	type Err = Error;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		if let Some(bytes) = hex_utils::to_vec(s) {
+			if let Ok(array) = bytes.try_into() {
+				return Ok(Self::from(LdkPaymentPreimage(array)));
 			}
 		}
-		Err(Error::InvalidPaymentPreimage.into())
+
+		Err(Error::InvalidPaymentPreimage)
 	}
+}
 
-	fn from_custom(obj: Self) -> Self::Builtin {
-		hex_utils::to_string(&obj.0)
+impl Writeable for PaymentPreimage {
+	fn write<W: lightning::util::ser::Writer>(
+		&self, writer: &mut W,
+	) -> Result<(), lightning::io::Error> {
+		let ldk_preimage = LdkPaymentPreimage::try_from(self.clone()).map_err(|_| {
+			lightning::io::Error::new(
+				lightning::io::ErrorKind::InvalidData,
+				"Invalid payment preimage",
+			)
+		})?;
+
+		ldk_preimage.0.write(writer)
+	}
+}
+
+impl Readable for PaymentPreimage {
+	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+		let buf: [u8; 32] = Readable::read(r)?;
+		Ok(PaymentPreimage { inner: buf.to_vec() })
 	}
 }