f: add WalletSync

Author: joostjager

lightning/src/events/bump_transaction.rs

@@ -375,8 +375,11 @@ pub trait CoinSelectionSourceSync {
 	fn sign_psbt(&self, psbt: Psbt) -> Result<Transaction, ()>;
 }
 
-/// A wrapper around [`CoinSelectionSourceSync`] to allow for async calls. This wrapper isn't intended to be used
-/// directly, because that would risk blocking an async context.
+/// A wrapper around [`CoinSelectionSourceSync`] to allow for async calls.
+///
+/// This wrapper isn't intended to be used directly, because that would risk blocking an async context. Instead, it is
+/// built for you in [`BumpTransactionEventHandlerSync::new`].
+#[doc(hidden)]
 #[cfg(any(test, feature = "_test_utils"))]
 pub struct CoinSelectionSourceSyncWrapper<T: Deref>(T)
 where
@@ -454,7 +457,11 @@ pub trait WalletSourceSync {
 }
 
 /// A wrapper around [`WalletSourceSync`] to allow for async calls.
-pub struct WalletSourceSyncWrapper<T: Deref>(T)
+///
+/// This wrapper isn't intended to be used directly, because that would risk blocking an async context. Instead, it is
+/// built for you in [`WalletSync::new`].
+#[doc(hidden)]
+pub(crate) struct WalletSourceSyncWrapper<T: Deref>(T)
 where
 	T::Target: WalletSourceSync;
 
@@ -494,6 +501,67 @@ where
 	}
 }
 
+/// A synchronous wrapper around [`Wallet`] to be used in contexts where async is not available.
+pub struct WalletSync<W: Deref + MaybeSync + MaybeSend, L: Deref + MaybeSync + MaybeSend>
+where
+	W::Target: WalletSourceSync + MaybeSend,
+	L::Target: Logger + MaybeSend,
+{
+	wallet: Wallet<Arc<WalletSourceSyncWrapper<W>>, L>,
+}
+
+impl<W: Deref + MaybeSync + MaybeSend, L: Deref + MaybeSync + MaybeSend> WalletSync<W, L>
+where
+	W::Target: WalletSourceSync + MaybeSend,
+	L::Target: Logger + MaybeSend,
+{
+	/// Constructs a new [`WalletSync`] instance.
+	pub fn new(source: W, logger: L) -> Self {
+		Self { wallet: Wallet::new(Arc::new(WalletSourceSyncWrapper::new(source)), logger) }
+	}
+}
+
+impl<W: Deref + MaybeSync + MaybeSend, L: Deref + MaybeSync + MaybeSend> CoinSelectionSourceSync
+	for WalletSync<W, L>
+where
+	W::Target: WalletSourceSync + MaybeSend + MaybeSync,
+	L::Target: Logger + MaybeSend + MaybeSync,
+{
+	fn select_confirmed_utxos(
+		&self, claim_id: ClaimId, must_spend: Vec<Input>, must_pay_to: &[TxOut],
+		target_feerate_sat_per_1000_weight: u32,
+	) -> Result<CoinSelection, ()> {
+		let mut fut = Box::pin(self.wallet.select_confirmed_utxos(
+			claim_id,
+			must_spend,
+			must_pay_to,
+			target_feerate_sat_per_1000_weight,
+		));
+		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 => {
+				unreachable!(
+					"Wallet::select_confirmed_utxos should not be pending in a sync context"
+				);
+			},
+		}
+	}
+
+	fn sign_psbt(&self, psbt: Psbt) -> Result<Transaction, ()> {
+		let mut fut = Box::pin(self.wallet.sign_psbt(psbt));
+		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 => {
+				unreachable!("Wallet::sign_psbt should not be pending in a sync context");
+			},
+		}
+	}
+}
+
 /// A wrapper over [`WalletSource`] that implements [`CoinSelection`] by preferring UTXOs that would
 /// avoid conflicting double spends. If not enough UTXOs are available to do so, conflicting double
 /// spends may happen.