ffi: use dictionary for PaidBolt12Invoice due to UniFFI limitation

This patch reverts PaidBolt12Invoice to a dictionary format in the UDL
while keeping the simplified structure without the redundant kind field.

Problem:
UniFFI doesn't support Object types (interfaces) in enum variant data.
The previous commit attempted to use [Enum] interface format, but this
fails to compile because Bolt12Invoice and StaticInvoice are defined
as interfaces.

Solution:
Use a dictionary with optional fields instead of an enum. Users check
which field is Some to determine the invoice type:
- bolt12_invoice: A standard BOLT12 invoice (supports proof of payment)
- static_invoice: A static invoice for async payments

This is still an improvement over the original implementation as it
removes the redundant PaidBolt12InvoiceKind enum field.

The non-uniffi Rust API keeps the cleaner enum representation.

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

Author: vincenzopalazzo

bindings/ldk_node.udl

@@ -873,10 +873,12 @@ interface StaticInvoice {
 	sequence<u8> encode();
 };
 
-[Enum]
-interface PaidBolt12Invoice {
-	Bolt12Invoice(Bolt12Invoice invoice);
-	StaticInvoice(StaticInvoice invoice);
+// Note: UniFFI doesn't support Object types in enum variant data, so we use
+// a dictionary with optional fields. Check which field is Some to determine
+// the invoice type.
+dictionary PaidBolt12Invoice {
+	Bolt12Invoice? bolt12_invoice;
+	StaticInvoice? static_invoice;
 };
 
 [Custom]

src/ffi/types.rs

@@ -801,39 +801,43 @@ impl AsRef<LdkStaticInvoice> for StaticInvoice {
 ///
 /// This is used in [`Event::PaymentSuccessful`] to provide proof of payment for BOLT12 payments.
 ///
+/// Note: Due to UniFFI limitations with Object types in enum variants, this is exposed as a
+/// struct with optional fields. Check which field is `Some` to determine the invoice type:
+/// - `bolt12_invoice`: A standard BOLT12 invoice (supports proof of payment)
+/// - `static_invoice`: A static invoice for async payments (does NOT support proof of payment)
+///
 /// [`Event::PaymentSuccessful`]: crate::Event::PaymentSuccessful
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum PaidBolt12Invoice {
-	/// A standard BOLT12 invoice.
-	Bolt12Invoice(Arc<Bolt12Invoice>),
-	/// A static invoice for async payments.
-	StaticInvoice(Arc<StaticInvoice>),
+pub struct PaidBolt12Invoice {
+	/// The paid BOLT12 invoice, if this is a regular BOLT12 invoice.
+	pub bolt12_invoice: Option<Arc<Bolt12Invoice>>,
+	/// The paid static invoice, if this is a static invoice (async payment).
+	pub static_invoice: Option<Arc<StaticInvoice>>,
 }
 
 impl From<LdkPaidBolt12Invoice> for PaidBolt12Invoice {
 	fn from(ldk_invoice: LdkPaidBolt12Invoice) -> Self {
 		match ldk_invoice {
-			LdkPaidBolt12Invoice::Bolt12Invoice(invoice) => {
-				PaidBolt12Invoice::Bolt12Invoice(Arc::new(Bolt12Invoice { inner: invoice }))
+			LdkPaidBolt12Invoice::Bolt12Invoice(invoice) => PaidBolt12Invoice {
+				bolt12_invoice: Some(Arc::new(Bolt12Invoice { inner: invoice })),
+				static_invoice: None,
 			},
-			LdkPaidBolt12Invoice::StaticInvoice(invoice) => {
-				PaidBolt12Invoice::StaticInvoice(Arc::new(StaticInvoice { inner: invoice }))
+			LdkPaidBolt12Invoice::StaticInvoice(invoice) => PaidBolt12Invoice {
+				bolt12_invoice: None,
+				static_invoice: Some(Arc::new(StaticInvoice { inner: 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.inner.encode().write(writer)?;
-			},
-			PaidBolt12Invoice::StaticInvoice(invoice) => {
-				1u8.write(writer)?;
-				invoice.inner.encode().write(writer)?;
-			},
+		if let Some(invoice) = &self.bolt12_invoice {
+			0u8.write(writer)?;
+			invoice.inner.encode().write(writer)?;
+		} else if let Some(invoice) = &self.static_invoice {
+			1u8.write(writer)?;
+			invoice.inner.encode().write(writer)?;
 		}
 		Ok(())
 	}
@@ -847,12 +851,18 @@ impl Readable for PaidBolt12Invoice {
 			0 => {
 				let invoice =
 					LdkBolt12Invoice::try_from(bytes).map_err(|_| DecodeError::InvalidValue)?;
-				Ok(PaidBolt12Invoice::Bolt12Invoice(Arc::new(Bolt12Invoice { inner: invoice })))
+				Ok(PaidBolt12Invoice {
+					bolt12_invoice: Some(Arc::new(Bolt12Invoice { inner: invoice })),
+					static_invoice: None,
+				})
 			},
 			1 => {
 				let invoice =
 					LdkStaticInvoice::try_from(bytes).map_err(|_| DecodeError::InvalidValue)?;
-				Ok(PaidBolt12Invoice::StaticInvoice(Arc::new(StaticInvoice { inner: invoice })))
+				Ok(PaidBolt12Invoice {
+					bolt12_invoice: None,
+					static_invoice: Some(Arc::new(StaticInvoice { inner: invoice })),
+				})
 			},
 			_ => Err(DecodeError::InvalidValue),
 		}