Expose list_{channels, peers} to bindings

Author: jurvis

bindings/ldk_node.udl

@@ -51,6 +51,8 @@ interface Node {
 	[Throws=NodeError]
 	Invoice receive_variable_amount_payment([ByRef]string description, u32 expiry_secs);
 	PaymentInfo? payment_info([ByRef]PaymentHash payment_hash);
+	sequence<PeerDetails> list_peers();
+	sequence<ChannelDetails> list_channels();
 };
 
 [Error]
@@ -67,6 +69,7 @@ enum NodeError {
 	"NonUniquePaymentHash",
 	"InvalidAmount",
 	"InvalidInvoice",
+	"InvalidTxid",
 	"InvoiceCreationFailed",
 	"InsufficientFunds",
 	"PaymentFailed",
@@ -110,6 +113,39 @@ dictionary PaymentInfo {
 	PaymentStatus status;
 };
 
+dictionary OutPoint {
+    Txid txid;
+    u32 vout;
+};
+
+dictionary ChannelDetails {
+    ChannelId channel_id;
+    PublicKey counterparty_node_id;
+    OutPoint? funding_txo;
+    u64? short_channel_id;
+    u64? outbound_scid_alias;
+    u64? inbound_scid_alias;
+    u64 channel_value_satoshis;
+    u64? unspendable_punishment_reserve;
+    UserChannelId user_channel_id;
+    u64 balance_msat;
+    u64 outbound_capacity_msat;
+    u64 inbound_capacity_msat;
+    u32? confirmations_required;
+    u32? confirmations;
+    boolean is_outbound;
+    boolean is_channel_ready;
+    boolean is_usable;
+    boolean is_public;
+    u16? cltv_expiry_delta;
+};
+
+dictionary PeerDetails {
+    PublicKey node_id;
+    SocketAddr address;
+    boolean is_connected;
+};
+
 [Custom]
 typedef string SocketAddr;
 
@@ -139,3 +175,6 @@ typedef string UserChannelId;
 
 [Custom]
 typedef string Network;
+
+[Custom]
+typedef string Txid;

src/error.rs

@@ -27,6 +27,8 @@ pub enum Error {
 	InvalidAmount,
 	/// The given invoice is invalid.
 	InvalidInvoice,
+	/// The given transaction identifier is invalid
+	InvalidTxid,
 	/// Invoice creation failed.
 	InvoiceCreationFailed,
 	/// There are insufficient funds to complete the given operation.
@@ -82,6 +84,7 @@ impl fmt::Display for Error {
 			Self::WalletOperationFailed => write!(f, "Failed to conduct wallet operation."),
 			Self::WalletSigningFailed => write!(f, "Failed to sign given transaction."),
 			Self::TxSyncFailed => write!(f, "Failed to sync transactions."),
+			Self::InvalidTxid => write!(f, "The given transaction identifier is invalid."),
 		}
 	}
 }

src/lib.rs

@@ -104,15 +104,17 @@ use types::{
 	ChainMonitor, ChannelManager, GossipSync, KeysManager, Network, NetworkGraph, OnionMessenger,
 	PeerManager, Scorer,
 };
-pub use types::{ChannelId, UserChannelId};
+pub use types::{
+	ChannelDetails, ChannelId, PeerDetails, UserChannelId
+};
 use wallet::Wallet;
 
 use logger::{log_error, log_info, FilesystemLogger, Logger};
 
 use lightning::chain::keysinterface::EntropySource;
 use lightning::chain::{chainmonitor, BestBlock, Confirm, Watch};
 use lightning::ln::channelmanager::{
-	self, ChainParameters, ChannelDetails, ChannelManagerReadArgs, PaymentId, Retry,
+	self, ChainParameters, ChannelManagerReadArgs, PaymentId, Retry,
 };
 use lightning::ln::peer_handler::{IgnoringMessageHandler, MessageHandler};
 use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
@@ -139,7 +141,7 @@ use bdk::template::Bip84;
 use bitcoin::hashes::sha256::Hash as Sha256;
 use bitcoin::hashes::Hash;
 use bitcoin::secp256k1::PublicKey;
-use bitcoin::{Address, BlockHash};
+use bitcoin::{Address, BlockHash, OutPoint, Txid};
 
 use rand::Rng;
 
