Add Refund wrapper for FFI bindings

Implement Refund struct in ffi/types.rs to provide a wrapper around LDK's Refund 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

@@ -759,6 +759,21 @@ interface Offer {
 	PublicKey? issuer_signing_pubkey();
 };
 
+interface Refund {
+	[Throws=NodeError, Name=from_str]
+	constructor([ByRef] string refund_str);
+	string description();
+	u64? absolute_expiry_seconds();
+	boolean is_expired();
+	string? issuer();
+	sequence<u8> payer_metadata();
+	Network? chain();
+	u64 amount_msats();
+	u64? quantity();
+	PublicKey payer_signing_pubkey();
+	string? payer_note();
+};
+
 [Custom]
 typedef string Txid;
 
@@ -777,9 +792,6 @@ typedef string NodeId;
 [Custom]
 typedef string Address;
 
-[Custom]
-typedef string Refund;
-
 [Custom]
 typedef string Bolt12Invoice;
 

src/ffi/conversions.rs

@@ -0,0 +1,106 @@
+// 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, refund::Refund as LdkRefund};
+	use lightning_invoice::{
+		Bolt11Invoice as LdkBolt11Invoice, Bolt11InvoiceDescription as LdkBolt11InvoiceDescription,
+	};
+
+	use crate::error::Error;
+	use crate::ffi::{Bolt11Invoice, Bolt11InvoiceDescription, Offer, Refund};
+
+	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()
+		}
+	}
+
+	impl UniffiType for Arc<Refund> {
+		type LdkType = LdkRefund;
+
+		fn from_ldk(ldk_value: Self::LdkType) -> Self {
+			Arc::new(Refund { inner: ldk_value })
+		}
+	}
+
+	impl UniffiConversionType for Arc<Refund> {
+		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;