move sync to sweeper

Author: joostjager

lightning-background-processor/src/lib.rs

@@ -992,22 +992,6 @@ impl BackgroundProcessor {
 				}
 				event_handler.handle_event(event)
 			};
-			let sweeper_handler = || {
-				let mut fut = Box::pin(sweeper.regenerate_and_broadcast_spend_if_necessary_locked());
-				let mut waker = dummy_waker();
-				let mut ctx = task::Context::from_waker(&mut waker);
-				match fut.as_mut().poll(&mut ctx) {
-					task::Poll::Ready(result) => {
-						if let Err(_) = result {
-							log_error!(logger, "Failed to sweep output")
-						}
-					},
-					task::Poll::Pending => {
-						// In a sync context, we can't wait for the future to complete.
-						debug_assert!(false);
-					},
-				}
-			};
 			define_run_body!(
 				persister,
 				chain_monitor,
@@ -1020,7 +1004,7 @@ impl BackgroundProcessor {
 				},
 				peer_manager,
 				gossip_sync,
-				sweeper_handler,
+				sweeper.regenerate_and_broadcast_spend_if_necessary_sync(),
 				logger,
 				scorer,
 				stop_thread.load(Ordering::Acquire),

lightning/src/lib.rs

@@ -30,7 +30,6 @@
 //! * `grind_signatures`
 
 #![cfg_attr(not(any(test, fuzzing, feature = "_test_utils")), deny(missing_docs))]
-#![cfg_attr(not(any(test, feature = "_test_utils")), forbid(unsafe_code))]
 
 #![deny(rustdoc::broken_intra_doc_links)]
 #![deny(rustdoc::private_intra_doc_links)]

lightning/src/util/async_poll.rs

@@ -13,7 +13,7 @@ use crate::prelude::*;
 use core::future::Future;
 use core::marker::Unpin;
 use core::pin::Pin;
-use core::task::{Context, Poll};
+use core::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
 
 pub(crate) enum ResultFuture<F: Future<Output = Result<(), E>>, E: Copy + Unpin> {
 	Pending(F),
@@ -74,3 +74,22 @@ impl<F: Future<Output = Result<(), E>> + Unpin, E: Copy + Unpin> Future
 		}
 	}
 }
+
+// If we want to poll a future without an async context to figure out if it has completed or
+// not without awaiting, we need a Waker, which needs a vtable...we fill it with dummy values
+// but sadly there's a good bit of boilerplate here.
+fn dummy_waker_clone(_: *const ()) -> RawWaker {
+	RawWaker::new(core::ptr::null(), &DUMMY_WAKER_VTABLE)
+}
+fn dummy_waker_action(_: *const ()) {}
+
+const DUMMY_WAKER_VTABLE: RawWakerVTable = RawWakerVTable::new(
+	dummy_waker_clone,
+	dummy_waker_action,
+	dummy_waker_action,
+	dummy_waker_action,
+);
+
+pub(crate) fn dummy_waker() -> Waker {
+	unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &DUMMY_WAKER_VTABLE)) }
+}

lightning/src/util/sweep.rs

@@ -30,7 +30,11 @@ use bitcoin::locktime::absolute::LockTime;
 use bitcoin::secp256k1::Secp256k1;
 use bitcoin::{BlockHash, ScriptBuf, Transaction, Txid};
 
+use core::future::Future;
 use core::ops::Deref;
+use core::task;
+
+use super::async_poll::dummy_waker;
 
 /// The number of blocks we wait before we prune the tracked spendable outputs.
 pub const PRUNE_DELAY_BLOCKS: u32 = ARCHIVAL_DELAY_BLOCKS + ANTI_REORG_DELAY;
@@ -449,6 +453,22 @@ where
 		self.sweeper_state.lock().unwrap().best_block
 	}
 
+	/// Regenerates and broadcasts the spending transaction for any outputs that are pending
+	pub fn regenerate_and_broadcast_spend_if_necessary_sync(&self) -> Result<(), ()> {
+		let mut fut = Box::pin(self.regenerate_and_broadcast_spend_if_necessary_locked());
+		let mut waker = dummy_waker();
+		let mut ctx = task::Context::from_waker(&mut waker);
+		match fut.as_mut().poll(&mut ctx) {
+			task::Poll::Ready(result) => {
+				result
+			},
+			task::Poll::Pending => {
+				// In a sync context, we can't wait for the future to complete.
+				panic!("task not ready");
+			},
+		}
+	}
+
 	/// Regenerates and broadcasts the spending transaction for any outputs that are pending
 	pub async fn regenerate_and_broadcast_spend_if_necessary_locked(&self) -> Result<(), ()> {
 		// Collect spendable output descriptors.