Drop Deref indirection for message handler traits

diff --git a/lightning-background-processor/src/lib.rs b/lightning-background-processor/src/lib.rs
index a67657b..4c41a2c 100644
--- a/lightning-background-processor/src/lib.rs
+++ b/lightning-background-processor/src/lib.rs
@@ -417,14 +417,10 @@ pub const NO_ONION_MESSENGER: Option<
 				Logger = &'static (dyn Logger + Send + Sync),
 				NL = &'static DynChannelManager,
 				MessageRouter = &'static DynMessageRouter,
-				OffersMessageHandler = lightning::ln::peer_handler::IgnoringMessageHandler,
-				OMH = &'static lightning::ln::peer_handler::IgnoringMessageHandler,
-				AsyncPaymentsMessageHandler = lightning::ln::peer_handler::IgnoringMessageHandler,
-				APH = &'static lightning::ln::peer_handler::IgnoringMessageHandler,
-				DNSResolverMessageHandler = lightning::ln::peer_handler::IgnoringMessageHandler,
-				DRH = &'static lightning::ln::peer_handler::IgnoringMessageHandler,
-				CustomOnionMessageHandler = lightning::ln::peer_handler::IgnoringMessageHandler,
-				CMH = &'static lightning::ln::peer_handler::IgnoringMessageHandler,
+				OMH = lightning::ln::peer_handler::IgnoringMessageHandler,
+				APH = lightning::ln::peer_handler::IgnoringMessageHandler,
+				DRH = lightning::ln::peer_handler::IgnoringMessageHandler,
+				CMH = lightning::ln::peer_handler::IgnoringMessageHandler,
 			> + Send
 			+ Sync,
 	>,
diff --git a/lightning-dns-resolver/src/lib.rs b/lightning-dns-resolver/src/lib.rs
index 900672d..e957884 100644
--- a/lightning-dns-resolver/src/lib.rs
+++ b/lightning-dns-resolver/src/lib.rs
@@ -6,7 +6,6 @@
 #![deny(rustdoc::private_intra_doc_links)]
 
 use std::net::SocketAddr;
-use std::ops::Deref;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex};
 
@@ -30,10 +29,7 @@ const WE_REQUIRE_32_OR_64_BIT_USIZE: u8 = 424242;
 
 /// A resolver which implements [`DNSResolverMessageHandler`] and replies to [`DNSSECQuery`]
 /// messages with with [`DNSSECProof`]s.
