diff --git a/protocols/v2/roles-logic-sv2/src/handlers2/common.rs b/protocols/v2/roles-logic-sv2/src/handlers2/common.rs
new file mode 100644
index 0000000000..9ce1c73103
--- /dev/null
+++ b/protocols/v2/roles-logic-sv2/src/handlers2/common.rs
@@ -0,0 +1,58 @@
+use crate::{errors::Error, parsers::CommonMessages};
+use common_messages_sv2::{
+    ChannelEndpointChanged, Reconnect, SetupConnectionError, SetupConnectionSuccess, *,
+};
+use core::convert::TryInto;
+
+pub trait ParseCommonMessagesFromUpstream {
+    fn handle_setup_connection_success(
+        &mut self,
+        msg: SetupConnectionSuccess,
+    ) -> Result<Option<CommonMessages<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_SETUP_CONNECTION_SUCCESS,
+        ))
+    }
+
+    fn handle_setup_connection_error(
+        &mut self,
+        msg: SetupConnectionError,
+    ) -> Result<Option<CommonMessages<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_SETUP_CONNECTION_ERROR,
+        ))
+    }
+
+    fn handle_channel_endpoint_changed(
+        &mut self,
+        msg: ChannelEndpointChanged,
+    ) -> Result<Option<CommonMessages<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_CHANNEL_ENDPOINT_CHANGED,
+        ))
+    }
+
+    fn handle_reconnect(
+        &mut self,
+        msg: Reconnect,
+    ) -> Result<Option<CommonMessages<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(MESSAGE_TYPE_RECONNECT))
+    }
+}
+
+pub trait ParseCommonMessagesFromDownstream
+where
+    Self: Sized,
+{
+    fn handle_setup_connection(
+        &mut self,
+        msg: SetupConnection,
+    ) -> Result<Option<CommonMessages<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(MESSAGE_TYPE_SETUP_CONNECTION))
+    }
+}
diff --git a/protocols/v2/roles-logic-sv2/src/handlers2/job_declaration.rs b/protocols/v2/roles-logic-sv2/src/handlers2/job_declaration.rs
new file mode 100644
index 0000000000..971232756d
--- /dev/null
+++ b/protocols/v2/roles-logic-sv2/src/handlers2/job_declaration.rs
@@ -0,0 +1,88 @@
+use crate::{errors::Error, parsers::JobDeclaration};
+use core::convert::TryInto;
+use job_declaration_sv2::{
+    MESSAGE_TYPE_ALLOCATE_MINING_JOB_TOKEN, MESSAGE_TYPE_ALLOCATE_MINING_JOB_TOKEN_SUCCESS,
+    MESSAGE_TYPE_DECLARE_MINING_JOB, MESSAGE_TYPE_DECLARE_MINING_JOB_ERROR,
+    MESSAGE_TYPE_DECLARE_MINING_JOB_SUCCESS, MESSAGE_TYPE_PROVIDE_MISSING_TRANSACTIONS,
+    MESSAGE_TYPE_PROVIDE_MISSING_TRANSACTIONS_SUCCESS, MESSAGE_TYPE_PUSH_SOLUTION, *,
+};
+
+pub trait ParseJobDeclarationMessagesFromUpstream {
+    fn handle_allocate_mining_job_token_success(
+        &mut self,
+        msg: AllocateMiningJobTokenSuccess,
+    ) -> Result<Option<JobDeclaration<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_ALLOCATE_MINING_JOB_TOKEN_SUCCESS,
+        ))
+    }
+
+    fn handle_declare_mining_job_success(
+        &mut self,
+        msg: DeclareMiningJobSuccess,
+    ) -> Result<Option<JobDeclaration<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_DECLARE_MINING_JOB_SUCCESS,
+        ))
+    }
+
+    fn handle_declare_mining_job_error(
+        &mut self,
+        msg: DeclareMiningJobError,
+    ) -> Result<Option<JobDeclaration<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_DECLARE_MINING_JOB_ERROR,
+        ))
+    }
+
+    fn handle_provide_missing_transactions(
+        &mut self,
+        msg: ProvideMissingTransactions,
+    ) -> Result<Option<JobDeclaration<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_PROVIDE_MISSING_TRANSACTIONS,
+        ))
+    }
+}
+
+pub trait ParseJobDeclarationMessagesFromDownstream {
+    fn handle_allocate_mining_job_token(
+        &mut self,
+        msg: AllocateMiningJobToken,
+    ) -> Result<Option<JobDeclaration<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_ALLOCATE_MINING_JOB_TOKEN,
+        ))
+    }
+
+    fn handle_declare_mining_job(
+        &mut self,
+        msg: DeclareMiningJob,
+    ) -> Result<Option<JobDeclaration<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(MESSAGE_TYPE_DECLARE_MINING_JOB))
+    }
+
+    fn handle_provide_missing_transactions_success(
+        &mut self,
+        msg: ProvideMissingTransactionsSuccess,
+    ) -> Result<Option<JobDeclaration<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_PROVIDE_MISSING_TRANSACTIONS_SUCCESS,
+        ))
+    }
+
+    fn handle_push_solution(
+        &mut self,
+        msg: PushSolution,
+    ) -> Result<Option<JobDeclaration<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(MESSAGE_TYPE_PUSH_SOLUTION))
+    }
+}
diff --git a/protocols/v2/roles-logic-sv2/src/handlers2/mining.rs b/protocols/v2/roles-logic-sv2/src/handlers2/mining.rs
new file mode 100644
index 0000000000..41692f25c6
--- /dev/null
+++ b/protocols/v2/roles-logic-sv2/src/handlers2/mining.rs
@@ -0,0 +1,240 @@
+use crate::{errors::Error, parsers::Mining};
+use codec_sv2::binary_sv2;
+use mining_sv2::{
+    CloseChannel, NewExtendedMiningJob, NewMiningJob, OpenExtendedMiningChannel,
+    OpenExtendedMiningChannelSuccess, OpenMiningChannelError, OpenStandardMiningChannel,
+    OpenStandardMiningChannelSuccess, SetCustomMiningJob, SetCustomMiningJobError,
+    SetCustomMiningJobSuccess, SetExtranoncePrefix, SetGroupChannel, SetNewPrevHash, SetTarget,
+    SubmitSharesError, SubmitSharesExtended, SubmitSharesStandard, SubmitSharesSuccess,
+    UpdateChannel, UpdateChannelError,
+};
+
+use mining_sv2::*;
+use std::fmt::Debug as D;
+use template_distribution_sv2::MESSAGE_TYPE_SET_NEW_PREV_HASH;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum SupportedChannelTypes {
+    Standard,
+    Extended,
+    Group,
+    GroupAndExtended,
+}
+
+#[derive(PartialEq, Eq)]
+pub enum DownstreamAuth {
+    NotImplemented,
+    Allow,
+    Restrict,
+}
+
+pub trait MiningChannelConfig {
+    fn get_channel_type(&self) -> SupportedChannelTypes {
+        SupportedChannelTypes::Extended
+    }
+    fn is_work_selection_enabled(&self) -> bool {
+        false
+    }
+
+    fn is_downstream_authorized(
+        &self,
+        user_identity: &binary_sv2::Str0255,
+    ) -> Result<DownstreamAuth, Error> {
+        Ok(DownstreamAuth::NotImplemented)
+    }
+}
+
+pub trait ParseMiningMessagesFromDownstream<Up: D>
+where
+    Self: Sized + D + MiningChannelConfig,
+{
+    fn handle_open_standard_mining_channel(
+        &mut self,
+        msg: OpenStandardMiningChannel,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_OPEN_STANDARD_MINING_CHANNEL,
+        ))
+    }
+
+    fn handle_open_extended_mining_channel(
+        &mut self,
+        msg: OpenExtendedMiningChannel,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_OPEN_EXTENDED_MINING_CHANNEL,
+        ))
+    }
+
+    fn handle_update_channel(
+        &mut self,
+        msg: UpdateChannel,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(MESSAGE_TYPE_UPDATE_CHANNEL))
+    }
+
+    fn handle_submit_shares_standard(
+        &mut self,
+        msg: SubmitSharesStandard,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_SUBMIT_SHARES_STANDARD,
+        ))
+    }
+
+    fn handle_submit_shares_extended(
+        &mut self,
+        msg: SubmitSharesExtended,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_SUBMIT_SHARES_EXTENDED,
+        ))
+    }
+
+    fn handle_set_custom_mining_job(
+        &mut self,
+        msg: SetCustomMiningJob,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_CUSTOM_MINING_JOB))
+    }
+}
+
+pub trait ParseMiningMessagesFromUpstream<Down: D>
+where
+    Self: Sized + D + MiningChannelConfig,
+{
+    fn handle_open_standard_mining_channel_success(
+        &mut self,
+        msg: OpenStandardMiningChannelSuccess,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_OPEN_STANDARD_MINING_CHANNEL_SUCCESS,
+        ))
+    }
+
+    fn handle_open_extended_mining_channel_success(
+        &mut self,
+        msg: OpenExtendedMiningChannelSuccess,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_OPEN_EXTENDED_MINING_CHANNEL_SUCCESS,
+        ))
+    }
+
+    fn handle_open_mining_channel_error(
+        &mut self,
+        msg: OpenMiningChannelError,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_OPEN_MINING_CHANNEL_ERROR,
+        ))
+    }
+
+    fn handle_update_channel_error(
+        &mut self,
+        msg: UpdateChannelError,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(MESSAGE_TYPE_UPDATE_CHANNEL_ERROR))
+    }
+
+    fn handle_close_channel(
+        &mut self,
+        msg: CloseChannel,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(MESSAGE_TYPE_CLOSE_CHANNEL))
+    }
+
+    fn handle_set_extranonce_prefix(
+        &mut self,
+        msg: SetExtranoncePrefix,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_EXTRANONCE_PREFIX))
+    }
+
+    fn handle_submit_shares_success(
+        &mut self,
+        msg: SubmitSharesSuccess,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(MESSAGE_TYPE_SUBMIT_SHARES_SUCCESS))
+    }
+
+    fn handle_submit_shares_error(
+        &mut self,
+        msg: SubmitSharesError,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(MESSAGE_TYPE_SUBMIT_SHARES_ERROR))
+    }
+
+    fn handle_new_mining_job(
+        &mut self,
+        msg: NewMiningJob,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(MESSAGE_TYPE_NEW_MINING_JOB))
+    }
+
+    fn handle_new_extended_mining_job(
+        &mut self,
+        msg: NewExtendedMiningJob,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_NEW_EXTENDED_MINING_JOB,
+        ))
+    }
+
+    fn handle_set_new_prev_hash_mining(
+        &mut self,
+        msg: SetNewPrevHash,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_NEW_PREV_HASH))
+    }
+
+    fn handle_set_custom_mining_job_success(
+        &mut self,
+        msg: SetCustomMiningJobSuccess,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_SET_CUSTOM_MINING_JOB_SUCCESS,
+        ))
+    }
+
+    fn handle_set_custom_mining_job_error(
+        &mut self,
+        msg: SetCustomMiningJobError,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_SET_CUSTOM_MINING_JOB_ERROR,
+        ))
+    }
+
+    fn handle_set_target(&mut self, msg: SetTarget) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_TARGET))
+    }
+
+    fn handle_set_group_channel(
+        &mut self,
+        msg: SetGroupChannel,
+    ) -> Result<Option<Mining<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_GROUP_CHANNEL))
+    }
+}
diff --git a/protocols/v2/roles-logic-sv2/src/handlers2/mod.rs b/protocols/v2/roles-logic-sv2/src/handlers2/mod.rs
new file mode 100644
index 0000000000..6f4d478bca
--- /dev/null
+++ b/protocols/v2/roles-logic-sv2/src/handlers2/mod.rs
@@ -0,0 +1,259 @@
+#![allow(warnings)]
+
+use std::convert::TryInto;
+
+use mining_sv2::{
+    MESSAGE_TYPE_NEW_EXTENDED_MINING_JOB, MESSAGE_TYPE_NEW_MINING_JOB,
+    MESSAGE_TYPE_OPEN_EXTENDED_MINING_CHANNEL, MESSAGE_TYPE_OPEN_EXTENDED_MINING_CHANNEL_SUCCESS,
+    MESSAGE_TYPE_OPEN_STANDARD_MINING_CHANNEL, MESSAGE_TYPE_OPEN_STANDARD_MINING_CHANNEL_SUCCESS,
+    MESSAGE_TYPE_SET_CUSTOM_MINING_JOB, MESSAGE_TYPE_SET_CUSTOM_MINING_JOB_ERROR,
+    MESSAGE_TYPE_SET_CUSTOM_MINING_JOB_SUCCESS, MESSAGE_TYPE_SET_GROUP_CHANNEL,
+    MESSAGE_TYPE_SUBMIT_SHARES_EXTENDED, MESSAGE_TYPE_SUBMIT_SHARES_STANDARD,
+};
+
+use crate::{
+    handlers2::{
+        common::{ParseCommonMessagesFromDownstream, ParseCommonMessagesFromUpstream},
+        job_declaration::{
+            ParseJobDeclarationMessagesFromDownstream, ParseJobDeclarationMessagesFromUpstream,
+        },
+        mining::{
+            DownstreamAuth, ParseMiningMessagesFromDownstream, ParseMiningMessagesFromUpstream,
+            SupportedChannelTypes,
+        },
+        template_distribution::{
+            ParseTemplateDistributionMessagesFromClient,
+            ParseTemplateDistributionMessagesFromServer,
+        },
+    },
+    parsers::{AnyMessage, CommonMessages, JobDeclaration, Mining, TemplateDistribution},
+    Error,
+};
+mod common;
+mod job_declaration;
+mod mining;
+mod template_distribution;
+pub trait Sv2Router<D: std::fmt::Debug>:
+    ParseCommonMessagesFromUpstream
+    + ParseCommonMessagesFromDownstream
+    + ParseMiningMessagesFromUpstream<D>
+    + ParseMiningMessagesFromDownstream<D>
+    + ParseJobDeclarationMessagesFromUpstream
+    + ParseJobDeclarationMessagesFromDownstream
+    + ParseTemplateDistributionMessagesFromServer
+    + ParseTemplateDistributionMessagesFromClient
+{
+    fn handle_message(
+        &mut self,
+        message_type: u8,
+        payload: &mut [u8],
+    ) -> Result<Option<AnyMessage<'static>>, Error> {
+        match message_type {
+            0x00..=0x05 => self.handle_common(message_type, payload),
+            0x10..=0x25 => self.handle_mining(message_type, payload),
+            0x50..=0x60 => self.handle_job_declaration(message_type, payload),
+            0x70..=0x76 => self.handle_template_distribution(message_type, payload),
+            _ => Ok(None),
+        }
+    }
+
+    fn handle_common(
+        &mut self,
+        message_type: u8,
+        payload: &mut [u8],
+    ) -> Result<Option<AnyMessage<'static>>, Error> {
+        let msg: CommonMessages = (message_type, payload).try_into()?;
+        let res = match msg {
+            CommonMessages::SetupConnectionSuccess(m) => self.handle_setup_connection_success(m),
+            CommonMessages::SetupConnectionError(m) => self.handle_setup_connection_error(m),
+            CommonMessages::ChannelEndpointChanged(m) => self.handle_channel_endpoint_changed(m),
+            CommonMessages::Reconnect(m) => self.handle_reconnect(m),
+            CommonMessages::SetupConnection(m) => self.handle_setup_connection(m),
+        };
+        res.map(|opt| opt.map(AnyMessage::Common))
+    }
+
+    fn handle_mining(
+        &mut self,
+        message_type: u8,
+        payload: &mut [u8],
+    ) -> Result<Option<AnyMessage<'static>>, Error> {
+        let msg: Mining = (message_type, payload).try_into()?;
+        let (chan, work) = (self.get_channel_type(), self.is_work_selection_enabled());
+
+        use SupportedChannelTypes::*;
+        let res = match msg {
+            Mining::OpenStandardMiningChannel(m) => {
+                if self.is_downstream_authorized(&m.user_identity)? == DownstreamAuth::Restrict {
+                    return Ok(Some(AnyMessage::Mining(Mining::OpenMiningChannelError(
+                        mining_sv2::OpenMiningChannelError::new_unknown_user(
+                            m.get_request_id_as_u32(),
+                        ),
+                    ))));
+                }
+                match chan {
+                    Standard | Group | GroupAndExtended => {
+                        self.handle_open_standard_mining_channel(m)
+                    }
+                    Extended => Err(Error::UnexpectedMessage(
+                        MESSAGE_TYPE_OPEN_STANDARD_MINING_CHANNEL,
+                    )),
+                }
+            }
+
+            Mining::OpenExtendedMiningChannel(m) => {
+                if self.is_downstream_authorized(&m.user_identity)? == DownstreamAuth::Restrict {
+                    return Ok(Some(AnyMessage::Mining(Mining::OpenMiningChannelError(
+                        mining_sv2::OpenMiningChannelError::new_unknown_user(
+                            m.get_request_id_as_u32(),
+                        ),
+                    ))));
+                }
+                match chan {
+                    Extended | GroupAndExtended => self.handle_open_extended_mining_channel(m),
+                    _ => Err(Error::UnexpectedMessage(
+                        MESSAGE_TYPE_OPEN_EXTENDED_MINING_CHANNEL,
+                    )),
+                }
+            }
+
+            Mining::UpdateChannel(m) => self.handle_update_channel(m),
+
+            Mining::SubmitSharesStandard(m) => match chan {
+                Standard | Group | GroupAndExtended => self.handle_submit_shares_standard(m),
+                Extended => Err(Error::UnexpectedMessage(
+                    MESSAGE_TYPE_SUBMIT_SHARES_STANDARD,
+                )),
+            },
+
+            Mining::SubmitSharesExtended(m) => match chan {
+                Extended | GroupAndExtended => self.handle_submit_shares_extended(m),
+                _ => Err(Error::UnexpectedMessage(
+                    MESSAGE_TYPE_SUBMIT_SHARES_EXTENDED,
+                )),
+            },
+
+            Mining::SetCustomMiningJob(m) => match (chan, work) {
+                (Extended, true) | (GroupAndExtended, true) => self.handle_set_custom_mining_job(m),
+                _ => Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_CUSTOM_MINING_JOB)),
+            },
+
+            Mining::OpenStandardMiningChannelSuccess(m) => match chan {
+                Standard | Group | GroupAndExtended => {
+                    self.handle_open_standard_mining_channel_success(m)
+                }
+                _ => Err(Error::UnexpectedMessage(
+                    MESSAGE_TYPE_OPEN_STANDARD_MINING_CHANNEL_SUCCESS,
+                )),
+            },
+
+            Mining::OpenExtendedMiningChannelSuccess(m) => match chan {
+                Extended | GroupAndExtended => self.handle_open_extended_mining_channel_success(m),
+                _ => Err(Error::UnexpectedMessage(
+                    MESSAGE_TYPE_OPEN_EXTENDED_MINING_CHANNEL_SUCCESS,
+                )),
+            },
+
+            Mining::OpenMiningChannelError(m) => self.handle_open_mining_channel_error(m),
+            Mining::UpdateChannelError(m) => self.handle_update_channel_error(m),
+            Mining::CloseChannel(m) => self.handle_close_channel(m),
+            Mining::SetExtranoncePrefix(m) => self.handle_set_extranonce_prefix(m),
+            Mining::SubmitSharesSuccess(m) => self.handle_submit_shares_success(m),
+            Mining::SubmitSharesError(m) => self.handle_submit_shares_error(m),
+
+            Mining::NewMiningJob(m) => match chan {
+                Standard => self.handle_new_mining_job(m),
+                _ => Err(Error::UnexpectedMessage(MESSAGE_TYPE_NEW_MINING_JOB)),
+            },
+
+            Mining::NewExtendedMiningJob(m) => match chan {
+                Extended | Group | GroupAndExtended => self.handle_new_extended_mining_job(m),
+                _ => Err(Error::UnexpectedMessage(
+                    MESSAGE_TYPE_NEW_EXTENDED_MINING_JOB,
+                )),
+            },
+
+            Mining::SetNewPrevHash(m) => self.handle_set_new_prev_hash_mining(m),
+
+            Mining::SetCustomMiningJobSuccess(m) => match (chan, work) {
+                (Extended, true) | (GroupAndExtended, true) => {
+                    self.handle_set_custom_mining_job_success(m)
+                }
+                _ => Err(Error::UnexpectedMessage(
+                    MESSAGE_TYPE_SET_CUSTOM_MINING_JOB_SUCCESS,
+                )),
+            },
+
+            Mining::SetCustomMiningJobError(m) => match (chan, work) {
+                (Extended, true) | (Group, true) | (GroupAndExtended, true) => {
+                    self.handle_set_custom_mining_job_error(m)
+                }
+                _ => Err(Error::UnexpectedMessage(
+                    MESSAGE_TYPE_SET_CUSTOM_MINING_JOB_ERROR,
+                )),
+            },
+
+            Mining::SetTarget(m) => self.handle_set_target(m),
+
+            Mining::SetGroupChannel(m) => match chan {
+                Group | GroupAndExtended => self.handle_set_group_channel(m),
+                _ => Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_GROUP_CHANNEL)),
+            },
+        };
+
+        res.map(|opt| opt.map(AnyMessage::Mining))
+    }
+
+    fn handle_job_declaration(
+        &mut self,
+        message_type: u8,
+        payload: &mut [u8],
+    ) -> Result<Option<AnyMessage<'static>>, Error> {
+        let msg: JobDeclaration = (message_type, payload).try_into()?;
+        let res = match msg {
+            JobDeclaration::AllocateMiningJobToken(m) => self.handle_allocate_mining_job_token(m),
+            JobDeclaration::DeclareMiningJob(m) => self.handle_declare_mining_job(m),
+            JobDeclaration::ProvideMissingTransactionsSuccess(m) => {
+                self.handle_provide_missing_transactions_success(m)
+            }
+            JobDeclaration::PushSolution(m) => self.handle_push_solution(m),
+            JobDeclaration::AllocateMiningJobTokenSuccess(m) => {
+                self.handle_allocate_mining_job_token_success(m)
+            }
+            JobDeclaration::DeclareMiningJobSuccess(m) => self.handle_declare_mining_job_success(m),
+            JobDeclaration::DeclareMiningJobError(m) => self.handle_declare_mining_job_error(m),
+            JobDeclaration::ProvideMissingTransactions(m) => {
+                self.handle_provide_missing_transactions(m)
+            }
+        };
+
+        res.map(|opt| opt.map(AnyMessage::JobDeclaration))
+    }
+
+    fn handle_template_distribution(
+        &mut self,
+        message_type: u8,
+        payload: &mut [u8],
+    ) -> Result<Option<AnyMessage<'static>>, Error> {
+        let msg: TemplateDistribution = (message_type, payload).try_into()?;
+        let res = match msg {
+            TemplateDistribution::CoinbaseOutputConstraints(m) => {
+                self.handle_coinbase_out_data_size(m)
+            }
+            TemplateDistribution::RequestTransactionData(m) => self.handle_request_tx_data(m),
+            TemplateDistribution::SubmitSolution(m) => self.handle_request_submit_solution(m),
+            TemplateDistribution::NewTemplate(m) => self.handle_new_template(m),
+            TemplateDistribution::SetNewPrevHash(m) => {
+                self.handle_set_new_prev_hash_template_distribution(m)
+            }
+            TemplateDistribution::RequestTransactionDataSuccess(m) => {
+                self.handle_request_tx_data_success(m)
+            }
+            TemplateDistribution::RequestTransactionDataError(m) => {
+                self.handle_request_tx_data_error(m)
+            }
+        };
+
+        res.map(|opt| opt.map(AnyMessage::TemplateDistribution))
+    }
+}
diff --git a/protocols/v2/roles-logic-sv2/src/handlers2/template_distribution.rs b/protocols/v2/roles-logic-sv2/src/handlers2/template_distribution.rs
new file mode 100644
index 0000000000..fa62da426e
--- /dev/null
+++ b/protocols/v2/roles-logic-sv2/src/handlers2/template_distribution.rs
@@ -0,0 +1,76 @@
+use crate::{errors::Error, parsers::TemplateDistribution};
+use template_distribution_sv2::{
+    CoinbaseOutputConstraints, NewTemplate, RequestTransactionData, RequestTransactionDataError,
+    RequestTransactionDataSuccess, SetNewPrevHash, SubmitSolution,
+};
+
+use core::convert::TryInto;
+use template_distribution_sv2::*;
+
+pub trait ParseTemplateDistributionMessagesFromServer {
+    fn handle_new_template(
+        &mut self,
+        msg: NewTemplate,
+    ) -> Result<Option<TemplateDistribution<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(MESSAGE_TYPE_NEW_TEMPLATE))
+    }
+
+    fn handle_set_new_prev_hash_template_distribution(
+        &mut self,
+        msg: SetNewPrevHash,
+    ) -> Result<Option<TemplateDistribution<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_NEW_PREV_HASH))
+    }
+
+    fn handle_request_tx_data_success(
+        &mut self,
+        msg: RequestTransactionDataSuccess,
+    ) -> Result<Option<TemplateDistribution<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_REQUEST_TRANSACTION_DATA_SUCCESS,
+        ))
+    }
+
+    fn handle_request_tx_data_error(
+        &mut self,
+        msg: RequestTransactionDataError,
+    ) -> Result<Option<TemplateDistribution<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_REQUEST_TRANSACTION_DATA_ERROR,
+        ))
+    }
+}
+
+pub trait ParseTemplateDistributionMessagesFromClient {
+    fn handle_coinbase_out_data_size(
+        &mut self,
+        msg: CoinbaseOutputConstraints,
+    ) -> Result<Option<TemplateDistribution<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_COINBASE_OUTPUT_CONSTRAINTS,
+        ))
+    }
+
+    fn handle_request_tx_data(
+        &mut self,
+        msg: RequestTransactionData,
+    ) -> Result<Option<TemplateDistribution<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(
+            MESSAGE_TYPE_REQUEST_TRANSACTION_DATA,
+        ))
+    }
+
+    fn handle_request_submit_solution(
+        &mut self,
+        msg: SubmitSolution,
+    ) -> Result<Option<TemplateDistribution<'static>>, Error> {
+        let _ = msg;
+        Err(Error::UnexpectedMessage(MESSAGE_TYPE_SUBMIT_SOLUTION))
+    }
+}
diff --git a/protocols/v2/roles-logic-sv2/src/lib.rs b/protocols/v2/roles-logic-sv2/src/lib.rs
index 865b73b92f..f5c65cf2f6 100644
--- a/protocols/v2/roles-logic-sv2/src/lib.rs
+++ b/protocols/v2/roles-logic-sv2/src/lib.rs
@@ -21,6 +21,7 @@ pub mod channel_logic;
 pub mod channels;
 pub mod errors;
 pub mod handlers;
+pub mod handlers2;
 pub mod job_creator;
 pub mod parsers;
 pub mod utils;