f Move IP/EH/R creation to runtime setup

Author: tnull

src/lib.rs

@@ -382,34 +382,6 @@ impl Builder {
 			Arc::new(EventQueue::new(Arc::clone(&persister)))
 		};
 
-		let event_handler = Arc::new(EventHandler::new(
-			Arc::clone(&wallet),
-			Arc::clone(&event_queue),
-			Arc::clone(&channel_manager),
-			Arc::clone(&network_graph),
-			Arc::clone(&keys_manager),
-			Arc::clone(&inbound_payments),
-			Arc::clone(&outbound_payments),
-			Arc::clone(&logger),
-			Arc::clone(&config),
-		));
-
-		//// Step 16: Create Router and InvoicePayer
-		let router = DefaultRouter::new(
-			Arc::clone(&network_graph),
-			Arc::clone(&logger),
-			keys_manager.get_secure_random_bytes(),
-			Arc::clone(&scorer),
-		);
-
-		let invoice_payer = Arc::new(InvoicePayer::new(
-			Arc::clone(&channel_manager),
-			router,
-			Arc::clone(&logger),
-			Arc::clone(&event_handler),
-			payment::Retry::Timeout(LDK_PAYMENT_RETRY_TIMEOUT),
-		));
-
 		let peer_store = if let Ok(mut f) = fs::File::open(format!(
 			"{}/{}",
 			ldk_data_dir.clone(),
@@ -431,16 +403,15 @@ impl Builder {
 			wallet,
 			tx_sync,
 			event_queue,
-			event_handler,
 			channel_manager,
 			chain_monitor,
 			peer_manager,
 			keys_manager,
+			network_graph,
 			gossip_sync,
 			persister,
 			logger,
 			scorer,
-			invoice_payer,
 			inbound_payments,
 			outbound_payments,
 			peer_store,
@@ -453,6 +424,8 @@ impl Builder {
 struct Runtime {
 	tokio_runtime: Arc<tokio::runtime::Runtime>,
 	_background_processor: BackgroundProcessor,
+	invoice_payer:
+		Arc<InvoicePayer<Arc<EventHandler<Arc<FilesystemPersister>, Arc<FilesystemLogger>>>>>,
 	stop_networking: Arc<AtomicBool>,
 	stop_wallet_sync: Arc<AtomicBool>,
 }
@@ -466,17 +439,15 @@ pub struct Node {
 	wallet: Arc<Wallet<bdk::sled::Tree>>,
 	tx_sync: Arc<EsploraSyncClient<Arc<FilesystemLogger>>>,
 	event_queue: Arc<EventQueue<Arc<FilesystemPersister>>>,
-	event_handler: Arc<EventHandler<Arc<FilesystemPersister>, Arc<FilesystemLogger>>>,
 	channel_manager: Arc<ChannelManager>,
 	chain_monitor: Arc<ChainMonitor>,
 	peer_manager: Arc<PeerManager>,
 	keys_manager: Arc<KeysManager>,
+	network_graph: Arc<NetworkGraph>,
 	gossip_sync: Arc<GossipSync>,
 	persister: Arc<FilesystemPersister>,
 	logger: Arc<FilesystemLogger>,
 	scorer: Arc<Mutex<Scorer>>,
-	invoice_payer:
-		Arc<InvoicePayer<Arc<EventHandler<Arc<FilesystemPersister>, Arc<FilesystemLogger>>>>>,
 	inbound_payments: Arc<PaymentInfoStorage>,
 	outbound_payments: Arc<PaymentInfoStorage>,
 	peer_store: Arc<PeerInfoStorage<FilesystemPersister>>,
@@ -517,7 +488,6 @@ impl Node {
 
 		// Drop the held runtimes.
 		self.wallet.drop_runtime();
-		self.event_handler.drop_runtime();
 
 		// Drop the runtime, which stops the background processor and any possibly remaining tokio threads.
 		*run_lock = None;
@@ -529,7 +499,34 @@ impl Node {
 			Arc::new(tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap());
 
 		self.wallet.set_runtime(Arc::clone(&tokio_runtime));
-		self.event_handler.set_runtime(Arc::clone(&tokio_runtime));
+
+		let event_handler = Arc::new(EventHandler::new(
+			Arc::clone(&self.wallet),
+			Arc::clone(&self.event_queue),
+			Arc::clone(&self.channel_manager),
+			Arc::clone(&self.network_graph),
+			Arc::clone(&self.keys_manager),
+			Arc::clone(&self.inbound_payments),
+			Arc::clone(&self.outbound_payments),
+			Arc::clone(&tokio_runtime),
+			Arc::clone(&self.logger),
+			Arc::clone(&self.config),
+		));
+
+		let router = DefaultRouter::new(
+			Arc::clone(&self.network_graph),
+			Arc::clone(&self.logger),
+			self.keys_manager.get_secure_random_bytes(),
+			Arc::clone(&self.scorer),
+		);
+
+		let invoice_payer = Arc::new(InvoicePayer::new(
+			Arc::clone(&self.channel_manager),
+			router,
+			Arc::clone(&self.logger),
+			Arc::clone(&event_handler),
+			payment::Retry::Timeout(LDK_PAYMENT_RETRY_TIMEOUT),
+		));
 
 		// Setup wallet sync
 		let wallet = Arc::clone(&self.wallet);
@@ -657,7 +654,7 @@ impl Node {
 		// Setup background processing
 		let _background_processor = BackgroundProcessor::start(
 			Arc::clone(&self.persister),
-			Arc::clone(&self.invoice_payer),
+			Arc::clone(&invoice_payer),
 			Arc::clone(&self.chain_monitor),
 			Arc::clone(&self.channel_manager),
 			BPGossipSync::p2p(Arc::clone(&self.gossip_sync)),
@@ -667,8 +664,13 @@ impl Node {
 		);
 
 		// TODO: frequently check back on background_processor if there was an error
-
-		Ok(Runtime { tokio_runtime, _background_processor, stop_networking, stop_wallet_sync })
+		Ok(Runtime {
+			tokio_runtime,
+			_background_processor,
+			invoice_payer,
+			stop_networking,
+			stop_wallet_sync,
+		})
 	}
 
 	/// Blocks until the next event is available.
@@ -717,10 +719,10 @@ impl Node {
 			return Err(Error::NotRunning);
 		}
 
-		let peer_info = PeerInfo::try_from(node_pubkey_and_address.to_string())?;
-
 		let runtime = runtime_lock.as_ref().unwrap();
 
+		let peer_info = PeerInfo::try_from(node_pubkey_and_address.to_string())?;
+
 		let con_peer_info = peer_info.clone();
 		let con_success = Arc::new(AtomicBool::new(false));
 		let con_success_cloned = Arc::clone(&con_success);
@@ -822,12 +824,15 @@ impl Node {
 
 	/// Send a payement given an invoice.
 	pub fn send_payment(&self, invoice: Invoice) -> Result<PaymentHash, Error> {
-		if self.running.read().unwrap().is_none() {
+		let runtime_lock = self.running.read().unwrap();
+		if runtime_lock.is_none() {
 			return Err(Error::NotRunning);
 		}
 
+		let runtime = runtime_lock.as_ref().unwrap();
+
 		// TODO: ensure we never tried paying the given payment hash before
-		let status = match self.invoice_payer.pay_invoice(&invoice) {
+		let status = match runtime.invoice_payer.pay_invoice(&invoice) {
 			Ok(_payment_id) => {
 				let payee_pubkey = invoice.recover_payee_pub_key();
 				// TODO: is this unwrap safe? Would a payment to an invoice with None amount ever
@@ -872,16 +877,18 @@ impl Node {
 	pub fn send_spontaneous_payment(
 		&self, amount_msat: u64, node_id: &str,
 	) -> Result<PaymentHash, Error> {
-		if self.running.read().unwrap().is_none() {
+		let runtime_lock = self.running.read().unwrap();
+		if runtime_lock.is_none() {
 			return Err(Error::NotRunning);
 		}
 
+		let runtime = runtime_lock.as_ref().unwrap();
 		let pubkey = hex_utils::to_compressed_pubkey(node_id).ok_or(Error::PeerInfoParseFailed)?;
 
 		let payment_preimage = PaymentPreimage(self.keys_manager.get_secure_random_bytes());
 		let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0).into_inner());
 
-		let status = match self.invoice_payer.pay_pubkey(
+		let status = match runtime.invoice_payer.pay_pubkey(
 			pubkey,
 			payment_preimage,
 			amount_msat,