Add Offer wrapper for FFI bindings

Implement Offer struct in ffi/types.rs to provide a wrapper around LDK's Offer for cross-language bindings.

Modified payment handling in bolt12.rs to:
- Support both native and FFI-compatible types via type aliasing
- Implement conditional compilation for transparent FFI support
- Update payment functions to handle wrapped types

Added testing to verify that properties are preserved when wrapping/unwrapping between native and FFI types.

Author: alexanderwiederin

bindings/ldk_node.udl

@@ -736,6 +736,29 @@ interface Bolt11Invoice {
 	PublicKey recover_payee_pub_key();
 };
 
+[Enum]
+interface OfferAmount {
+	Bitcoin(u64 amount_msats);
+	Currency(string iso4217_code, u64 amount);
+};
+
+interface Offer {
+	[Throws=NodeError, Name=from_str]
+	constructor([ByRef] string offer_str);
+	OfferId id();
+	boolean is_expired();
+	string? description();
+	string? issuer();
+	OfferAmount? amount();
+	boolean is_valid_quantity(u64 quantity);
+	boolean expects_quantity();
+	boolean supports_chain(Network chain);
+	sequence<Network> chains();
+	sequence<u8>? metadata();
+	u64? absolute_expiry_seconds();
+	PublicKey? issuer_signing_pubkey();
+};
+
 [Custom]
 typedef string Txid;
 
@@ -754,9 +777,6 @@ typedef string NodeId;
 [Custom]
 typedef string Address;
 
-[Custom]
-typedef string Offer;
-
 [Custom]
 typedef string Refund;
 

src/ffi/conversions.rs

@@ -0,0 +1,92 @@
+// This file is Copyright its original authors, visible in version control history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. You may not use this file except in
+// accordance with one or both of these licenses.
+
+mod uniffi_impl {
+	use std::sync::Arc;
+
+	use lightning::offers::offer::Offer as LdkOffer;
+	use lightning_invoice::{
+		Bolt11Invoice as LdkBolt11Invoice, Bolt11InvoiceDescription as LdkBolt11InvoiceDescription,
+	};
+
+	use crate::error::Error;
+	use crate::ffi::{Bolt11Invoice, Bolt11InvoiceDescription, Offer};
+
+	pub trait UniffiType {
+		type LdkType;
+
+		fn from_ldk(ldk_value: Self::LdkType) -> Self;
+	}
+
+	pub trait UniffiConversionType: UniffiType {
+		fn as_ldk(&self) -> Self::LdkType;
+	}
+
+	pub trait UniffiFallibleConversionType: UniffiType {
+		fn try_as_ldk(&self) -> Result<Self::LdkType, Error>;
+	}
+
+	impl UniffiType for Bolt11InvoiceDescription {
+		type LdkType = LdkBolt11InvoiceDescription;
+
+		fn from_ldk(ldk_value: Self::LdkType) -> Self {
+			Bolt11InvoiceDescription::from(ldk_value)
+		}
+	}
+
+	impl UniffiFallibleConversionType for Bolt11InvoiceDescription {
+		fn try_as_ldk(&self) -> Result<Self::LdkType, Error> {
+			LdkBolt11InvoiceDescription::try_from(self)
+		}
+	}
+
+	impl UniffiType for Arc<Bolt11Invoice> {
+		type LdkType = LdkBolt11Invoice;
+
+		fn from_ldk(ldk_value: Self::LdkType) -> Self {
+			Arc::new(Bolt11Invoice { inner: ldk_value })
+		}
+	}
+
+	impl UniffiConversionType for Arc<Bolt11Invoice> {
+		fn as_ldk(&self) -> Self::LdkType {
+			self.inner.clone()
+		}
+	}
+
+	impl UniffiType for Arc<Offer> {
+		type LdkType = LdkOffer;
+
+		fn from_ldk(ldk_value: Self::LdkType) -> Self {
+			Arc::new(Offer { inner: ldk_value })
+		}
+	}
+
+	impl UniffiConversionType for Arc<Offer> {
+		fn as_ldk(&self) -> Self::LdkType {
+			self.inner.clone()
+		}
+	}
+
+	pub fn maybe_convert<T: UniffiConversionType>(value: &T) -> T::LdkType {
+		value.as_ldk()
+	}
+
+	pub fn maybe_try_convert<T: UniffiFallibleConversionType>(
+		value: &T,
+	) -> Result<T::LdkType, Error> {
+		value.try_as_ldk()
+	}
+
+	pub fn maybe_wrap<T: UniffiType>(ldk_value: T::LdkType) -> T {
+		T::from_ldk(ldk_value)
+	}
+}
+
+pub use uniffi_impl::maybe_convert;
+pub use uniffi_impl::maybe_try_convert;
+pub use uniffi_impl::maybe_wrap;