use bitcoin::BlockHash;
use bitcoin_bech32::WitnessProgram;
use disk::{INBOUND_PAYMENTS_FNAME, OUTBOUND_PAYMENTS_FNAME};
-use lightning::chain::keysinterface::{
- EntropySource, InMemorySigner, KeysManager, SpendableOutputDescriptor,
-};
use lightning::chain::{chainmonitor, ChannelMonitorUpdateStatus};
use lightning::chain::{Filter, Watch};
use lightning::events::{Event, PaymentFailureReason, PaymentPurpose};
use lightning::ln::msgs::DecodeError;
use lightning::ln::peer_handler::{IgnoringMessageHandler, MessageHandler, SimpleArcPeerManager};
use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
-use lightning::onion_message::SimpleArcOnionMessenger;
+use lightning::onion_message::{DefaultMessageRouter, SimpleArcOnionMessenger};
use lightning::routing::gossip;
use lightning::routing::gossip::{NodeId, P2PGossipSync};
use lightning::routing::router::DefaultRouter;
+use lightning::routing::scoring::ProbabilisticScoringFeeParameters;
+use lightning::sign::{EntropySource, InMemorySigner, KeysManager, SpendableOutputDescriptor};
use lightning::util::config::UserConfig;
use lightning::util::persist::KVStorePersister;
use lightning::util::ser::{Readable, ReadableArgs, Writeable, Writer};
via_user_channel_id: _,
claim_deadline: _,
onion_fields: _,
+ counterparty_skimmed_fee_msat: _,
} => {
println!(
"\nEVENT: received payment from payment hash {} of {} millisatoshis",
}
persister.persist(OUTBOUND_PAYMENTS_FNAME, &*outbound).unwrap();
}
- Event::OpenChannelRequest { .. } => {
- // Unreachable, we don't set manually_accept_inbound_channels
+ Event::OpenChannelRequest {
+ ref temporary_channel_id, ref counterparty_node_id, ..
+ } => {
+ let mut random_bytes = [0u8; 16];
+ random_bytes.copy_from_slice(&keys_manager.get_secure_random_bytes()[..16]);
+ let user_channel_id = u128::from_be_bytes(random_bytes);
+ let res = channel_manager.accept_inbound_channel(
+ temporary_channel_id,
+ counterparty_node_id,
+ user_channel_id,
+ );
+
+ if let Err(e) = res {
+ print!(
+ "\nEVENT: Failed to accept inbound channel ({}) from {}: {:?}",
+ hex_utils::hex_str(&temporary_channel_id[..]),
+ hex_utils::hex_str(&counterparty_node_id.serialize()),
+ e,
+ );
+ } else {
+ print!(
+ "\nEVENT: Accepted inbound channel ({}) from {}",
+ hex_utils::hex_str(&temporary_channel_id[..]),
+ hex_utils::hex_str(&counterparty_node_id.serialize()),
+ );
+ }
+ print!("> ");
+ io::stdout().flush().unwrap();
}
Event::PaymentPathSuccessful { .. } => {}
Event::PaymentPathFailed { .. } => {}
// the funding transaction either confirms, or this event is generated.
}
Event::HTLCIntercepted { .. } => {}
+ Event::BumpTransaction(_) => {}
}
}
)));
// Step 10: Create Router
+ let scoring_fee_params = ProbabilisticScoringFeeParameters::default();
let router = Arc::new(DefaultRouter::new(
network_graph.clone(),
logger.clone(),
keys_manager.get_secure_random_bytes(),
scorer.clone(),
+ scoring_fee_params,
));
// Step 11: Initialize the ChannelManager
let mut user_config = UserConfig::default();
user_config.channel_handshake_limits.force_announced_channel_preference = false;
+ user_config.manually_accept_inbound_channels = true;
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())) {
keys_manager.clone(),
user_config,
chain_params,
+ cur.as_secs() as u32,
);
(polled_best_block_hash, fresh_channel_manager)
}
Arc::clone(&keys_manager),
Arc::clone(&keys_manager),
Arc::clone(&logger),
+ Arc::new(DefaultMessageRouter {}),
+ IgnoringMessageHandler {},
IgnoringMessageHandler {},
));
let mut ephemeral_bytes = [0; 32];
chan_handler: channel_manager.clone(),
route_handler: gossip_sync.clone(),
onion_message_handler: onion_messenger.clone(),
+ custom_message_handler: IgnoringMessageHandler {},
};
let peer_manager: Arc<PeerManager> = Arc::new(PeerManager::new(
lightning_msg_handler,
current_time.try_into().unwrap(),
&ephemeral_bytes,
logger.clone(),
- IgnoringMessageHandler {},
Arc::clone(&keys_manager),
));
// Step 20: Background Processing
let (bp_exit, bp_exit_check) = tokio::sync::watch::channel(());
- let background_processor = tokio::spawn(process_events_async(
+ let mut background_processor = tokio::spawn(process_events_async(
Arc::clone(&persister),
event_handler,
chain_monitor.clone(),
Arc::clone(&logger),
Arc::clone(&persister),
Arc::clone(&bitcoind_client),
+ Arc::clone(&channel_manager),
));
// Start the CLI.
- cli::poll_for_user_input(
+ let cli_poll = tokio::spawn(cli::poll_for_user_input(
Arc::clone(&peer_manager),
Arc::clone(&channel_manager),
Arc::clone(&keys_manager),
network,
Arc::clone(&logger),
Arc::clone(&persister),
- )
- .await;
+ ));
+
+ // Exit if either CLI polling exits or the background processor exits (which shouldn't happen
+ // unless we fail to write to the filesystem).
+ tokio::select! {
+ _ = cli_poll => {},
+ bg_res = &mut background_processor => {
+ stop_listen_connect.store(true, Ordering::Release);
+ peer_manager.disconnect_all_peers();
+ panic!("ERR: background processing stopped with result {:?}, exiting", bg_res);
+ },
+ }
// 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.
peer_manager.disconnect_all_peers();
// Stop the background processor.
- bp_exit.send(()).unwrap();
- background_processor.await.unwrap().unwrap();
+ if !bp_exit.is_closed() {
+ bp_exit.send(()).unwrap();
+ background_processor.await.unwrap().unwrap();
+ }
}
#[tokio::main]