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

@@ -8,6 +8,22 @@ description = "A ready-to-go node implementation built using LDK."
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[lib]
+crate-type = ["staticlib", "cdylib"]
+name = "ldk_node"
+
+[[bin]]
+name = "uniffi-bindgen"
+path = "uniffi-bindgen.rs"
+
+[profile.release-smaller]
+inherits = "release"
+opt-level = 'z'     # Optimize for size.
+lto = true          # Enable Link Time Optimization
+codegen-units = 1   # Reduce number of codegen units to increase optimizations.
+panic = 'abort'     # Abort on panic
+strip = true        # Strip symbols from binary*
+
 [dependencies]
 lightning = { version = "0.0.115", features = ["max_level_trace", "std"] }
 lightning-invoice = { version = "0.23" }
@@ -46,13 +62,18 @@ serde_json = { version = "1.0" }
 tokio = { version = "1", default-features = false, features = [ "rt-multi-thread", "time", "sync" ] }
 esplora-client = { version = "0.4", default-features = false }
 libc = "0.2"
+uniffi = { version = "0.23.0", features = ["build"] }
 
 [dev-dependencies]
 electrsd = { version = "0.22.0", features = ["legacy", "esplora_a33e97e1", "bitcoind_23_0"] }
 electrum-client = "0.12.0"
 proptest = "1.0.0"
 regex = "1.5.6"
 
+[build-dependencies]
+uniffi = { version = "0.23.0", features = ["build", "cli"] }
+
+
 [profile.release]
 panic = "abort"
 

bindings/ldk_node.udl

@@ -0,0 +1,157 @@
+namespace ldk_node {
+};
+
+dictionary Config {
+	string storage_dir_path;
+	string esplora_server_url;
+	Network network;
+	SocketAddr? listening_address;
+	u32 default_cltv_expiry_delta;
+};
+
+interface Builder {
+	constructor();
+	[Name=from_config]
+	constructor(Config config);
+	Node build();
+};
+
+interface Node {
+	[Throws=NodeError]
+	void start();
+	[Throws=NodeError]
+	void stop();
+	Event next_event();
+	void event_handled();
+	PublicKey node_id();
+	SocketAddr? listening_address();
+	[Throws=NodeError]
+	Address new_funding_address();
+	[Throws=NodeError]
+    Txid send_to_onchain_address([ByRef]Address address, u64 amount_msat);
+	[Throws=NodeError]
+    Txid send_all_to_onchain_address([ByRef]Address address);
+	[Throws=NodeError]
+	u64 spendable_onchain_balance_sats();
+	[Throws=NodeError]
+	u64 total_onchain_balance_sats();
+	[Throws=NodeError]
+	void connect(PublicKey node_id, SocketAddr address, boolean permanently);
+	[Throws=NodeError]
+	void disconnect([ByRef]PublicKey node_id);
+	[Throws=NodeError]
+	void connect_open_channel(PublicKey node_id, SocketAddr address, u64 channel_amount_sats, u64? push_to_counterparty_msat, boolean announce_channel);
+	[Throws=NodeError]
+	void close_channel([ByRef]ChannelId channel_id, [ByRef]PublicKey counterparty_node_id);
+	[Throws=NodeError]
+	void sync_wallets();
+	[Throws=NodeError]
+	PaymentHash send_payment([ByRef]Invoice invoice);
+	[Throws=NodeError]
+	PaymentHash send_payment_using_amount([ByRef]Invoice invoice, u64 amount_msat);
+	[Throws=NodeError]
+	PaymentHash send_spontaneous_payment(u64 amount_msat, [ByRef]PublicKey node_id);
+	[Throws=NodeError]
+	Invoice receive_payment(u64 amount_msat, [ByRef]string description, u32 expiry_secs);
+	[Throws=NodeError]
+	Invoice receive_variable_amount_payment([ByRef]string description, u32 expiry_secs);
+	PaymentDetails? payment([ByRef]PaymentHash payment_hash);
+	[Throws=NodeError]
+	boolean remove_payment([ByRef]PaymentHash payment_hash);
+};
+
+[Error]
+enum NodeError {
+	"AlreadyRunning",
+	"NotRunning",
+	"OnchainTxCreationFailed",
+	"ConnectionFailed",
+	"AddressInvalid",
+	"PublicKeyInvalid",
+	"PaymentHashInvalid",
+	"PaymentPreimageInvalid",
+	"PaymentSecretInvalid",
+	"NonUniquePaymentHash",
+	"InvalidAmount",
+	"InvalidInvoice",
+	"InvoiceCreationFailed",
+	"InsufficientFunds",
+	"PaymentFailed",
+	"ChannelIdInvalid",
+	"NetworkInvalid",
+	"PeerInfoParseFailed",
+	"ChannelCreationFailed",
+	"ChannelClosingFailed",
+	"PersistenceFailed",
+	"WalletOperationFailed",
+	"WalletSigningFailed",
+	"TxSyncFailed",
+};
+
+[Enum]
+interface Event {
+	PaymentSuccessful( PaymentHash payment_hash );
+	PaymentFailed( PaymentHash payment_hash );
+	PaymentReceived( PaymentHash payment_hash, u64 amount_msat);
+	ChannelPending ( ChannelId channel_id, UserChannelId user_channel_id, ChannelId former_temporary_channel_id, PublicKey counterparty_node_id, OutPoint funding_txo );
+	ChannelReady ( ChannelId channel_id, UserChannelId user_channel_id );
+	ChannelClosed ( ChannelId channel_id, UserChannelId user_channel_id );
+};
+
+enum PaymentDirection {
+	"Inbound",
+	"Outbound",
+};
+
+enum PaymentStatus {
+	"Pending",
+	"Succeeded",
+	"Failed",
+};
+
+dictionary PaymentDetails {
+	PaymentHash hash;
+	PaymentPreimage? preimage;
+	PaymentSecret? secret;
+	u64? amount_msat;
+	PaymentDirection direction;
+	PaymentStatus status;
+};
+
+dictionary OutPoint {
+    Txid txid;
+    u32 vout;
+};
+
+[Custom]
+typedef string Txid;
+
+[Custom]
+typedef string SocketAddr;
+
+[Custom]
+typedef string PublicKey;
+
+[Custom]
+typedef string Address;
+
+[Custom]
+typedef string Invoice;
+
+[Custom]
+typedef string PaymentHash;
+
+[Custom]
+typedef string PaymentPreimage;
+
+[Custom]
+typedef string PaymentSecret;
+
+[Custom]
+typedef string ChannelId;
+
+[Custom]
+typedef string UserChannelId;
+
+[Custom]
+typedef string Network;