-pub struct OMDomainResolver<PH: Deref>
-where
-	PH::Target: DNSResolverMessageHandler,
-{
+pub struct OMDomainResolver<PH: DNSResolverMessageHandler> {
 	state: Arc<OMResolverState>,
 	proof_handler: Option<PH>,
 	runtime_handle: Mutex<Option<Handle>>,
@@ -56,10 +52,7 @@ impl OMDomainResolver<IgnoringMessageHandler> {
 	}
 }
 
-impl<PH: Deref> OMDomainResolver<PH>
-where
-	PH::Target: DNSResolverMessageHandler,
-{
+impl<PH: DNSResolverMessageHandler> OMDomainResolver<PH> {
 	/// Creates a new [`OMDomainResolver`] given the [`SocketAddr`] of a DNS resolver listening on
 	/// TCP (e.g. 8.8.8.8:53, 1.1.1.1:53 or your local DNS resolver).
 	///
@@ -103,10 +96,7 @@ where
 	}
 }
 
-impl<PH: Deref> DNSResolverMessageHandler for OMDomainResolver<PH>
-where
-	PH::Target: DNSResolverMessageHandler,
-{
+impl<PH: DNSResolverMessageHandler> DNSResolverMessageHandler for OMDomainResolver<PH> {
 	fn handle_dnssec_proof(&self, proof: DNSSECProof, context: DNSResolverContext) {
 		if let Some(proof_handler) = &self.proof_handler {
 			proof_handler.handle_dnssec_proof(proof, context);
@@ -169,7 +159,6 @@ mod test {
 	use lightning::ln::msgs::{
 		BaseMessageHandler, ChannelMessageHandler, Init, OnionMessageHandler,
 	};
-	use lightning::ln::peer_handler::IgnoringMessageHandler;
 	use lightning::offers::offer::Offer;
 	use lightning::onion_message::dns_resolution::{HumanReadableName, OMNameResolver};
 	use lightning::onion_message::messenger::{
@@ -184,7 +173,6 @@ mod test {
 	use lightning::expect_payment_claimed;
 	use lightning_types::string::UntrustedString;
 
-	use std::ops::Deref;
 	use std::sync::Mutex;
 	use std::time::{Duration, Instant, SystemTime};
 
diff --git a/lightning/src/ln/msgs.rs b/lightning/src/ln/msgs.rs
index 2f7d1c4..b11a0b8 100644
--- a/lightning/src/ln/msgs.rs
+++ b/lightning/src/ln/msgs.rs
@@ -50,6 +50,7 @@ use crate::io_extras::read_to_end;
 use core::fmt;
 use core::fmt::Debug;
 use core::fmt::Display;
+use core::ops::Deref;
 #[cfg(feature = "std")]
 use core::str::FromStr;
 #[cfg(feature = "std")]
@@ -2074,6 +2075,26 @@ pub trait BaseMessageHandler {
 		-> Result<(), ()>;
 }
 
+impl<T: BaseMessageHandler + ?Sized, B: Deref<Target = T>> BaseMessageHandler for B {
+	fn get_and_clear_pending_msg_events(&self) -> Vec<MessageSendEvent> {
+		self.deref().get_and_clear_pending_msg_events()
+	}
+	fn peer_disconnected(&self, their_node_id: PublicKey) {
+		self.deref().peer_disconnected(their_node_id)
+	}
+	fn provided_node_features(&self) -> NodeFeatures {
+		self.deref().provided_node_features()
+	}
+	fn provided_init_features(&self, their_node_id: PublicKey) -> InitFeatures {
+		self.deref().provided_init_features(their_node_id)
+	}
+	fn peer_connected(
+		&self, their_node_id: PublicKey, msg: &Init, inbound: bool,
+	) -> Result<(), ()> {
+		self.deref().peer_connected(their_node_id, msg, inbound)
+	}
+}
+
 /// A trait to describe an object which can receive channel messages.
 ///
 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however
@@ -2214,6 +2235,137 @@ pub trait ChannelMessageHandler: BaseMessageHandler {
 	fn message_received(&self);
 }
 
+impl<T: ChannelMessageHandler + ?Sized, C: Deref<Target = T>> ChannelMessageHandler for C {
+	fn handle_open_channel(&self, their_node_id: PublicKey, msg: &OpenChannel) {
+		self.deref().handle_open_channel(their_node_id, msg)
+	}
+	fn handle_open_channel_v2(&self, their_node_id: PublicKey, msg: &OpenChannelV2) {
+		self.deref().handle_open_channel_v2(their_node_id, msg)
+	}
+	fn handle_accept_channel(&self, their_node_id: PublicKey, msg: &AcceptChannel) {
+		self.deref().handle_accept_channel(their_node_id, msg)
+	}
+	fn handle_accept_channel_v2(&self, their_node_id: PublicKey, msg: &AcceptChannelV2) {
+		self.deref().handle_accept_channel_v2(their_node_id, msg)
+	}
+	fn handle_funding_created(&self, their_node_id: PublicKey, msg: &FundingCreated) {
+		self.deref().handle_funding_created(their_node_id, msg)
+	}
+	fn handle_funding_signed(&self, their_node_id: PublicKey, msg: &FundingSigned) {
+		self.deref().handle_funding_signed(their_node_id, msg)
+	}
+	fn handle_channel_ready(&self, their_node_id: PublicKey, msg: &ChannelReady) {
+		self.deref().handle_channel_ready(their_node_id, msg)
+	}
+	fn handle_peer_storage(&self, their_node_id: PublicKey, msg: PeerStorage) {
+		self.deref().handle_peer_storage(their_node_id, msg)
+	}
+	fn handle_peer_storage_retrieval(&self, their_node_id: PublicKey, msg: PeerStorageRetrieval) {
+		self.deref().handle_peer_storage_retrieval(their_node_id, msg)
+	}
+	fn handle_shutdown(&self, their_node_id: PublicKey, msg: &Shutdown) {
+		self.deref().handle_shutdown(their_node_id, msg)
+	}
+	fn handle_closing_signed(&self, their_node_id: PublicKey, msg: &ClosingSigned) {
+		self.deref().handle_closing_signed(their_node_id, msg)
+	}
+	#[cfg(simple_close)]
+	fn handle_closing_complete(&self, their_node_id: PublicKey, msg: ClosingComplete) {
+		self.deref().handle_closing_complete(their_node_id, msg)
+	}
+	#[cfg(simple_close)]
+	fn handle_closing_sig(&self, their_node_id: PublicKey, msg: ClosingSig) {
+		self.deref().handle_closing_sig(their_node_id, msg)
+	}
+	fn handle_stfu(&self, their_node_id: PublicKey, msg: &Stfu) {
+		self.deref().handle_stfu(their_node_id, msg)
+	}
+	fn handle_splice_init(&self, their_node_id: PublicKey, msg: &SpliceInit) {
+		self.deref().handle_splice_init(their_node_id, msg)
+	}
+	fn handle_splice_ack(&self, their_node_id: PublicKey, msg: &SpliceAck) {
+		self.deref().handle_splice_ack(their_node_id, msg)
+	}
+	fn handle_splice_locked(&self, their_node_id: PublicKey, msg: &SpliceLocked) {
+		self.deref().handle_splice_locked(their_node_id, msg)
+	}
+	fn handle_tx_add_input(&self, their_node_id: PublicKey, msg: &TxAddInput) {
+		self.deref().handle_tx_add_input(their_node_id, msg)
+	}
+	fn handle_tx_add_output(&self, their_node_id: PublicKey, msg: &TxAddOutput) {
+		self.deref().handle_tx_add_output(their_node_id, msg)
+	}
+	fn handle_tx_remove_input(&self, their_node_id: PublicKey, msg: &TxRemoveInput) {
+		self.deref().handle_tx_remove_input(their_node_id, msg)
+	}
+	fn handle_tx_remove_output(&self, their_node_id: PublicKey, msg: &TxRemoveOutput) {
+		self.deref().handle_tx_remove_output(their_node_id, msg)
+	}
+	fn handle_tx_complete(&self, their_node_id: PublicKey, msg: &TxComplete) {
+		self.deref().handle_tx_complete(their_node_id, msg)
+	}
+	fn handle_tx_signatures(&self, their_node_id: PublicKey, msg: &TxSignatures) {
+		self.deref().handle_tx_signatures(their_node_id, msg)
+	}
+	fn handle_tx_init_rbf(&self, their_node_id: PublicKey, msg: &TxInitRbf) {
+		self.deref().handle_tx_init_rbf(their_node_id, msg)
+	}
+	fn handle_tx_ack_rbf(&self, their_node_id: PublicKey, msg: &TxAckRbf) {
+		self.deref().handle_tx_ack_rbf(their_node_id, msg)
+	}
+	fn handle_tx_abort(&self, their_node_id: PublicKey, msg: &TxAbort) {
+		self.deref().handle_tx_abort(their_node_id, msg)
+	}
+	fn handle_update_add_htlc(&self, their_node_id: PublicKey, msg: &UpdateAddHTLC) {
+		self.deref().handle_update_add_htlc(their_node_id, msg)
+	}
+	fn handle_update_fulfill_htlc(&self, their_node_id: PublicKey, msg: UpdateFulfillHTLC) {
+		self.deref().handle_update_fulfill_htlc(their_node_id, msg)
+	}
+	fn handle_update_fail_htlc(&self, their_node_id: PublicKey, msg: &UpdateFailHTLC) {
+		self.deref().handle_update_fail_htlc(their_node_id, msg)
+	}
+	fn handle_update_fail_malformed_htlc(
+		&self, their_node_id: PublicKey, msg: &UpdateFailMalformedHTLC,
+	) {
+		self.deref().handle_update_fail_malformed_htlc(their_node_id, msg)
+	}
+	fn handle_commitment_signed(&self, their_node_id: PublicKey, msg: &CommitmentSigned) {
+		self.deref().handle_commitment_signed(their_node_id, msg)
+	}
+	fn handle_commitment_signed_batch(
+		&self, their_node_id: PublicKey, channel_id: ChannelId, batch: Vec<CommitmentSigned>,
+	) {
+		self.deref().handle_commitment_signed_batch(their_node_id, channel_id, batch)
+	}
+	fn handle_revoke_and_ack(&self, their_node_id: PublicKey, msg: &RevokeAndACK) {
+		self.deref().handle_revoke_and_ack(their_node_id, msg)
+	}
+	fn handle_update_fee(&self, their_node_id: PublicKey, msg: &UpdateFee) {
+		self.deref().handle_update_fee(their_node_id, msg)
+	}
+	fn handle_announcement_signatures(
+		&self, their_node_id: PublicKey, msg: &AnnouncementSignatures,
+	) {
+		self.deref().handle_announcement_signatures(their_node_id, msg)
+	}
+	fn handle_channel_reestablish(&self, their_node_id: PublicKey, msg: &ChannelReestablish) {
+		self.deref().handle_channel_reestablish(their_node_id, msg)
+	}
+	fn handle_channel_update(&self, their_node_id: PublicKey, msg: &ChannelUpdate) {
+		self.deref().handle_channel_update(their_node_id, msg)
+	}
+	fn handle_error(&self, their_node_id: PublicKey, msg: &ErrorMessage) {
+		self.deref().handle_error(their_node_id, msg)
+	}
+	fn get_chain_hashes(&self) -> Option<Vec<ChainHash>> {
+		self.deref().get_chain_hashes()
+	}
+	fn message_received(&self) {
+		self.deref().message_received()
+	}
+}
+
 /// A trait to describe an object which can receive routing messages.
 ///
 /// # Implementor DoS Warnings
@@ -2288,6 +2440,57 @@ pub trait RoutingMessageHandler: BaseMessageHandler {
 	fn processing_queue_high(&self) -> bool;
 }
 
+impl<T: RoutingMessageHandler + ?Sized, R: Deref<Target = T>> RoutingMessageHandler for R {
+	fn handle_node_announcement(
+		&self, their_node_id: Option<PublicKey>, msg: &NodeAnnouncement,
+	) -> Result<bool, LightningError> {
+		self.deref().handle_node_announcement(their_node_id, msg)
+	}
+	fn handle_channel_announcement(
+		&self, their_node_id: Option<PublicKey>, msg: &ChannelAnnouncement,
+	) -> Result<bool, LightningError> {
+		self.deref().handle_channel_announcement(their_node_id, msg)
+	}
+	fn handle_channel_update(
+		&self, their_node_id: Option<PublicKey>, msg: &ChannelUpdate,
+	) -> Result<Option<(NodeId, NodeId)>, LightningError> {
+		self.deref().handle_channel_update(their_node_id, msg)
+	}
+	fn get_next_channel_announcement(
+		&self, starting_point: u64,
+	) -> Option<(ChannelAnnouncement, Option<ChannelUpdate>, Option<ChannelUpdate>)> {
+		self.deref().get_next_channel_announcement(starting_point)
+	}
+	fn get_next_node_announcement(
+		&self, starting_point: Option<&NodeId>,
+	) -> Option<NodeAnnouncement> {
+		self.deref().get_next_node_announcement(starting_point)
+	}
+	fn handle_reply_channel_range(
+		&self, their_node_id: PublicKey, msg: ReplyChannelRange,
+	) -> Result<(), LightningError> {
+		self.deref().handle_reply_channel_range(their_node_id, msg)
+	}
+	fn handle_reply_short_channel_ids_end(
+		&self, their_node_id: PublicKey, msg: ReplyShortChannelIdsEnd,
+	) -> Result<(), LightningError> {
+		self.deref().handle_reply_short_channel_ids_end(their_node_id, msg)
+	}
+	fn handle_query_channel_range(
+		&self, their_node_id: PublicKey, msg: QueryChannelRange,
+	) -> Result<(), LightningError> {
+		self.deref().handle_query_channel_range(their_node_id, msg)
+	}
+	fn handle_query_short_channel_ids(
+		&self, their_node_id: PublicKey, msg: QueryShortChannelIds,
+	) -> Result<(), LightningError> {
+		self.deref().handle_query_short_channel_ids(their_node_id, msg)
+	}
+	fn processing_queue_high(&self) -> bool {
+		self.deref().processing_queue_high()
+	}
+}
+
 /// A handler for received [`OnionMessage`]s and for providing generated ones to send.
 pub trait OnionMessageHandler: BaseMessageHandler {
 	/// Handle an incoming `onion_message` message from the given peer.
@@ -2304,6 +2507,18 @@ pub trait OnionMessageHandler: BaseMessageHandler {
 	fn timer_tick_occurred(&self);
 }
 
+impl<T: OnionMessageHandler + ?Sized, O: Deref<Target = T>> OnionMessageHandler for O {
+	fn handle_onion_message(&self, peer_node_id: PublicKey, msg: &OnionMessage) {
+		self.deref().handle_onion_message(peer_node_id, msg)
+	}
+	fn next_onion_message_for_peer(&self, peer_node_id: PublicKey) -> Option<OnionMessage> {
+		self.deref().next_onion_message_for_peer(peer_node_id)
+	}
+	fn timer_tick_occurred(&self) {
+		self.deref().timer_tick_occurred()
+	}
+}
+
 /// A handler which can only be used to send messages.
 ///
 /// This is implemented by [`ChainMonitor`].
@@ -2311,6 +2526,8 @@ pub trait OnionMessageHandler: BaseMessageHandler {
 /// [`ChainMonitor`]: crate::chain::chainmonitor::ChainMonitor
 pub trait SendOnlyMessageHandler: BaseMessageHandler {}
 
+impl<T: SendOnlyMessageHandler + ?Sized, S: Deref<Target = T>> SendOnlyMessageHandler for S {}
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 /// Information communicated in the onion to the recipient for multi-part tracking and proof that
 /// the payment is associated with an invoice.
diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs
index 1891c52..759a1e7 100644
--- a/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@ -53,7 +53,6 @@ use crate::util::ser::{VecWriter, Writeable, Writer};
 #[allow(unused_imports)]
 use crate::prelude::*;
 
-use super::wire::CustomMessageReader;
 use crate::io;
 use crate::sync::{FairRwLock, Mutex, MutexGuard};
 use core::convert::Infallible;
@@ -126,6 +125,31 @@ pub trait CustomMessageHandler: wire::CustomMessageReader {
 	fn provided_init_features(&self, their_node_id: PublicKey) -> InitFeatures;
 }
 
+impl<T: CustomMessageHandler + ?Sized, C: Deref<Target = T>> CustomMessageHandler for C {
+	fn handle_custom_message(
+		&self, msg: Self::CustomMessage, sender_node_id: PublicKey,
+	) -> Result<(), LightningError> {
+		self.deref().handle_custom_message(msg, sender_node_id)
+	}
+	fn get_and_clear_pending_msg(&self) -> Vec<(PublicKey, Self::CustomMessage)> {
+		self.deref().get_and_clear_pending_msg()
+	}
+	fn peer_disconnected(&self, their_node_id: PublicKey) {
+		self.deref().peer_disconnected(their_node_id)
+	}
+	fn peer_connected(
+		&self, their_node_id: PublicKey, msg: &Init, inbound: bool,
+	) -> Result<(), ()> {
+		self.deref().peer_connected(their_node_id, msg, inbound)
+	}
+	fn provided_node_features(&self) -> NodeFeatures {
+		self.deref().provided_node_features()
+	}
+	fn provided_init_features(&self, their_node_id: PublicKey) -> InitFeatures {
+		self.deref().provided_init_features(their_node_id)
+	}
+}
+
 /// A dummy struct which implements `RoutingMessageHandler` without storing any routing information
 /// or doing any processing. You can provide one of these as the route_handler in a MessageHandler.
 pub struct IgnoringMessageHandler {}
@@ -288,13 +312,6 @@ impl OnionMessageContents for Infallible {
 	}
 }
 
-impl Deref for IgnoringMessageHandler {
-	type Target = IgnoringMessageHandler;
-	fn deref(&self) -> &Self {
-		self
-	}
-}
-
 // Implement Type for Infallible, note that it cannot be constructed, and thus you can never call a
 // method that takes self for it.
 impl wire::Type for Infallible {
@@ -568,22 +585,14 @@ impl ChannelMessageHandler for ErroringMessageHandler {
 	fn message_received(&self) {}
 }
 
-impl Deref for ErroringMessageHandler {
-	type Target = ErroringMessageHandler;
-	fn deref(&self) -> &Self {
-		self
-	}
-}
-
 /// Provides references to trait impls which handle different types of messages.
-pub struct MessageHandler<CM: Deref, RM: Deref, OM: Deref, CustomM: Deref, SM: Deref>
-where
-	CM::Target: ChannelMessageHandler,
-	RM::Target: RoutingMessageHandler,
-	OM::Target: OnionMessageHandler,
-	CustomM::Target: CustomMessageHandler,
-	SM::Target: SendOnlyMessageHandler,
-{
+pub struct MessageHandler<
+	CM: ChannelMessageHandler,
+	RM: RoutingMessageHandler,
+	OM: OnionMessageHandler,
+	CustomM: CustomMessageHandler,
+	SM: SendOnlyMessageHandler,
+> {
 	/// A message handler which handles messages specific to channels. Usually this is just a
 	/// [`ChannelManager`] object or an [`ErroringMessageHandler`].
 	///
@@ -971,18 +980,13 @@ pub type SimpleRefPeerManager<
 #[allow(missing_docs)]
 pub trait APeerManager {
 	type Descriptor: SocketDescriptor;
-	type CMT: ChannelMessageHandler + ?Sized;
-	type CM: Deref<Target = Self::CMT>;
-	type RMT: RoutingMessageHandler + ?Sized;
-	type RM: Deref<Target = Self::RMT>;
-	type OMT: OnionMessageHandler + ?Sized;
-	type OM: Deref<Target = Self::OMT>;
+	type CM: ChannelMessageHandler;
+	type RM: RoutingMessageHandler;
+	type OM: OnionMessageHandler;
 	type Logger: Logger;
-	type CMHT: CustomMessageHandler + ?Sized;
-	type CMH: Deref<Target = Self::CMHT>;
+	type CMH: CustomMessageHandler;
 	type NodeSigner: NodeSigner;
-	type SMT: SendOnlyMessageHandler + ?Sized;
-	type SM: Deref<Target = Self::SMT>;
+	type SM: SendOnlyMessageHandler;
 	/// Gets a reference to the underlying [`PeerManager`].
 	fn as_ref(
 		&self,
@@ -1000,33 +1004,22 @@ pub trait APeerManager {
 
 impl<
 		Descriptor: SocketDescriptor,
-		CM: Deref,
-		RM: Deref,
-		OM: Deref,
+		CM: ChannelMessageHandler,
+		RM: RoutingMessageHandler,
+		OM: OnionMessageHandler,
 		L: Logger,
-		CMH: Deref,
+		CMH: CustomMessageHandler,
 		NS: NodeSigner,
-		SM: Deref,
+		SM: SendOnlyMessageHandler,
 	> APeerManager for PeerManager<Descriptor, CM, RM, OM, L, CMH, NS, SM>
-where
-	CM::Target: ChannelMessageHandler,
-	RM::Target: RoutingMessageHandler,
-	OM::Target: OnionMessageHandler,
-	CMH::Target: CustomMessageHandler,
-	SM::Target: SendOnlyMessageHandler,
 {
 	type Descriptor = Descriptor;
-	type CMT = <CM as Deref>::Target;
 	type CM = CM;
-	type RMT = <RM as Deref>::Target;
 	type RM = RM;
-	type OMT = <OM as Deref>::Target;
 	type OM = OM;
 	type Logger = L;
-	type CMHT = <CMH as Deref>::Target;
 	type CMH = CMH;
 	type NodeSigner = NS;
-	type SMT = <SM as Deref>::Target;
 	type SM = SM;
 	fn as_ref(&self) -> &PeerManager<Descriptor, CM, RM, OM, L, CMH, NS, SM> {
 		self
@@ -1054,20 +1047,14 @@ where
 /// [`read_event`]: PeerManager::read_event
 pub struct PeerManager<
 	Descriptor: SocketDescriptor,
-	CM: Deref,
-	RM: Deref,
-	OM: Deref,
+	CM: ChannelMessageHandler,
+	RM: RoutingMessageHandler,
+	OM: OnionMessageHandler,
 	L: Logger,
-	CMH: Deref,
+	CMH: CustomMessageHandler,
 	NS: NodeSigner,
-	SM: Deref,
-> where
-	CM::Target: ChannelMessageHandler,
-	RM::Target: RoutingMessageHandler,
-	OM::Target: OnionMessageHandler,
-	CMH::Target: CustomMessageHandler,
-	SM::Target: SendOnlyMessageHandler,
-{
+	SM: SendOnlyMessageHandler,
+> {
 	message_handler: MessageHandler<CM, RM, OM, CMH, SM>,
 	/// Connection state for each connected peer - we have an outer read-write lock which is taken
 	/// as read while we're doing processing for a peer and taken write when a peer is being added
@@ -1143,12 +1130,14 @@ fn encode_message<T: wire::Type>(message: wire::Message<T>) -> Vec<u8> {
 	buffer.0
 }
 
-impl<Descriptor: SocketDescriptor, CM: Deref, OM: Deref, L: Logger, NS: NodeSigner, SM: Deref>
-	PeerManager<Descriptor, CM, IgnoringMessageHandler, OM, L, IgnoringMessageHandler, NS, SM>
-where
-	CM::Target: ChannelMessageHandler,
-	OM::Target: OnionMessageHandler,
-	SM::Target: SendOnlyMessageHandler,
+impl<
+		Descriptor: SocketDescriptor,
+		CM: ChannelMessageHandler,
+		OM: OnionMessageHandler,
+		L: Logger,
+		NS: NodeSigner,
+		SM: SendOnlyMessageHandler,
+	> PeerManager<Descriptor, CM, IgnoringMessageHandler, OM, L, IgnoringMessageHandler, NS, SM>
 {
 	/// Constructs a new `PeerManager` with the given `ChannelMessageHandler` and
 	/// `OnionMessageHandler`. No routing message handler is used and network graph messages are
@@ -1184,7 +1173,7 @@ where
 	}
 }
 
-impl<Descriptor: SocketDescriptor, RM: Deref, L: Logger, NS: NodeSigner>
+impl<Descriptor: SocketDescriptor, RM: RoutingMessageHandler, L: Logger, NS: NodeSigner>
 	PeerManager<
 		Descriptor,
 		ErroringMessageHandler,
@@ -1194,8 +1183,7 @@ impl<Descriptor: SocketDescriptor, RM: Deref, L: Logger, NS: NodeSigner>
 		IgnoringMessageHandler,
 		NS,
 		IgnoringMessageHandler,
-	> where
-	RM::Target: RoutingMessageHandler,
+	>
 {
 	/// Constructs a new `PeerManager` with the given `RoutingMessageHandler`. No channel message
 	/// handler or onion message handler is used and onion and channel messages will be ignored (or
@@ -1281,20 +1269,14 @@ fn filter_addresses(ip_address: Option<SocketAddress>) -> Option<SocketAddress>
 
 impl<
 		Descriptor: SocketDescriptor,
-		CM: Deref,
-		RM: Deref,
-		OM: Deref,
+		CM: ChannelMessageHandler,
+		RM: RoutingMessageHandler,
+		OM: OnionMessageHandler,
 		L: Logger,
-		CMH: Deref,
+		CMH: CustomMessageHandler,
 		NS: NodeSigner,
-		SM: Deref,
+		SM: SendOnlyMessageHandler,
 	> PeerManager<Descriptor, CM, RM, OM, L, CMH, NS, SM>
-where
-	CM::Target: ChannelMessageHandler,
-	RM::Target: RoutingMessageHandler,
-	OM::Target: OnionMessageHandler,
-	CMH::Target: CustomMessageHandler,
-	SM::Target: SendOnlyMessageHandler,
 {
 	/// Constructs a new `PeerManager` with the given message handlers.
 	///
@@ -1721,10 +1703,7 @@ where
 	}
 
 	/// Append a message to a peer's pending outbound/write buffer
-	fn enqueue_message(
-		&self, peer: &mut Peer,
-		message: Message<<CMH::Target as CustomMessageReader>::CustomMessage>,
-	) {
+	fn enqueue_message(&self, peer: &mut Peer, message: Message<CMH::CustomMessage>) {
 		let their_node_id = peer.their_node_id.map(|p| p.0);
 		if their_node_id.is_some() {
 			let logger = WithContext::from(&self.logger, their_node_id, None, None);
@@ -1940,7 +1919,7 @@ where
 								let message_result = wire::read(
 									&mut &peer.pending_read_buffer
 										[..peer.pending_read_buffer.len() - 16],
-									&*self.message_handler.custom_message_handler,
+									&self.message_handler.custom_message_handler,
 								);
 
 								// Reset read buffer
@@ -2067,7 +2046,7 @@ where
 	/// Returns the message back if it needs to be broadcasted to all other peers.
 	fn handle_message(
 		&self, peer_mutex: &Mutex<Peer>, peer_lock: MutexGuard<Peer>,
-		message: Message<<<CMH as Deref>::Target as wire::CustomMessageReader>::CustomMessage>,
+		message: Message<CMH::CustomMessage>,
 	) -> Result<Option<BroadcastGossipMessage>, MessageHandlingError> {
 		let their_node_id = peer_lock
 			.their_node_id
@@ -2107,15 +2086,9 @@ where
 	// Returns `None` if the message was fully processed and otherwise returns the message back to
 	// allow it to be subsequently processed by `do_handle_message_without_peer_lock`.
 	fn do_handle_message_holding_peer_lock<'a>(
-		&self, mut peer_lock: MutexGuard<Peer>,
-		message: Message<<<CMH as Deref>::Target as wire::CustomMessageReader>::CustomMessage>,
+		&self, mut peer_lock: MutexGuard<Peer>, message: Message<CMH::CustomMessage>,
 		their_node_id: PublicKey, logger: &WithContext<'a, L>,
-	) -> Result<
-		Option<
-			LogicalMessage<<<CMH as Deref>::Target as wire::CustomMessageReader>::CustomMessage>,
-		>,
-		MessageHandlingError,
-	> {
+	) -> Result<Option<LogicalMessage<CMH::CustomMessage>>, MessageHandlingError> {
 		peer_lock.received_message_since_timer_tick = true;
 
 		// Need an Init as first message
@@ -2387,8 +2360,7 @@ where
 	//
 	// Returns the message back if it needs to be broadcasted to all other peers.
 	fn do_handle_message_without_peer_lock<'a>(
-		&self, peer_mutex: &Mutex<Peer>,
-		message: Message<<<CMH as Deref>::Target as wire::CustomMessageReader>::CustomMessage>,
+		&self, peer_mutex: &Mutex<Peer>, message: Message<CMH::CustomMessage>,
 		their_node_id: PublicKey, logger: &WithContext<'a, L>,
 	) -> Result<Option<BroadcastGossipMessage>, MessageHandlingError> {
 		if is_gossip_msg(message.type_id()) {
@@ -2657,8 +2629,7 @@ where
 				let scid = msg.contents.short_channel_id;
 				let node_id_1 = msg.contents.node_id_1;
 				let node_id_2 = msg.contents.node_id_2;
-				let msg: Message<<CMH::Target as CustomMessageReader>::CustomMessage> =
-					Message::ChannelAnnouncement(msg);
+				let msg: Message<CMH::CustomMessage> = Message::ChannelAnnouncement(msg);
 				let encoded_msg = encode_message(msg);
 				for (_, peer_mutex) in peers.iter() {
 					let mut peer = peer_mutex.lock().unwrap();
@@ -2704,8 +2675,7 @@ where
 				let our_announcement = self.our_node_id == msg.contents.node_id;
 				let msg_node_id = msg.contents.node_id;
 
-				let msg: Message<<CMH::Target as CustomMessageReader>::CustomMessage> =
-					Message::NodeAnnouncement(msg);
+				let msg: Message<CMH::CustomMessage> = Message::NodeAnnouncement(msg);
 				let encoded_msg = encode_message(msg);
 				for (_, peer_mutex) in peers.iter() {
 					let mut peer = peer_mutex.lock().unwrap();
@@ -2750,8 +2720,7 @@ where
 				);
 				let our_channel = self.our_node_id == node_id_1 || self.our_node_id == node_id_2;
 				let scid = msg.contents.short_channel_id;
-				let msg: Message<<CMH::Target as CustomMessageReader>::CustomMessage> =
-					Message::ChannelUpdate(msg);
+				let msg: Message<CMH::CustomMessage> = Message::ChannelUpdate(msg);
 				let encoded_msg = encode_message(msg);
 				for (_, peer_mutex) in peers.iter() {
 					let mut peer = peer_mutex.lock().unwrap();
@@ -3285,9 +3254,8 @@ where
 									// We do not have the peers write lock, so we just store that we're
 									// about to disconnect the peer and do it after we finish
 									// processing most messages.
-									let msg = msg.map(|msg| {
-										Message::<<<CMH as Deref>::Target as wire::CustomMessageReader>::CustomMessage>::Error(msg)
-									});
+									let msg =
+										msg.map(|msg| Message::<CMH::CustomMessage>::Error(msg));
 									peers_to_disconnect.insert(node_id, msg);
 								},
 								msgs::ErrorAction::DisconnectPeerWithWarning { msg } => {
@@ -3557,8 +3525,7 @@ where
 		if peer.awaiting_pong_timer_tick_intervals == 0 {
 			peer.awaiting_pong_timer_tick_intervals = -1;
 			let ping = msgs::Ping { ponglen: 0, byteslen: 64 };
-			let msg: Message<<CMH::Target as CustomMessageReader>::CustomMessage> =
-				Message::Ping(ping);
+			let msg: Message<CMH::CustomMessage> = Message::Ping(ping);
 			self.enqueue_message(peer, msg);
 		}
 	}
diff --git a/lightning/src/ln/wire.rs b/lightning/src/ln/wire.rs
index 9065c49..a2078ce 100644
--- a/lightning/src/ln/wire.rs
+++ b/lightning/src/ln/wire.rs
@@ -15,6 +15,7 @@
 use crate::io;
 use crate::ln::msgs;
 use crate::util::ser::{LengthLimitedRead, LengthReadable, Readable, Writeable, Writer};
+use core::ops::Deref;
 
 /// Trait to be implemented by custom message (unrelated to the channel/gossip LN layers)
 /// decoders.
@@ -30,6 +31,15 @@ pub trait CustomMessageReader {
 	) -> Result<Option<Self::CustomMessage>, msgs::DecodeError>;
 }
 
+impl<T: CustomMessageReader + ?Sized, C: Deref<Target = T>> CustomMessageReader for C {
+	type CustomMessage = T::CustomMessage;
+	fn read<R: LengthLimitedRead>(
+		&self, message_type: u16, buffer: &mut R,
+	) -> Result<Option<Self::CustomMessage>, msgs::DecodeError> {
+		self.deref().read(message_type, buffer)
+	}
+}
+
 // TestEq is a dummy trait which requires PartialEq when built in testing, and otherwise is
 // blanket-implemented for all types.
 
@@ -244,23 +254,21 @@ impl<T: core::fmt::Debug + Type + TestEq> Message<T> {
 /// # Errors
 ///
 /// Returns an error if the message payload could not be decoded as the specified type.
-pub(crate) fn read<R: LengthLimitedRead, T, H: core::ops::Deref>(
+pub(crate) fn read<R: LengthLimitedRead, T, H: CustomMessageReader<CustomMessage = T>>(
 	buffer: &mut R, custom_reader: H,
 ) -> Result<Message<T>, (msgs::DecodeError, Option<u16>)>
 where
 	T: core::fmt::Debug + Type + Writeable,
-	H::Target: CustomMessageReader<CustomMessage = T>,
 {
 	let message_type = <u16 as Readable>::read(buffer).map_err(|e| (e, None))?;
 	do_read(buffer, message_type, custom_reader).map_err(|e| (e, Some(message_type)))
 }
 
-fn do_read<R: LengthLimitedRead, T, H: core::ops::Deref>(
+fn do_read<R: LengthLimitedRead, T, H: CustomMessageReader<CustomMessage = T>>(
 	buffer: &mut R, message_type: u16, custom_reader: H,
 ) -> Result<Message<T>, msgs::DecodeError>
 where
 	T: core::fmt::Debug + Type + Writeable,
-	H::Target: CustomMessageReader<CustomMessage = T>,
 {
 	match message_type {
 		msgs::Init::TYPE => {
@@ -876,7 +884,7 @@ mod tests {
 	#[test]
 	fn read_custom_message() {
 		let buffer = [35, 40];
-		let decoded_msg = read(&mut &buffer[..], &TestCustomMessageReader {}).unwrap();
+		let decoded_msg = read(&mut &buffer[..], TestCustomMessageReader {}).unwrap();
 		match decoded_msg {
 			Message::Custom(custom) => {
 				assert_eq!(custom.type_id(), CUSTOM_MESSAGE_TYPE);
@@ -889,7 +897,7 @@ mod tests {
 	#[test]
 	fn read_with_custom_reader_unknown_message_type() {
 		let buffer = [35, 42];
-		let decoded_msg = read(&mut &buffer[..], &TestCustomMessageReader {}).unwrap();
+		let decoded_msg = read(&mut &buffer[..], TestCustomMessageReader {}).unwrap();
 		match decoded_msg {
 			Message::Unknown(_) => {},
 			_ => panic!("Expected unknown message, found message type: {}", decoded_msg.type_id()),
diff --git a/lightning/src/onion_message/async_payments.rs b/lightning/src/onion_message/async_payments.rs
index 127126e..41108cd 100644
--- a/lightning/src/onion_message/async_payments.rs
+++ b/lightning/src/onion_message/async_payments.rs
@@ -17,6 +17,7 @@ use crate::onion_message::messenger::{MessageSendInstructions, Responder, Respon
 use crate::onion_message::packet::OnionMessageContents;
 use crate::prelude::*;
 use crate::util::ser::{Readable, ReadableArgs, Writeable, Writer};
+use core::ops::Deref;
 
 // TLV record types for the `onionmsg_tlv` TLV stream as defined in BOLT 4.
 const OFFER_PATHS_REQ_TLV_TYPE: u64 = 75540;
@@ -89,6 +90,45 @@ pub trait AsyncPaymentsMessageHandler {
 	}
 }
 
+impl<T: AsyncPaymentsMessageHandler + ?Sized, A: Deref<Target = T>> AsyncPaymentsMessageHandler
+	for A
+{
+	fn handle_offer_paths_request(
+		&self, message: OfferPathsRequest, context: AsyncPaymentsContext,
+		responder: Option<Responder>,
+	) -> Option<(OfferPaths, ResponseInstruction)> {
+		self.deref().handle_offer_paths_request(message, context, responder)
+	}
+	fn handle_offer_paths(
+		&self, message: OfferPaths, context: AsyncPaymentsContext, responder: Option<Responder>,
+	) -> Option<(ServeStaticInvoice, ResponseInstruction)> {
+		self.deref().handle_offer_paths(message, context, responder)
+	}
+	fn handle_serve_static_invoice(
+		&self, message: ServeStaticInvoice, context: AsyncPaymentsContext,
+		responder: Option<Responder>,
+	) {
+		self.deref().handle_serve_static_invoice(message, context, responder)
+	}
+	fn handle_static_invoice_persisted(
+		&self, message: StaticInvoicePersisted, context: AsyncPaymentsContext,
+	) {
+		self.deref().handle_static_invoice_persisted(message, context)
+	}
+	fn handle_held_htlc_available(
+		&self, message: HeldHtlcAvailable, context: AsyncPaymentsContext,
+		responder: Option<Responder>,
+	) -> Option<(ReleaseHeldHtlc, ResponseInstruction)> {
+		self.deref().handle_held_htlc_available(message, context, responder)
+	}
+	fn handle_release_held_htlc(&self, message: ReleaseHeldHtlc, context: AsyncPaymentsContext) {
+		self.deref().handle_release_held_htlc(message, context)
+	}
+	fn release_pending_messages(&self) -> Vec<(AsyncPaymentsMessage, MessageSendInstructions)> {
+		self.deref().release_pending_messages()
+	}
+}
+
 /// Possible async payment messages sent and received via an [`OnionMessage`].
 ///
 /// [`OnionMessage`]: crate::ln::msgs::OnionMessage
diff --git a/lightning/src/onion_message/dns_resolution.rs b/lightning/src/onion_message/dns_resolution.rs
index 47d4bc0..e857a35 100644
--- a/lightning/src/onion_message/dns_resolution.rs
+++ b/lightning/src/onion_message/dns_resolution.rs
@@ -37,6 +37,7 @@ use dnssec_prover::rr::Name;
 use lightning_types::features::NodeFeatures;
 
 use core::fmt;
+use core::ops::Deref;
 
 use crate::blinded_path::message::DNSResolverContext;
 use crate::io;
@@ -89,6 +90,23 @@ pub trait DNSResolverMessageHandler {
 	}
 }
 
+impl<T: DNSResolverMessageHandler + ?Sized, D: Deref<Target = T>> DNSResolverMessageHandler for D {
+	fn handle_dnssec_query(
+		&self, message: DNSSECQuery, responder: Option<Responder>,
+	) -> Option<(DNSResolverMessage, ResponseInstruction)> {
+		self.deref().handle_dnssec_query(message, responder)
+	}
+	fn handle_dnssec_proof(&self, message: DNSSECProof, context: DNSResolverContext) {
+		self.deref().handle_dnssec_proof(message, context)
+	}
+	fn provided_node_features(&self) -> NodeFeatures {
+		self.deref().provided_node_features()
+	}
+	fn release_pending_messages(&self) -> Vec<(DNSResolverMessage, MessageSendInstructions)> {
+		self.deref().release_pending_messages()
+	}
+}
+
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 /// An enum containing the possible onion messages which are used uses to request and receive
 /// DNSSEC proofs.
diff --git a/lightning/src/onion_message/messenger.rs b/lightning/src/onion_message/messenger.rs
index 5e2ec2d..e688c02 100644
--- a/lightning/src/onion_message/messenger.rs
+++ b/lightning/src/onion_message/messenger.rs
@@ -76,21 +76,13 @@ pub trait AOnionMessenger {
 	/// A type implementing [`MessageRouter`]
 	type MessageRouter: MessageRouter;
 	/// A type implementing [`OffersMessageHandler`]
-	type OffersMessageHandler: OffersMessageHandler + ?Sized;
-	/// A type that may be dereferenced to [`Self::OffersMessageHandler`]
-	type OMH: Deref<Target = Self::OffersMessageHandler>;
+	type OMH: OffersMessageHandler;
 	/// A type implementing [`AsyncPaymentsMessageHandler`]
-	type AsyncPaymentsMessageHandler: AsyncPaymentsMessageHandler + ?Sized;
-	/// A type that may be dereferenced to [`Self::AsyncPaymentsMessageHandler`]
-	type APH: Deref<Target = Self::AsyncPaymentsMessageHandler>;
+	type APH: AsyncPaymentsMessageHandler;
 	/// A type implementing [`DNSResolverMessageHandler`]
-	type DNSResolverMessageHandler: DNSResolverMessageHandler + ?Sized;
-	/// A type that may be dereferenced to [`Self::DNSResolverMessageHandler`]
-	type DRH: Deref<Target = Self::DNSResolverMessageHandler>;
+	type DRH: DNSResolverMessageHandler;
 	/// A type implementing [`CustomOnionMessageHandler`]
-	type CustomOnionMessageHandler: CustomOnionMessageHandler + ?Sized;
-	/// A type that may be dereferenced to [`Self::CustomOnionMessageHandler`]
-	type CMH: Deref<Target = Self::CustomOnionMessageHandler>;
+	type CMH: CustomOnionMessageHandler;
 	/// Returns a reference to the actual [`OnionMessenger`] object.
 	fn get_om(
 		&self,
@@ -113,29 +105,20 @@ impl<
 		L: Logger,
 		NL: NodeIdLookUp,
 		MR: MessageRouter,
-		OMH: Deref,
-		APH: Deref,
-		DRH: Deref,
-		CMH: Deref,
+		OMH: OffersMessageHandler,
+		APH: AsyncPaymentsMessageHandler,
+		DRH: DNSResolverMessageHandler,
+		CMH: CustomOnionMessageHandler,
 	> AOnionMessenger for OnionMessenger<ES, NS, L, NL, MR, OMH, APH, DRH, CMH>
-where
-	OMH::Target: OffersMessageHandler,
-	APH::Target: AsyncPaymentsMessageHandler,
-	DRH::Target: DNSResolverMessageHandler,
-	CMH::Target: CustomOnionMessageHandler,
 {
 	type EntropySource = ES;
 	type NodeSigner = NS;
 	type Logger = L;
 	type NL = NL;
 	type MessageRouter = MR;
-	type OffersMessageHandler = OMH::Target;
 	type OMH = OMH;
-	type AsyncPaymentsMessageHandler = APH::Target;
 	type APH = APH;
-	type DNSResolverMessageHandler = DRH::Target;
 	type DRH = DRH;
-	type CustomOnionMessageHandler = CMH::Target;
 	type CMH = CMH;
 	fn get_om(&self) -> &OnionMessenger<ES, NS, L, NL, MR, OMH, APH, DRH, CMH> {
 		self
@@ -269,16 +252,11 @@ pub struct OnionMessenger<
 	L: Logger,
 	NL: NodeIdLookUp,
 	MR: MessageRouter,
-	OMH: Deref,
-	APH: Deref,
-	DRH: Deref,
-	CMH: Deref,
-> where
-	OMH::Target: OffersMessageHandler,
-	APH::Target: AsyncPaymentsMessageHandler,
-	DRH::Target: DNSResolverMessageHandler,
-	CMH::Target: CustomOnionMessageHandler,
-{
+	OMH: OffersMessageHandler,
+	APH: AsyncPaymentsMessageHandler,
+	DRH: DNSResolverMessageHandler,
+	CMH: CustomOnionMessageHandler,
+> {
 	entropy_source: ES,
 	#[cfg(test)]
 	pub(super) node_signer: NS,
@@ -1007,6 +985,25 @@ pub trait CustomOnionMessageHandler {
 	) -> Vec<(Self::CustomMessage, MessageSendInstructions)>;
 }
 
+impl<T: CustomOnionMessageHandler + ?Sized, C: Deref<Target = T>> CustomOnionMessageHandler for C {
+	type CustomMessage = T::CustomMessage;
+	fn handle_custom_message(
+		&self, message: Self::CustomMessage, context: Option<Vec<u8>>, responder: Option<Responder>,
+	) -> Option<(Self::CustomMessage, ResponseInstruction)> {
+		self.deref().handle_custom_message(message, context, responder)
+	}
+	fn read_custom_message<R: io::Read>(
+		&self, message_type: u64, buffer: &mut R,
+	) -> Result<Option<Self::CustomMessage>, msgs::DecodeError> {
+		self.deref().read_custom_message(message_type, buffer)
+	}
+	fn release_pending_custom_messages(
+		&self,
+	) -> Vec<(Self::CustomMessage, MessageSendInstructions)> {
+		self.deref().release_pending_custom_messages()
+	}
+}
+
 /// A processed incoming onion message, containing either a Forward (another onion message)
 /// or a Receive payload with decrypted contents.
 #[derive(Clone, Debug)]
@@ -1144,13 +1141,10 @@ pub fn create_onion_message<
 ///
 /// Returns either the next layer of the onion for forwarding or the decrypted content for the
 /// receiver.
-pub fn peel_onion_message<NS: NodeSigner, L: Logger, CMH: Deref>(
+pub fn peel_onion_message<NS: NodeSigner, L: Logger, CMH: CustomOnionMessageHandler>(
 	msg: &OnionMessage, secp_ctx: &Secp256k1<secp256k1::All>, node_signer: NS, logger: L,
 	custom_handler: CMH,
-) -> Result<PeeledOnion<<<CMH>::Target as CustomOnionMessageHandler>::CustomMessage>, ()>
-where
-	CMH::Target: CustomOnionMessageHandler,
-{
+) -> Result<PeeledOnion<CMH::CustomMessage>, ()> {
 	let control_tlvs_ss = match node_signer.ecdh(Recipient::Node, &msg.blinding_point, None) {
 		Ok(ss) => ss,
 		Err(e) => {
@@ -1179,7 +1173,7 @@ where
 		onion_decode_ss,
 		&msg.onion_routing_packet.hop_data[..],
 		msg.onion_routing_packet.hmac,
-		(control_tlvs_ss, custom_handler.deref(), receiving_context_auth_key, &logger),
+		(control_tlvs_ss, &custom_handler, receiving_context_auth_key, &logger),
 	);
 
 	// Constructs the next onion message using packet data and blinding logic.
@@ -1370,16 +1364,11 @@ impl<
 		L: Logger,
 		NL: NodeIdLookUp,
 		MR: MessageRouter,
-		OMH: Deref,
-		APH: Deref,
-		DRH: Deref,
-		CMH: Deref,
+		OMH: OffersMessageHandler,
+		APH: AsyncPaymentsMessageHandler,
+		DRH: DNSResolverMessageHandler,
+		CMH: CustomOnionMessageHandler,
 	> OnionMessenger<ES, NS, L, NL, MR, OMH, APH, DRH, CMH>
-where
-	OMH::Target: OffersMessageHandler,
-	APH::Target: AsyncPaymentsMessageHandler,
-	DRH::Target: DNSResolverMessageHandler,
-	CMH::Target: CustomOnionMessageHandler,
 {
 	/// Constructs a new `OnionMessenger` to send, forward, and delegate received onion messages to
 	/// their respective handlers.
@@ -1770,13 +1759,13 @@ where
 
 	pub(crate) fn peel_onion_message(
 		&self, msg: &OnionMessage,
-	) -> Result<PeeledOnion<<<CMH>::Target as CustomOnionMessageHandler>::CustomMessage>, ()> {
+	) -> Result<PeeledOnion<CMH::CustomMessage>, ()> {
 		peel_onion_message(
 			msg,
 			&self.secp_ctx,
 			&self.node_signer,
 			&self.logger,
-			&*self.custom_handler,
+			&self.custom_handler,
 		)
 	}
 
@@ -2009,16 +1998,11 @@ impl<
 		L: Logger,
 		NL: NodeIdLookUp,
 		MR: MessageRouter,
-		OMH: Deref,
-		APH: Deref,
-		DRH: Deref,
-		CMH: Deref,
+		OMH: OffersMessageHandler,
+		APH: AsyncPaymentsMessageHandler,
+		DRH: DNSResolverMessageHandler,
+		CMH: CustomOnionMessageHandler,
 	> EventsProvider for OnionMessenger<ES, NS, L, NL, MR, OMH, APH, DRH, CMH>
-where
-	OMH::Target: OffersMessageHandler,
-	APH::Target: AsyncPaymentsMessageHandler,
-	DRH::Target: DNSResolverMessageHandler,
-	CMH::Target: CustomOnionMessageHandler,
 {
 	fn process_pending_events<H: Deref>(&self, handler: H)
 	where
@@ -2125,16 +2109,11 @@ impl<
 		L: Logger,
 		NL: NodeIdLookUp,
 		MR: MessageRouter,
-		OMH: Deref,
-		APH: Deref,
-		DRH: Deref,
-		CMH: Deref,
+		OMH: OffersMessageHandler,
+		APH: AsyncPaymentsMessageHandler,
+		DRH: DNSResolverMessageHandler,
+		CMH: CustomOnionMessageHandler,
 	> BaseMessageHandler for OnionMessenger<ES, NS, L, NL, MR, OMH, APH, DRH, CMH>
-where
-	OMH::Target: OffersMessageHandler,
-	APH::Target: AsyncPaymentsMessageHandler,
-	DRH::Target: DNSResolverMessageHandler,
-	CMH::Target: CustomOnionMessageHandler,
 {
 	fn provided_node_features(&self) -> NodeFeatures {
 		let mut features = NodeFeatures::empty();
@@ -2192,16 +2171,11 @@ impl<
 		L: Logger,
 		NL: NodeIdLookUp,
 		MR: MessageRouter,
-		OMH: Deref,
-		APH: Deref,
-		DRH: Deref,
-		CMH: Deref,
+		OMH: OffersMessageHandler,
+		APH: AsyncPaymentsMessageHandler,
+		DRH: DNSResolverMessageHandler,
+		CMH: CustomOnionMessageHandler,
 	> OnionMessageHandler for OnionMessenger<ES, NS, L, NL, MR, OMH, APH, DRH, CMH>
-where
-	OMH::Target: OffersMessageHandler,
-	APH::Target: AsyncPaymentsMessageHandler,
-	DRH::Target: DNSResolverMessageHandler,
-	CMH::Target: CustomOnionMessageHandler,
 {
 	fn handle_onion_message(&self, peer_node_id: PublicKey, msg: &OnionMessage) {
 		let logger = WithContext::from(&self.logger, Some(peer_node_id), None, None);
diff --git a/lightning/src/onion_message/offers.rs b/lightning/src/onion_message/offers.rs
index 06988d4..8e3afdf 100644
--- a/lightning/src/onion_message/offers.rs
+++ b/lightning/src/onion_message/offers.rs
@@ -22,6 +22,7 @@ use crate::onion_message::packet::OnionMessageContents;
 use crate::util::logger::Logger;
 use crate::util::ser::{Readable, ReadableArgs, Writeable, Writer};
 use core::fmt;
+use core::ops::Deref;
 
 use crate::prelude::*;
 
@@ -63,6 +64,17 @@ pub trait OffersMessageHandler {
 	}
 }
 
+impl<T: OffersMessageHandler + ?Sized, O: Deref<Target = T>> OffersMessageHandler for O {
+	fn handle_message(
+		&self, message: OffersMessage, context: Option<OffersContext>, responder: Option<Responder>,
+	) -> Option<(OffersMessage, ResponseInstruction)> {
+		self.deref().handle_message(message, context, responder)
+	}
+	fn release_pending_messages(&self) -> Vec<(OffersMessage, MessageSendInstructions)> {
+		self.deref().release_pending_messages()
+	}
+}
+
 /// Possible BOLT 12 Offers messages sent and received via an [`OnionMessage`].
 ///
 /// [`OnionMessage`]: crate::ln::msgs::OnionMessage