feat: Add Bolt11Invoice interface and wrapper implementation for FFI bindings

- Convert Bolt11Invoice from string type to full interface in UDL
- Define required Bolt11Invoice methods in the UDL interface (expiry_time_seconds, min_final_cltv_expiry_delta, amount_milli_satoshis, is_expired, etc.)
- Create Bolt11Invoice struct in uniffi_types.rs to wrap LdkBolt11Invoice
- Implement methods required by the UDL interface
- Add From/Into implementations for conversion between wrapper and LDK types
- Add tests for the wrapper struct

Author: alexanderwiederin

bindings/ldk_node.udl

@@ -698,6 +698,46 @@ dictionary NodeAnnouncementInfo {
 	sequence<SocketAddress> addresses;
 };
 
+enum Currency {
+	"Bitcoin",
+	"BitcoinTestnet",
+	"Regtest",
+	"Simnet",
+	"Signet",
+};
+
+dictionary RouteHintHop {
+	PublicKey src_node_id;
+	u64 short_channel_id;
+	u16 cltv_expiry_delta;
+	u64? htlc_minimum_msat;
+	u64? htlc_maximum_msat;
+	RoutingFees fees;
+};
+
+interface Bolt11Invoice {
+	[Throws=NodeError, Name=from_str]
+	constructor([ByRef] string invoice_str);
+	sequence<u8> signable_hash();
+	u64 expiry_time_seconds();
+	u64 min_final_cltv_expiry_delta();
+	u64? amount_milli_satoshis();
+	boolean is_expired();
+	u64 seconds_since_epoch();
+	boolean would_expire(u64 at_time_seconds);
+	u64 seconds_until_expiry();
+	PaymentHash payment_hash();
+	u64 timestamp_seconds();
+	Currency currency();
+	PaymentSecret payment_secret();
+	Bolt11InvoiceDescription description();
+	sequence<Address> fallback_addresses();
+	sequence<sequence<RouteHintHop>> route_hints();
+	sequence<u8>? features();
+	PublicKey recover_payee_pub_key();
+	Network network();
+};
+
 [Custom]
 typedef string Txid;
 
@@ -716,9 +756,6 @@ typedef string NodeId;
 [Custom]
 typedef string Address;
 
-[Custom]
-typedef string Bolt11Invoice;
-
 [Custom]
 typedef string Offer;
 

src/uniffi_types.rs

@@ -33,12 +33,10 @@ pub use lightning::util::string::UntrustedString;
 
 pub use lightning_types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
 
-pub use lightning_invoice::{Bolt11Invoice, Description};
+pub use lightning_invoice::{Description, SignedRawBolt11Invoice};
 
 pub use lightning_liquidity::lsps1::msgs::ChannelInfo as ChannelOrderInfo;
-pub use lightning_liquidity::lsps1::msgs::{
-	Bolt11PaymentInfo, OrderId, OrderParameters, PaymentState,
-};
+pub use lightning_liquidity::lsps1::msgs::{OrderId, OrderParameters, PaymentState};
 
 pub use bitcoin::{Address, BlockHash, FeeRate, Network, OutPoint, Txid};
 
@@ -60,10 +58,12 @@ use bitcoin::hashes::Hash;
 use bitcoin::secp256k1::PublicKey;
 use lightning::ln::channelmanager::PaymentId;
 use lightning::util::ser::Writeable;
-use lightning_invoice::SignedRawBolt11Invoice;
+use lightning_invoice::{Bolt11Invoice as LdkBolt11Invoice, Bolt11InvoiceDescriptionRef};
 
 use std::convert::TryInto;
 use std::str::FromStr;
+use std::sync::Arc;
+use std::time::{Duration, UNIX_EPOCH};
 
 impl UniffiCustomTypeConverter for PublicKey {
 	type Builtin = String;
@@ -113,24 +113,6 @@ impl UniffiCustomTypeConverter for Address {
 	}
 }
 