build.rs

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

scripts/uniffi_bindgen_generate.sh

@@ -0,0 +1 @@
+#!/bin/bash

src/error.rs

@@ -11,6 +11,16 @@ pub enum Error {
 	OnchainTxCreationFailed,
 	/// 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,
+	/// The given payment preimage is invalid.
+	PaymentPreimageInvalid,
+	/// The given payment secret is invalid.
+	PaymentSecretInvalid,
 	/// Payment of the given invoice has already been intiated.
 	NonUniquePaymentHash,
 	/// The given amount is invalid.
@@ -23,6 +33,10 @@ pub enum Error {
 	InsufficientFunds,
 	/// An attempted payment has failed.
 	PaymentFailed,
+	/// The given channel ID is invalid.
+	ChannelIdInvalid,
+	/// The given network is invalid.
+	NetworkInvalid,
 	/// A given peer info could not be parsed.
 	PeerInfoParseFailed,
 	/// A channel could not be opened.
@@ -48,6 +62,11 @@ impl fmt::Display for Error {
 				write!(f, "On-chain 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::PaymentPreimageInvalid => write!(f, "The given payment preimage is invalid."),
+			Self::PaymentSecretInvalid => write!(f, "The given payment secret is invalid."),
 			Self::NonUniquePaymentHash => write!(f, "An invoice must not get payed twice."),
 			Self::InvalidAmount => write!(f, "The given amount is invalid."),
 			Self::InvalidInvoice => write!(f, "The given invoice is invalid."),
@@ -56,6 +75,8 @@ impl fmt::Display for Error {
 				write!(f, "There are insufficient funds to complete the given operation.")
 			}
 			Self::PaymentFailed => write!(f, "Failed to send the given payment."),
+			Self::ChannelIdInvalid => write!(f, "The given channel ID is invalid."),
+			Self::NetworkInvalid => write!(f, "The given network is invalid."),
 			Self::PeerInfoParseFailed => write!(f, "Failed to parse the given peer information."),
 			Self::ChannelCreationFailed => write!(f, "Failed to create channel."),
 			Self::ChannelClosingFailed => write!(f, "Failed to close channel."),

src/event.rs

@@ -1,4 +1,7 @@
-use crate::{hex_utils, ChannelManager, Config, Error, KeysManager, NetworkGraph, Wallet};
+use crate::{
+	hex_utils, ChannelId, ChannelManager, Config, Error, KeysManager, NetworkGraph, UserChannelId,
+	Wallet,
+};
 
 use crate::payment_store::{
 	PaymentDetails, PaymentDetailsUpdate, PaymentDirection, PaymentStatus, PaymentStore,
@@ -51,11 +54,11 @@ pub enum Event {
 	/// A channel has been created and is pending confirmation on-chain.
 	ChannelPending {
 		/// 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,
 		/// The `temporary_channel_id` this channel used to be known by during channel establishment.
-		former_temporary_channel_id: [u8; 32],
+		former_temporary_channel_id: ChannelId,
 		/// The `node_id` of the channel counterparty.
 		counterparty_node_id: PublicKey,
 		/// The outpoint of the channel's funding transaction.
@@ -64,16 +67,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,
 	},
 }
 
@@ -641,9 +644,11 @@ where
 				);
 				self.event_queue
 					.add_event(Event::ChannelPending {
-						channel_id,
-						user_channel_id,
-						former_temporary_channel_id: former_temporary_channel_id.unwrap(),
+						channel_id: ChannelId(channel_id),
+						user_channel_id: UserChannelId(user_channel_id),
+						former_temporary_channel_id: ChannelId(
+							former_temporary_channel_id.unwrap(),
+						),
 						counterparty_node_id,
 						funding_txo,
 					})
@@ -659,7 +664,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 } => {
@@ -670,7 +678,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 { .. } => {}
@@ -690,7 +701,10 @@ mod tests {
 		let logger = Arc::new(TestLogger::new());
 		let event_queue = EventQueue::new(Arc::clone(&store), Arc::clone(&logger));
 
-		let expected_event = Event::ChannelReady { channel_id: [23u8; 32], user_channel_id: 2323 };
+		let expected_event = Event::ChannelReady {
+			channel_id: ChannelId([23u8; 32]),
+			user_channel_id: UserChannelId(2323),
+		};
 		event_queue.add_event(expected_event.clone()).unwrap();
 		assert!(store.get_and_clear_did_persist());