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.112", features = ["max_level_trace", "std"] }
 #lightning-invoice = { version = "0.20" }
@@ -46,13 +50,18 @@ chrono = "0.4"
 futures = "0.3"
 serde_json = { version = "1.0" }
 tokio = { version = "1", features = [ "full" ] }
+uniffi = { version = "0.21.0", features = ["builtin-bindgen"] }
+uniffi_macros = { version = "0.21.0", features = ["builtin-bindgen"] }
 
 [dev-dependencies]
 electrsd = { version = "0.22.0", features = ["legacy", "esplora_a33e97e1", "bitcoind_23_0"] }
 electrum-client = "0.12.0"
 lazy_static = "1.4.0"
 once_cell = "1.16.0"
 
+[build-dependencies]
+uniffi_build = "0.21.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

@@ -11,12 +11,20 @@ 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.
 	InvoiceInvalid,
 	/// Invoice creation failed.
 	InvoiceCreationFailed,
+	/// The given channel ID is invalid.
+	ChannelIdInvalid,
 	/// No route for the given target could be found.
 	RoutingFailed,
 	/// A given peer info could not be parsed.
@@ -40,13 +48,15 @@ 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."),
+			Self::ChannelIdInvalid => write!(f, "The given channel ID is invalid."),
 			Self::RoutingFailed => write!(f, "Failed to find route."),
 			Self::PeerInfoParseFailed => write!(f, "Failed to parse the given peer information."),
 			Self::ChannelCreationFailed => write!(f, "Failed to create channel."),

src/event.rs

@@ -1,6 +1,6 @@
 use crate::{
-	hex_utils, ChannelManager, Config, Error, NetworkGraph, PaymentInfo, PaymentInfoStorage,
-	PaymentStatus, Wallet,
+	hex_utils, ChannelId, ChannelManager, Config, Error, NetworkGraph, PaymentInfo,
+	PaymentInfoStorage, PaymentStatus, UserChannelId, Wallet,
 };
 
 use crate::logger::{log_error, log_given_level, log_info, log_internal, Logger};
@@ -50,16 +50,16 @@ pub enum Event {
 	/// A channel is ready to be used.
 	ChannelReady {
 		/// The `channel_id` of the channel.
-		channel_id: [u8; 32],
+		channel_id: ChannelId,
 		/// The `user_channel_id` of the channel.
-		user_channel_id: u128,
+		user_channel_id: UserChannelId,
 	},
 	/// A channel has been closed.
 	ChannelClosed {
 		/// The `channel_id` of the channel.
-		channel_id: [u8; 32],
+		channel_id: ChannelId,
 		/// The `user_channel_id` of the channel.
-		user_channel_id: u128,
+		user_channel_id: UserChannelId,
 	},
 }
 
@@ -83,13 +83,13 @@ impl Readable for Event {
 				Ok(Self::PaymentReceived { payment_hash, amount_msat })
 			}
 			3u8 => {
-				let channel_id: [u8; 32] = Readable::read(reader)?;
-				let user_channel_id: u128 = Readable::read(reader)?;
+				let channel_id = ChannelId(Readable::read(reader)?);
+				let user_channel_id = UserChannelId(Readable::read(reader)?);
 				Ok(Self::ChannelReady { channel_id, user_channel_id })
 			}
 			4u8 => {
-				let channel_id: [u8; 32] = Readable::read(reader)?;
-				let user_channel_id: u128 = Readable::read(reader)?;
+				let channel_id = ChannelId(Readable::read(reader)?);
+				let user_channel_id = UserChannelId(Readable::read(reader)?);
 				Ok(Self::ChannelClosed { channel_id, user_channel_id })
 			}
 			_ => Err(lightning::ln::msgs::DecodeError::InvalidValue),
@@ -118,14 +118,14 @@ impl Writeable for Event {
 			}
 			Self::ChannelReady { channel_id, user_channel_id } => {
 				3u8.write(writer)?;
-				channel_id.write(writer)?;
-				user_channel_id.write(writer)?;
+				channel_id.0.write(writer)?;
+				user_channel_id.0.write(writer)?;
 				Ok(())
 			}
 			Self::ChannelClosed { channel_id, user_channel_id } => {
 				4u8.write(writer)?;
-				channel_id.write(writer)?;
-				user_channel_id.write(writer)?;
+				channel_id.0.write(writer)?;
+				user_channel_id.0.write(writer)?;
 				Ok(())
 			}
 		}
