Generate UniFFI scaffolding

We generate the scaffolding from an UDL file and include it in `lib.rs`.
Furthermore, we add a bindings generation shell script for convenience.

Author: tnull

Cargo.toml

@@ -7,6 +7,10 @@ edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[lib]
+crate-type = ["staticlib", "cdylib"]
+name = "ldk_lite"
+
 [dependencies]
 lightning = { version = "0.0.110", features = ["max_level_trace", "std"] }
 lightning-invoice = { version = "0.18" }
@@ -24,7 +28,11 @@ chrono = "0.4"
 futures = "0.3"
 serde_json = { version = "1.0" }
 tokio = { version = "1", features = [ "io-util", "macros", "rt", "rt-multi-thread", "sync", "net", "time" ] }
+uniffi = { version = "0.20.0", features = ["builtin-bindgen"] }
+uniffi_macros = { version = "0.20.0", features = ["builtin-bindgen"] }
 
+[build-dependencies]
+uniffi_build = "0.20.0"
 
 [profile.release]
 panic = "abort"

build.rs

@@ -0,0 +1,3 @@
+fn main() {
+	uniffi_build::generate_scaffolding("uniffi/ldk_lite.udl").unwrap();
+}

src/error.rs

@@ -12,6 +12,12 @@ pub enum Error {
 	FundingTxCreationFailed,
 	/// A network connection has been closed.
 	ConnectionFailed,
+	/// The given address is invalid.
+	AddressInvalid,
+	/// The given public key is invalid.
+	PublicKeyInvalid,
+	/// The given payment hash is invalid.
+	PaymentHashInvalid,
 	/// Payment of the given invoice has already been intiated.
 	NonUniquePaymentHash,
 	/// The given invoice is invalid.
@@ -41,10 +47,11 @@ impl fmt::Display for Error {
 		match *self {
 			Self::AlreadyRunning => write!(f, "LDKLite is already running."),
 			Self::NotRunning => write!(f, "LDKLite is not running."),
-			Self::FundingTxCreationFailed => {
-				write!(f, "Funding transaction could not be created.")
-			}
+			Self::FundingTxCreationFailed => write!(f, "Funding transaction could not be created."),
 			Self::ConnectionFailed => write!(f, "Network connection closed."),
+			Self::AddressInvalid => write!(f, "The given address is invalid."),
+			Self::PublicKeyInvalid => write!(f, "The given public key is invalid."),
+			Self::PaymentHashInvalid => write!(f, "The given payment hash is invalid."),
 			Self::NonUniquePaymentHash => write!(f, "An invoice must not get payed twice."),
 			Self::InvoiceInvalid => write!(f, "The given invoice is invalid."),
 			Self::InvoiceCreationFailed => write!(f, "Failed to create invoice."),

src/event.rs

@@ -50,11 +50,11 @@ pub enum Event {
 	// TODO: Implement after a corresponding LDK event is added.
 	//ChannelOpened {
 	//},
-	/// A channel has been closed.
-	ChannelClosed {
-		/// The channel_id of the channel which has been closed.
-		channel_id: [u8; 32],
-	},
+	///// A channel has been closed.
+	//ChannelClosed {
+	//	/// The channel_id of the channel which has been closed.
+	//	channel_id: [u8; 32],
+	//},
 	// TODO: Implement on-chain events when better integrating with BDK wallet sync.
 	//OnChainPaymentSent {
 	//},
@@ -83,10 +83,10 @@ impl Readable for Event {
 			//3u8 => {
 			// TODO ChannelOpened
 			//}
-			4u8 => {
-				let channel_id: [u8; 32] = Readable::read(reader)?;
-				Ok(Self::ChannelClosed { channel_id })
-			}
+			//4u8 => {
+			//	let channel_id: [u8; 32] = Readable::read(reader)?;
+			//	Ok(Self::ChannelClosed { channel_id })
+			//}
 			//5u8 => {
 			// TODO OnChainPaymentSent
 			//}
@@ -116,15 +116,14 @@ impl Writeable for Event {
 				payment_hash.write(writer)?;
 				amount_msat.write(writer)?;
 				Ok(())
-			}
-			//Self::ChannelOpened { .. } => {
-			//TODO
-			//}
-			Self::ChannelClosed { channel_id } => {
-				4u8.write(writer)?;
-				channel_id.write(writer)?;
-				Ok(())
-			} //Self::OnChainPaymentSent { .. } => {
+			} //Self::ChannelOpened { .. } => {
+			  //TODO
+			  //}
+			  //Self::ChannelClosed { channel_id } => {
+			  //	4u8.write(writer)?;
+			  //	channel_id.write(writer)?;
+			  //	Ok(())
+			  //} //Self::OnChainPaymentSent { .. } => {
 			  //TODO
 			  //}
 			  //Self::OnChainPaymentReceived { .. } => {
@@ -485,9 +484,9 @@ impl LdkEventHandler for EventHandler {
 					hex_utils::to_string(channel_id),
 					reason
 				);
-				self.event_queue
-					.add_event(Event::ChannelClosed { channel_id: *channel_id })
-					.unwrap();
+				//self.event_queue
+				//	.add_event(Event::ChannelClosed { channel_id: *channel_id })
+				//	.unwrap();
 			}
 			LdkEvent::DiscardFunding { .. } => {}
 		}

src/lib.rs

@@ -17,7 +17,6 @@
 //! - Wallet and channel states are persisted to disk.
 //! - Gossip is retrieved over the P2P network.
 
-#![deny(missing_docs)]
 #![deny(broken_intra_doc_links)]
 #![deny(private_intra_doc_links)]
 #![allow(bare_trait_objects)]
@@ -62,7 +61,7 @@ use lightning_persister::FilesystemPersister;
 use lightning_net_tokio::SocketDescriptor;
 
 use lightning_invoice::utils::DefaultRouter;
-use lightning_invoice::{payment, Currency, Invoice};
+use lightning_invoice::{payment, Currency, Invoice, SignedRawInvoice};
 
 use bdk::bitcoin::secp256k1::Secp256k1;
 use bdk::blockchain::esplora::EsploraBlockchain;
@@ -72,10 +71,11 @@ use bdk::template::Bip84;
 use bitcoin::hashes::sha256::Hash as Sha256;
 use bitcoin::hashes::Hash;
 use bitcoin::secp256k1::PublicKey;
-use bitcoin::BlockHash;
+use bitcoin::{Address, BlockHash};
 
 use rand::Rng;
 
+use core::str::FromStr;
 use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::fs;
@@ -84,6 +84,8 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex, RwLock};
 use std::time::{Duration, Instant, SystemTime};
 
+uniffi_macros::include_scaffolding!("ldk_lite");
+
 // The used 'stop gap' parameter used by BDK's wallet sync. This seems to configure the threshold
 // number of blocks after which BDK stops looking for scripts belonging to the wallet.
 const BDK_CLIENT_STOP_GAP: usize = 20;
@@ -184,7 +186,7 @@ impl Builder {
 	}
 
 	/// Builds an [`LdkLite`] instance according to the options previously configured.
-	pub fn build(&self) -> LdkLite {
+	pub fn build(&self) -> Arc<LdkLite> {
 		let config = Arc::new(self.config.clone());
 
 		let ldk_data_dir = format!("{}/ldk", &config.storage_dir_path.clone());
@@ -397,7 +399,7 @@ impl Builder {
 
 		let running = RwLock::new(None);
 
-		LdkLite {
+		Arc::new(LdkLite {
 			running,
 			config,
 			chain_access,
@@ -414,7 +416,7 @@ impl Builder {
 			inbound_payments,
 			outbound_payments,
 			peer_store,
-		}
+		})
 	}
 }
 
@@ -453,7 +455,7 @@ impl LdkLite {
 	/// Starts the necessary background tasks, such as handling events coming from user input,
 	/// LDK/BDK, and the peer-to-peer network. After this returns, the [`LdkLite`] instance can be
 	/// controlled via the provided API methods in a thread-safe manner.
-	pub fn start(&mut self) -> Result<(), Error> {
+	pub fn start(&self) -> Result<(), Error> {
 		// Acquire a run lock and hold it until we're setup.
 		let mut run_lock = self.running.write().unwrap();
 		if run_lock.is_some() {
@@ -467,7 +469,7 @@ impl LdkLite {
 	}
 
 	/// Disconnects all peers, stops all running background tasks, and shuts down [`LdkLite`].
-	pub fn stop(&mut self) -> Result<(), Error> {
+	pub fn stop(&self) -> Result<(), Error> {
 		let mut run_lock = self.running.write().unwrap();
 		if run_lock.is_none() {
 			return Err(Error::NotRunning);
@@ -638,7 +640,7 @@ impl LdkLite {
 	}
 
 	/// Retrieve a new on-chain/funding address.
-	pub fn new_funding_address(&mut self) -> Result<bitcoin::Address, Error> {
+	pub fn new_funding_address(&self) -> Result<Address, Error> {
 		if self.running.read().unwrap().is_none() {
 			return Err(Error::NotRunning);
 		}
@@ -1006,5 +1008,68 @@ pub(crate) type NetworkGraph = gossip::NetworkGraph<Arc<FilesystemLogger>>;
 
 pub(crate) type PaymentInfoStorage = Mutex<HashMap<PaymentHash, PaymentInfo>>;
 
-#[cfg(test)]
-mod tests {}
+impl UniffiCustomTypeConverter for PublicKey {
+	type Builtin = String;
+
+	fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
+		if let Ok(key) = PublicKey::from_str(&val) {
+			return Ok(key);
+		}
+
+		Err(Error::PublicKeyInvalid.into())
+	}
+
+	fn from_custom(obj: Self) -> Self::Builtin {
+		obj.to_string()
+	}
+}
+
+impl UniffiCustomTypeConverter for Address {
+	type Builtin = String;
+
+	fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
+		if let Ok(addr) = Address::from_str(&val) {
+			return Ok(addr);
+		}
+
+		Err(Error::AddressInvalid.into())
+	}
+
+	fn from_custom(obj: Self) -> Self::Builtin {
+		obj.to_string()
+	}
+}
+
+impl UniffiCustomTypeConverter for Invoice {
+	type Builtin = String;
+
+	fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
+		if let Ok(signed) = val.parse::<SignedRawInvoice>() {
+			if let Ok(invoice) = Invoice::from_signed(signed) {
+				return Ok(invoice);
+			}
+		}
+
+		Err(Error::InvoiceInvalid.into())
+	}
+
+	fn from_custom(obj: Self) -> Self::Builtin {
+		obj.to_string()
+	}
+}
+
+impl UniffiCustomTypeConverter for PaymentHash {
+	type Builtin = String;
+
+	fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
+		if let Ok(hash) = Sha256::from_str(&val) {
+			Ok(PaymentHash(hash.into_inner()))
+		} else {
+			Err(Error::PaymentHashInvalid.into())
+		}
+	}
+
+	fn from_custom(obj: Self) -> Self::Builtin {
+		Sha256::from_slice(&obj.0).unwrap().to_string()
+	}
+}

uniffi/ldk_lite.udl

@@ -0,0 +1,72 @@
+namespace ldk_lite {
+};
+
+interface Builder {
+	constructor();
+	LdkLite build();
+};
+
+interface LdkLite {
+	[Throws=Error]
+	void start();
+	[Throws=Error]
+	void stop();
+	Event next_event();
+	void event_handled();
+	[Throws=Error]
+	PublicKey my_node_id();
+	[Throws=Error]
+	Address new_funding_address();
+	[Throws=Error]
+	void connect_open_channel([ByRef]string node_pubkey_and_address, u64 channel_amount_sats, boolean announce_channel);
+	[Throws=Error]
+	PaymentHash send_payment(Invoice invoice);
+	[Throws=Error]
+	PaymentHash send_spontaneous_payment(u64 amount_msat, [ByRef]string node_id);
+	[Throws=Error]
+	Invoice receive_payment(u64? amount_msat, [ByRef]string description, u32 expiry_secs);
+	// TODO: payment_info()
+};
+
+[Error]
+enum Error {
+	"AlreadyRunning",
+	"NotRunning",
+	"FundingTxCreationFailed",
+	"ConnectionFailed",
+	"AddressInvalid",
+	"PublicKeyInvalid",
+	"PaymentHashInvalid",
+	"NonUniquePaymentHash",
+	"InvoiceInvalid",
+	"InvoiceCreationFailed",
+	"RoutingFailed",
+	"PeerInfoParseFailed",
+	"ChannelCreationFailed",
+	"ChannelClosingFailed",
+	"PersistenceFailed",
+	"WalletOperationFailed",
+	"WalletSigningFailed",
+	"ChainAccessFailed",
+};
+
+[Enum]
+interface Event {
+	PaymentSuccessful( PaymentHash payment_hash );
+	PaymentFailed( PaymentHash payment_hash );
+	PaymentReceived( PaymentHash payment_hash, u64 amount_msat);
+	// TODO: ChannelClosed
+};
+
+[Custom]
+typedef string PublicKey;
+
+[Custom]
+typedef string Address;
+
+[Custom]
+typedef string Invoice;
+
+[Custom]
+typedef string PaymentHash;
+

uniffi_bindgen_generate.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+uniffi-bindgen generate uniffi/ldk_lite.udl --language swift
+uniffi-bindgen generate uniffi/ldk_lite.udl --language python
+uniffi-bindgen generate uniffi/ldk_lite.udl --language kotlin