feat(wip): uniffi wrapper for payment preimage

Author: enigbe

bindings/ldk_node.udl

@@ -803,6 +803,11 @@ interface Bolt12Invoice {
 	sequence<u8> encode();
 };
 
+interface PaymentPreimage {
+	[Throws=NodeError, Name=from_str]
+	constructor([ByRef] string preimage_str);
+};
+
 [Custom]
 typedef string Txid;
 
@@ -830,9 +835,6 @@ typedef string PaymentId;
 [Custom]
 typedef string PaymentHash;
 
-[Custom]
-typedef string PaymentPreimage;
-
 [Custom]
 typedef string PaymentSecret;
 

src/ffi/types.rs

@@ -18,7 +18,8 @@ pub use crate::graph::{ChannelInfo, ChannelUpdateInfo, NodeAnnouncementInfo, Nod
 pub use crate::liquidity::{LSPS1OrderStatus, LSPS2ServiceConfig, OnchainPaymentInfo, PaymentInfo};
 pub use crate::logger::{LogLevel, LogRecord, LogWriter};
 pub use crate::payment::store::{
-	ConfirmationStatus, LSPFeeLimits, PaymentDirection, PaymentKind, PaymentStatus,
+	ConfirmationStatus, LSPFeeLimits, PaymentDirection, PaymentKind as NodePaymentKind,
+	PaymentStatus,
 };
 pub use crate::payment::{MaxTotalRoutingFeeLimit, QrPaymentResult, SendingParameters};
 
@@ -29,7 +30,9 @@ 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};
 
@@ -665,21 +668,133 @@ impl UniffiCustomTypeConverter for PaymentHash {
 	}
 }
 
-impl UniffiCustomTypeConverter for PaymentPreimage {
-	type Builtin = String;
+/// The payment preimage is the "secret key" which is used to claim the funds of an HTLC on-chain
+/// or in a lightning channel.
+#[derive(Hash, Copy, Clone, PartialEq, Eq, Ord, PartialOrd)]
+pub struct PaymentPreimage {
+	pub(crate) inner: LdkPaymentPreimage,
+}
 
-	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 PaymentPreimage {
+	pub fn from_str(preimage_str: &str) -> Result<Self, Error> {
+		preimage_str.parse()
+	}
+}
+
+impl FromStr for PaymentPreimage {
+	type Err = Error;
+
+	fn from_str(preimage_str: &str) -> Result<Self, Self::Err> {
+		if let Some(bytes) = hex_utils::to_vec(preimage_str) {
+			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 From<LdkPaymentPreimage> for PaymentPreimage {
+	fn from(preimage: LdkPaymentPreimage) -> Self {
+		PaymentPreimage { inner: preimage }
+	}
+}
+
+impl std::fmt::Display for PaymentPreimage {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "{}", self.inner)
+	}
+}
+
+/// Represents the kind of a payment.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum PaymentKind {
+	Onchain {
+		txid: Txid,
+		status: ConfirmationStatus,
+	},
+	Bolt11 {
+		hash: PaymentHash,
+		preimage: Option<Arc<PaymentPreimage>>,
+		secret: Option<PaymentSecret>,
+	},
+	Bolt11Jit {
+		hash: PaymentHash,
+		preimage: Option<Arc<PaymentPreimage>>,
+		secret: Option<PaymentSecret>,
+		counterparty_skimmed_fee_msat: Option<u64>,
+		lsp_fee_limits: LSPFeeLimits,
+	},
+	Bolt12Offer {
+		hash: Option<PaymentHash>,
+		preimage: Option<Arc<PaymentPreimage>>,
+		secret: Option<PaymentSecret>,
+		offer_id: OfferId,
+		payer_note: Option<UntrustedString>,
+		quantity: Option<u64>,
+	},
+	Bolt12Refund {
+		hash: Option<PaymentHash>,
+		preimage: Option<Arc<PaymentPreimage>>,
+		secret: Option<PaymentSecret>,
+		payer_note: Option<UntrustedString>,
+		quantity: Option<u64>,
+	},
+	Spontaneous {
+		hash: PaymentHash,
+		preimage: Option<Arc<PaymentPreimage>>,
+	},
+}
+
+impl From<NodePaymentKind> for PaymentKind {
+	fn from(payment_kind: NodePaymentKind) -> Self {
+		match payment_kind {
+			NodePaymentKind::Onchain { txid, status } => PaymentKind::Onchain { txid, status },
+			NodePaymentKind::Bolt11 { hash, preimage, secret } => {
+				PaymentKind::Bolt11 { hash, preimage: preimage.map(|p| Arc::new(p)), secret }
+			},
+			NodePaymentKind::Bolt11Jit {
+				hash,
+				preimage,
+				secret,
+				counterparty_skimmed_fee_msat,
+				lsp_fee_limits,
+			} => PaymentKind::Bolt11Jit {
+				hash,
+				preimage: preimage.map(|p| Arc::new(p)),
+				secret,
+				counterparty_skimmed_fee_msat,
+				lsp_fee_limits,
+			},
+			NodePaymentKind::Bolt12Offer {
+				hash,
+				preimage,
+				secret,
+				offer_id,
+				payer_note,
+				quantity,
+			} => PaymentKind::Bolt12Offer {
+				hash,
+				preimage: preimage.map(|p| Arc::new(p)),
+				secret,
+				offer_id,
+				payer_note,
+				quantity,
+			},
+			NodePaymentKind::Bolt12Refund { hash, preimage, secret, payer_note, quantity } => {
+				PaymentKind::Bolt12Refund {
+					hash,
+					preimage: preimage.map(|p| Arc::new(p)),
+					secret,
+					payer_note,
+					quantity,
+				}
+			},
+			NodePaymentKind::Spontaneous { hash, preimage } => {
+				PaymentKind::Spontaneous { hash, preimage: preimage.map(|p| Arc::new(p)) }
+			},
+		}
 	}
 }