};
use lightning::ln::peer_handler::{IgnoringMessageHandler, MessageHandler, SimpleArcPeerManager};
use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
-use lightning::routing::network_graph::{NetGraphMsgHandler, NetworkGraph};
+use lightning::routing::gossip;
+use lightning::routing::gossip::{NodeId, P2PGossipSync};
use lightning::routing::scoring::ProbabilisticScorer;
use lightning::util::config::UserConfig;
use lightning::util::events::{Event, PaymentPurpose};
use lightning_invoice::utils::DefaultRouter;
use lightning_net_tokio::SocketDescriptor;
use lightning_persister::FilesystemPersister;
+use lightning_rapid_gossip_sync::RapidGossipSync;
use rand::{thread_rng, Rng};
use std::collections::hash_map::Entry;
use std::collections::HashMap;
pub(crate) type InvoicePayer<E> = payment::InvoicePayer<
Arc<ChannelManager>,
Router,
- Arc<Mutex<ProbabilisticScorer<Arc<NetworkGraph>>>>,
+ Arc<Mutex<ProbabilisticScorer<Arc<NetworkGraph>, Arc<FilesystemLogger>>>>,
Arc<FilesystemLogger>,
E,
>;
type Router = DefaultRouter<Arc<NetworkGraph>, Arc<FilesystemLogger>>;
+type GossipSync<P, G, A, L> =
+ lightning_background_processor::GossipSync<P, Arc<RapidGossipSync<G, L>>, G, A, L>;
+
+pub(crate) type NetworkGraph = gossip::NetworkGraph<Arc<FilesystemLogger>>;
+
async fn handle_ldk_events(
- channel_manager: Arc<ChannelManager>, bitcoind_client: Arc<BitcoindClient>,
- keys_manager: Arc<KeysManager>, inbound_payments: PaymentInfoStorage,
- outbound_payments: PaymentInfoStorage, network: Network, event: &Event,
+ channel_manager: &Arc<ChannelManager>, bitcoind_client: &BitcoindClient,
+ network_graph: &NetworkGraph, keys_manager: &KeysManager,
+ inbound_payments: &PaymentInfoStorage, outbound_payments: &PaymentInfoStorage,
+ network: Network, event: &Event,
) {
match event {
Event::FundingGenerationReady {
temporary_channel_id,
+ counterparty_node_id,
channel_value_satoshis,
output_script,
..
encode::deserialize(&hex_utils::to_vec(&signed_tx.hex).unwrap()).unwrap();
// Give the funding transaction back to LDK for opening the channel.
if channel_manager
- .funding_transaction_generated(&temporary_channel_id, final_tx)
+ .funding_transaction_generated(
+ &temporary_channel_id,
+ counterparty_node_id,
+ final_tx,
+ )
.is_err()
{
println!(
io::stdout().flush().unwrap();
}
}
- Event::PaymentReceived { payment_hash, purpose, amt, .. } => {
- let mut payments = inbound_payments.lock().unwrap();
+ Event::PaymentReceived { payment_hash, purpose, amount_msat } => {
+ println!(
+ "\nEVENT: received payment from payment hash {} of {} millisatoshis",
+ hex_utils::hex_str(&payment_hash.0),
+ amount_msat,
+ );
+ print!("> ");
+ io::stdout().flush().unwrap();
+ let payment_preimage = match purpose {
+ PaymentPurpose::InvoicePayment { payment_preimage, .. } => *payment_preimage,
+ PaymentPurpose::SpontaneousPayment(preimage) => Some(*preimage),
+ };
+ channel_manager.claim_funds(payment_preimage.unwrap());
+ }
+ Event::PaymentClaimed { payment_hash, purpose, amount_msat } => {
+ println!(
+ "\nEVENT: claimed payment from payment hash {} of {} millisatoshis",
+ hex_utils::hex_str(&payment_hash.0),
+ amount_msat,
+ );
+ print!("> ");
+ io::stdout().flush().unwrap();
let (payment_preimage, payment_secret) = match purpose {
PaymentPurpose::InvoicePayment { payment_preimage, payment_secret, .. } => {
(*payment_preimage, Some(*payment_secret))
}
PaymentPurpose::SpontaneousPayment(preimage) => (Some(*preimage), None),
};
- let status = match channel_manager.claim_funds(payment_preimage.unwrap()) {
- true => {
- println!(
- "\nEVENT: received payment from payment hash {} of {} millisatoshis",
- hex_utils::hex_str(&payment_hash.0),
- amt
- );
- print!("> ");
- io::stdout().flush().unwrap();
- HTLCStatus::Succeeded
- }
- _ => HTLCStatus::Failed,
- };
+ let mut payments = inbound_payments.lock().unwrap();
match payments.entry(*payment_hash) {
Entry::Occupied(mut e) => {
let payment = e.get_mut();
- payment.status = status;
+ payment.status = HTLCStatus::Succeeded;
payment.preimage = payment_preimage;
payment.secret = payment_secret;
}
e.insert(PaymentInfo {
preimage: payment_preimage,
secret: payment_secret,
- status,
- amt_msat: MillisatAmount(Some(*amt)),
+ status: HTLCStatus::Succeeded,
+ amt_msat: MillisatAmount(Some(*amount_msat)),
});
}
}
payment.status = HTLCStatus::Failed;
}
}
- Event::PaymentForwarded { fee_earned_msat, claim_from_onchain_tx } => {
+ Event::PaymentForwarded {
+ prev_channel_id,
+ next_channel_id,
+ fee_earned_msat,
+ claim_from_onchain_tx,
+ } => {
+ let read_only_network_graph = network_graph.read_only();
+ let nodes = read_only_network_graph.nodes();
+ let channels = channel_manager.list_channels();
+
+ let node_str = |channel_id: &Option<[u8; 32]>| match channel_id {
+ None => String::new(),
+ Some(channel_id) => match channels.iter().find(|c| c.channel_id == *channel_id) {
+ None => String::new(),
+ Some(channel) => {
+ match nodes.get(&NodeId::from_pubkey(&channel.counterparty.node_id)) {
+ None => " from private node".to_string(),
+ Some(node) => match &node.announcement_info {
+ None => " from unnamed node".to_string(),
+ Some(announcement) => {
+ format!(" from node {}", announcement.alias)
+ }
+ },
+ }
+ }
+ },
+ };
+ let channel_str = |channel_id: &Option<[u8; 32]>| {
+ channel_id
+ .map(|channel_id| format!(" with channel {}", hex_utils::hex_str(&channel_id)))
+ .unwrap_or_default()
+ };
+ let from_prev_str =
+ format!("{}{}", node_str(prev_channel_id), channel_str(prev_channel_id));
+ let to_next_str =
+ format!("{}{}", node_str(next_channel_id), channel_str(next_channel_id));
+
let from_onchain_str = if *claim_from_onchain_tx {
"from onchain downstream claim"
} else {
};
if let Some(fee_earned) = fee_earned_msat {
println!(
- "\nEVENT: Forwarded payment, earning {} msat {}",
- fee_earned, from_onchain_str
+ "\nEVENT: Forwarded payment{}{}, earning {} msat {}",
+ from_prev_str, to_next_str, fee_earned, from_onchain_str
);
} else {
- println!("\nEVENT: Forwarded payment, claiming onchain {}", from_onchain_str);
+ println!(
+ "\nEVENT: Forwarded payment{}{}, claiming onchain {}",
+ from_prev_str, to_next_str, from_onchain_str
+ );
}
print!("> ");
io::stdout().flush().unwrap();
// Step 8: Initialize the ChannelManager
let mut user_config = UserConfig::default();
- user_config.peer_channel_config_limits.force_announced_channel_preference = false;
+ user_config.channel_handshake_limits.force_announced_channel_preference = false;
let mut restarting_node = true;
let (channel_manager_blockhash, channel_manager) = {
if let Ok(mut f) = fs::File::open(format!("{}/manager", ldk_data_dir.clone())) {
chain_monitor.watch_channel(funding_outpoint, channel_monitor).unwrap();
}
- // Step 11: Optional: Initialize the NetGraphMsgHandler
+ // Step 11: Optional: Initialize the P2PGossipSync
let genesis = genesis_block(args.network).header.block_hash();
let network_graph_path = format!("{}/network_graph", ldk_data_dir.clone());
- let network_graph = Arc::new(disk::read_network(Path::new(&network_graph_path), genesis));
- let network_gossip = Arc::new(NetGraphMsgHandler::new(
+ let network_graph =
+ Arc::new(disk::read_network(Path::new(&network_graph_path), genesis, logger.clone()));
+ let gossip_sync = Arc::new(P2PGossipSync::new(
Arc::clone(&network_graph),
None::<Arc<dyn chain::Access + Send + Sync>>,
logger.clone(),
));
- let network_graph_persist = Arc::clone(&network_graph);
- tokio::spawn(async move {
- let mut interval = tokio::time::interval(Duration::from_secs(600));
- loop {
- interval.tick().await;
- if disk::persist_network(Path::new(&network_graph_path), &network_graph_persist)
- .is_err()
- {
- // Persistence errors here are non-fatal as we can just fetch the routing graph
- // again later, but they may indicate a disk error which could be fatal elsewhere.
- eprintln!(
- "Warning: Failed to persist network graph, check your disk and permissions"
- );
- }
- }
- });
// Step 12: Initialize the PeerManager
let channel_manager: Arc<ChannelManager> = Arc::new(channel_manager);
rand::thread_rng().fill_bytes(&mut ephemeral_bytes);
let lightning_msg_handler = MessageHandler {
chan_handler: channel_manager.clone(),
- route_handler: network_gossip.clone(),
+ route_handler: gossip_sync.clone(),
};
let peer_manager: Arc<PeerManager> = Arc::new(PeerManager::new(
lightning_msg_handler,
let peer_manager_connection_handler = peer_manager.clone();
let listening_port = args.ldk_peer_listening_port;
- let stop_listen = Arc::new(AtomicBool::new(false));
- let stop_listen_ref = Arc::clone(&stop_listen);
+ 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))
.await
loop {
let peer_mgr = peer_manager_connection_handler.clone();
let tcp_stream = listener.accept().await.unwrap().0;
- if stop_listen_ref.load(Ordering::Acquire) {
+ if stop_listen.load(Ordering::Acquire) {
return;
}
tokio::spawn(async move {
let outbound_pmts_for_events = outbound_payments.clone();
let network = args.network;
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| {
handle.block_on(handle_ldk_events(
- channel_manager_event_listener.clone(),
- bitcoind_rpc.clone(),
- keys_manager_listener.clone(),
- inbound_pmts_for_events.clone(),
- outbound_pmts_for_events.clone(),
+ &channel_manager_event_listener,
+ &bitcoind_rpc,
+ &network_graph_events,
+ &keys_manager_listener,
+ &inbound_pmts_for_events,
+ &outbound_pmts_for_events,
network,
event,
));
};
// Step 16: Initialize routing ProbabilisticScorer
- let scorer_path = format!("{}/prob_scorer", ldk_data_dir.clone());
+ let scorer_path = format!("{}/scorer", ldk_data_dir.clone());
let scorer = Arc::new(Mutex::new(disk::read_scorer(
Path::new(&scorer_path),
Arc::clone(&network_graph),
+ Arc::clone(&logger),
)));
- let scorer_persist = Arc::clone(&scorer);
- tokio::spawn(async move {
- let mut interval = tokio::time::interval(Duration::from_secs(600));
- loop {
- interval.tick().await;
- if disk::persist_scorer(Path::new(&scorer_path), &scorer_persist.lock().unwrap())
- .is_err()
- {
- // Persistence errors here are non-fatal as channels will be re-scored as payments
- // fail, but they may indicate a disk error which could be fatal elsewhere.
- eprintln!("Warning: Failed to persist scorer, check your disk and permissions");
- }
- }
- });
// Step 17: Create InvoicePayer
- let router = DefaultRouter::new(network_graph.clone(), logger.clone());
+ let router = DefaultRouter::new(
+ network_graph.clone(),
+ logger.clone(),
+ keys_manager.get_secure_random_bytes(),
+ );
let invoice_payer = Arc::new(InvoicePayer::new(
channel_manager.clone(),
router,
scorer.clone(),
logger.clone(),
event_handler,
- payment::RetryAttempts(5),
+ payment::Retry::Timeout(Duration::from_secs(10)),
));
- // Step 18: Persist ChannelManager
- let data_dir = ldk_data_dir.clone();
- let persist_channel_manager_callback =
- move |node: &ChannelManager| FilesystemPersister::persist_manager(data_dir.clone(), &*node);
+ // Step 18: Persist ChannelManager and NetworkGraph
+ let persister = Arc::new(FilesystemPersister::new(ldk_data_dir.clone()));
// Step 19: Background Processing
let background_processor = BackgroundProcessor::start(
- persist_channel_manager_callback,
+ persister,
invoice_payer.clone(),
chain_monitor.clone(),
channel_manager.clone(),
- Some(network_gossip.clone()),
+ GossipSync::P2P(gossip_sync.clone()),
peer_manager.clone(),
logger.clone(),
+ Some(scorer.clone()),
);
// Regularly reconnect to channel peers.
let connect_cm = Arc::clone(&channel_manager);
let connect_pm = Arc::clone(&peer_manager);
let peer_data_path = format!("{}/channel_peer_data", ldk_data_dir.clone());
+ let stop_connect = Arc::clone(&stop_listen_connect);
tokio::spawn(async move {
let mut interval = tokio::time::interval(Duration::from_secs(1));
loop {
.map(|chan| chan.counterparty.node_id)
.filter(|id| !peers.contains(id))
{
+ if stop_connect.load(Ordering::Acquire) {
+ return;
+ }
for (pubkey, peer_addr) in info.iter() {
if *pubkey == node_id {
let _ = cli::do_connect_peer(
// Start the CLI.
cli::poll_for_user_input(
- invoice_payer.clone(),
- peer_manager.clone(),
- channel_manager.clone(),
- keys_manager.clone(),
+ Arc::clone(&invoice_payer),
+ Arc::clone(&peer_manager),
+ Arc::clone(&channel_manager),
+ Arc::clone(&keys_manager),
+ Arc::clone(&network_graph),
inbound_payments,
outbound_payments,
ldk_data_dir.clone(),
// Disconnect our peers and stop accepting new connections. This ensures we don't continue
// updating our channel data after we've stopped the background processor.
- stop_listen.store(true, Ordering::Release);
+ stop_listen_connect.store(true, Ordering::Release);
peer_manager.disconnect_all_peers();
// Stop the background processor.
projects / ldk-sample / blobdiff