event: conditionally expose bolt12_invoice for non-UniFFI builds only

Due to UniFFI 0.28 limitations (Object types in enum variants are not
supported), the `bolt12_invoice` field in `PaymentSuccessful` cannot be
exposed in bindings until we upgrade to UniFFI 0.29+.

Problem:
The previous commit added `PaidBolt12Invoice` to the `PaymentSuccessful`
event, but UniFFI 0.28 cannot handle Object types (like `Bolt12Invoice`)
inside enum variant data, causing binding generation to fail.

Solution:
Use `#[cfg(not(feature = "uniffi"))]` to conditionally compile the
`bolt12_invoice` field only for non-UniFFI builds. This requires
duplicating the `impl_writeable_tlv_based_enum!` macro invocation for
Event, but the serialization formats remain compatible: TLV tag 7
written by non-UniFFI builds is silently skipped by UniFFI builds
(unknown optional TLV), and vice versa.

Changes:
- Add `#[cfg]` guards to `bolt12_invoice` field in `PaymentSuccessful`
- Duplicate Event serialization macro for UniFFI/non-UniFFI builds
- Remove unused `StaticInvoice` and `PaidBolt12Invoice` FFI wrappers
- Add consistent TODO comments referencing #757 for tracking
- Update tests to handle both build configurations

Author: vincenzopalazzo

bindings/ldk_node.udl

