types: re-export LDK's PaidBolt12Invoice directly for non-uniffi

This patch removes the custom PaidBolt12Invoice type and its
Writeable/Readable implementations for non-uniffi builds, instead
re-exporting LDK's type directly.

Problem:
We were reimplementing serialization for PaidBolt12Invoice when
LDK already provides it via impl_writeable_tlv_based_enum!. This
adds unnecessary boilerplate and potential for bugs.

Solution:
For non-uniffi builds, simply re-export lightning::events::PaidBolt12Invoice.
This uses LDK's existing serialization and avoids code duplication.

For uniffi builds, we still need our own struct type due to UniFFI
limitations with enum variant data containing Objects.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: vincenzopalazzo

src/event.rs

@@ -1078,15 +1078,17 @@ where
 					);
 				});
 
-				// Convert LDK's PaidBolt12Invoice to our wrapped type.
-				let bolt12_invoice_wrapped = bolt12_invoice.map(PaidBolt12Invoice::from);
+				// For UniFFI builds, convert LDK's PaidBolt12Invoice to our wrapped type.
+				// For non-UniFFI builds, we use LDK's type directly.
+				#[cfg(feature = "uniffi")]
+				let bolt12_invoice = bolt12_invoice.map(PaidBolt12Invoice::from);
 
 				let event = Event::PaymentSuccessful {
 					payment_id: Some(payment_id),
 					payment_hash,
 					payment_preimage: Some(payment_preimage),
 					fee_paid_msat,
-					bolt12_invoice: bolt12_invoice_wrapped,
+					bolt12_invoice,
 				};
 
 				match self.event_queue.add_event(event).await {

src/types.rs

@@ -14,19 +14,11 @@ use bitcoin::secp256k1::PublicKey;
 use bitcoin::{OutPoint, ScriptBuf};
 use bitcoin_payment_instructions::onion_message_resolver::LDKOnionMessageDNSSECHrnResolver;
 use lightning::chain::chainmonitor;
-#[cfg(not(feature = "uniffi"))]
-use lightning::events::PaidBolt12Invoice as LdkPaidBolt12Invoice;
 use lightning::impl_writeable_tlv_based;
 use lightning::ln::channel_state::ChannelDetails as LdkChannelDetails;
-#[cfg(not(feature = "uniffi"))]
-use lightning::ln::msgs::DecodeError;
 use lightning::ln::msgs::{RoutingMessageHandler, SocketAddress};
 use lightning::ln::peer_handler::IgnoringMessageHandler;
 use lightning::ln::types::ChannelId;
-#[cfg(not(feature = "uniffi"))]
-use lightning::offers::invoice::Bolt12Invoice as LdkBolt12Invoice;
-#[cfg(not(feature = "uniffi"))]
-use lightning::offers::static_invoice::StaticInvoice as LdkStaticInvoice;
 use lightning::routing::gossip;
 use lightning::routing::router::DefaultRouter;
 use lightning::routing::scoring::{CombinedScorer, ProbabilisticScoringFeeParameters};
@@ -619,76 +611,10 @@ impl From<&(u64, Vec<u8>)> for CustomTlvRecord {
 }
 
 // Re-export the invoice types. When UniFFI is enabled, we use the types from ffi::types
-// which have additional UniFFI-specific implementations. Otherwise, we use simpler wrappers.
-#[cfg(feature = "uniffi")]
-pub use crate::ffi::{Bolt12Invoice, PaidBolt12Invoice, StaticInvoice};
-
+// which have additional UniFFI-specific implementations. Otherwise, we re-export LDK's
+// types directly to avoid unnecessary wrappers and serialization reimplementation.
 #[cfg(not(feature = "uniffi"))]
-mod invoice_types {
-	use super::*;
-
-	/// Represents a BOLT12 invoice that was paid.
-	///
-	/// This is used in [`Event::PaymentSuccessful`] to provide proof of payment for BOLT12 payments.
-	///
-	/// [`Event::PaymentSuccessful`]: crate::Event::PaymentSuccessful
-	#[derive(Debug, Clone, PartialEq, Eq)]
-	pub enum PaidBolt12Invoice {
-		/// A standard BOLT12 invoice.
-		Bolt12Invoice(Arc<LdkBolt12Invoice>),
-		/// A static invoice for async payments.
-		StaticInvoice(Arc<LdkStaticInvoice>),
-	}
-
-	impl From<LdkPaidBolt12Invoice> for PaidBolt12Invoice {
-		fn from(ldk_invoice: LdkPaidBolt12Invoice) -> Self {
-			match ldk_invoice {
-				LdkPaidBolt12Invoice::Bolt12Invoice(invoice) => {
-					PaidBolt12Invoice::Bolt12Invoice(Arc::new(invoice))
-				},
-				LdkPaidBolt12Invoice::StaticInvoice(invoice) => {
-					PaidBolt12Invoice::StaticInvoice(Arc::new(invoice))
-				},
-			}
-		}
-	}
-
-	impl Writeable for PaidBolt12Invoice {
-		fn write<W: Writer>(&self, writer: &mut W) -> Result<(), lightning::io::Error> {
-			match self {
-				PaidBolt12Invoice::Bolt12Invoice(invoice) => {
-					0u8.write(writer)?;
-					invoice.encode().write(writer)?;
-				},
-				PaidBolt12Invoice::StaticInvoice(invoice) => {
-					1u8.write(writer)?;
-					invoice.encode().write(writer)?;
-				},
-			}
-			Ok(())
-		}
-	}
-
-	impl Readable for PaidBolt12Invoice {
-		fn read<R: lightning::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
-			let tag: u8 = Readable::read(reader)?;
-			let bytes: Vec<u8> = Readable::read(reader)?;
-			match tag {
-				0 => {
-					let invoice =
-						LdkBolt12Invoice::try_from(bytes).map_err(|_| DecodeError::InvalidValue)?;
-					Ok(PaidBolt12Invoice::Bolt12Invoice(Arc::new(invoice)))
-				},
-				1 => {
-					let invoice =
-						LdkStaticInvoice::try_from(bytes).map_err(|_| DecodeError::InvalidValue)?;
-					Ok(PaidBolt12Invoice::StaticInvoice(Arc::new(invoice)))
-				},
-				_ => Err(DecodeError::InvalidValue),
-			}
-		}
-	}
-}
+pub use lightning::events::PaidBolt12Invoice;
 
-#[cfg(not(feature = "uniffi"))]
-pub use invoice_types::*;
+#[cfg(feature = "uniffi")]
+pub use crate::ffi::{Bolt12Invoice, PaidBolt12Invoice, StaticInvoice};