lightning-net-tokio 0.0.4

A socket handling library for those running in Tokio environments who wish to use rust-lightning with native TcpStreams.

Designed to be as simple as possible, the high-level usage is almost as simple as "hand over a TcpStream and a reference to a PeerManager and the rest is handled", except for the Event handlng mechanism, see below.

The PeerHandler, due to the fire-and-forget nature of this logic, must be an Arc, and must use the SocketDescriptor provided here as the PeerHandler's SocketDescriptor.

Three methods are exposed to register a new connection for handling in tokio::spawn calls, see their individual docs for more. All three take a mpsc::Sender<()> which is sent into every time something occurs which may result in lightning Events. The call site should, thus, look something like this:

use tokio::sync::mpsc;
use tokio::net::TcpStream;
use secp256k1::key::PublicKey;
use lightning::util::events::EventsProvider;
use std::net::SocketAddr;
use std::sync::Arc;

// Define concrete types for our high-level objects:
type TxBroadcaster = dyn lightning::chain::chaininterface::BroadcasterInterface;
type FeeEstimator = dyn lightning::chain::chaininterface::FeeEstimator;
type ChannelMonitor = lightning::ln::channelmonitor::SimpleManyChannelMonitor<lightning::chain::transaction::OutPoint, lightning::chain::keysinterface::InMemoryChannelKeys, Arc<TxBroadcaster>, Arc<FeeEstimator>>;
type ChannelManager = lightning::ln::channelmanager::SimpleArcChannelManager<ChannelMonitor, TxBroadcaster, FeeEstimator>;
type PeerManager = lightning::ln::peer_handler::SimpleArcPeerManager<lightning_net_tokio::SocketDescriptor, ChannelMonitor, TxBroadcaster, FeeEstimator>;

// Connect to node with pubkey their_node_id at addr:
async fn connect_to_node(peer_manager: PeerManager, channel_monitor: Arc<ChannelMonitor>, channel_manager: ChannelManager, their_node_id: PublicKey, addr: SocketAddr) {
let (sender, mut receiver) = mpsc::channel(2);
lightning_net_tokio::connect_outbound(peer_manager, sender, their_node_id, addr).await;
loop {
receiver.recv().await;
for _event in channel_manager.get_and_clear_pending_events().drain(..) {
// Handle the event!
}
for _event in channel_monitor.get_and_clear_pending_events().drain(..) {
// Handle the event!
}
}
}

// Begin reading from a newly accepted socket and talk to the peer:
async fn accept_socket(peer_manager: PeerManager, channel_monitor: Arc<ChannelMonitor>, channel_manager: ChannelManager, socket: TcpStream) {
let (sender, mut receiver) = mpsc::channel(2);
lightning_net_tokio::setup_inbound(peer_manager, sender, socket);
loop {
receiver.recv().await;
for _event in channel_manager.get_and_clear_pending_events().drain(..) {
// Handle the event!
}
for _event in channel_monitor.get_and_clear_pending_events().drain(..) {
// Handle the event!
}
}
}