feat: Add Bolt11Invoice wrapper struct for FFI bindings

- 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

src/uniffi_types.rs

@@ -33,12 +33,12 @@ pub use lightning::util::string::UntrustedString;
 
 pub use lightning_types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
 
-pub use lightning_invoice::{Bolt11Invoice, Description};
+pub use lightning_invoice::{
+	Bolt11Invoice as LdkBolt11Invoice, 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 +60,11 @@ use bitcoin::hashes::Hash;
 use bitcoin::secp256k1::PublicKey;
 use lightning::ln::channelmanager::PaymentId;
 use lightning::util::ser::Writeable;
-use lightning_invoice::SignedRawBolt11Invoice;
 
 use std::convert::TryInto;
 use std::str::FromStr;
+use std::sync::Arc;
+use std::time::Duration;
 
 impl UniffiCustomTypeConverter for PublicKey {
 	type Builtin = String;
@@ -113,24 +114,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 +388,100 @@ impl From<lightning_invoice::Bolt11InvoiceDescription> for Bolt11InvoiceDescript
 	}
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Bolt11Invoice {
+	pub inner: LdkBolt11Invoice,
+}
+
+impl Bolt11Invoice {
+	pub fn signable_hash(&self) -> Vec<u8> {
+		self.inner.signable_hash().to_vec()
+	}
+
+	pub fn expiry_time(&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 duration_since_epoch(&self) -> u64 {
+		self.inner.duration_since_epoch().as_secs()
+	}
+
+	pub fn would_expire(&self, at_time: u64) -> bool {
+		self.inner.would_expire(Duration::from_secs(at_time))
+	}
+
+	pub fn duration_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 into_inner(self) -> lightning_invoice::Bolt11Invoice {
+		self.inner
+	}
+
+	pub fn from_string(invoice_str: String) -> Result<Arc<Self>, Error> {
+		match invoice_str.parse::<SignedRawBolt11Invoice>() {
+			Ok(signed) => match LdkBolt11Invoice::from_signed(signed) {
+				Ok(invoice) => Ok(Arc::new(Bolt11Invoice { inner: invoice })),
+				Err(_) => Err(Error::InvalidInvoice.into()),
+			},
+			Err(_) => Err(Error::InvalidInvoice.into()),
+		}
+	}
+
+	pub fn to_string(&self) -> String {
+		format!("{}", self.inner)
+	}
+}
+
+impl From<lightning_invoice::Bolt11Invoice> for Bolt11Invoice {
+	fn from(invoice: lightning_invoice::Bolt11Invoice) -> Self {
+		Bolt11Invoice { inner: invoice }
+	}
+}
+
+impl From<Bolt11Invoice> for lightning_invoice::Bolt11Invoice {
+	fn from(wrapper: Bolt11Invoice) -> Self {
+		wrapper.into_inner()
+	}
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Bolt11PaymentInfo {
+	pub state: lightning_liquidity::lsps1::msgs::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 +518,59 @@ 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::from_str(invoice_string).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());
+		assert_eq!(
+			ldk_invoice.min_final_cltv_expiry_delta(),
+			wrapped_invoice.min_final_cltv_expiry_delta()
+		);
+
+		let future_time = Duration::from_secs(wrapped_invoice.duration_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::from_string(invoice_str);
+		assert_eq!(
+			wrapped_invoice.inner.payment_hash().to_byte_array().to_vec(),
+			parsed_invoice.unwrap().inner.payment_hash().to_byte_array().to_vec()
+		);
+	}
+
+	#[test]
+	fn test_bolt11_invoice_roundtrip() {
+		let invoice_string = "lnbc1pn8g249pp5f6ytj32ty90jhvw69enf30hwfgdhyymjewywcmfjevflg6s4z86qdqqcqzzgxqyz5vqrzjqwnvuc0u4txn35cafc7w94gxvq5p3cu9dd95f7hlrh0fvs46wpvhdfjjzh2j9f7ye5qqqqryqqqqthqqpysp5mm832athgcal3m7h35sc29j63lmgzvwc5smfjh2es65elc2ns7dq9qrsgqu2xcje2gsnjp0wn97aknyd3h58an7sjj6nhcrm40846jxphv47958c6th76whmec8ttr2wmg6sxwchvxmsc00kqrzqcga6lvsf9jtqgqy5yexa";
+		let original_invoice = LdkBolt11Invoice::from_str(invoice_string).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());
+	}
 }