-impl UniffiCustomTypeConverter for Bolt11Invoice {
-	type Builtin = String;
-
-	fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
-		if let Ok(signed) = val.parse::<SignedRawBolt11Invoice>() {
-			if let Ok(invoice) = Bolt11Invoice::from_signed(signed) {
-				return Ok(invoice);
-			}
-		}
-
-		Err(Error::InvalidInvoice.into())
-	}
-
-	fn from_custom(obj: Self) -> Self::Builtin {
-		obj.to_string()
-	}
-}
-
 impl UniffiCustomTypeConverter for Offer {
 	type Builtin = String;
 
@@ -405,6 +387,211 @@ impl From<lightning_invoice::Bolt11InvoiceDescription> for Bolt11InvoiceDescript
 	}
 }
 
+impl<'a> From<Bolt11InvoiceDescriptionRef<'a>> for Bolt11InvoiceDescription {
+	fn from(value: Bolt11InvoiceDescriptionRef<'a>) -> Self {
+		match value {
+			lightning_invoice::Bolt11InvoiceDescriptionRef::Direct(description) => {
+				Bolt11InvoiceDescription::Direct { description: description.to_string() }
+			},
+			lightning_invoice::Bolt11InvoiceDescriptionRef::Hash(hash) => {
+				Bolt11InvoiceDescription::Hash { hash: hex_utils::to_string(hash.0.as_ref()) }
+			},
+		}
+	}
+}
+
+#[derive(Debug, Clone, Hash, Eq, PartialEq, Ord, PartialOrd)]
+pub enum Currency {
+	Bitcoin,
+	BitcoinTestnet,
+	Regtest,
+	Simnet,
+	Signet,
+}
+
+impl From<lightning_invoice::Currency> for Currency {
+	fn from(currency: lightning_invoice::Currency) -> Self {
+		match currency {
+			lightning_invoice::Currency::Bitcoin => Currency::Bitcoin,
+			lightning_invoice::Currency::BitcoinTestnet => Currency::BitcoinTestnet,
+			lightning_invoice::Currency::Regtest => Currency::Regtest,
+			lightning_invoice::Currency::Simnet => Currency::Simnet,
+			lightning_invoice::Currency::Signet => Currency::Signet,
+		}
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RouteHintHop {
+	pub src_node_id: PublicKey,
+	pub short_channel_id: u64,
+	pub cltv_expiry_delta: u16,
+	pub htlc_minimum_msat: Option<u64>,
+	pub htlc_maximum_msat: Option<u64>,
+	pub fees: RoutingFees,
+}
+
+impl From<lightning::routing::router::RouteHintHop> for RouteHintHop {
+	fn from(hop: lightning::routing::router::RouteHintHop) -> Self {
+		Self {
+			src_node_id: hop.src_node_id,
+			short_channel_id: hop.short_channel_id,
+			cltv_expiry_delta: hop.cltv_expiry_delta,
+			htlc_minimum_msat: hop.htlc_minimum_msat,
+			htlc_maximum_msat: hop.htlc_maximum_msat,
+			fees: hop.fees,
+		}
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Bolt11Invoice {
+	pub inner: LdkBolt11Invoice,
+}
+
+impl Bolt11Invoice {
+	pub fn from_str(invoice_str: &str) -> Result<Self, Error> {
+		invoice_str.parse()
+	}
+
+	pub fn signable_hash(&self) -> Vec<u8> {
+		self.inner.signable_hash().to_vec()
+	}
+
+	pub fn expiry_time_seconds(&self) -> u64 {
+		self.inner.expiry_time().as_secs()
+	}
+
+	pub fn min_final_cltv_expiry_delta(&self) -> u64 {
+		self.inner.min_final_cltv_expiry_delta()
+	}
+
+	pub fn amount_milli_satoshis(&self) -> Option<u64> {
+		self.inner.amount_milli_satoshis()
+	}
+
+	pub fn is_expired(&self) -> bool {
+		self.inner.is_expired()
+	}
+
+	pub fn seconds_since_epoch(&self) -> u64 {
+		self.inner.duration_since_epoch().as_secs()
+	}
+
+	pub fn would_expire(&self, at_time_seconds: u64) -> bool {
+		self.inner.would_expire(Duration::from_secs(at_time_seconds))
+	}
+
+	pub fn seconds_until_expiry(&self) -> u64 {
+		self.inner.duration_until_expiry().as_secs()
+	}
+
+	pub fn payment_hash(&self) -> PaymentHash {
+		PaymentHash(self.inner.payment_hash().to_byte_array())
+	}
+
+	pub fn timestamp_seconds(&self) -> u64 {
+		self.inner.timestamp().duration_since(UNIX_EPOCH).unwrap().as_secs()
+	}
+
+	pub fn currency(&self) -> Currency {
+		self.inner.currency().into()
+	}
+
+	pub fn payment_secret(&self) -> PaymentSecret {
+		PaymentSecret(self.inner.payment_secret().0)
+	}
+
+	pub fn description(&self) -> Bolt11InvoiceDescription {
+		self.inner.description().into()
+	}
+
+	pub fn fallback_addresses(&self) -> Vec<Address> {
+		self.inner.fallback_addresses()
+	}
+
+	pub fn route_hints(&self) -> Vec<Vec<RouteHintHop>> {
+		self.inner
+			.route_hints()
+			.iter()
+			.map(|route| {
+				route.0.iter()
+					.map(|hop| RouteHintHop::from(hop.clone()))
+					.collect()
+			})
+			.collect()
+	}
+	
+	pub fn features(&self) -> Option<Vec<u8>> {
+		self.inner.features().map(|f| f.encode())
+	}
+	
+	pub fn recover_payee_pub_key(&self) -> PublicKey {
+		self.inner.recover_payee_pub_key()
+	}
+	
+	pub fn network(&self) -> Network {
+		self.inner.network()
+	}
+
+	pub fn into_inner(self) -> lightning_invoice::Bolt11Invoice {
+		self.inner
+	}
+}
+
+impl std::str::FromStr for Bolt11Invoice {
+	type Err = Error;
+
+	fn from_str(invoice_str: &str) -> Result<Self, Self::Err> {
+		match invoice_str.parse::<SignedRawBolt11Invoice>() {
+			Ok(signed) => match LdkBolt11Invoice::from_signed(signed) {
+				Ok(invoice) => Ok(Bolt11Invoice { inner: invoice }),
+				Err(_) => Err(Error::InvalidInvoice),
+			},
+			Err(_) => Err(Error::InvalidInvoice),
+		}
+	}
+}
+
+impl std::fmt::Display for Bolt11Invoice {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "{}", self.inner)
+	}
+}
+
+impl From<LdkBolt11Invoice> for Bolt11Invoice {
+	fn from(invoice: LdkBolt11Invoice) -> Self {
+		Bolt11Invoice { inner: invoice }
+	}
+}
+
+impl From<Bolt11Invoice> for LdkBolt11Invoice {
+	fn from(wrapper: Bolt11Invoice) -> Self {
+		wrapper.into_inner()
+	}
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Bolt11PaymentInfo {
+	pub state: PaymentState,
+	pub expires_at: chrono::DateTime<chrono::Utc>,
+	pub fee_total_sat: u64,
+	pub order_total_sat: u64,
+	pub invoice: Arc<Bolt11Invoice>,
+}
+
+impl From<lightning_liquidity::lsps1::msgs::Bolt11PaymentInfo> for Bolt11PaymentInfo {
+	fn from(info: lightning_liquidity::lsps1::msgs::Bolt11PaymentInfo) -> Self {
+		Self {
+			state: info.state,
+			expires_at: info.expires_at,
+			fee_total_sat: info.fee_total_sat,
+			order_total_sat: info.order_total_sat,
+			invoice: Arc::new(info.invoice.into()),
+		}
+	}
+}
+
 impl UniffiCustomTypeConverter for OrderId {
 	type Builtin = String;
 
@@ -441,4 +628,67 @@ mod tests {
 		let reconverted_description: Bolt11InvoiceDescription = converted_description.into();
 		assert_eq!(description, reconverted_description);
 	}
+
+	#[test]
+	fn test_bolt11_invoice() {
+		let invoice_string = "lnbc1pn8g249pp5f6ytj32ty90jhvw69enf30hwfgdhyymjewywcmfjevflg6s4z86qdqqcqzzgxqyz5vqrzjqwnvuc0u4txn35cafc7w94gxvq5p3cu9dd95f7hlrh0fvs46wpvhdfjjzh2j9f7ye5qqqqryqqqqthqqpysp5mm832athgcal3m7h35sc29j63lmgzvwc5smfjh2es65elc2ns7dq9qrsgqu2xcje2gsnjp0wn97aknyd3h58an7sjj6nhcrm40846jxphv47958c6th76whmec8ttr2wmg6sxwchvxmsc00kqrzqcga6lvsf9jtqgqy5yexa";
+		let ldk_invoice: LdkBolt11Invoice = invoice_string.parse().unwrap();
+
+		let wrapped_invoice = Bolt11Invoice::from(ldk_invoice.clone());
+
+		assert_eq!(
+			ldk_invoice.payment_hash().to_byte_array().to_vec(),
+			wrapped_invoice.payment_hash().0.to_vec()
+		);
+		assert_eq!(ldk_invoice.amount_milli_satoshis(), wrapped_invoice.amount_milli_satoshis());
+		assert_eq!(ldk_invoice.expiry_time().as_secs(), wrapped_invoice.expiry_time_seconds());
+		assert_eq!(
+			ldk_invoice.min_final_cltv_expiry_delta(),
+			wrapped_invoice.min_final_cltv_expiry_delta()
+		);
+		assert_eq!(
+			ldk_invoice.duration_since_epoch().as_secs(),
+			wrapped_invoice.seconds_since_epoch()
+		);
+		assert_eq!(
+			ldk_invoice.duration_until_expiry().as_secs(),
+			wrapped_invoice.seconds_until_expiry()
+		);
+
+		let future_time = Duration::from_secs(wrapped_invoice.seconds_since_epoch() + 10000);
+		assert!(!ldk_invoice.would_expire(future_time));
+		assert!(!wrapped_invoice.would_expire(future_time.as_secs()));
+
+		let invoice_str = wrapped_invoice.to_string();
+		let parsed_invoice: Bolt11Invoice = invoice_str.parse().unwrap();
+		assert_eq!(
+			wrapped_invoice.inner.payment_hash().to_byte_array().to_vec(),
+			parsed_invoice.inner.payment_hash().to_byte_array().to_vec()
+		);
+	}
+
+	#[test]
+	fn test_bolt11_invoice_roundtrip() {
+		let invoice_string = "lnbc1pn8g249pp5f6ytj32ty90jhvw69enf30hwfgdhyymjewywcmfjevflg6s4z86qdqqcqzzgxqyz5vqrzjqwnvuc0u4txn35cafc7w94gxvq5p3cu9dd95f7hlrh0fvs46wpvhdfjjzh2j9f7ye5qqqqryqqqqthqqpysp5mm832athgcal3m7h35sc29j63lmgzvwc5smfjh2es65elc2ns7dq9qrsgqu2xcje2gsnjp0wn97aknyd3h58an7sjj6nhcrm40846jxphv47958c6th76whmec8ttr2wmg6sxwchvxmsc00kqrzqcga6lvsf9jtqgqy5yexa";
+		let original_invoice: LdkBolt11Invoice = invoice_string.parse().unwrap();
+		let wrapped_invoice = Bolt11Invoice { inner: original_invoice.clone() };
+		let unwrapped_invoice: LdkBolt11Invoice = wrapped_invoice.clone().into();
+
+		assert_eq!(original_invoice.payment_hash(), unwrapped_invoice.payment_hash());
+		assert_eq!(original_invoice.payment_secret(), unwrapped_invoice.payment_secret());
+		assert_eq!(
+			original_invoice.amount_milli_satoshis(),
+			unwrapped_invoice.amount_milli_satoshis()
+		);
+		assert_eq!(original_invoice.timestamp(), unwrapped_invoice.timestamp());
+		assert_eq!(original_invoice.expiry_time(), unwrapped_invoice.expiry_time());
+		assert_eq!(
+			original_invoice.min_final_cltv_expiry_delta(),
+			unwrapped_invoice.min_final_cltv_expiry_delta()
+		);
+
+		let original_hints = original_invoice.route_hints();
+		let unwrapped_hints = unwrapped_invoice.route_hints();
+		assert_eq!(original_hints.len(), unwrapped_hints.len());
+	}
 }