@@ -853,7 +855,7 @@ impl Node {
 
 	/// Retrieve a list of known channels.
 	pub fn list_channels(&self) -> Vec<ChannelDetails> {
-		self.channel_manager.list_channels()
+		self.channel_manager.list_channels().into_iter().map(|c| c.into()).collect()
 	}
 
 	/// Connect to a node on the peer-to-peer network.
@@ -1341,6 +1343,21 @@ impl Node {
 	pub fn payment_info(&self, payment_hash: &PaymentHash) -> Option<PaymentInfo> {
 		self.payment_store.get(payment_hash)
 	}
+
+	/// Retrieves a list of known peers.
+	pub fn list_peers(&self) -> Vec<PeerDetails> {
+		let active_connected_peers: Vec<PublicKey> =
+			self.peer_manager.get_peer_node_ids().iter().map(|p| p.0).collect();
+		self.peer_store
+			.list_peers()
+			.iter()
+			.map(|p| PeerDetails {
+				node_id: p.pubkey,
+				address: p.address,
+				is_connected: active_connected_peers.contains(&p.pubkey),
+			})
+			.collect()
+	}
 }
 
 async fn connect_peer_if_necessary(

src/test/functional_tests.rs

@@ -37,6 +37,11 @@ fn channel_full_cycle() {
 		.connect_open_channel(&node_b.node_id(), &node_b.listening_address().unwrap(), 50000, true)
 		.unwrap();
 
+	assert_eq!(
+		node_a.list_peers().iter().map(|p| p.node_id).collect::<Vec<_>>(),
+		[node_b.node_id()]
+	);
+
 	let funding_txo = loop {
 		let details = node_a.list_channels();
 
@@ -153,7 +158,7 @@ fn channel_full_cycle() {
 	expect_event!(node_a, ChannelClosed);
 	expect_event!(node_b, ChannelClosed);
 
-	wait_for_outpoint_spend(&electrsd, funding_txo.into_bitcoin_outpoint());
+	wait_for_outpoint_spend(&electrsd, funding_txo);
 
 	generate_blocks_and_wait(&bitcoind, &electrsd, 1);
 	node_a.sync_wallets().unwrap();

src/types.rs

@@ -7,6 +7,7 @@ use crate::UniffiCustomTypeConverter;
 
 use lightning::chain::chainmonitor;
 use lightning::chain::keysinterface::InMemorySigner;
+use lightning::ln::channelmanager::ChannelDetails as LdkChannelDetails;
 use lightning::ln::peer_handler::IgnoringMessageHandler;
 use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 use lightning::routing::gossip;
@@ -22,7 +23,7 @@ use lightning_transaction_sync::EsploraSyncClient;
 use bitcoin::hashes::sha256::Hash as Sha256;
 use bitcoin::hashes::Hash;
 use bitcoin::secp256k1::PublicKey;
-use bitcoin::Address;
+use bitcoin::{Address, OutPoint, Txid};
 
 use std::convert::TryInto;
 use std::default::Default;
@@ -339,3 +340,165 @@ impl UniffiCustomTypeConverter for Network {
 		obj.0.to_string()
 	}
 }
+
+/// Details of a channel as returned by [`Node::list_channels`].
+///
+/// [`Node::list_channels`]: [`crate::Node::list_channels`]
+pub struct ChannelDetails {
+	/// The channel's ID (prior to funding transaction generation, this is a random 32 bytes,
+	/// thereafter this is the transaction ID of the funding transaction XOR the funding transaction
+	/// output).
+	///
+	/// Note that this means this value is *not* persistent - it can change once during the
+	/// lifetime of the channel.
+	pub channel_id: ChannelId,
+	/// The `node_id` of our channel's counterparty.
+	pub counterparty_node_id: PublicKey,
+	/// The channel's funding transaction output, if we've negotiated the funding transaction with
+	/// our counterparty already.
+	pub funding_txo: Option<OutPoint>,
+	/// Position of the funding transaction on-chain. `None` unless the funding transaction has been
+	/// confirmed and the channel is fully opened.
+	///
+	/// Note that if [`inbound_scid_alias`] is set, it must be used for invoices and inbound
+	/// payments instead of this.
+	///
+	/// For channels with [`confirmations_required`] set to `Some(0)`, [`outbound_scid_alias`] may
+	///  be used in place of this in outbound routes.
+	///
+	/// [`inbound_scid_alias`]: Self::inbound_scid_alias
+	/// [`outbound_scid_alias`]: Self::outbound_scid_alias
+	/// [`confirmations_required`]: Self::confirmations_required
+	pub short_channel_id: Option<u64>,
+	/// An optional [`short_channel_id`] alias for this channel, randomly generated by us and
+	/// usable in place of [`short_channel_id`] to reference the channel in outbound routes when
+	/// the channel has not yet been confirmed (as long as [`confirmations_required`] is
+	/// `Some(0)`).
+	///
+	/// This will be `None` as long as the channel is not available for routing outbound payments.
+	///
+	/// [`short_channel_id`]: Self::short_channel_id
+	/// [`confirmations_required`]: Self::confirmations_required
+	pub outbound_scid_alias: Option<u64>,
+	/// An optional [`short_channel_id`] alias for this channel, randomly generated by our
+	/// counterparty and usable in place of [`short_channel_id`] in invoice route hints. Our
+	/// counterparty will recognize the alias provided here in place of the [`short_channel_id`]
+	/// when they see a payment to be routed to us.
+	///
+	/// Our counterparty may choose to rotate this value at any time, though will always recognize
+	/// previous values for inbound payment forwarding.
+	///
+	/// [`short_channel_id`]: Self::short_channel_id
+	pub inbound_scid_alias: Option<u64>,
+	/// The value, in satoshis, of this channel as appears in the funding output.
+	pub channel_value_satoshis: u64,
+	/// The value, in satoshis, that must always be held in the channel for us. This value ensures
+	/// that if we broadcast a revoked state, our counterparty can punish us by claiming at least
+	/// this value on chain.
+	///
+	/// This value is not included in [`outbound_capacity_msat`] as it can never be spent.
+	///
+	/// This value will be `None` for outbound channels until the counterparty accepts the channel.
+	///
+	/// [`outbound_capacity_msat`]: Self::outbound_capacity_msat
+	pub unspendable_punishment_reserve: Option<u64>,
+	/// The local `user_channel_id` of this channel.
+	pub user_channel_id: UserChannelId,
+	/// Total balance of the channel. This is the amount that will be returned to the user if the
+	/// channel is closed.
+	///
+	/// The value is not exact, due to potential in-flight and fee-rate changes. Therefore, exactly
+	/// this amount is likely irrecoverable on close.
+	pub balance_msat: u64,
+	/// Available outbound capacity for sending HTLCs to the remote peer.
+	///
+	/// The amount does not include any pending HTLCs which are not yet resolved (and, thus, whose
+	/// balance is not available for inclusion in new outbound HTLCs). This further does not include
+	/// any pending outgoing HTLCs which are awaiting some other resolution to be sent.
+	pub outbound_capacity_msat: u64,
+	/// Available outbound capacity for sending HTLCs to the remote peer.
+	///
+	/// The amount does not include any pending HTLCs which are not yet resolved
+	/// (and, thus, whose balance is not available for inclusion in new inbound HTLCs). This further
+	/// does not include any pending outgoing HTLCs which are awaiting some other resolution to be
+	/// sent.
+	pub inbound_capacity_msat: u64,
+	/// The number of required confirmations on the funding transactions before the funding is
+	/// considered "locked". The amount is selected by the channel fundee.
+	///
+	/// The value will be `None` for outbound channels until the counterparty accepts the channel.
+	pub confirmations_required: Option<u32>,
+	/// The current number of confirmations on the funding transaction.
+	pub confirmations: Option<u32>,
+	/// Returns `true` if the channel was initiated (and therefore funded) by us.
+	pub is_outbound: bool,
+	/// Returns `true` if the channel is confirmed, both parties have exchanged `channel_ready`
+	/// messages, and the channel is not currently being shut down. Both parties exchange
+	/// `channel_ready` messages upon independently verifying that the required confirmations count
+	/// provided by `confirmations_required` has been reached.
+	pub is_channel_ready: bool,
+	/// Returns `true` if the channel is (a) confirmed and `channel_ready` has been exchanged,
+	/// (b) the peer is connected, and (c) the channel is not currently negotiating shutdown.
+	///
+	/// This is a strict superset of `is_channel_ready`.
+	pub is_usable: bool,
+	/// Returns `true` if this channel is (or will be) publicly-announced
+	pub is_public: bool,
+	/// The difference in the CLTV value between incoming HTLCs and an outbound HTLC forwarded over
+	/// the channel.
+	pub cltv_expiry_delta: Option<u16>,
+}
+
+impl From<LdkChannelDetails> for ChannelDetails {
+	fn from(value: LdkChannelDetails) -> Self {
+		ChannelDetails {
+			channel_id: ChannelId(value.channel_id),
+			counterparty_node_id: value.counterparty.node_id,
+			funding_txo: value.funding_txo.and_then(|o| Some(o.into_bitcoin_outpoint())),
+			short_channel_id: value.short_channel_id,
+			outbound_scid_alias: value.outbound_scid_alias,
+			inbound_scid_alias: value.inbound_scid_alias,
+			channel_value_satoshis: value.channel_value_satoshis,
+			unspendable_punishment_reserve: value.unspendable_punishment_reserve,
+			user_channel_id: UserChannelId(value.user_channel_id),
+			balance_msat: value.balance_msat,
+			outbound_capacity_msat: value.outbound_capacity_msat,
+			inbound_capacity_msat: value.inbound_capacity_msat,
+			confirmations_required: value.confirmations_required,
+			confirmations: value.confirmations,
+			is_outbound: value.is_outbound,
+			is_channel_ready: value.is_channel_ready,
+			is_usable: value.is_usable,
+			is_public: value.is_public,
+			cltv_expiry_delta: value.config.and_then(|c| Some(c.cltv_expiry_delta)),
+		}
+	}
+}
+
+impl UniffiCustomTypeConverter for Txid {
+	type Builtin = String;
+
+	fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
+		if let Ok(txid) = Txid::from_str(&val) {
+			return Ok(txid);
+		}
+
+		Err(Error::InvalidTxid.into())
+	}
+
+	fn from_custom(obj: Self) -> Self::Builtin {
+		obj.to_string()
+	}
+}
+
+/// Details of a known lightning peer as returned by [`Node::list_peers`].
+///
+/// [`Node::list_peers`]: [`crate::Node::list_peers`]
+pub struct PeerDetails {
+	/// Our peer's node ID.
+	pub node_id: PublicKey,
+	/// The IP address and TCP port of the peer.
+	pub address: SocketAddr,
+	/// Indicates whether or not the user is currently has an active connection with the peer.
+	pub is_connected: bool,
+}