@@ -136,7 +136,7 @@ pub(crate) struct EventQueue<K: Deref>
 where
 	K::Target: KVStorePersister,
 {
-	queue: Mutex<VecDeque<Arc<Event>>>,
+	queue: Mutex<VecDeque<Event>>,
 	notifier: Condvar,
 	persister: K,
 }
@@ -146,26 +146,26 @@ where
 	K::Target: KVStorePersister,
 {
 	pub(crate) fn new(persister: K) -> Self {
-		let queue: Mutex<VecDeque<Arc<Event>>> = Mutex::new(VecDeque::new());
+		let queue: Mutex<VecDeque<Event>> = Mutex::new(VecDeque::new());
 		let notifier = Condvar::new();
 		Self { queue, notifier, persister }
 	}
 
 	pub(crate) fn add_event(&self, event: Event) -> Result<(), Error> {
 		{
 			let mut locked_queue = self.queue.lock().unwrap();
-			locked_queue.push_back(Arc::new(event));
+			locked_queue.push_back(event);
 			self.persist_queue(&*locked_queue)?;
 		}
 
 		self.notifier.notify_one();
 		Ok(())
 	}
 
-	pub(crate) fn next_event(&self) -> Arc<Event> {
+	pub(crate) fn next_event(&self) -> Event {
 		let locked_queue =
 			self.notifier.wait_while(self.queue.lock().unwrap(), |queue| queue.is_empty()).unwrap();
-		Arc::clone(&locked_queue.front().unwrap())
+		locked_queue.front().unwrap().clone()
 	}
 
 	pub(crate) fn event_handled(&self) -> Result<(), Error> {
@@ -178,7 +178,7 @@ where
 		Ok(())
 	}
 
-	fn persist_queue(&self, locked_queue: &VecDeque<Arc<Event>>) -> Result<(), Error> {
+	fn persist_queue(&self, locked_queue: &VecDeque<Event>) -> Result<(), Error> {
 		self.persister
 			.persist(EVENTS_PERSISTENCE_KEY, &EventQueueSerWrapper(locked_queue))
 			.map_err(|_| Error::PersistenceFailed)?;
@@ -195,13 +195,13 @@ where
 		reader: &mut R, persister: K,
 	) -> Result<Self, lightning::ln::msgs::DecodeError> {
 		let read_queue: EventQueueDeserWrapper = Readable::read(reader)?;
-		let queue: Mutex<VecDeque<Arc<Event>>> = Mutex::new(read_queue.0);
+		let queue: Mutex<VecDeque<Event>> = Mutex::new(read_queue.0);
 		let notifier = Condvar::new();
 		Ok(Self { queue, notifier, persister })
 	}
 }
 
-struct EventQueueDeserWrapper(VecDeque<Arc<Event>>);
+struct EventQueueDeserWrapper(VecDeque<Event>);
 
 impl Readable for EventQueueDeserWrapper {
 	fn read<R: lightning::io::Read>(
@@ -210,13 +210,13 @@ impl Readable for EventQueueDeserWrapper {
 		let len: u16 = Readable::read(reader)?;
 		let mut queue = VecDeque::with_capacity(len as usize);
 		for _ in 0..len {
-			queue.push_back(Arc::new(Readable::read(reader)?));
+			queue.push_back(Readable::read(reader)?);
 		}
 		Ok(Self(queue))
 	}
 }
 
-struct EventQueueSerWrapper<'a>(&'a VecDeque<Arc<Event>>);
+struct EventQueueSerWrapper<'a>(&'a VecDeque<Event>);
 
 impl Writeable for EventQueueSerWrapper<'_> {
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), lightning::io::Error> {
@@ -559,7 +559,10 @@ where
 					counterparty_node_id,
 				);
 				self.event_queue
-					.add_event(Event::ChannelReady { channel_id, user_channel_id })
+					.add_event(Event::ChannelReady {
+						channel_id: ChannelId(channel_id),
+						user_channel_id: UserChannelId(user_channel_id),
+					})
 					.expect("Failed to push to event queue");
 			}
 			LdkEvent::ChannelClosed { channel_id, reason, user_channel_id } => {
@@ -570,7 +573,10 @@ where
 					reason
 				);
 				self.event_queue
-					.add_event(Event::ChannelClosed { channel_id, user_channel_id })
+					.add_event(Event::ChannelClosed {
+						channel_id: ChannelId(channel_id),
+						user_channel_id: UserChannelId(user_channel_id),
+					})
 					.expect("Failed to push to event queue");
 			}
 			LdkEvent::DiscardFunding { .. } => {}