+mod args;
pub mod bitcoind_client;
mod cli;
mod convert;
use lightning::onion_message::SimpleArcOnionMessenger;
use lightning::routing::gossip;
use lightning::routing::gossip::{NodeId, P2PGossipSync};
+use lightning::routing::router::DefaultRouter;
use lightning::routing::scoring::ProbabilisticScorer;
use lightning::util::config::UserConfig;
use lightning::util::events::{Event, PaymentPurpose};
use lightning_block_sync::SpvClient;
use lightning_block_sync::UnboundedCache;
use lightning_invoice::payment;
-use lightning_invoice::utils::DefaultRouter;
use lightning_net_tokio::SocketDescriptor;
use lightning_persister::FilesystemPersister;
use rand::{thread_rng, Rng};
io::stdout().flush().unwrap();
}
}
- Event::PaymentReceived { payment_hash, purpose, amount_msat } => {
+ Event::PaymentClaimable {
+ payment_hash,
+ purpose,
+ amount_msat,
+ receiver_node_id: _,
+ via_channel_id: _,
+ via_user_channel_id: _,
+ } => {
println!(
"\nEVENT: received payment from payment hash {} of {} millisatoshis",
hex_utils::hex_str(&payment_hash.0),
};
channel_manager.claim_funds(payment_preimage.unwrap());
}
- Event::PaymentClaimed { payment_hash, purpose, amount_msat } => {
+ Event::PaymentClaimed { payment_hash, purpose, amount_msat, receiver_node_id: _ } => {
println!(
"\nEVENT: claimed payment from payment hash {} of {} millisatoshis",
hex_utils::hex_str(&payment_hash.0),
.unwrap();
bitcoind_client.broadcast_transaction(&spending_tx);
}
+ Event::ChannelReady {
+ ref channel_id,
+ user_channel_id: _,
+ ref counterparty_node_id,
+ channel_type: _,
+ } => {
+ println!(
+ "\nEVENT: Channel {} with peer {} is ready to be used!",
+ hex_utils::hex_str(channel_id),
+ hex_utils::hex_str(&counterparty_node_id.serialize()),
+ );
+ print!("> ");
+ io::stdout().flush().unwrap();
+ }
Event::ChannelClosed { channel_id, reason, user_channel_id: _ } => {
println!(
"\nEVENT: Channel {} closed due to: {:?}",
// A "real" node should probably "lock" the UTXOs spent in funding transactions until
// the funding transaction either confirms, or this event is generated.
}
+ Event::HTLCIntercepted { .. } => {}
}
}
async fn start_ldk() {
- let args = match cli::parse_startup_args() {
+ let args = match args::parse_startup_args() {
Ok(user_args) => user_args,
Err(()) => return,
};
// Step 10: Sync ChannelMonitors and ChannelManager to chain tip
let mut chain_listener_channel_monitors = Vec::new();
let mut cache = UnboundedCache::new();
- let mut chain_tip: Option<poll::ValidatedBlockHeader> = None;
- if restarting_node {
+ let chain_tip = if restarting_node {
let mut chain_listeners = vec![(
channel_manager_blockhash,
&channel_manager as &(dyn chain::Listen + Send + Sync),
&monitor_listener_info.1 as &(dyn chain::Listen + Send + Sync),
));
}
- chain_tip = Some(
- init::synchronize_listeners(
- bitcoind_client.as_ref(),
- args.network,
- &mut cache,
- chain_listeners,
- )
- .await
- .unwrap(),
- );
- }
+
+ init::synchronize_listeners(
+ bitcoind_client.as_ref(),
+ args.network,
+ &mut cache,
+ chain_listeners,
+ )
+ .await
+ .unwrap()
+ } else {
+ polled_chain_tip
+ };
// Step 11: Give ChannelMonitors to ChainMonitor
for item in chain_listener_channel_monitors.drain(..) {
let stop_listen_connect = Arc::new(AtomicBool::new(false));
let stop_listen = Arc::clone(&stop_listen_connect);
tokio::spawn(async move {
- let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{}", listening_port))
+ let listener = tokio::net::TcpListener::bind(format!("[::]:{}", listening_port))
.await
.expect("Failed to bind to listen port - is something else already listening on it?");
loop {
});
// Step 15: Connect and Disconnect Blocks
- if chain_tip.is_none() {
- chain_tip = Some(polled_chain_tip);
- }
let channel_manager_listener = channel_manager.clone();
let chain_monitor_listener = chain_monitor.clone();
let bitcoind_block_source = bitcoind_client.clone();
tokio::spawn(async move {
let chain_poller = poll::ChainPoller::new(bitcoind_block_source.as_ref(), network);
let chain_listener = (chain_monitor_listener, channel_manager_listener);
- let mut spv_client =
- SpvClient::new(chain_tip.unwrap(), chain_poller, &mut cache, &chain_listener);
+ let mut spv_client = SpvClient::new(chain_tip, chain_poller, &mut cache, &chain_listener);
loop {
spv_client.poll_best_tip().await.unwrap();
tokio::time::sleep(Duration::from_secs(1)).await;
let bitcoind_rpc = bitcoind_client.clone();
let network_graph_events = network_graph.clone();
let handle = tokio::runtime::Handle::current();
- let event_handler = move |event: &Event| {
+ let event_handler = move |event: Event| {
handle.block_on(handle_ldk_events(
&channel_manager_event_listener,
&bitcoind_rpc,
&inbound_pmts_for_events,
&outbound_pmts_for_events,
network,
- event,
+ &event,
));
};