Drop Deref indirection for SignerProvider

diff --git a/lightning/src/chain/chainmonitor.rs b/lightning/src/chain/chainmonitor.rs
index 87943bd..8835e9c 100644
--- a/lightning/src/chain/chainmonitor.rs
+++ b/lightning/src/chain/chainmonitor.rs
@@ -260,12 +260,11 @@ pub struct AsyncPersister<
 	S: FutureSpawner,
 	L: Logger + MaybeSend + MaybeSync + 'static,
 	ES: EntropySource + MaybeSend + MaybeSync + 'static,
-	SP: Deref + MaybeSend + MaybeSync + 'static,
+	SP: SignerProvider + MaybeSend + MaybeSync + 'static,
 	BI: BroadcasterInterface + MaybeSend + MaybeSync + 'static,
 	FE: FeeEstimator + MaybeSend + MaybeSync + 'static,
 > where
 	K::Target: KVStore + MaybeSync,
-	SP::Target: SignerProvider + Sized,
 {
 	persister: MonitorUpdatingPersisterAsync<K, S, L, ES, SP, BI, FE>,
 	event_notifier: Arc<Notifier>,
@@ -276,13 +275,12 @@ impl<
 		S: FutureSpawner,
 		L: Logger + MaybeSend + MaybeSync + 'static,
 		ES: EntropySource + MaybeSend + MaybeSync + 'static,
-		SP: Deref + MaybeSend + MaybeSync + 'static,
+		SP: SignerProvider + MaybeSend + MaybeSync + 'static,
 		BI: BroadcasterInterface + MaybeSend + MaybeSync + 'static,
 		FE: FeeEstimator + MaybeSend + MaybeSync + 'static,
 	> Deref for AsyncPersister<K, S, L, ES, SP, BI, FE>
 where
 	K::Target: KVStore + MaybeSync,
-	SP::Target: SignerProvider + Sized,
 {
 	type Target = Self;
 	fn deref(&self) -> &Self {
@@ -295,18 +293,16 @@ impl<
 		S: FutureSpawner,
 		L: Logger + MaybeSend + MaybeSync + 'static,
 		ES: EntropySource + MaybeSend + MaybeSync + 'static,
-		SP: Deref + MaybeSend + MaybeSync + 'static,
+		SP: SignerProvider + MaybeSend + MaybeSync + 'static,
 		BI: BroadcasterInterface + MaybeSend + MaybeSync + 'static,
 		FE: FeeEstimator + MaybeSend + MaybeSync + 'static,
-	> Persist<<SP::Target as SignerProvider>::EcdsaSigner> for AsyncPersister<K, S, L, ES, SP, BI, FE>
+	> Persist<SP::EcdsaSigner> for AsyncPersister<K, S, L, ES, SP, BI, FE>
 where
 	K::Target: KVStore + MaybeSync,
-	SP::Target: SignerProvider + Sized,
-	<SP::Target as SignerProvider>::EcdsaSigner: MaybeSend + 'static,
+	SP::EcdsaSigner: MaybeSend + 'static,
 {
 	fn persist_new_channel(
-		&self, monitor_name: MonitorName,
-		monitor: &ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>,
+		&self, monitor_name: MonitorName, monitor: &ChannelMonitor<SP::EcdsaSigner>,
 	) -> ChannelMonitorUpdateStatus {
 		let notifier = Arc::clone(&self.event_notifier);
 		self.persister.spawn_async_persist_new_channel(monitor_name, monitor, notifier);
@@ -315,7 +311,7 @@ where
 
 	fn update_persisted_channel(
 		&self, monitor_name: MonitorName, monitor_update: Option<&ChannelMonitorUpdate>,
-		monitor: &ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>,
+		monitor: &ChannelMonitor<SP::EcdsaSigner>,
 	) -> ChannelMonitorUpdateStatus {
 		let notifier = Arc::clone(&self.event_notifier);
 		self.persister.spawn_async_update_channel(monitor_name, monitor_update, monitor, notifier);
@@ -386,26 +382,17 @@ pub struct ChainMonitor<
 impl<
 		K: Deref + MaybeSend + MaybeSync + 'static,
 		S: FutureSpawner,
-		SP: Deref + MaybeSend + MaybeSync + 'static,
+		SP: SignerProvider + MaybeSend + MaybeSync + 'static,
 		C: Deref,
 		T: BroadcasterInterface + MaybeSend + MaybeSync + 'static,
 		F: FeeEstimator + MaybeSend + MaybeSync + 'static,
 		L: Logger + MaybeSend + MaybeSync + 'static,
 		ES: EntropySource + MaybeSend + MaybeSync + 'static,
-	>
-	ChainMonitor<
-		<SP::Target as SignerProvider>::EcdsaSigner,
-		C,
-		T,
-		F,
-		L,
-		AsyncPersister<K, S, L, ES, SP, T, F>,
-		ES,
-	> where
+	> ChainMonitor<SP::EcdsaSigner, C, T, F, L, AsyncPersister<K, S, L, ES, SP, T, F>, ES>
+where
 	K::Target: KVStore + MaybeSync,
-	SP::Target: SignerProvider + Sized,
 	C::Target: chain::Filter,
-	<SP::Target as SignerProvider>::EcdsaSigner: MaybeSend + 'static,
+	SP::EcdsaSigner: MaybeSend + 'static,
 {
 	/// Creates a new `ChainMonitor` used to watch on-chain activity pertaining to channels.
 	///
diff --git a/lightning/src/events/bump_transaction/mod.rs b/lightning/src/events/bump_transaction/mod.rs
index bc91212..1b3496c 100644
--- a/lightning/src/events/bump_transaction/mod.rs
+++ b/lightning/src/events/bump_transaction/mod.rs
@@ -691,10 +691,13 @@ where
 ///
 /// [`Event::BumpTransaction`]: crate::events::Event::BumpTransaction
 // Note that updates to documentation on this struct should be copied to the synchronous version.
-pub struct BumpTransactionEventHandler<B: BroadcasterInterface, C: Deref, SP: Deref, L: Logger>
-where
+pub struct BumpTransactionEventHandler<
+	B: BroadcasterInterface,
+	C: Deref,
+	SP: SignerProvider,
+	L: Logger,
+> where
 	C::Target: CoinSelectionSource,
-	SP::Target: SignerProvider,
 {
 	broadcaster: B,
 	utxo_source: C,
@@ -703,11 +706,10 @@ where
 	secp: Secp256k1<secp256k1::All>,
 }
 
-impl<B: BroadcasterInterface, C: Deref, SP: Deref, L: Logger>
+impl<B: BroadcasterInterface, C: Deref, SP: SignerProvider, L: Logger>
 	BumpTransactionEventHandler<B, C, SP, L>
 where
 	C::Target: CoinSelectionSource,
-	SP::Target: SignerProvider,
 {
 	/// Returns a new instance capable of handling [`Event::BumpTransaction`] events.
 	///
diff --git a/lightning/src/events/bump_transaction/sync.rs b/lightning/src/events/bump_transaction/sync.rs
index e19ab3d..f4245cd 100644
--- a/lightning/src/events/bump_transaction/sync.rs
+++ b/lightning/src/events/bump_transaction/sync.rs
@@ -264,20 +264,22 @@ where
 ///
 /// [`Event::BumpTransaction`]: crate::events::Event::BumpTransaction
 // Note that updates to documentation on this struct should be copied to the synchronous version.
-pub struct BumpTransactionEventHandlerSync<B: BroadcasterInterface, C: Deref, SP: Deref, L: Logger>
-where
+pub struct BumpTransactionEventHandlerSync<
+	B: BroadcasterInterface,
+	C: Deref,
+	SP: SignerProvider,
+	L: Logger,
+> where
 	C::Target: CoinSelectionSourceSync,
-	SP::Target: SignerProvider,
 {
 	bump_transaction_event_handler:
 		BumpTransactionEventHandler<B, CoinSelectionSourceSyncWrapper<C>, SP, L>,
 }
 
-impl<B: BroadcasterInterface, C: Deref, SP: Deref, L: Logger>
+impl<B: BroadcasterInterface, C: Deref, SP: SignerProvider, L: Logger>
 	BumpTransactionEventHandlerSync<B, C, SP, L>
 where
 	C::Target: CoinSelectionSourceSync,
-	SP::Target: SignerProvider,
 {
 	/// Constructs a new instance of [`BumpTransactionEventHandlerSync`].
 	pub fn new(broadcaster: B, utxo_source: C, signer_provider: SP, logger: L) -> Self {
diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs
index fc20708..042b388 100644
--- a/lightning/src/ln/channel.rs
+++ b/lightning/src/ln/channel.rs
@@ -93,7 +93,6 @@ use crate::prelude::*;
 use crate::sign::type_resolver::ChannelSignerType;
 #[cfg(any(test, fuzzing, debug_assertions))]
 use crate::sync::Mutex;
-use core::ops::Deref;
 use core::time::Duration;
 use core::{cmp, fmt, mem};
 
@@ -1002,12 +1001,9 @@ impl<'a, L: Logger> Logger for WithChannelContext<'a, L> {
 }
 
 impl<'a, 'b, L: Logger> WithChannelContext<'a, L> {
-	pub(super) fn from<S: Deref>(
+	pub(super) fn from<S: SignerProvider>(
 		logger: &'a L, context: &'b ChannelContext<S>, payment_hash: Option<PaymentHash>,
-	) -> Self
-	where
-		S::Target: SignerProvider,
-	{
+	) -> Self {
 		WithChannelContext {
 			logger,
 			peer_id: Some(context.counterparty_node_id),
@@ -1242,9 +1238,7 @@ struct HolderCommitmentPoint {
 
 impl HolderCommitmentPoint {
 	#[rustfmt::skip]
-	pub fn new<SP: Deref>(signer: &ChannelSignerType<SP>, secp_ctx: &Secp256k1<secp256k1::All>) -> Option<Self>
-		where SP::Target: SignerProvider
-	{
+	pub fn new<SP: SignerProvider>(signer: &ChannelSignerType<SP>, secp_ctx: &Secp256k1<secp256k1::All>) -> Option<Self> {
 		Some(HolderCommitmentPoint {
 			next_transaction_number: INITIAL_COMMITMENT_NUMBER,
 			previous_revoked_point: None,
@@ -1285,11 +1279,9 @@ impl HolderCommitmentPoint {
 
 	/// If we are pending advancing the next commitment point, this method tries asking the signer
 	/// again.
-	pub fn try_resolve_pending<SP: Deref, L: Logger>(
+	pub fn try_resolve_pending<SP: SignerProvider, L: Logger>(
 		&mut self, signer: &ChannelSignerType<SP>, secp_ctx: &Secp256k1<secp256k1::All>, logger: &L,
-	) where
-		SP::Target: SignerProvider,
-	{
+	) {
 		if !self.can_advance() {
 			let pending_next_point = signer
 				.as_ref()
@@ -1321,12 +1313,9 @@ impl HolderCommitmentPoint {
 	///
 	/// If our signer is ready to provide the next commitment point, the next call to `advance` will
 	/// succeed.
-	pub fn advance<SP: Deref, L: Logger>(
+	pub fn advance<SP: SignerProvider, L: Logger>(
 		&mut self, signer: &ChannelSignerType<SP>, secp_ctx: &Secp256k1<secp256k1::All>, logger: &L,
-	) -> Result<(), ()>
-	where
-		SP::Target: SignerProvider,
-	{
+	) -> Result<(), ()> {
 		if let Some(next_point) = self.pending_next_point {
 			*self = Self {
 				next_transaction_number: self.next_transaction_number - 1,
@@ -1442,19 +1431,13 @@ impl_writeable_tlv_based!(PendingChannelMonitorUpdate, {
 
 /// A payment channel with a counterparty throughout its life-cycle, encapsulating negotiation and
 /// funding phases.
-pub(super) struct Channel<SP: Deref>
-where
-	SP::Target: SignerProvider,
-{
+pub(super) struct Channel<SP: SignerProvider> {
 	phase: ChannelPhase<SP>,
 }
 
 /// The `ChannelPhase` enum describes the current phase in life of a lightning channel with each of
 /// its variants containing an appropriate channel struct.
-enum ChannelPhase<SP: Deref>
-where
-	SP::Target: SignerProvider,
-{
+enum ChannelPhase<SP: SignerProvider> {
 	Undefined,
 	UnfundedOutboundV1(OutboundV1Channel<SP>),
 	UnfundedInboundV1(InboundV1Channel<SP>),
@@ -1462,10 +1445,9 @@ where
 	Funded(FundedChannel<SP>),
 }
 
-impl<SP: Deref> Channel<SP>
+impl<SP: SignerProvider> Channel<SP>
 where
-	SP::Target: SignerProvider,
-	<SP::Target as SignerProvider>::EcdsaSigner: ChannelSigner,
+	SP::EcdsaSigner: ChannelSigner,
 {
 	pub fn context(&self) -> &ChannelContext<SP> {
 		match &self.phase {
@@ -2007,7 +1989,7 @@ where
 	#[rustfmt::skip]
 	pub fn funding_signed<L: Logger>(
 		&mut self, msg: &msgs::FundingSigned, best_block: BestBlock, signer_provider: &SP, logger: &L
-	) -> Result<(&mut FundedChannel<SP>, ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>), ChannelError> {
+	) -> Result<(&mut FundedChannel<SP>, ChannelMonitor<SP::EcdsaSigner>), ChannelError> {
 		let phase = core::mem::replace(&mut self.phase, ChannelPhase::Undefined);
 		let result = if let ChannelPhase::UnfundedOutboundV1(chan) = phase {
 			let channel_state = chan.context.channel_state;
@@ -2277,7 +2259,7 @@ where
 	#[rustfmt::skip]
 	pub fn commitment_signed<F: FeeEstimator, L: Logger>(
 		&mut self, msg: &msgs::CommitmentSigned, best_block: BestBlock, signer_provider: &SP, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &L
-	) -> Result<(Option<ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>>, Option<ChannelMonitorUpdate>), ChannelError> {
+	) -> Result<(Option<ChannelMonitor<SP::EcdsaSigner>>, Option<ChannelMonitorUpdate>), ChannelError> {
 		let phase = core::mem::replace(&mut self.phase, ChannelPhase::Undefined);
 		match phase {
 			ChannelPhase::UnfundedV2(chan) => {
@@ -2396,40 +2378,36 @@ where
 	}
 }
 
-impl<SP: Deref> From<OutboundV1Channel<SP>> for Channel<SP>
+impl<SP: SignerProvider> From<OutboundV1Channel<SP>> for Channel<SP>
 where
-	SP::Target: SignerProvider,
-	<SP::Target as SignerProvider>::EcdsaSigner: ChannelSigner,
+	SP::EcdsaSigner: ChannelSigner,
 {
 	fn from(channel: OutboundV1Channel<SP>) -> Self {
 		Channel { phase: ChannelPhase::UnfundedOutboundV1(channel) }
 	}
 }
 
-impl<SP: Deref> From<InboundV1Channel<SP>> for Channel<SP>
+impl<SP: SignerProvider> From<InboundV1Channel<SP>> for Channel<SP>
 where
-	SP::Target: SignerProvider,
-	<SP::Target as SignerProvider>::EcdsaSigner: ChannelSigner,
+	SP::EcdsaSigner: ChannelSigner,
 {
 	fn from(channel: InboundV1Channel<SP>) -> Self {
 		Channel { phase: ChannelPhase::UnfundedInboundV1(channel) }
 	}
 }
 
-impl<SP: Deref> From<PendingV2Channel<SP>> for Channel<SP>
+impl<SP: SignerProvider> From<PendingV2Channel<SP>> for Channel<SP>
 where
-	SP::Target: SignerProvider,
-	<SP::Target as SignerProvider>::EcdsaSigner: ChannelSigner,
+	SP::EcdsaSigner: ChannelSigner,
 {
 	fn from(channel: PendingV2Channel<SP>) -> Self {
 		Channel { phase: ChannelPhase::UnfundedV2(channel) }
 	}
 }
 
-impl<SP: Deref> From<FundedChannel<SP>> for Channel<SP>
+impl<SP: SignerProvider> From<FundedChannel<SP>> for Channel<SP>
 where
-	SP::Target: SignerProvider,
-	<SP::Target as SignerProvider>::EcdsaSigner: ChannelSigner,
+	SP::EcdsaSigner: ChannelSigner,
 {
 	fn from(channel: FundedChannel<SP>) -> Self {
 		Channel { phase: ChannelPhase::Funded(channel) }
@@ -2681,14 +2659,11 @@ impl FundingScope {
 	}
 
 	/// Constructs a `FundingScope` for splicing a channel.
-	fn for_splice<SP: Deref>(
+	fn for_splice<SP: SignerProvider>(
 		prev_funding: &Self, context: &ChannelContext<SP>, our_funding_contribution: SignedAmount,
 		their_funding_contribution: SignedAmount, counterparty_funding_pubkey: PublicKey,
 		our_new_holder_keys: ChannelPublicKeys,
-	) -> Self
-	where
-		SP::Target: SignerProvider,
-	{
+	) -> Self {
 		debug_assert!(our_funding_contribution.abs() <= SignedAmount::MAX_MONEY);
 		debug_assert!(their_funding_contribution.abs() <= SignedAmount::MAX_MONEY);
 
@@ -2877,12 +2852,9 @@ impl FundingNegotiation {
 }
 
 impl PendingFunding {
-	fn check_get_splice_locked<SP: Deref>(
+	fn check_get_splice_locked<SP: SignerProvider>(
 		&mut self, context: &ChannelContext<SP>, confirmed_funding_index: usize, height: u32,
-	) -> Option<msgs::SpliceLocked>
-	where
-		SP::Target: SignerProvider,
-	{
+	) -> Option<msgs::SpliceLocked> {
 		debug_assert!(confirmed_funding_index < self.negotiated_candidates.len());
 
 		let funding = &self.negotiated_candidates[confirmed_funding_index];
@@ -2988,10 +2960,7 @@ impl<'a> From<&'a Transaction> for ConfirmedTransaction<'a> {
 
 /// Contains everything about the channel including state, and various flags.
 #[cfg_attr(test, derive(Debug))]
-pub(super) struct ChannelContext<SP: Deref>
-where
-	SP::Target: SignerProvider,
-{
+pub(super) struct ChannelContext<SP: SignerProvider> {
 	config: LegacyChannelConfig,
 
 	// Track the previous `ChannelConfig` so that we can continue forwarding HTLCs that were
@@ -3280,10 +3249,7 @@ where
 
 /// A channel struct implementing this trait can receive an initial counterparty commitment
 /// transaction signature.
-trait InitialRemoteCommitmentReceiver<SP: Deref>
-where
-	SP::Target: SignerProvider,
-{
+trait InitialRemoteCommitmentReceiver<SP: SignerProvider> {
 	fn context(&self) -> &ChannelContext<SP>;
 
 	fn context_mut(&mut self) -> &mut ChannelContext<SP>;
@@ -3321,7 +3287,7 @@ where
 	fn initial_commitment_signed<L: Logger>(
 		&mut self, channel_id: ChannelId, counterparty_signature: Signature, holder_commitment_point: &mut HolderCommitmentPoint,
 		best_block: BestBlock, signer_provider: &SP, logger: &L,
-	) -> Result<(ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>, CommitmentTransaction), ChannelError> {
+	) -> Result<(ChannelMonitor<SP::EcdsaSigner>, CommitmentTransaction), ChannelError> {
 		let initial_commitment_tx = match self.check_counterparty_commitment_signature(&counterparty_signature, holder_commitment_point, logger) {
 			Ok(res) => res,
 			Err(ChannelError::Close(e)) => {
@@ -3409,10 +3375,7 @@ where
 	fn is_v2_established(&self) -> bool;
 }
 
-impl<SP: Deref> InitialRemoteCommitmentReceiver<SP> for OutboundV1Channel<SP>
-where
-	SP::Target: SignerProvider,
-{
+impl<SP: SignerProvider> InitialRemoteCommitmentReceiver<SP> for OutboundV1Channel<SP> {
 	fn context(&self) -> &ChannelContext<SP> {
 		&self.context
 	}
@@ -3438,10 +3401,7 @@ where
 	}
 }
 
-impl<SP: Deref> InitialRemoteCommitmentReceiver<SP> for InboundV1Channel<SP>
-where
-	SP::Target: SignerProvider,
-{
+impl<SP: SignerProvider> InitialRemoteCommitmentReceiver<SP> for InboundV1Channel<SP> {
 	fn context(&self) -> &ChannelContext<SP> {
 		&self.context
 	}
@@ -3467,10 +3427,7 @@ where
 	}
 }
 
-impl<SP: Deref> InitialRemoteCommitmentReceiver<SP> for FundedChannel<SP>
-where
-	SP::Target: SignerProvider,
-{
+impl<SP: SignerProvider> InitialRemoteCommitmentReceiver<SP> for FundedChannel<SP> {
 	fn context(&self) -> &ChannelContext<SP> {
 		&self.context
 	}
@@ -3505,10 +3462,7 @@ where
 	}
 }
 
-impl<SP: Deref> ChannelContext<SP>
-where
-	SP::Target: SignerProvider,
-{
+impl<SP: SignerProvider> ChannelContext<SP> {
 	#[rustfmt::skip]
 	fn new_for_inbound_channel<'a, ES: EntropySource, F: FeeEstimator, L: Logger>(
 		fee_estimator: &'a LowerBoundedFeeEstimator<F>,
@@ -3528,10 +3482,7 @@ where
 		msg_channel_reserve_satoshis: u64,
 		msg_push_msat: u64,
 		open_channel_fields: msgs::CommonOpenChannelFields,
-	) -> Result<(FundingScope, ChannelContext<SP>), ChannelError>
-		where
-			SP::Target: SignerProvider,
-	{
+	) -> Result<(FundingScope, ChannelContext<SP>), ChannelError> {
 		let logger = WithContext::from(logger, Some(counterparty_node_id), Some(open_channel_fields.temporary_channel_id), None);
 		let announce_for_forwarding = if (open_channel_fields.channel_flags & 1) == 1 { true } else { false };
 
@@ -3867,12 +3818,9 @@ where
 		temporary_channel_id_fn: Option<impl Fn(&ChannelPublicKeys) -> ChannelId>,
 		holder_selected_channel_reserve_satoshis: u64,
 		channel_keys_id: [u8; 32],
-		holder_signer: <SP::Target as SignerProvider>::EcdsaSigner,
+		holder_signer: SP::EcdsaSigner,
 		_logger: L,
-	) -> Result<(FundingScope, ChannelContext<SP>), APIError>
-		where
-			SP::Target: SignerProvider,
-	{
+	) -> Result<(FundingScope, ChannelContext<SP>), APIError> {
 		// This will be updated with the counterparty contribution if this is a dual-funded channel
 		let channel_value_satoshis = funding_satoshis;
 
@@ -6363,10 +6311,7 @@ where
 
 	fn get_initial_counterparty_commitment_signatures<L: Logger>(
 		&self, funding: &FundingScope, logger: &L,
-	) -> Option<(Signature, Vec<Signature>)>
-	where
-		SP::Target: SignerProvider,
-	{
+	) -> Option<(Signature, Vec<Signature>)> {
 		let mut commitment_number = self.counterparty_next_commitment_transaction_number;
 		let mut commitment_point = self.counterparty_next_commitment_point.unwrap();
 
@@ -6407,10 +6352,7 @@ where
 
 	fn get_initial_commitment_signed_v2<L: Logger>(
 		&self, funding: &FundingScope, logger: &L,
-	) -> Option<msgs::CommitmentSigned>
-	where
-		SP::Target: SignerProvider,
-	{
+	) -> Option<msgs::CommitmentSigned> {
 		let signatures = self.get_initial_counterparty_commitment_signatures(funding, logger);
 		if let Some((signature, htlc_signatures)) = signatures {
 			log_info!(logger, "Generated commitment_signed for peer",);
@@ -6750,13 +6692,10 @@ pub(super) struct FundingNegotiationContext {
 impl FundingNegotiationContext {
 	/// Prepare and start interactive transaction negotiation.
 	/// If error occurs, it is caused by our side, not the counterparty.
-	fn into_interactive_tx_constructor<SP: Deref, ES: EntropySource>(
+	fn into_interactive_tx_constructor<SP: SignerProvider, ES: EntropySource>(
 		mut self, context: &ChannelContext<SP>, funding: &FundingScope, signer_provider: &SP,
 		entropy_source: &ES, holder_node_id: PublicKey,
-	) -> Result<InteractiveTxConstructor, NegotiationError>
-	where
-		SP::Target: SignerProvider,
-	{
+	) -> Result<InteractiveTxConstructor, NegotiationError> {
 		debug_assert_eq!(
 			self.shared_funding_input.is_some(),
 			funding.channel_transaction_parameters.splice_parent_funding_txid.is_some(),
@@ -6860,10 +6799,7 @@ impl FundingNegotiationContext {
 // Holder designates channel data owned for the benefit of the user client.
 // Counterparty designates channel data owned by the another channel participant entity.
 #[cfg_attr(test, derive(Debug))]
-pub(super) struct FundedChannel<SP: Deref>
-where
-	SP::Target: SignerProvider,
-{
+pub(super) struct FundedChannel<SP: SignerProvider> {
 	pub funding: FundingScope,
 	pub context: ChannelContext<SP>,
 	holder_commitment_point: HolderCommitmentPoint,
@@ -7068,10 +7004,9 @@ pub struct SpliceFundingPromotion {
 	pub discarded_funding: Vec<FundingInfo>,
 }
 
-impl<SP: Deref> FundedChannel<SP>
+impl<SP: SignerProvider> FundedChannel<SP>
 where
-	SP::Target: SignerProvider,
-	<SP::Target as SignerProvider>::EcdsaSigner: EcdsaChannelSigner,
+	SP::EcdsaSigner: EcdsaChannelSigner,
 {
 	pub fn context(&self) -> &ChannelContext<SP> {
 		&self.context
@@ -7987,7 +7922,7 @@ where
 	pub fn initial_commitment_signed_v2<L: Logger>(
 		&mut self, msg: &msgs::CommitmentSigned, best_block: BestBlock, signer_provider: &SP,
 		logger: &L,
-	) -> Result<ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>, ChannelError> {
+	) -> Result<ChannelMonitor<SP::EcdsaSigner>, ChannelError> {
 		if let Some(signing_session) = self.context.interactive_tx_signing_session.as_ref() {
 			if signing_session.has_received_tx_signatures() {
 				let msg = "Received initial commitment_signed after peer's tx_signatures received!";
@@ -13411,10 +13346,7 @@ where
 }
 
 /// A not-yet-funded outbound (from holder) channel using V1 channel establishment.
-pub(super) struct OutboundV1Channel<SP: Deref>
-where
-	SP::Target: SignerProvider,
-{
+pub(super) struct OutboundV1Channel<SP: SignerProvider> {
 	pub funding: FundingScope,
 	pub context: ChannelContext<SP>,
 	pub unfunded_context: UnfundedChannelContext,
@@ -13424,10 +13356,7 @@ where
 	pub signer_pending_open_channel: bool,
 }
 
-impl<SP: Deref> OutboundV1Channel<SP>
-where
-	SP::Target: SignerProvider,
-{
+impl<SP: SignerProvider> OutboundV1Channel<SP> {
 	pub fn abandon_unfunded_chan(&mut self, closure_reason: ClosureReason) -> ShutdownResult {
 		self.context.force_shutdown(&self.funding, closure_reason)
 	}
@@ -13663,7 +13592,7 @@ where
 		mut self, msg: &msgs::FundingSigned, best_block: BestBlock, signer_provider: &SP,
 		logger: &L,
 	) -> Result<
-		(FundedChannel<SP>, ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>),
+		(FundedChannel<SP>, ChannelMonitor<SP::EcdsaSigner>),
 		(OutboundV1Channel<SP>, ChannelError),
 	> {
 		if !self.funding.is_outbound() {
@@ -13767,10 +13696,7 @@ where
 }
 
 /// A not-yet-funded inbound (from counterparty) channel using V1 channel establishment.
-pub(super) struct InboundV1Channel<SP: Deref>
-where
-	SP::Target: SignerProvider,
-{
+pub(super) struct InboundV1Channel<SP: SignerProvider> {
 	pub funding: FundingScope,
 	pub context: ChannelContext<SP>,
 	pub unfunded_context: UnfundedChannelContext,
@@ -13808,10 +13734,7 @@ pub(super) fn channel_type_from_open_channel(
 	Ok(channel_type.clone())
 }
 
-impl<SP: Deref> InboundV1Channel<SP>
-where
-	SP::Target: SignerProvider,
-{
+impl<SP: SignerProvider> InboundV1Channel<SP> {
 	/// Creates a new channel from a remote sides' request for one.
 	/// Assumes chain_hash has already been checked and corresponds with what we expect!
 	#[rustfmt::skip]
@@ -13949,11 +13872,7 @@ where
 		mut self, msg: &msgs::FundingCreated, best_block: BestBlock, signer_provider: &SP,
 		logger: &L,
 	) -> Result<
-		(
-			FundedChannel<SP>,
-			Option<msgs::FundingSigned>,
-			ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>,
-		),
+		(FundedChannel<SP>, Option<msgs::FundingSigned>, ChannelMonitor<SP::EcdsaSigner>),
 		(Self, ChannelError),
 	> {
 		if self.funding.is_outbound() {
@@ -14058,10 +13977,7 @@ where
 }
 
 // A not-yet-funded channel using V2 channel establishment.
-pub(super) struct PendingV2Channel<SP: Deref>
-where
-	SP::Target: SignerProvider,
-{
+pub(super) struct PendingV2Channel<SP: SignerProvider> {
 	pub funding: FundingScope,
 	pub context: ChannelContext<SP>,
 	pub unfunded_context: UnfundedChannelContext,
@@ -14070,10 +13986,7 @@ where
 	pub interactive_tx_constructor: Option<InteractiveTxConstructor>,
 }
 
-impl<SP: Deref> PendingV2Channel<SP>
-where
-	SP::Target: SignerProvider,
-{
+impl<SP: SignerProvider> PendingV2Channel<SP> {
 	#[allow(dead_code)] // TODO(dual_funding): Remove once creating V2 channels is enabled.
 	#[rustfmt::skip]
 	pub fn new_outbound<ES: EntropySource, F: FeeEstimator, L: Logger>(
@@ -14480,10 +14393,7 @@ impl Readable for AnnouncementSigsState {
 	}
 }
 
-impl<SP: Deref> Writeable for FundedChannel<SP>
-where
-	SP::Target: SignerProvider,
-{
+impl<SP: SignerProvider> Writeable for FundedChannel<SP> {
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
 		// Note that we write out as if remove_uncommitted_htlcs_and_mark_paused had just been
 		// called.
@@ -14972,10 +14882,8 @@ where
 	}
 }
 
-impl<'a, 'b, 'c, ES: EntropySource, SP: Deref>
+impl<'a, 'b, 'c, ES: EntropySource, SP: SignerProvider>
 	ReadableArgs<(&'a ES, &'b SP, &'c ChannelTypeFeatures)> for FundedChannel<SP>
-where
-	SP::Target: SignerProvider,
 {
 	fn read<R: io::Read>(
 		reader: &mut R, args: (&'a ES, &'b SP, &'c ChannelTypeFeatures),
diff --git a/lightning/src/ln/channel_state.rs b/lightning/src/ln/channel_state.rs
index 7c591ff..86e53ba 100644
--- a/lightning/src/ln/channel_state.rs
+++ b/lightning/src/ln/channel_state.rs
@@ -22,8 +22,6 @@ use crate::types::features::{ChannelTypeFeatures, InitFeatures};
 use crate::types::payment::PaymentHash;
 use crate::util::config::ChannelConfig;
 
-use core::ops::Deref;
-
 /// Exposes the state of pending inbound HTLCs.
 ///
 /// At a high level, an HTLC being forwarded from one Lightning node to another Lightning node goes
@@ -524,13 +522,10 @@ impl ChannelDetails {
 		}
 	}
 
-	pub(super) fn from_channel<SP: Deref, F: FeeEstimator>(
+	pub(super) fn from_channel<SP: SignerProvider, F: FeeEstimator>(
 		channel: &Channel<SP>, best_block_height: u32, latest_features: InitFeatures,
 		fee_estimator: &LowerBoundedFeeEstimator<F>,
-	) -> Self
-	where
-		SP::Target: SignerProvider,
-	{
+	) -> Self {
 		let context = channel.context();
 		let funding = channel.funding();
 		let balance = channel.get_available_balances(fee_estimator);
diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
index 7ee7b6d..cd61a59 100644
--- a/lightning/src/ln/channelmanager.rs
+++ b/lightning/src/ln/channelmanager.rs
@@ -1549,10 +1549,7 @@ impl Readable for Option<RAAMonitorUpdateBlockingAction> {
 }
 
 /// State we hold per-peer.
-pub(super) struct PeerState<SP: Deref>
-where
-	SP::Target: SignerProvider,
-{
+pub(super) struct PeerState<SP: SignerProvider> {
 	/// `channel_id` -> `Channel`
 	///
 	/// Holds all channels where the peer is the counterparty.
@@ -1627,10 +1624,7 @@ where
 	peer_storage: Vec<u8>,
 }
 
-impl<SP: Deref> PeerState<SP>
-where
-	SP::Target: SignerProvider,
-{
+impl<SP: SignerProvider> PeerState<SP> {
 	/// Indicates that a peer meets the criteria where we're ok to remove it from our storage.
 	/// If true is passed for `require_disconnected`, the function will return false if we haven't
 	/// disconnected from the node already, ie. `PeerState::is_connected` is set to `true`.
@@ -1795,9 +1789,7 @@ pub trait AChannelManager {
 	/// A type implementing [`EcdsaChannelSigner`].
 	type Signer: EcdsaChannelSigner + Sized;
 	/// A type implementing [`SignerProvider`] for [`Self::Signer`].
-	type SignerProvider: SignerProvider<EcdsaSigner = Self::Signer> + ?Sized;
-	/// A type that may be dereferenced to [`Self::SignerProvider`].
-	type SP: Deref<Target = Self::SignerProvider>;
+	type SP: SignerProvider<EcdsaSigner = Self::Signer>;
 	/// A type implementing [`FeeEstimator`].
 	type FeeEstimator: FeeEstimator;
 	/// A type implementing [`Router`].
@@ -1827,23 +1819,21 @@ impl<
 		T: BroadcasterInterface,
 		ES: EntropySource,
 		NS: NodeSigner,
-		SP: Deref,
+		SP: SignerProvider,
 		F: FeeEstimator,
 		R: Router,
 		MR: MessageRouter,
 		L: Logger,
 	> AChannelManager for ChannelManager<M, T, ES, NS, SP, F, R, MR, L>
 where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	type Watch = M::Target;
 	type M = M;
 	type Broadcaster = T;
 	type EntropySource = ES;
 	type NodeSigner = NS;
-	type Signer = <SP::Target as SignerProvider>::EcdsaSigner;
-	type SignerProvider = SP::Target;
+	type Signer = SP::EcdsaSigner;
 	type SP = SP;
 	type FeeEstimator = F;
 	type Router = R;
@@ -2598,14 +2588,13 @@ pub struct ChannelManager<
 	T: BroadcasterInterface,
 	ES: EntropySource,
 	NS: NodeSigner,
-	SP: Deref,
+	SP: SignerProvider,
 	F: FeeEstimator,
 	R: Router,
 	MR: MessageRouter,
 	L: Logger,
 > where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	config: RwLock<UserConfig>,
 	chain_hash: ChainHash,
@@ -3381,15 +3370,14 @@ impl<
 		T: BroadcasterInterface,
 		ES: EntropySource,
 		NS: NodeSigner,
-		SP: Deref,
+		SP: SignerProvider,
 		F: FeeEstimator,
 		R: Router,
 		MR: MessageRouter,
 		L: Logger,
 	> ChannelManager<M, T, ES, NS, SP, F, R, MR, L>
 where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	/// Constructs a new `ChannelManager` to hold several channels and route between them.
 	///
@@ -4423,10 +4411,7 @@ where
 	/// The same closure semantics as described in [`ChannelManager::locked_handle_force_close`] apply.
 	fn locked_handle_unfunded_close(
 		&self, err: ChannelError, chan: &mut Channel<SP>,
-	) -> (bool, MsgHandleErrInternal)
-	where
-		SP::Target: SignerProvider,
-	{
+	) -> (bool, MsgHandleErrInternal) {
 		let chan_id = chan.context().channel_id();
 		convert_channel_err_internal(err, chan_id, |reason, msg| {
 			let logger = WithChannelContext::from(&self.logger, chan.context(), None);
@@ -13509,15 +13494,14 @@ impl<
 		T: BroadcasterInterface,
 		ES: EntropySource,
 		NS: NodeSigner,
-		SP: Deref,
+		SP: SignerProvider,
 		F: FeeEstimator,
 		R: Router,
 		MR: MessageRouter,
 		L: Logger,
 	> ChannelManager<M, T, ES, NS, SP, F, R, MR, L>
 where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	#[cfg(not(c_bindings))]
 	create_offer_builder!(self, OfferBuilder<'_, DerivedMetadata, secp256k1::All>);
@@ -14379,15 +14363,14 @@ impl<
 		T: BroadcasterInterface,
 		ES: EntropySource,
 		NS: NodeSigner,
-		SP: Deref,
+		SP: SignerProvider,
 		F: FeeEstimator,
 		R: Router,
 		MR: MessageRouter,
 		L: Logger,
 	> BaseMessageHandler for ChannelManager<M, T, ES, NS, SP, F, R, MR, L>
 where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	fn provided_node_features(&self) -> NodeFeatures {
 		provided_node_features(&self.config.read().unwrap())
@@ -14743,15 +14726,14 @@ impl<
 		T: BroadcasterInterface,
 		ES: EntropySource,
 		NS: NodeSigner,
-		SP: Deref,
+		SP: SignerProvider,
 		F: FeeEstimator,
 		R: Router,
 		MR: MessageRouter,
 		L: Logger,
 	> EventsProvider for ChannelManager<M, T, ES, NS, SP, F, R, MR, L>
 where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	/// Processes events that must be periodically handled.
 	///
@@ -14771,15 +14753,14 @@ impl<
 		T: BroadcasterInterface,
 		ES: EntropySource,
 		NS: NodeSigner,
-		SP: Deref,
+		SP: SignerProvider,
 		F: FeeEstimator,
 		R: Router,
 		MR: MessageRouter,
 		L: Logger,
 	> chain::Listen for ChannelManager<M, T, ES, NS, SP, F, R, MR, L>
 where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	fn filtered_block_connected(&self, header: &Header, txdata: &TransactionData, height: u32) {
 		{
@@ -14825,15 +14806,14 @@ impl<
 		T: BroadcasterInterface,
 		ES: EntropySource,
 		NS: NodeSigner,
-		SP: Deref,
+		SP: SignerProvider,
 		F: FeeEstimator,
 		R: Router,
 		MR: MessageRouter,
 		L: Logger,
 	> chain::Confirm for ChannelManager<M, T, ES, NS, SP, F, R, MR, L>
 where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	#[rustfmt::skip]
 	fn transactions_confirmed(&self, header: &Header, txdata: &TransactionData, height: u32) {
@@ -14991,15 +14971,14 @@ impl<
 		T: BroadcasterInterface,
 		ES: EntropySource,
 		NS: NodeSigner,
-		SP: Deref,
+		SP: SignerProvider,
 		F: FeeEstimator,
 		R: Router,
 		MR: MessageRouter,
 		L: Logger,
 	> ChannelManager<M, T, ES, NS, SP, F, R, MR, L>
 where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	/// Calls a function which handles an on-chain event (blocks dis/connected, transactions
 	/// un/confirmed, etc) on each channel, handling any resulting errors or messages generated by
@@ -15346,15 +15325,14 @@ impl<
 		T: BroadcasterInterface,
 		ES: EntropySource,
 		NS: NodeSigner,
-		SP: Deref,
+		SP: SignerProvider,
 		F: FeeEstimator,
 		R: Router,
 		MR: MessageRouter,
 		L: Logger,
 	> ChannelMessageHandler for ChannelManager<M, T, ES, NS, SP, F, R, MR, L>
 where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	fn handle_open_channel(&self, counterparty_node_id: PublicKey, message: &msgs::OpenChannel) {
 		// Note that we never need to persist the updated ChannelManager for an inbound
@@ -15914,15 +15892,14 @@ impl<
 		T: BroadcasterInterface,
 		ES: EntropySource,
 		NS: NodeSigner,
-		SP: Deref,
+		SP: SignerProvider,
 		F: FeeEstimator,
 		R: Router,
 		MR: MessageRouter,
 		L: Logger,
 	> OffersMessageHandler for ChannelManager<M, T, ES, NS, SP, F, R, MR, L>
 where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	#[rustfmt::skip]
 	fn handle_message(
@@ -16125,15 +16102,14 @@ impl<
 		T: BroadcasterInterface,
 		ES: EntropySource,
 		NS: NodeSigner,
-		SP: Deref,
+		SP: SignerProvider,
 		F: FeeEstimator,
 		R: Router,
 		MR: MessageRouter,
 		L: Logger,
 	> AsyncPaymentsMessageHandler for ChannelManager<M, T, ES, NS, SP, F, R, MR, L>
 where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	fn handle_offer_paths_request(
 		&self, message: OfferPathsRequest, context: AsyncPaymentsContext,
@@ -16363,15 +16339,14 @@ impl<
 		T: BroadcasterInterface,
 		ES: EntropySource,
 		NS: NodeSigner,
-		SP: Deref,
+		SP: SignerProvider,
 		F: FeeEstimator,
 		R: Router,
 		MR: MessageRouter,
 		L: Logger,
 	> DNSResolverMessageHandler for ChannelManager<M, T, ES, NS, SP, F, R, MR, L>
 where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	fn handle_dnssec_query(
 		&self, _message: DNSSECQuery, _responder: Option<Responder>,
@@ -16424,15 +16399,14 @@ impl<
 		T: BroadcasterInterface,
 		ES: EntropySource,
 		NS: NodeSigner,
-		SP: Deref,
+		SP: SignerProvider,
 		F: FeeEstimator,
 		R: Router,
 		MR: MessageRouter,
 		L: Logger,
 	> NodeIdLookUp for ChannelManager<M, T, ES, NS, SP, F, R, MR, L>
 where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	fn next_node_id(&self, short_channel_id: u64) -> Option<PublicKey> {
 		self.short_to_chan_info.read().unwrap().get(&short_channel_id).map(|(pubkey, _)| *pubkey)
@@ -16933,15 +16907,14 @@ impl<
 		T: BroadcasterInterface,
 		ES: EntropySource,
 		NS: NodeSigner,
-		SP: Deref,
+		SP: SignerProvider,
 		F: FeeEstimator,
 		R: Router,
 		MR: MessageRouter,
 		L: Logger,
 	> Writeable for ChannelManager<M, T, ES, NS, SP, F, R, MR, L>
 where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	#[rustfmt::skip]
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
@@ -17293,14 +17266,13 @@ pub struct ChannelManagerReadArgs<
 	T: BroadcasterInterface,
 	ES: EntropySource,
 	NS: NodeSigner,
-	SP: Deref,
+	SP: SignerProvider,
 	F: FeeEstimator,
 	R: Router,
 	MR: MessageRouter,
 	L: Logger + Clone,
 > where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	/// A cryptographically secure source of entropy.
 	pub entropy_source: ES,
@@ -17356,8 +17328,7 @@ pub struct ChannelManagerReadArgs<
 	/// this struct.
 	///
 	/// This is not exported to bindings users because we have no HashMap bindings
-	pub channel_monitors:
-		HashMap<ChannelId, &'a ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>>,
+	pub channel_monitors: HashMap<ChannelId, &'a ChannelMonitor<SP::EcdsaSigner>>,
 }
 
 impl<
@@ -17366,15 +17337,14 @@ impl<
 		T: BroadcasterInterface,
 		ES: EntropySource,
 		NS: NodeSigner,
-		SP: Deref,
+		SP: SignerProvider,
 		F: FeeEstimator,
 		R: Router,
 		MR: MessageRouter,
 		L: Logger + Clone,
 	> ChannelManagerReadArgs<'a, M, T, ES, NS, SP, F, R, MR, L>
 where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	/// Simple utility function to create a ChannelManagerReadArgs which creates the monitor
 	/// HashMap for you. This is primarily useful for C bindings where it is not practical to
@@ -17382,8 +17352,7 @@ where
 	pub fn new(
 		entropy_source: ES, node_signer: NS, signer_provider: SP, fee_estimator: F,
 		chain_monitor: M, tx_broadcaster: T, router: R, message_router: MR, logger: L,
-		config: UserConfig,
-		mut channel_monitors: Vec<&'a ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>>,
+		config: UserConfig, mut channel_monitors: Vec<&'a ChannelMonitor<SP::EcdsaSigner>>,
 	) -> Self {
 		Self {
 			entropy_source,
@@ -17445,7 +17414,7 @@ impl<
 		T: BroadcasterInterface,
 		ES: EntropySource,
 		NS: NodeSigner,
-		SP: Deref,
+		SP: SignerProvider,
 		F: FeeEstimator,
 		R: Router,
 		MR: MessageRouter,
@@ -17453,8 +17422,7 @@ impl<
 	> ReadableArgs<ChannelManagerReadArgs<'a, M, T, ES, NS, SP, F, R, MR, L>>
 	for (BlockHash, Arc<ChannelManager<M, T, ES, NS, SP, F, R, MR, L>>)
 where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	fn read<Reader: io::Read>(
 		reader: &mut Reader, args: ChannelManagerReadArgs<'a, M, T, ES, NS, SP, F, R, MR, L>,
@@ -17471,7 +17439,7 @@ impl<
 		T: BroadcasterInterface,
 		ES: EntropySource,
 		NS: NodeSigner,
-		SP: Deref,
+		SP: SignerProvider,
 		F: FeeEstimator,
 		R: Router,
 		MR: MessageRouter,
@@ -17479,8 +17447,7 @@ impl<
 	> ReadableArgs<ChannelManagerReadArgs<'a, M, T, ES, NS, SP, F, R, MR, L>>
 	for (BlockHash, ChannelManager<M, T, ES, NS, SP, F, R, MR, L>)
 where
-	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
-	SP::Target: SignerProvider,
+	M::Target: chain::Watch<SP::EcdsaSigner>,
 {
 	fn read<Reader: io::Read>(
 		reader: &mut Reader, mut args: ChannelManagerReadArgs<'a, M, T, ES, NS, SP, F, R, MR, L>,
diff --git a/lightning/src/sign/mod.rs b/lightning/src/sign/mod.rs
index fea2062..f4f4c5c 100644
--- a/lightning/src/sign/mod.rs
+++ b/lightning/src/sign/mod.rs
@@ -1082,6 +1082,13 @@ pub type DynSignerProvider =
 pub type DynSignerProvider = dyn SignerProvider<EcdsaSigner = InMemorySigner>;
 
 /// A trait that can return signer instances for individual channels.
+///
+/// Instantiations of this trait should generally be shared by reference across the lightning
+/// node's components. E.g., it would be unsafe to provide a different [`SignerProvider`] to
+/// [`ChannelManager`] vs [`MonitorUpdatingPersister`].
+///
+/// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+/// [`MonitorUpdatingPersister`]: crate::util::persist::MonitorUpdatingPersister
 pub trait SignerProvider {
 	/// A type which implements [`EcdsaChannelSigner`] which will be returned by [`Self::derive_channel_signer`].
 	type EcdsaSigner: EcdsaChannelSigner;
@@ -1125,6 +1132,28 @@ pub trait SignerProvider {
 	fn get_shutdown_scriptpubkey(&self) -> Result<ShutdownScript, ()>;
 }
 
+impl<T: SignerProvider + ?Sized, SP: Deref<Target = T>> SignerProvider for SP {
+	type EcdsaSigner = T::EcdsaSigner;
+	#[cfg(taproot)]
+	type TaprootSigner = T::TaprootSigner;
+
+	fn generate_channel_keys_id(&self, inbound: bool, user_channel_id: u128) -> [u8; 32] {
+		self.deref().generate_channel_keys_id(inbound, user_channel_id)
+	}
+
+	fn derive_channel_signer(&self, channel_keys_id: [u8; 32]) -> Self::EcdsaSigner {
+		self.deref().derive_channel_signer(channel_keys_id)
+	}
+
+	fn get_destination_script(&self, channel_keys_id: [u8; 32]) -> Result<ScriptBuf, ()> {
+		self.deref().get_destination_script(channel_keys_id)
+	}
+
+	fn get_shutdown_scriptpubkey(&self) -> Result<ShutdownScript, ()> {
+		self.deref().get_shutdown_scriptpubkey()
+	}
+}
+
 /// A helper trait that describes an on-chain wallet capable of returning a (change) destination
 /// script.
 ///
diff --git a/lightning/src/sign/type_resolver.rs b/lightning/src/sign/type_resolver.rs
index a84886c..405e346 100644
--- a/lightning/src/sign/type_resolver.rs
+++ b/lightning/src/sign/type_resolver.rs
@@ -1,32 +1,21 @@
 use crate::sign::{ChannelSigner, SignerProvider};
-use core::ops::Deref;
 
-pub(crate) enum ChannelSignerType<SP: Deref>
-where
-	SP::Target: SignerProvider,
-{
+pub(crate) enum ChannelSignerType<SP: SignerProvider> {
 	// in practice, this will only ever be an EcdsaChannelSigner (specifically, Writeable)
-	Ecdsa(<SP::Target as SignerProvider>::EcdsaSigner),
+	Ecdsa(SP::EcdsaSigner),
 	#[cfg(taproot)]
 	#[allow(unused)]
-	Taproot(<SP::Target as SignerProvider>::TaprootSigner),
+	Taproot(SP::TaprootSigner),
 }
 
 #[cfg(test)]
-impl<SP> std::fmt::Debug for ChannelSignerType<SP>
-where
-	SP: Deref,
-	SP::Target: SignerProvider,
-{
+impl<SP: SignerProvider> std::fmt::Debug for ChannelSignerType<SP> {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		f.debug_struct("ChannelSignerType").finish()
 	}
 }
 
-impl<SP: Deref> ChannelSignerType<SP>
-where
-	SP::Target: SignerProvider,
-{
+impl<SP: SignerProvider> ChannelSignerType<SP> {
 	pub(crate) fn as_ref(&self) -> &dyn ChannelSigner {
 		match self {
 			ChannelSignerType::Ecdsa(ecs) => ecs,
@@ -37,7 +26,7 @@ where
 	}
 
 	#[allow(unused)]
-	pub(crate) fn as_ecdsa(&self) -> Option<&<SP::Target as SignerProvider>::EcdsaSigner> {
+	pub(crate) fn as_ecdsa(&self) -> Option<&SP::EcdsaSigner> {
 		match self {
 			ChannelSignerType::Ecdsa(ecs) => Some(ecs),
 			_ => None,
@@ -45,9 +34,7 @@ where
 	}
 
 	#[allow(unused)]
-	pub(crate) fn as_mut_ecdsa(
-		&mut self,
-	) -> Option<&mut <SP::Target as SignerProvider>::EcdsaSigner> {
+	pub(crate) fn as_mut_ecdsa(&mut self) -> Option<&mut SP::EcdsaSigner> {
 		match self {
 			ChannelSignerType::Ecdsa(ecs) => Some(ecs),
 			_ => None,
diff --git a/lightning/src/util/persist.rs b/lightning/src/util/persist.rs
index a71e634..7742abf 100644
--- a/lightning/src/util/persist.rs
+++ b/lightning/src/util/persist.rs
@@ -445,12 +445,11 @@ impl<ChannelSigner: EcdsaChannelSigner, K: KVStoreSync + ?Sized> Persist<Channel
 }
 
 /// Read previously persisted [`ChannelMonitor`]s from the store.
-pub fn read_channel_monitors<K: Deref, ES: EntropySource, SP: Deref>(
+pub fn read_channel_monitors<K: Deref, ES: EntropySource, SP: SignerProvider>(
 	kv_store: K, entropy_source: ES, signer_provider: SP,
-) -> Result<Vec<(BlockHash, ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>)>, io::Error>
+) -> Result<Vec<(BlockHash, ChannelMonitor<SP::EcdsaSigner>)>, io::Error>
 where
 	K::Target: KVStoreSync,
-	SP::Target: SignerProvider + Sized,
 {
 	let mut res = Vec::new();
 
@@ -458,13 +457,13 @@ where
 		CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE,
 		CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE,
 	)? {
-		match <Option<(BlockHash, ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>)>>::read(
+		match <Option<(BlockHash, ChannelMonitor<SP::EcdsaSigner>)>>::read(
 			&mut io::Cursor::new(kv_store.read(
 				CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE,
 				CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE,
 				&stored_key,
 			)?),
-			(&entropy_source, &*signer_provider),
+			(&entropy_source, &signer_provider),
 		) {
 			Ok(Some((block_hash, channel_monitor))) => {
 				let monitor_name = MonitorName::from_str(&stored_key)?;
@@ -591,25 +590,23 @@ pub struct MonitorUpdatingPersister<
 	K: Deref,
 	L: Logger,
 	ES: EntropySource,
-	SP: Deref,
+	SP: SignerProvider,
 	BI: BroadcasterInterface,
 	FE: FeeEstimator,
 >(MonitorUpdatingPersisterAsync<KVStoreSyncWrapper<K>, PanicingSpawner, L, ES, SP, BI, FE>)
 where
-	K::Target: KVStoreSync,
-	SP::Target: SignerProvider + Sized;
+	K::Target: KVStoreSync;
 
 impl<
 		K: Deref,
 		L: Logger,
 		ES: EntropySource,
-		SP: Deref,
+		SP: SignerProvider,
 		BI: BroadcasterInterface,
 		FE: FeeEstimator,
 	> MonitorUpdatingPersister<K, L, ES, SP, BI, FE>
 where
 	K::Target: KVStoreSync,
-	SP::Target: SignerProvider + Sized,
 {
 	/// Constructs a new [`MonitorUpdatingPersister`].
 	///
@@ -653,10 +650,7 @@ where
 	/// Reads all stored channel monitors, along with any stored updates for them.
 	pub fn read_all_channel_monitors_with_updates(
 		&self,
-	) -> Result<
-		Vec<(BlockHash, ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>)>,
-		io::Error,
-	> {
+	) -> Result<Vec<(BlockHash, ChannelMonitor<SP::EcdsaSigner>)>, io::Error> {
 		poll_sync_future(self.0.read_all_channel_monitors_with_updates())
 	}
 
@@ -677,8 +671,7 @@ where
 	/// function to accomplish this. Take care to limit the number of parallel readers.
 	pub fn read_channel_monitor_with_updates(
 		&self, monitor_key: &str,
-	) -> Result<(BlockHash, ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>), io::Error>
-	{
+	) -> Result<(BlockHash, ChannelMonitor<SP::EcdsaSigner>), io::Error> {
 		poll_sync_future(self.0.read_channel_monitor_with_updates(monitor_key))
 	}
 
@@ -698,13 +691,12 @@ impl<
 		K: Deref,
 		L: Logger,
 		ES: EntropySource,
-		SP: Deref,
+		SP: SignerProvider,
 		BI: BroadcasterInterface,
 		FE: FeeEstimator,
 	> Persist<ChannelSigner> for MonitorUpdatingPersister<K, L, ES, SP, BI, FE>
 where
 	K::Target: KVStoreSync,
-	SP::Target: SignerProvider + Sized,
 {
 	/// Persists a new channel. This means writing the entire monitor to the
 	/// parametrized [`KVStoreSync`].
@@ -780,25 +772,23 @@ pub struct MonitorUpdatingPersisterAsync<
 	S: FutureSpawner,
 	L: Logger,
 	ES: EntropySource,
-	SP: Deref,
+	SP: SignerProvider,
 	BI: BroadcasterInterface,
 	FE: FeeEstimator,
 >(Arc<MonitorUpdatingPersisterAsyncInner<K, S, L, ES, SP, BI, FE>>)
 where
-	K::Target: KVStore,
-	SP::Target: SignerProvider + Sized;
+	K::Target: KVStore;
 
 struct MonitorUpdatingPersisterAsyncInner<
 	K: Deref,
 	S: FutureSpawner,
 	L: Logger,
 	ES: EntropySource,
-	SP: Deref,
+	SP: SignerProvider,
 	BI: BroadcasterInterface,
 	FE: FeeEstimator,
 > where
 	K::Target: KVStore,
-	SP::Target: SignerProvider + Sized,
 {
 	kv_store: K,
 	async_completed_updates: Mutex<Vec<(ChannelId, u64)>>,
@@ -816,13 +806,12 @@ impl<
 		S: FutureSpawner,
 		L: Logger,
 		ES: EntropySource,
-		SP: Deref,
+		SP: SignerProvider,
 		BI: BroadcasterInterface,
 		FE: FeeEstimator,
 	> MonitorUpdatingPersisterAsync<K, S, L, ES, SP, BI, FE>
 where
 	K::Target: KVStore,
-	SP::Target: SignerProvider + Sized,
 {
 	/// Constructs a new [`MonitorUpdatingPersisterAsync`].
 	///
@@ -855,10 +844,7 @@ where
 	/// deserialization as well.
 	pub async fn read_all_channel_monitors_with_updates(
 		&self,
-	) -> Result<
-		Vec<(BlockHash, ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>)>,
-		io::Error,
-	> {
+	) -> Result<Vec<(BlockHash, ChannelMonitor<SP::EcdsaSigner>)>, io::Error> {
 		let primary = CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE;
 		let secondary = CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE;
 		let monitor_list = self.0.kv_store.list(primary, secondary).await?;
@@ -889,10 +875,7 @@ where
 	/// `Arc` that can live for `'static` and be sent and accessed across threads.
 	pub async fn read_all_channel_monitors_with_updates_parallel(
 		self: &Arc<Self>,
-	) -> Result<
-		Vec<(BlockHash, ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>)>,
-		io::Error,
-	>
+	) -> Result<Vec<(BlockHash, ChannelMonitor<SP::EcdsaSigner>)>, io::Error>
 	where
 		K: MaybeSend + MaybeSync + 'static,
 		L: MaybeSend + MaybeSync + 'static,
@@ -900,7 +883,7 @@ where
 		SP: MaybeSend + MaybeSync + 'static,
 		BI: MaybeSend + MaybeSync + 'static,
 		FE: MaybeSend + MaybeSync + 'static,
-		<SP::Target as SignerProvider>::EcdsaSigner: MaybeSend,
+		SP::EcdsaSigner: MaybeSend,
 	{
 		let primary = CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE;
 		let secondary = CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE;
@@ -942,8 +925,7 @@ where
 	/// function to accomplish this. Take care to limit the number of parallel readers.
 	pub async fn read_channel_monitor_with_updates(
 		&self, monitor_key: &str,
-	) -> Result<(BlockHash, ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>), io::Error>
-	{
+	) -> Result<(BlockHash, ChannelMonitor<SP::EcdsaSigner>), io::Error> {
 		self.0.read_channel_monitor_with_updates(monitor_key).await
 	}
 
@@ -963,18 +945,16 @@ impl<
 		S: FutureSpawner,
 		L: Logger + MaybeSend + MaybeSync + 'static,
 		ES: EntropySource + MaybeSend + MaybeSync + 'static,
-		SP: Deref + MaybeSend + MaybeSync + 'static,
+		SP: SignerProvider + MaybeSend + MaybeSync + 'static,
 		BI: BroadcasterInterface + MaybeSend + MaybeSync + 'static,
 		FE: FeeEstimator + MaybeSend + MaybeSync + 'static,
 	> MonitorUpdatingPersisterAsync<K, S, L, ES, SP, BI, FE>
 where
 	K::Target: KVStore + MaybeSync,
-	SP::Target: SignerProvider + Sized,
-	<SP::Target as SignerProvider>::EcdsaSigner: MaybeSend + 'static,
+	SP::EcdsaSigner: MaybeSend + 'static,
 {
 	pub(crate) fn spawn_async_persist_new_channel(
-		&self, monitor_name: MonitorName,
-		monitor: &ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>,
+		&self, monitor_name: MonitorName, monitor: &ChannelMonitor<SP::EcdsaSigner>,
 		notifier: Arc<Notifier>,
 	) {
 		let inner = Arc::clone(&self.0);
@@ -1001,8 +981,7 @@ where
 
 	pub(crate) fn spawn_async_update_channel(
 		&self, monitor_name: MonitorName, update: Option<&ChannelMonitorUpdate>,
-		monitor: &ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>,
-		notifier: Arc<Notifier>,
+		monitor: &ChannelMonitor<SP::EcdsaSigner>, notifier: Arc<Notifier>,
 	) {
 		let inner = Arc::clone(&self.0);
 		// Note that `update_persisted_channel` is a sync method which calls all the way through to
@@ -1051,18 +1030,16 @@ impl<
 		S: FutureSpawner,
 		L: Logger,
 		ES: EntropySource,
-		SP: Deref,
+		SP: SignerProvider,
 		BI: BroadcasterInterface,
 		FE: FeeEstimator,
 	> MonitorUpdatingPersisterAsyncInner<K, S, L, ES, SP, BI, FE>
 where
 	K::Target: KVStore,
-	SP::Target: SignerProvider + Sized,
 {
 	pub async fn read_channel_monitor_with_updates(
 		&self, monitor_key: &str,
-	) -> Result<(BlockHash, ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>), io::Error>
-	{
+	) -> Result<(BlockHash, ChannelMonitor<SP::EcdsaSigner>), io::Error> {
 		match self.maybe_read_channel_monitor_with_updates(monitor_key).await? {
 			Some(res) => Ok(res),
 			None => Err(io::Error::new(
@@ -1079,10 +1056,7 @@ where
 
 	async fn maybe_read_channel_monitor_with_updates(
 		&self, monitor_key: &str,
-	) -> Result<
-		Option<(BlockHash, ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>)>,
-		io::Error,
-	> {
+	) -> Result<Option<(BlockHash, ChannelMonitor<SP::EcdsaSigner>)>, io::Error> {
 		let monitor_name = MonitorName::from_str(monitor_key)?;
 		let read_future = pin!(self.maybe_read_monitor(&monitor_name, monitor_key));
 		let list_future = pin!(self
@@ -1126,10 +1100,7 @@ where
 	/// Read a channel monitor.
 	async fn maybe_read_monitor(
 		&self, monitor_name: &MonitorName, monitor_key: &str,
-	) -> Result<
-		Option<(BlockHash, ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>)>,
-		io::Error,
-	> {
+	) -> Result<Option<(BlockHash, ChannelMonitor<SP::EcdsaSigner>)>, io::Error> {
 		let primary = CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE;
 		let secondary = CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE;
 		let monitor_bytes = self.kv_store.read(primary, secondary, monitor_key).await?;
@@ -1138,9 +1109,9 @@ where
 		if monitor_cursor.get_ref().starts_with(MONITOR_UPDATING_PERSISTER_PREPEND_SENTINEL) {
 			monitor_cursor.set_position(MONITOR_UPDATING_PERSISTER_PREPEND_SENTINEL.len() as u64);
 		}
-		match <Option<(BlockHash, ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>)>>::read(
+		match <Option<(BlockHash, ChannelMonitor<SP::EcdsaSigner>)>>::read(
 			&mut monitor_cursor,
-			(&self.entropy_source, &*self.signer_provider),
+			(&self.entropy_source, &self.signer_provider),
 		) {
 			Ok(None) => Ok(None),
 			Ok(Some((blockhash, channel_monitor))) => {