@@ -400,7 +400,8 @@ enum VssHeaderProviderError {
 
 [Enum]
 interface Event {
-	PaymentSuccessful(PaymentId? payment_id, PaymentHash payment_hash, PaymentPreimage? payment_preimage, u64? fee_paid_msat, PaidBolt12Invoice? bolt12_invoice);
+	// TODO: Add bolt12_invoice field once we upgrade to UniFFI 0.29+. See #757.
+	PaymentSuccessful(PaymentId? payment_id, PaymentHash payment_hash, PaymentPreimage? payment_preimage, u64? fee_paid_msat);
 	PaymentFailed(PaymentId? payment_id, PaymentHash? payment_hash, PaymentFailureReason? reason);
 	PaymentReceived(PaymentId? payment_id, PaymentHash payment_hash, u64 amount_msat, sequence<CustomTlvRecord> custom_records);
 	PaymentClaimable(PaymentId payment_id, PaymentHash payment_hash, u64 claimable_amount_msat, u32? claim_deadline, sequence<CustomTlvRecord> custom_records);
@@ -857,29 +858,7 @@ interface Bolt12Invoice {
 	sequence<u8> encode();
 };
 
-interface StaticInvoice {
-	[Throws=NodeError, Name=from_str]
-	constructor([ByRef] string invoice_str);
-	OfferId offer_id();
-	boolean is_offer_expired();
-	PublicKey signing_pubkey();
-	PublicKey? issuer_signing_pubkey();
-	string? invoice_description();
-	string? issuer();
-	OfferAmount? amount();
-	sequence<u8> chain();
-	sequence<u8>? metadata();
-	u64? absolute_expiry_seconds();
-	sequence<u8> encode();
-};
-
-// 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;
-};
+// TODO: Add StaticInvoice and PaidBolt12Invoice once we upgrade to UniFFI 0.29+. See #757.
 
 [Custom]
 typedef string Txid;

src/event.rs

@@ -48,9 +48,9 @@ use crate::payment::store::{
 	PaymentDetails, PaymentDetailsUpdate, PaymentDirection, PaymentKind, PaymentStatus,
 };
 use crate::runtime::Runtime;
-use crate::types::{
-	CustomTlvRecord, DynStore, OnionMessenger, PaidBolt12Invoice, PaymentStore, Sweeper, Wallet,
-};
+#[cfg(not(feature = "uniffi"))]
+use crate::types::PaidBolt12Invoice;
+use crate::types::{CustomTlvRecord, DynStore, OnionMessenger, PaymentStore, Sweeper, Wallet};
 use crate::{
 	hex_utils, BumpTransactionEventHandler, ChannelManager, Error, Graph, PeerInfo, PeerStore,
 	UserChannelId,
@@ -87,6 +87,11 @@ pub enum Event {
 		/// Note that static invoices (indicated by [`PaidBolt12Invoice::StaticInvoice`], used for
 		/// async payments) do not support proof of payment as the payment hash is not derived
 		/// from a preimage known only to the recipient.
+		///
+		/// This field is only available in non-UniFFI builds. See the module documentation for
+		/// more information.
+		// TODO: Expose in bindings once we upgrade to UniFFI 0.29+. See #757.
+		#[cfg(not(feature = "uniffi"))]
 		bolt12_invoice: Option<PaidBolt12Invoice>,
 	},
 	/// A sent payment has failed.
@@ -271,6 +276,17 @@ pub enum Event {
 	},
 }
 
+// TODO: These two macros are duplicated because the `Event::PaymentSuccessful` variant has a
+// different set of fields depending on the `uniffi` feature flag. The `bolt12_invoice` field
+// only exists in non-UniFFI builds, and the macro generates code that references struct fields
+// by name, so we can't use a single macro for both. The duplication can be removed once we
+// upgrade to UniFFI 0.29+, which supports Object types in enum variants.
+// See https://github.com/lightningdevkit/ldk-node/issues/757
+//
+// Note: The serialization formats are compatible - TLV tag 7 (bolt12_invoice) written by
+// non-UniFFI builds is silently skipped by UniFFI builds (unknown optional TLV), and UniFFI
+// builds write without tag 7, which non-UniFFI builds read as `bolt12_invoice: None`.
+#[cfg(not(feature = "uniffi"))]
 impl_writeable_tlv_based_enum!(Event,
 	(0, PaymentSuccessful) => {
 		(0, payment_hash, required),
@@ -342,6 +358,78 @@ impl_writeable_tlv_based_enum!(Event,
 	},
 );
 
+// UniFFI version of the macro - see the comment above for why this duplication exists.
+#[cfg(feature = "uniffi")]
+impl_writeable_tlv_based_enum!(Event,
+	(0, PaymentSuccessful) => {
+		(0, payment_hash, required),
+		(1, fee_paid_msat, option),
+		(3, payment_id, option),
+		(5, payment_preimage, option),
+	},
+	(1, PaymentFailed) => {
+		(0, payment_hash, option),
+		(1, reason, upgradable_option),
+		(3, payment_id, option),
+	},
+	(2, PaymentReceived) => {
+		(0, payment_hash, required),
+		(1, payment_id, option),
+		(2, amount_msat, required),
+		(3, custom_records, optional_vec),
+	},
+	(3, ChannelReady) => {
+		(0, channel_id, required),
+		(1, counterparty_node_id, option),
+		(2, user_channel_id, required),
+		(3, funding_txo, option),
+	},
+	(4, ChannelPending) => {
+		(0, channel_id, required),
+		(2, user_channel_id, required),
+		(4, former_temporary_channel_id, required),
+		(6, counterparty_node_id, required),
+		(8, funding_txo, required),
+	},
+	(5, ChannelClosed) => {
+		(0, channel_id, required),
+		(1, counterparty_node_id, option),
+		(2, user_channel_id, required),
+		(3, reason, upgradable_option),
+	},
+	(6, PaymentClaimable) => {
+		(0, payment_hash, required),
+		(2, payment_id, required),
+		(4, claimable_amount_msat, required),
+		(6, claim_deadline, option),
+		(7, custom_records, optional_vec),
+	},
+	(7, PaymentForwarded) => {
+		(0, prev_channel_id, required),
+		(1, prev_node_id, option),
+		(2, next_channel_id, required),
+		(3, next_node_id, option),
+		(4, prev_user_channel_id, option),
+		(6, next_user_channel_id, option),
+		(8, total_fee_earned_msat, option),
+		(10, skimmed_fee_msat, option),
+		(12, claim_from_onchain_tx, required),
+		(14, outbound_amount_forwarded_msat, option),
+	},
+	(8, SplicePending) => {
+		(1, channel_id, required),
+		(3, counterparty_node_id, required),
+		(5, user_channel_id, required),
+		(7, new_funding_txo, required),
+	},
+	(9, SpliceFailed) => {
+		(1, channel_id, required),
+		(3, counterparty_node_id, required),
+		(5, user_channel_id, required),
+		(7, abandoned_funding_txo, option),
+	},
+);
+
 pub struct EventQueue<L: Deref>
 where
 	L::Target: LdkLogger,
@@ -1078,11 +1166,7 @@ where
 					);
 				});
 
-				// 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);
-
+				#[cfg(not(feature = "uniffi"))]
 				let event = Event::PaymentSuccessful {
 					payment_id: Some(payment_id),
 					payment_hash,
@@ -1091,6 +1175,18 @@ where
 					bolt12_invoice,
 				};
 
+				#[cfg(feature = "uniffi")]
+				let event = {
+					// bolt12_invoice not exposed in uniffi builds until UniFFI 0.29+
+					let _ = bolt12_invoice;
+					Event::PaymentSuccessful {
+						payment_id: Some(payment_id),
+						payment_hash,
+						payment_preimage: Some(payment_preimage),
+						fee_paid_msat,
+					}
+				};
+
 				match self.event_queue.add_event(event).await {
 					Ok(_) => return Ok(()),
 					Err(e) => {

src/ffi/types.rs

@@ -22,20 +22,17 @@ use bitcoin::hashes::Hash;
 use bitcoin::secp256k1::PublicKey;
 pub use bitcoin::{Address, BlockHash, FeeRate, Network, OutPoint, ScriptBuf, Txid};
 pub use lightning::chain::channelmonitor::BalanceSource;
-use lightning::events::PaidBolt12Invoice as LdkPaidBolt12Invoice;
 pub use lightning::events::{ClosureReason, PaymentFailureReason};
 use lightning::ln::channelmanager::PaymentId;
-use lightning::ln::msgs::DecodeError;
 pub use lightning::ln::types::ChannelId;
 use lightning::offers::invoice::Bolt12Invoice as LdkBolt12Invoice;
 pub use lightning::offers::offer::OfferId;
 use lightning::offers::offer::{Amount as LdkAmount, Offer as LdkOffer};
 use lightning::offers::refund::Refund as LdkRefund;
-use lightning::offers::static_invoice::StaticInvoice as LdkStaticInvoice;
 use lightning::onion_message::dns_resolution::HumanReadableName as LdkHumanReadableName;
 pub use lightning::routing::gossip::{NodeAlias, NodeId, RoutingFees};
 pub use lightning::routing::router::RouteParametersConfig;
-use lightning::util::ser::{Readable, Writeable, Writer};
+use lightning::util::ser::Writeable;
 use lightning_invoice::{Bolt11Invoice as LdkBolt11Invoice, Bolt11InvoiceDescriptionRef};
 pub use lightning_invoice::{Description, SignedRawBolt11Invoice};
 pub use lightning_liquidity::lsps0::ser::LSPSDateTime;
@@ -689,172 +686,6 @@ impl AsRef<LdkBolt12Invoice> for Bolt12Invoice {
 	}
 }
 
-/// A `StaticInvoice` is used for async payments where the recipient may be offline.
-///
-/// Unlike [`Bolt12Invoice`], a `StaticInvoice` does not support proof of payment
-/// because the payment hash is not derived from a preimage known only to the recipient.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct StaticInvoice {
-	pub(crate) inner: LdkStaticInvoice,
-}
-
-impl StaticInvoice {
-	pub fn from_str(invoice_str: &str) -> Result<Self, Error> {
-		invoice_str.parse()
-	}
-
-	/// Returns the [`OfferId`] of the underlying [`Offer`] this invoice corresponds to.
-	///
-	/// [`Offer`]: lightning::offers::offer::Offer
-	pub fn offer_id(&self) -> OfferId {
-		OfferId(self.inner.offer_id().0)
-	}
-
-	/// Whether the offer this invoice corresponds to has expired.
-	pub fn is_offer_expired(&self) -> bool {
-		self.inner.is_offer_expired()
-	}
-
-	/// A typically transient public key corresponding to the key used to sign the invoice.
-	pub fn signing_pubkey(&self) -> PublicKey {
-		self.inner.signing_pubkey()
-	}
-
-	/// The public key used by the recipient to sign invoices.
-	pub fn issuer_signing_pubkey(&self) -> Option<PublicKey> {
-		self.inner.issuer_signing_pubkey()
-	}
-
-	/// A complete description of the purpose of the originating offer.
-	pub fn invoice_description(&self) -> Option<String> {
-		self.inner.description().map(|printable| printable.to_string())
-	}
-
-	/// The issuer of the offer.
-	pub fn issuer(&self) -> Option<String> {
-		self.inner.issuer().map(|printable| printable.to_string())
-	}
-
-	/// The minimum amount required for a successful payment of a single item.
-	pub fn amount(&self) -> Option<OfferAmount> {
-		self.inner.amount().map(|amount| amount.into())
-	}
-
-	/// The chain that must be used when paying the invoice.
-	pub fn chain(&self) -> Vec<u8> {
-		self.inner.chain().to_bytes().to_vec()
-	}
-
-	/// Opaque bytes set by the originating [`Offer`].
-	///
-	/// [`Offer`]: lightning::offers::offer::Offer
-	pub fn metadata(&self) -> Option<Vec<u8>> {
-		self.inner.metadata().cloned()
-	}
-
-	/// Seconds since the Unix epoch when an invoice should no longer be requested.
-	///
-	/// If `None`, the offer does not expire.
-	pub fn absolute_expiry_seconds(&self) -> Option<u64> {
-		self.inner.absolute_expiry().map(|duration| duration.as_secs())
-	}
-
-	/// Writes `self` out to a `Vec<u8>`.
-	pub fn encode(&self) -> Vec<u8> {
-		self.inner.encode()
-	}
-}
-
-impl std::str::FromStr for StaticInvoice {
-	type Err = Error;
-
-	fn from_str(invoice_str: &str) -> Result<Self, Self::Err> {
-		if let Some(bytes_vec) = hex_utils::to_vec(invoice_str) {
-			if let Ok(invoice) = LdkStaticInvoice::try_from(bytes_vec) {
-				return Ok(StaticInvoice { inner: invoice });
-			}
-		}
-		Err(Error::InvalidInvoice)
-	}
-}
-
-impl From<LdkStaticInvoice> for StaticInvoice {
-	fn from(invoice: LdkStaticInvoice) -> Self {
-		StaticInvoice { inner: invoice }
-	}
-}
-
-impl Deref for StaticInvoice {
-	type Target = LdkStaticInvoice;
-	fn deref(&self) -> &Self::Target {
-		&self.inner
-	}
-}
-
-impl AsRef<LdkStaticInvoice> for StaticInvoice {
-	fn as_ref(&self) -> &LdkStaticInvoice {
-		self.deref()
-	}
-}
-
-/// Represents a BOLT12 invoice that was paid.
-///
-/// 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 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 {
-				bolt12_invoice: Some(super::maybe_wrap(invoice)),
-				static_invoice: None,
-			},
-			LdkPaidBolt12Invoice::StaticInvoice(invoice) => PaidBolt12Invoice {
-				bolt12_invoice: None,
-				static_invoice: Some(super::maybe_wrap(invoice)),
-			},
-		}
-	}
-}
-
-impl Writeable for PaidBolt12Invoice {
-	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), lightning::io::Error> {
-		// Convert our struct back to LDK's enum and delegate serialization
-		let ldk_invoice: LdkPaidBolt12Invoice = match (&self.bolt12_invoice, &self.static_invoice) {
-			(Some(inv), None) => LdkPaidBolt12Invoice::Bolt12Invoice(inv.inner.clone()),
-			(None, Some(inv)) => LdkPaidBolt12Invoice::StaticInvoice(inv.inner.clone()),
-			_ => {
-				return Err(lightning::io::Error::new(
-					lightning::io::ErrorKind::InvalidData,
-					"PaidBolt12Invoice must have exactly one variant set",
-				));
-			},
-		};
-		ldk_invoice.write(writer)
-	}
-}
-
-impl Readable for PaidBolt12Invoice {
-	fn read<R: lightning::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
-		// Read using LDK's deserialization, then convert to our type
-		let ldk_invoice: LdkPaidBolt12Invoice = Readable::read(reader)?;
-		Ok(PaidBolt12Invoice::from(ldk_invoice))
-	}
-}
-
 impl UniffiCustomTypeConverter for OfferId {
 	type Builtin = String;
 

src/payment/mod.rs

@@ -24,6 +24,5 @@ pub use store::{
 };
 pub use unified::{UnifiedPayment, UnifiedPaymentResult};
 
+#[cfg(not(feature = "uniffi"))]
 pub use crate::types::PaidBolt12Invoice;
-#[cfg(feature = "uniffi")]
-pub use crate::types::{Bolt12Invoice, StaticInvoice};