From 476247e8b68b3204a893f024423ec84473ae2569 Mon Sep 17 00:00:00 2001 From: bit-aloo Date: Tue, 8 Jul 2025 18:37:04 +0530 Subject: [PATCH 1/4] handlers refactor poc --- .../roles-logic-sv2/src/handlers2/common.rs | 59 ++++ .../src/handlers2/job_declaration.rs | 134 ++++++++ .../roles-logic-sv2/src/handlers2/mining.rs | 302 ++++++++++++++++++ .../v2/roles-logic-sv2/src/handlers2/mod.rs | 5 + .../src/handlers2/template_distribution.rs | 124 +++++++ protocols/v2/roles-logic-sv2/src/lib.rs | 1 + 6 files changed, 625 insertions(+) create mode 100644 protocols/v2/roles-logic-sv2/src/handlers2/common.rs create mode 100644 protocols/v2/roles-logic-sv2/src/handlers2/job_declaration.rs create mode 100644 protocols/v2/roles-logic-sv2/src/handlers2/mining.rs create mode 100644 protocols/v2/roles-logic-sv2/src/handlers2/mod.rs create mode 100644 protocols/v2/roles-logic-sv2/src/handlers2/template_distribution.rs 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..3f21c30159 --- /dev/null +++ b/protocols/v2/roles-logic-sv2/src/handlers2/common.rs @@ -0,0 +1,59 @@ +use crate::{errors::Error, parsers::CommonMessages}; +use common_messages_sv2::{ + ChannelEndpointChanged, Reconnect, SetupConnectionError, + SetupConnectionSuccess, *, +}; +use core::convert::TryInto; + +pub trait ParseCommonMessagesFromUpstream{ + fn handle_common_message( + &mut self, + message_type: u8, + payload: &mut [u8], + ) -> Result>, Error> { + let parsed: CommonMessages<'_> = (message_type, payload).try_into()?; + self.dispatch_common_message(parsed) + } + + fn dispatch_common_message( + &mut self, + message: CommonMessages<'_>, + ) -> Result>, Error> { + match message { + CommonMessages::SetupConnectionSuccess(msg) => { + self.handle_setup_connection_success(msg) + } + CommonMessages::SetupConnectionError(msg) => { + self.handle_setup_connection_error(msg) + } + CommonMessages::ChannelEndpointChanged(msg) => { + self.handle_channel_endpoint_changed(msg) + } + CommonMessages::Reconnect(msg) => self.handle_reconnect(msg), + + CommonMessages::SetupConnection(_) => { + Err(Error::UnexpectedMessage(MESSAGE_TYPE_SETUP_CONNECTION)) + } + } + } + + fn handle_setup_connection_success( + &mut self, + msg: SetupConnectionSuccess, + ) -> Result>, Error>; + + fn handle_setup_connection_error( + &mut self, + msg: SetupConnectionError, + ) -> Result>, Error>; + + fn handle_channel_endpoint_changed( + &mut self, + msg: ChannelEndpointChanged, + ) -> Result>, Error>; + + fn handle_reconnect( + &mut self, + msg: Reconnect, + ) -> Result>, Error>; +} 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..f37665eda3 --- /dev/null +++ b/protocols/v2/roles-logic-sv2/src/handlers2/job_declaration.rs @@ -0,0 +1,134 @@ +use crate::parsers::JobDeclaration; +use crate::errors::Error; +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_job_declaration_message( + &mut self, + message_type: u8, + payload: &mut [u8], + ) -> Result>, Error> { + let parsed: JobDeclaration<'_> = (message_type, payload).try_into()?; + self.dispatch_job_declaration(parsed) + } + + fn dispatch_job_declaration( + &mut self, + message: JobDeclaration<'_>, + ) -> Result>, Error> { + match message { + JobDeclaration::AllocateMiningJobTokenSuccess(msg) => { + self.handle_allocate_mining_job_token_success(msg) + } + JobDeclaration::DeclareMiningJobSuccess(msg) => { + self.handle_declare_mining_job_success(msg) + } + JobDeclaration::DeclareMiningJobError(msg) => { + self.handle_declare_mining_job_error(msg) + } + JobDeclaration::ProvideMissingTransactions(msg) => { + self.handle_provide_missing_transactions(msg) + } + JobDeclaration::AllocateMiningJobToken(_) => { + Err(Error::UnexpectedMessage(MESSAGE_TYPE_ALLOCATE_MINING_JOB_TOKEN)) + } + JobDeclaration::DeclareMiningJob(_) => { + Err(Error::UnexpectedMessage(MESSAGE_TYPE_DECLARE_MINING_JOB)) + } + JobDeclaration::ProvideMissingTransactionsSuccess(_) => { + Err(Error::UnexpectedMessage(MESSAGE_TYPE_PROVIDE_MISSING_TRANSACTIONS_SUCCESS)) + } + JobDeclaration::PushSolution(_) => { + Err(Error::UnexpectedMessage(MESSAGE_TYPE_PUSH_SOLUTION)) + } + } + } + + fn handle_allocate_mining_job_token_success( + &mut self, + message: AllocateMiningJobTokenSuccess, + ) -> Result>, Error>; + + fn handle_declare_mining_job_success( + &mut self, + message: DeclareMiningJobSuccess, + ) -> Result>, Error>; + + fn handle_declare_mining_job_error( + &mut self, + message: DeclareMiningJobError, + ) -> Result>, Error>; + + fn handle_provide_missing_transactions( + &mut self, + message: ProvideMissingTransactions, + ) -> Result>, Error>; +} + + +pub trait ParseJobDeclarationMessagesFromDownstream { + fn handle_job_declaration_message( + &mut self, + message_type: u8, + payload: &mut [u8], + ) -> Result>, Error> { + let parsed: JobDeclaration<'_> = (message_type, payload).try_into()?; + self.dispatch_job_declaration(parsed) + } + + fn dispatch_job_declaration( + &mut self, + message: JobDeclaration<'_>, + ) -> Result>, Error> { + match message { + JobDeclaration::AllocateMiningJobToken(msg) => { + self.handle_allocate_mining_job_token(msg) + } + JobDeclaration::DeclareMiningJob(msg) => self.handle_declare_mining_job(msg), + JobDeclaration::ProvideMissingTransactionsSuccess(msg) => { + self.handle_provide_missing_transactions_success(msg) + } + JobDeclaration::PushSolution(msg) => self.handle_push_solution(msg), + + JobDeclaration::AllocateMiningJobTokenSuccess(_) => { + Err(Error::UnexpectedMessage(MESSAGE_TYPE_ALLOCATE_MINING_JOB_TOKEN_SUCCESS)) + } + JobDeclaration::DeclareMiningJobSuccess(_) => { + Err(Error::UnexpectedMessage(MESSAGE_TYPE_DECLARE_MINING_JOB_SUCCESS)) + } + JobDeclaration::DeclareMiningJobError(_) => { + Err(Error::UnexpectedMessage(MESSAGE_TYPE_DECLARE_MINING_JOB_ERROR)) + } + JobDeclaration::ProvideMissingTransactions(_) => { + Err(Error::UnexpectedMessage(MESSAGE_TYPE_PROVIDE_MISSING_TRANSACTIONS)) + } + } + } + + fn handle_allocate_mining_job_token( + &mut self, + message: AllocateMiningJobToken, + ) -> Result>, Error>; + + fn handle_declare_mining_job( + &mut self, + message: DeclareMiningJob, + ) -> Result>, Error>; + + fn handle_provide_missing_transactions_success( + &mut self, + message: ProvideMissingTransactionsSuccess, + ) -> Result>, Error>; + + fn handle_push_solution( + &mut self, + message: PushSolution, + ) -> Result>, Error>; +} \ No newline at end of file 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..f64846f7c7 --- /dev/null +++ b/protocols/v2/roles-logic-sv2/src/handlers2/mining.rs @@ -0,0 +1,302 @@ +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 crate::common_properties::{IsMiningDownstream, IsMiningUpstream}; + +use mining_sv2::*; +use std::fmt::Debug as D; + +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum SupportedChannelTypes { + Standard, + Extended, + Group, + GroupAndExtended, +} + + +pub trait ParseMiningMessagesFromDownstream +where + Self: Sized + D, +{ + fn get_channel_type(&self) -> SupportedChannelTypes; + fn is_work_selection_enabled(&self) -> bool; + + fn is_downstream_authorized( + &self, + user_identity: &binary_sv2::Str0255, + ) -> Result; + + fn handle_mining_message(&mut self, message: Mining) -> Result>, Error> { + let (channel_type, work_selection) = + (self.get_channel_type(), self.is_work_selection_enabled()); + + use Mining::*; + match message { + OpenStandardMiningChannel(m) => { + if !self.is_downstream_authorized(&m.user_identity)? { + return Ok(Some(Mining::OpenMiningChannelError( + mining_sv2::OpenMiningChannelError::new_unknown_user(m.get_request_id_as_u32()), + ))); + } + + match channel_type { + SupportedChannelTypes::Standard + | SupportedChannelTypes::Group + | SupportedChannelTypes::GroupAndExtended => { + self.handle_open_standard_mining_channel(m) + } + SupportedChannelTypes::Extended => Err(Error::UnexpectedMessage( + MESSAGE_TYPE_OPEN_STANDARD_MINING_CHANNEL, + )), + } + } + OpenExtendedMiningChannel(m) => { + if !self.is_downstream_authorized(&m.user_identity)? { + return Ok(Some(Mining::OpenMiningChannelError( + mining_sv2::OpenMiningChannelError::new_unknown_user(m.get_request_id_as_u32()), + ))); + } + + match channel_type { + SupportedChannelTypes::Extended + | SupportedChannelTypes::GroupAndExtended => { + self.handle_open_extended_mining_channel(m) + } + _ => Err(Error::UnexpectedMessage(MESSAGE_TYPE_OPEN_EXTENDED_MINING_CHANNEL)), + } + } + UpdateChannel(m) => self.handle_update_channel(m), + + SubmitSharesStandard(m) => match channel_type { + SupportedChannelTypes::Standard + | SupportedChannelTypes::Group + | SupportedChannelTypes::GroupAndExtended => { + self.handle_submit_shares_standard(m) + } + SupportedChannelTypes::Extended => Err(Error::UnexpectedMessage( + MESSAGE_TYPE_SUBMIT_SHARES_STANDARD, + )), + }, + + SubmitSharesExtended(m) => match channel_type { + SupportedChannelTypes::Extended + | SupportedChannelTypes::GroupAndExtended => { + self.handle_submit_shares_extended(m) + } + _ => Err(Error::UnexpectedMessage(MESSAGE_TYPE_SUBMIT_SHARES_EXTENDED)), + }, + + SetCustomMiningJob(m) => match (channel_type, work_selection) { + (SupportedChannelTypes::Extended, true) + | (SupportedChannelTypes::GroupAndExtended, true) => { + self.handle_set_custom_mining_job(m) + } + _ => Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_CUSTOM_MINING_JOB)), + }, + + _ => Err(Error::UnexpectedMessage(0)), + } + } + + fn handle_open_standard_mining_channel( + &mut self, + m: OpenStandardMiningChannel, + ) -> Result>, Error>; + + fn handle_open_extended_mining_channel( + &mut self, + m: OpenExtendedMiningChannel, + ) -> Result>, Error>; + + fn handle_update_channel( + &mut self, + m: UpdateChannel, + ) -> Result>, Error>; + + fn handle_submit_shares_standard( + &mut self, + m: SubmitSharesStandard, + ) -> Result>, Error>; + + fn handle_submit_shares_extended( + &mut self, + m: SubmitSharesExtended, + ) -> Result>, Error>; + + fn handle_set_custom_mining_job( + &mut self, + m: SetCustomMiningJob, + ) -> Result>, Error>; +} + + +pub trait ParseMiningMessagesFromUpstream +where + Self: Sized + D, +{ + fn get_channel_type(&self) -> SupportedChannelTypes; + fn is_work_selection_enabled(&self) -> bool; + + fn handle_mining_message(&mut self, message: Mining) -> Result>, Error> { + let (channel_type, work_selection) = + (self.get_channel_type(), self.is_work_selection_enabled()); + + use Mining::*; + match message { + OpenStandardMiningChannelSuccess(m) => match channel_type { + SupportedChannelTypes::Standard + | SupportedChannelTypes::Group + | SupportedChannelTypes::GroupAndExtended => { + self.handle_open_standard_mining_channel_success(m) + } + _ => Err(Error::UnexpectedMessage( + MESSAGE_TYPE_OPEN_STANDARD_MINING_CHANNEL_SUCCESS, + )), + }, + + OpenExtendedMiningChannelSuccess(m) => match channel_type { + SupportedChannelTypes::Extended + | SupportedChannelTypes::GroupAndExtended => { + self.handle_open_extended_mining_channel_success(m) + } + _ => Err(Error::UnexpectedMessage( + MESSAGE_TYPE_OPEN_EXTENDED_MINING_CHANNEL_SUCCESS, + )), + }, + + OpenMiningChannelError(m) => self.handle_open_mining_channel_error(m), + UpdateChannelError(m) => self.handle_update_channel_error(m), + CloseChannel(m) => self.handle_close_channel(m), + SetExtranoncePrefix(m) => self.handle_set_extranonce_prefix(m), + SubmitSharesSuccess(m) => self.handle_submit_shares_success(m), + SubmitSharesError(m) => self.handle_submit_shares_error(m), + + NewMiningJob(m) => match channel_type { + SupportedChannelTypes::Standard => self.handle_new_mining_job(m), + _ => Err(Error::UnexpectedMessage(MESSAGE_TYPE_NEW_MINING_JOB)), + }, + + NewExtendedMiningJob(m) => match channel_type { + SupportedChannelTypes::Extended + | SupportedChannelTypes::Group + | SupportedChannelTypes::GroupAndExtended => { + self.handle_new_extended_mining_job(m) + } + _ => Err(Error::UnexpectedMessage(MESSAGE_TYPE_NEW_EXTENDED_MINING_JOB)), + }, + + SetNewPrevHash(m) => self.handle_set_new_prev_hash(m), + + SetCustomMiningJobSuccess(m) => match (channel_type, work_selection) { + (SupportedChannelTypes::Extended, true) + | (SupportedChannelTypes::GroupAndExtended, true) => { + self.handle_set_custom_mining_job_success(m) + } + _ => Err(Error::UnexpectedMessage( + MESSAGE_TYPE_SET_CUSTOM_MINING_JOB_SUCCESS, + )), + }, + + SetCustomMiningJobError(m) => match (channel_type, work_selection) { + (SupportedChannelTypes::Extended, true) + | (SupportedChannelTypes::Group, true) + | (SupportedChannelTypes::GroupAndExtended, true) => { + self.handle_set_custom_mining_job_error(m) + } + _ => Err(Error::UnexpectedMessage( + MESSAGE_TYPE_SET_CUSTOM_MINING_JOB_ERROR, + )), + }, + + SetTarget(m) => self.handle_set_target(m), + + SetGroupChannel(m) => match channel_type { + SupportedChannelTypes::Group | SupportedChannelTypes::GroupAndExtended => { + self.handle_set_group_channel(m) + } + _ => Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_GROUP_CHANNEL)), + }, + + _ => Err(Error::UnexpectedMessage(0)), + } + } + + fn handle_open_standard_mining_channel_success( + &mut self, + m: OpenStandardMiningChannelSuccess, + ) -> Result>, Error>; + + fn handle_open_extended_mining_channel_success( + &mut self, + m: OpenExtendedMiningChannelSuccess, + ) -> Result>, Error>; + + fn handle_open_mining_channel_error( + &mut self, + m: OpenMiningChannelError, + ) -> Result>, Error>; + + fn handle_update_channel_error( + &mut self, + m: UpdateChannelError, + ) -> Result>, Error>; + + fn handle_close_channel( + &mut self, + m: CloseChannel, + ) -> Result>, Error>; + + fn handle_set_extranonce_prefix( + &mut self, + m: SetExtranoncePrefix, + ) -> Result>, Error>; + + fn handle_submit_shares_success( + &mut self, + m: SubmitSharesSuccess, + ) -> Result>, Error>; + + fn handle_submit_shares_error( + &mut self, + m: SubmitSharesError, + ) -> Result>, Error>; + + fn handle_new_mining_job( + &mut self, + m: NewMiningJob, + ) -> Result>, Error>; + + fn handle_new_extended_mining_job( + &mut self, + m: NewExtendedMiningJob, + ) -> Result>, Error>; + + fn handle_set_new_prev_hash( + &mut self, + m: SetNewPrevHash, + ) -> Result>, Error>; + + fn handle_set_custom_mining_job_success( + &mut self, + m: SetCustomMiningJobSuccess, + ) -> Result>, Error>; + + fn handle_set_custom_mining_job_error( + &mut self, + m: SetCustomMiningJobError, + ) -> Result>, Error>; + + fn handle_set_target(&mut self, m: SetTarget) -> Result>, Error>; + + fn handle_set_group_channel(&mut self, m: SetGroupChannel) + -> Result>, Error>; +} 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..92bf57faa1 --- /dev/null +++ b/protocols/v2/roles-logic-sv2/src/handlers2/mod.rs @@ -0,0 +1,5 @@ +#![allow(warnings)] +mod common; +mod job_declaration; +mod template_distribution; +mod mining; 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..485f1e1692 --- /dev/null +++ b/protocols/v2/roles-logic-sv2/src/handlers2/template_distribution.rs @@ -0,0 +1,124 @@ +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_template_distribution_message( + &mut self, + message_type: u8, + payload: &mut [u8], + ) -> Result>, Error> { + let parsed: TemplateDistribution<'_> = (message_type, payload).try_into()?; + self.dispatch_template_distribution(parsed) + } + + fn dispatch_template_distribution( + &mut self, + message: TemplateDistribution<'_>, + ) -> Result>, Error> { + match message { + TemplateDistribution::NewTemplate(m) => self.handle_new_template(m), + TemplateDistribution::SetNewPrevHash(m) => self.handle_set_new_prev_hash(m), + TemplateDistribution::RequestTransactionDataSuccess(m) => { + self.handle_request_tx_data_success(m) + } + TemplateDistribution::RequestTransactionDataError(m) => { + self.handle_request_tx_data_error(m) + } + + TemplateDistribution::CoinbaseOutputConstraints(_) => { + Err(Error::UnexpectedMessage(MESSAGE_TYPE_COINBASE_OUTPUT_CONSTRAINTS)) + } + TemplateDistribution::RequestTransactionData(_) => { + Err(Error::UnexpectedMessage(MESSAGE_TYPE_REQUEST_TRANSACTION_DATA)) + } + TemplateDistribution::SubmitSolution(_) => { + Err(Error::UnexpectedMessage(MESSAGE_TYPE_SUBMIT_SOLUTION)) + } + } + } + + fn handle_new_template( + &mut self, + m: NewTemplate, + ) -> Result>, Error>; + + fn handle_set_new_prev_hash( + &mut self, + m: SetNewPrevHash, + ) -> Result>, Error>; + + fn handle_request_tx_data_success( + &mut self, + m: RequestTransactionDataSuccess, + ) -> Result>, Error>; + + fn handle_request_tx_data_error( + &mut self, + m: RequestTransactionDataError, + ) -> Result>, Error>; +} + + +pub trait ParseTemplateDistributionMessagesFromClient { + fn handle_template_distribution_message( + &mut self, + message_type: u8, + payload: &mut [u8], + ) -> Result>, Error> { + let parsed: TemplateDistribution<'_> = (message_type, payload).try_into()?; + self.dispatch_template_distribution(parsed) + } + + fn dispatch_template_distribution( + &mut self, + message: TemplateDistribution<'_>, + ) -> Result>, Error> { + match message { + 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(_) => { + Err(Error::UnexpectedMessage(MESSAGE_TYPE_NEW_TEMPLATE)) + } + TemplateDistribution::SetNewPrevHash(_) => { + Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_NEW_PREV_HASH)) + } + TemplateDistribution::RequestTransactionDataSuccess(_) => { + Err(Error::UnexpectedMessage(MESSAGE_TYPE_REQUEST_TRANSACTION_DATA_SUCCESS)) + } + TemplateDistribution::RequestTransactionDataError(_) => { + Err(Error::UnexpectedMessage(MESSAGE_TYPE_REQUEST_TRANSACTION_DATA_ERROR)) + } + } + } + + fn handle_coinbase_out_data_size( + &mut self, + m: CoinbaseOutputConstraints, + ) -> Result>, Error>; + + fn handle_request_tx_data( + &mut self, + m: RequestTransactionData, + ) -> Result>, Error>; + + fn handle_request_submit_solution( + &mut self, + m: SubmitSolution, + ) -> Result>, Error>; +} \ No newline at end of file diff --git a/protocols/v2/roles-logic-sv2/src/lib.rs b/protocols/v2/roles-logic-sv2/src/lib.rs index 865b73b92f..cafd4a2596 100644 --- a/protocols/v2/roles-logic-sv2/src/lib.rs +++ b/protocols/v2/roles-logic-sv2/src/lib.rs @@ -23,6 +23,7 @@ pub mod errors; pub mod handlers; pub mod job_creator; pub mod parsers; +pub mod handlers2; pub mod utils; pub mod vardiff; pub use bitcoin; From 166deac1613a81c72dfdfa4d4dbecc69e80fd199 Mon Sep 17 00:00:00 2001 From: bit-aloo Date: Wed, 9 Jul 2025 11:31:46 +0530 Subject: [PATCH 2/4] add dummy implementation to traits --- .../roles-logic-sv2/src/handlers2/common.rs | 20 +++++-- .../src/handlers2/job_declaration.rs | 52 ++++++++++++++----- .../v2/roles-logic-sv2/src/handlers2/mod.rs | 2 + .../src/handlers2/template_distribution.rs | 49 ++++++++++++----- 4 files changed, 91 insertions(+), 32 deletions(-) diff --git a/protocols/v2/roles-logic-sv2/src/handlers2/common.rs b/protocols/v2/roles-logic-sv2/src/handlers2/common.rs index 3f21c30159..1d19357c00 100644 --- a/protocols/v2/roles-logic-sv2/src/handlers2/common.rs +++ b/protocols/v2/roles-logic-sv2/src/handlers2/common.rs @@ -40,20 +40,32 @@ pub trait ParseCommonMessagesFromUpstream{ fn handle_setup_connection_success( &mut self, msg: SetupConnectionSuccess, - ) -> Result>, Error>; + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_setup_connection_error( &mut self, msg: SetupConnectionError, - ) -> Result>, Error>; + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_channel_endpoint_changed( &mut self, msg: ChannelEndpointChanged, - ) -> Result>, Error>; + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_reconnect( &mut self, msg: Reconnect, - ) -> Result>, Error>; + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } } diff --git a/protocols/v2/roles-logic-sv2/src/handlers2/job_declaration.rs b/protocols/v2/roles-logic-sv2/src/handlers2/job_declaration.rs index f37665eda3..562701e68d 100644 --- a/protocols/v2/roles-logic-sv2/src/handlers2/job_declaration.rs +++ b/protocols/v2/roles-logic-sv2/src/handlers2/job_declaration.rs @@ -53,23 +53,35 @@ pub trait ParseJobDeclarationMessagesFromUpstream { fn handle_allocate_mining_job_token_success( &mut self, - message: AllocateMiningJobTokenSuccess, - ) -> Result>, Error>; + msg: AllocateMiningJobTokenSuccess, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_declare_mining_job_success( &mut self, - message: DeclareMiningJobSuccess, - ) -> Result>, Error>; + msg: DeclareMiningJobSuccess, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_declare_mining_job_error( &mut self, message: DeclareMiningJobError, - ) -> Result>, Error>; + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_provide_missing_transactions( &mut self, message: ProvideMissingTransactions, - ) -> Result>, Error>; + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } } @@ -114,21 +126,33 @@ pub trait ParseJobDeclarationMessagesFromDownstream { fn handle_allocate_mining_job_token( &mut self, - message: AllocateMiningJobToken, - ) -> Result>, Error>; + msg: AllocateMiningJobToken, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_declare_mining_job( &mut self, - message: DeclareMiningJob, - ) -> Result>, Error>; + msg: DeclareMiningJob, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_provide_missing_transactions_success( &mut self, - message: ProvideMissingTransactionsSuccess, - ) -> Result>, Error>; + msg: ProvideMissingTransactionsSuccess, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_push_solution( &mut self, - message: PushSolution, - ) -> Result>, Error>; + msg: PushSolution, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } } \ No newline at end of file diff --git a/protocols/v2/roles-logic-sv2/src/handlers2/mod.rs b/protocols/v2/roles-logic-sv2/src/handlers2/mod.rs index 92bf57faa1..f4c8236da3 100644 --- a/protocols/v2/roles-logic-sv2/src/handlers2/mod.rs +++ b/protocols/v2/roles-logic-sv2/src/handlers2/mod.rs @@ -3,3 +3,5 @@ mod common; mod job_declaration; mod template_distribution; mod mining; + + diff --git a/protocols/v2/roles-logic-sv2/src/handlers2/template_distribution.rs b/protocols/v2/roles-logic-sv2/src/handlers2/template_distribution.rs index 485f1e1692..f9807de236 100644 --- a/protocols/v2/roles-logic-sv2/src/handlers2/template_distribution.rs +++ b/protocols/v2/roles-logic-sv2/src/handlers2/template_distribution.rs @@ -47,23 +47,35 @@ pub trait ParseTemplateDistributionMessagesFromServer { fn handle_new_template( &mut self, - m: NewTemplate, - ) -> Result>, Error>; + msg: NewTemplate, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_set_new_prev_hash( &mut self, - m: SetNewPrevHash, - ) -> Result>, Error>; + msg: SetNewPrevHash, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_request_tx_data_success( &mut self, - m: RequestTransactionDataSuccess, - ) -> Result>, Error>; + msg: RequestTransactionDataSuccess, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_request_tx_data_error( &mut self, - m: RequestTransactionDataError, - ) -> Result>, Error>; + msg: RequestTransactionDataError, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } } @@ -109,16 +121,25 @@ pub trait ParseTemplateDistributionMessagesFromClient { fn handle_coinbase_out_data_size( &mut self, - m: CoinbaseOutputConstraints, - ) -> Result>, Error>; + msg: CoinbaseOutputConstraints, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_request_tx_data( &mut self, - m: RequestTransactionData, - ) -> Result>, Error>; + msg: RequestTransactionData, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_request_submit_solution( &mut self, - m: SubmitSolution, - ) -> Result>, Error>; + msg: SubmitSolution, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } } \ No newline at end of file From 90144da7062876f22163556e5d0fc7c17c68e12d Mon Sep 17 00:00:00 2001 From: bit-aloo Date: Wed, 9 Jul 2025 11:44:53 +0530 Subject: [PATCH 3/4] add impl for mining --- .../src/handlers2/job_declaration.rs | 4 +- .../roles-logic-sv2/src/handlers2/mining.rs | 151 ++++++++++++------ 2 files changed, 108 insertions(+), 47 deletions(-) diff --git a/protocols/v2/roles-logic-sv2/src/handlers2/job_declaration.rs b/protocols/v2/roles-logic-sv2/src/handlers2/job_declaration.rs index 562701e68d..3671d550ee 100644 --- a/protocols/v2/roles-logic-sv2/src/handlers2/job_declaration.rs +++ b/protocols/v2/roles-logic-sv2/src/handlers2/job_declaration.rs @@ -69,7 +69,7 @@ pub trait ParseJobDeclarationMessagesFromUpstream { fn handle_declare_mining_job_error( &mut self, - message: DeclareMiningJobError, + msg: DeclareMiningJobError, ) -> Result>, Error> { let _ = msg; Ok(None) @@ -77,7 +77,7 @@ pub trait ParseJobDeclarationMessagesFromUpstream { fn handle_provide_missing_transactions( &mut self, - message: ProvideMissingTransactions, + msg: ProvideMissingTransactions, ) -> Result>, Error> { let _ = msg; Ok(None) diff --git a/protocols/v2/roles-logic-sv2/src/handlers2/mining.rs b/protocols/v2/roles-logic-sv2/src/handlers2/mining.rs index f64846f7c7..4d378517cf 100644 --- a/protocols/v2/roles-logic-sv2/src/handlers2/mining.rs +++ b/protocols/v2/roles-logic-sv2/src/handlers2/mining.rs @@ -9,8 +9,6 @@ use mining_sv2::{ UpdateChannel, UpdateChannelError, }; -use crate::common_properties::{IsMiningDownstream, IsMiningUpstream}; - use mining_sv2::*; use std::fmt::Debug as D; @@ -23,7 +21,7 @@ pub enum SupportedChannelTypes { } -pub trait ParseMiningMessagesFromDownstream +pub trait ParseMiningMessagesFromDownstream where Self: Sized + D, { @@ -109,37 +107,55 @@ where fn handle_open_standard_mining_channel( &mut self, - m: OpenStandardMiningChannel, - ) -> Result>, Error>; + msg: OpenStandardMiningChannel, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_open_extended_mining_channel( &mut self, - m: OpenExtendedMiningChannel, - ) -> Result>, Error>; + msg: OpenExtendedMiningChannel, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_update_channel( &mut self, - m: UpdateChannel, - ) -> Result>, Error>; + msg: UpdateChannel, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_submit_shares_standard( &mut self, - m: SubmitSharesStandard, - ) -> Result>, Error>; + msg: SubmitSharesStandard, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_submit_shares_extended( &mut self, - m: SubmitSharesExtended, - ) -> Result>, Error>; + msg: SubmitSharesExtended, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_set_custom_mining_job( &mut self, - m: SetCustomMiningJob, - ) -> Result>, Error>; + msg: SetCustomMiningJob, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } } -pub trait ParseMiningMessagesFromUpstream +pub trait ParseMiningMessagesFromUpstream where Self: Sized + D, { @@ -232,71 +248,116 @@ where fn handle_open_standard_mining_channel_success( &mut self, - m: OpenStandardMiningChannelSuccess, - ) -> Result>, Error>; + msg: OpenStandardMiningChannelSuccess, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_open_extended_mining_channel_success( &mut self, - m: OpenExtendedMiningChannelSuccess, - ) -> Result>, Error>; + msg: OpenExtendedMiningChannelSuccess, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_open_mining_channel_error( &mut self, - m: OpenMiningChannelError, - ) -> Result>, Error>; + msg: OpenMiningChannelError, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_update_channel_error( &mut self, - m: UpdateChannelError, - ) -> Result>, Error>; + msg: UpdateChannelError, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_close_channel( &mut self, - m: CloseChannel, - ) -> Result>, Error>; + msg: CloseChannel, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_set_extranonce_prefix( &mut self, - m: SetExtranoncePrefix, - ) -> Result>, Error>; + msg: SetExtranoncePrefix, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_submit_shares_success( &mut self, - m: SubmitSharesSuccess, - ) -> Result>, Error>; + msg: SubmitSharesSuccess, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_submit_shares_error( &mut self, - m: SubmitSharesError, - ) -> Result>, Error>; + msg: SubmitSharesError, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_new_mining_job( &mut self, - m: NewMiningJob, - ) -> Result>, Error>; + msg: NewMiningJob, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_new_extended_mining_job( &mut self, - m: NewExtendedMiningJob, - ) -> Result>, Error>; + msg: NewExtendedMiningJob, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_set_new_prev_hash( &mut self, - m: SetNewPrevHash, - ) -> Result>, Error>; + msg: SetNewPrevHash, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_set_custom_mining_job_success( &mut self, - m: SetCustomMiningJobSuccess, - ) -> Result>, Error>; + msg: SetCustomMiningJobSuccess, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } fn handle_set_custom_mining_job_error( &mut self, - m: SetCustomMiningJobError, - ) -> Result>, Error>; + msg: SetCustomMiningJobError, + ) -> Result>, Error> { + let _ = msg; + Ok(None) + } - fn handle_set_target(&mut self, m: SetTarget) -> Result>, Error>; + fn handle_set_target(&mut self, msg: SetTarget) -> Result>, Error> { + let _ = msg; + Ok(None) + } - fn handle_set_group_channel(&mut self, m: SetGroupChannel) - -> Result>, Error>; + fn handle_set_group_channel(&mut self, msg: SetGroupChannel) + -> Result>, Error> { + let _ = msg; + Ok(None) + } } From d8fa5c5d4276452772736c4a47c99c1625fbe81c Mon Sep 17 00:00:00 2001 From: bit-aloo Date: Wed, 9 Jul 2025 13:25:33 +0530 Subject: [PATCH 4/4] have a central router for handlers --- .../roles-logic-sv2/src/handlers2/common.rs | 63 ++--- .../src/handlers2/job_declaration.rs | 120 ++------ .../roles-logic-sv2/src/handlers2/mining.rs | 265 +++++------------- .../v2/roles-logic-sv2/src/handlers2/mod.rs | 254 ++++++++++++++++- .../src/handlers2/template_distribution.rs | 103 ++----- protocols/v2/roles-logic-sv2/src/lib.rs | 2 +- 6 files changed, 392 insertions(+), 415 deletions(-) diff --git a/protocols/v2/roles-logic-sv2/src/handlers2/common.rs b/protocols/v2/roles-logic-sv2/src/handlers2/common.rs index 1d19357c00..9ce1c73103 100644 --- a/protocols/v2/roles-logic-sv2/src/handlers2/common.rs +++ b/protocols/v2/roles-logic-sv2/src/handlers2/common.rs @@ -1,48 +1,18 @@ use crate::{errors::Error, parsers::CommonMessages}; use common_messages_sv2::{ - ChannelEndpointChanged, Reconnect, SetupConnectionError, - SetupConnectionSuccess, *, + ChannelEndpointChanged, Reconnect, SetupConnectionError, SetupConnectionSuccess, *, }; use core::convert::TryInto; -pub trait ParseCommonMessagesFromUpstream{ - fn handle_common_message( - &mut self, - message_type: u8, - payload: &mut [u8], - ) -> Result>, Error> { - let parsed: CommonMessages<'_> = (message_type, payload).try_into()?; - self.dispatch_common_message(parsed) - } - - fn dispatch_common_message( - &mut self, - message: CommonMessages<'_>, - ) -> Result>, Error> { - match message { - CommonMessages::SetupConnectionSuccess(msg) => { - self.handle_setup_connection_success(msg) - } - CommonMessages::SetupConnectionError(msg) => { - self.handle_setup_connection_error(msg) - } - CommonMessages::ChannelEndpointChanged(msg) => { - self.handle_channel_endpoint_changed(msg) - } - CommonMessages::Reconnect(msg) => self.handle_reconnect(msg), - - CommonMessages::SetupConnection(_) => { - Err(Error::UnexpectedMessage(MESSAGE_TYPE_SETUP_CONNECTION)) - } - } - } - +pub trait ParseCommonMessagesFromUpstream { fn handle_setup_connection_success( &mut self, msg: SetupConnectionSuccess, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_SETUP_CONNECTION_SUCCESS, + )) } fn handle_setup_connection_error( @@ -50,7 +20,9 @@ pub trait ParseCommonMessagesFromUpstream{ msg: SetupConnectionError, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_SETUP_CONNECTION_ERROR, + )) } fn handle_channel_endpoint_changed( @@ -58,7 +30,9 @@ pub trait ParseCommonMessagesFromUpstream{ msg: ChannelEndpointChanged, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_CHANNEL_ENDPOINT_CHANGED, + )) } fn handle_reconnect( @@ -66,6 +40,19 @@ pub trait ParseCommonMessagesFromUpstream{ msg: Reconnect, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage(MESSAGE_TYPE_RECONNECT)) + } +} + +pub trait ParseCommonMessagesFromDownstream +where + Self: Sized, +{ + fn handle_setup_connection( + &mut self, + msg: SetupConnection, + ) -> Result>, 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 index 3671d550ee..971232756d 100644 --- a/protocols/v2/roles-logic-sv2/src/handlers2/job_declaration.rs +++ b/protocols/v2/roles-logic-sv2/src/handlers2/job_declaration.rs @@ -1,5 +1,4 @@ -use crate::parsers::JobDeclaration; -use crate::errors::Error; +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, @@ -8,55 +7,15 @@ use job_declaration_sv2::{ MESSAGE_TYPE_PROVIDE_MISSING_TRANSACTIONS_SUCCESS, MESSAGE_TYPE_PUSH_SOLUTION, *, }; - pub trait ParseJobDeclarationMessagesFromUpstream { - fn handle_job_declaration_message( - &mut self, - message_type: u8, - payload: &mut [u8], - ) -> Result>, Error> { - let parsed: JobDeclaration<'_> = (message_type, payload).try_into()?; - self.dispatch_job_declaration(parsed) - } - - fn dispatch_job_declaration( - &mut self, - message: JobDeclaration<'_>, - ) -> Result>, Error> { - match message { - JobDeclaration::AllocateMiningJobTokenSuccess(msg) => { - self.handle_allocate_mining_job_token_success(msg) - } - JobDeclaration::DeclareMiningJobSuccess(msg) => { - self.handle_declare_mining_job_success(msg) - } - JobDeclaration::DeclareMiningJobError(msg) => { - self.handle_declare_mining_job_error(msg) - } - JobDeclaration::ProvideMissingTransactions(msg) => { - self.handle_provide_missing_transactions(msg) - } - JobDeclaration::AllocateMiningJobToken(_) => { - Err(Error::UnexpectedMessage(MESSAGE_TYPE_ALLOCATE_MINING_JOB_TOKEN)) - } - JobDeclaration::DeclareMiningJob(_) => { - Err(Error::UnexpectedMessage(MESSAGE_TYPE_DECLARE_MINING_JOB)) - } - JobDeclaration::ProvideMissingTransactionsSuccess(_) => { - Err(Error::UnexpectedMessage(MESSAGE_TYPE_PROVIDE_MISSING_TRANSACTIONS_SUCCESS)) - } - JobDeclaration::PushSolution(_) => { - Err(Error::UnexpectedMessage(MESSAGE_TYPE_PUSH_SOLUTION)) - } - } - } - fn handle_allocate_mining_job_token_success( &mut self, msg: AllocateMiningJobTokenSuccess, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_ALLOCATE_MINING_JOB_TOKEN_SUCCESS, + )) } fn handle_declare_mining_job_success( @@ -64,72 +23,41 @@ pub trait ParseJobDeclarationMessagesFromUpstream { msg: DeclareMiningJobSuccess, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_DECLARE_MINING_JOB_SUCCESS, + )) } fn handle_declare_mining_job_error( &mut self, msg: DeclareMiningJobError, ) -> Result>, Error> { - let _ = msg; - Ok(None) + let _ = msg; + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_DECLARE_MINING_JOB_ERROR, + )) } fn handle_provide_missing_transactions( &mut self, msg: ProvideMissingTransactions, ) -> Result>, Error> { - let _ = msg; - Ok(None) + let _ = msg; + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_PROVIDE_MISSING_TRANSACTIONS, + )) } } - pub trait ParseJobDeclarationMessagesFromDownstream { - fn handle_job_declaration_message( - &mut self, - message_type: u8, - payload: &mut [u8], - ) -> Result>, Error> { - let parsed: JobDeclaration<'_> = (message_type, payload).try_into()?; - self.dispatch_job_declaration(parsed) - } - - fn dispatch_job_declaration( - &mut self, - message: JobDeclaration<'_>, - ) -> Result>, Error> { - match message { - JobDeclaration::AllocateMiningJobToken(msg) => { - self.handle_allocate_mining_job_token(msg) - } - JobDeclaration::DeclareMiningJob(msg) => self.handle_declare_mining_job(msg), - JobDeclaration::ProvideMissingTransactionsSuccess(msg) => { - self.handle_provide_missing_transactions_success(msg) - } - JobDeclaration::PushSolution(msg) => self.handle_push_solution(msg), - - JobDeclaration::AllocateMiningJobTokenSuccess(_) => { - Err(Error::UnexpectedMessage(MESSAGE_TYPE_ALLOCATE_MINING_JOB_TOKEN_SUCCESS)) - } - JobDeclaration::DeclareMiningJobSuccess(_) => { - Err(Error::UnexpectedMessage(MESSAGE_TYPE_DECLARE_MINING_JOB_SUCCESS)) - } - JobDeclaration::DeclareMiningJobError(_) => { - Err(Error::UnexpectedMessage(MESSAGE_TYPE_DECLARE_MINING_JOB_ERROR)) - } - JobDeclaration::ProvideMissingTransactions(_) => { - Err(Error::UnexpectedMessage(MESSAGE_TYPE_PROVIDE_MISSING_TRANSACTIONS)) - } - } - } - fn handle_allocate_mining_job_token( &mut self, msg: AllocateMiningJobToken, ) -> Result>, Error> { - let _ = msg; - Ok(None) + let _ = msg; + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_ALLOCATE_MINING_JOB_TOKEN, + )) } fn handle_declare_mining_job( @@ -137,7 +65,7 @@ pub trait ParseJobDeclarationMessagesFromDownstream { msg: DeclareMiningJob, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage(MESSAGE_TYPE_DECLARE_MINING_JOB)) } fn handle_provide_missing_transactions_success( @@ -145,7 +73,9 @@ pub trait ParseJobDeclarationMessagesFromDownstream { msg: ProvideMissingTransactionsSuccess, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_PROVIDE_MISSING_TRANSACTIONS_SUCCESS, + )) } fn handle_push_solution( @@ -153,6 +83,6 @@ pub trait ParseJobDeclarationMessagesFromDownstream { msg: PushSolution, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage(MESSAGE_TYPE_PUSH_SOLUTION)) } -} \ No newline at end of file +} diff --git a/protocols/v2/roles-logic-sv2/src/handlers2/mining.rs b/protocols/v2/roles-logic-sv2/src/handlers2/mining.rs index 4d378517cf..41692f25c6 100644 --- a/protocols/v2/roles-logic-sv2/src/handlers2/mining.rs +++ b/protocols/v2/roles-logic-sv2/src/handlers2/mining.rs @@ -11,6 +11,7 @@ use mining_sv2::{ 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 { @@ -20,97 +21,41 @@ pub enum SupportedChannelTypes { GroupAndExtended, } +#[derive(PartialEq, Eq)] +pub enum DownstreamAuth { + NotImplemented, + Allow, + Restrict, +} -pub trait ParseMiningMessagesFromDownstream -where - Self: Sized + D, -{ - fn get_channel_type(&self) -> SupportedChannelTypes; - fn is_work_selection_enabled(&self) -> bool; +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; - - fn handle_mining_message(&mut self, message: Mining) -> Result>, Error> { - let (channel_type, work_selection) = - (self.get_channel_type(), self.is_work_selection_enabled()); - - use Mining::*; - match message { - OpenStandardMiningChannel(m) => { - if !self.is_downstream_authorized(&m.user_identity)? { - return Ok(Some(Mining::OpenMiningChannelError( - mining_sv2::OpenMiningChannelError::new_unknown_user(m.get_request_id_as_u32()), - ))); - } - - match channel_type { - SupportedChannelTypes::Standard - | SupportedChannelTypes::Group - | SupportedChannelTypes::GroupAndExtended => { - self.handle_open_standard_mining_channel(m) - } - SupportedChannelTypes::Extended => Err(Error::UnexpectedMessage( - MESSAGE_TYPE_OPEN_STANDARD_MINING_CHANNEL, - )), - } - } - OpenExtendedMiningChannel(m) => { - if !self.is_downstream_authorized(&m.user_identity)? { - return Ok(Some(Mining::OpenMiningChannelError( - mining_sv2::OpenMiningChannelError::new_unknown_user(m.get_request_id_as_u32()), - ))); - } - - match channel_type { - SupportedChannelTypes::Extended - | SupportedChannelTypes::GroupAndExtended => { - self.handle_open_extended_mining_channel(m) - } - _ => Err(Error::UnexpectedMessage(MESSAGE_TYPE_OPEN_EXTENDED_MINING_CHANNEL)), - } - } - UpdateChannel(m) => self.handle_update_channel(m), - - SubmitSharesStandard(m) => match channel_type { - SupportedChannelTypes::Standard - | SupportedChannelTypes::Group - | SupportedChannelTypes::GroupAndExtended => { - self.handle_submit_shares_standard(m) - } - SupportedChannelTypes::Extended => Err(Error::UnexpectedMessage( - MESSAGE_TYPE_SUBMIT_SHARES_STANDARD, - )), - }, - - SubmitSharesExtended(m) => match channel_type { - SupportedChannelTypes::Extended - | SupportedChannelTypes::GroupAndExtended => { - self.handle_submit_shares_extended(m) - } - _ => Err(Error::UnexpectedMessage(MESSAGE_TYPE_SUBMIT_SHARES_EXTENDED)), - }, - - SetCustomMiningJob(m) => match (channel_type, work_selection) { - (SupportedChannelTypes::Extended, true) - | (SupportedChannelTypes::GroupAndExtended, true) => { - self.handle_set_custom_mining_job(m) - } - _ => Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_CUSTOM_MINING_JOB)), - }, - - _ => Err(Error::UnexpectedMessage(0)), - } + ) -> Result { + Ok(DownstreamAuth::NotImplemented) } +} +pub trait ParseMiningMessagesFromDownstream +where + Self: Sized + D + MiningChannelConfig, +{ fn handle_open_standard_mining_channel( &mut self, msg: OpenStandardMiningChannel, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_OPEN_STANDARD_MINING_CHANNEL, + )) } fn handle_open_extended_mining_channel( @@ -118,7 +63,9 @@ where msg: OpenExtendedMiningChannel, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_OPEN_EXTENDED_MINING_CHANNEL, + )) } fn handle_update_channel( @@ -126,7 +73,7 @@ where msg: UpdateChannel, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage(MESSAGE_TYPE_UPDATE_CHANNEL)) } fn handle_submit_shares_standard( @@ -134,7 +81,9 @@ where msg: SubmitSharesStandard, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_SUBMIT_SHARES_STANDARD, + )) } fn handle_submit_shares_extended( @@ -142,7 +91,9 @@ where msg: SubmitSharesExtended, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_SUBMIT_SHARES_EXTENDED, + )) } fn handle_set_custom_mining_job( @@ -150,108 +101,22 @@ where msg: SetCustomMiningJob, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_CUSTOM_MINING_JOB)) } } - -pub trait ParseMiningMessagesFromUpstream +pub trait ParseMiningMessagesFromUpstream where - Self: Sized + D, + Self: Sized + D + MiningChannelConfig, { - fn get_channel_type(&self) -> SupportedChannelTypes; - fn is_work_selection_enabled(&self) -> bool; - - fn handle_mining_message(&mut self, message: Mining) -> Result>, Error> { - let (channel_type, work_selection) = - (self.get_channel_type(), self.is_work_selection_enabled()); - - use Mining::*; - match message { - OpenStandardMiningChannelSuccess(m) => match channel_type { - SupportedChannelTypes::Standard - | SupportedChannelTypes::Group - | SupportedChannelTypes::GroupAndExtended => { - self.handle_open_standard_mining_channel_success(m) - } - _ => Err(Error::UnexpectedMessage( - MESSAGE_TYPE_OPEN_STANDARD_MINING_CHANNEL_SUCCESS, - )), - }, - - OpenExtendedMiningChannelSuccess(m) => match channel_type { - SupportedChannelTypes::Extended - | SupportedChannelTypes::GroupAndExtended => { - self.handle_open_extended_mining_channel_success(m) - } - _ => Err(Error::UnexpectedMessage( - MESSAGE_TYPE_OPEN_EXTENDED_MINING_CHANNEL_SUCCESS, - )), - }, - - OpenMiningChannelError(m) => self.handle_open_mining_channel_error(m), - UpdateChannelError(m) => self.handle_update_channel_error(m), - CloseChannel(m) => self.handle_close_channel(m), - SetExtranoncePrefix(m) => self.handle_set_extranonce_prefix(m), - SubmitSharesSuccess(m) => self.handle_submit_shares_success(m), - SubmitSharesError(m) => self.handle_submit_shares_error(m), - - NewMiningJob(m) => match channel_type { - SupportedChannelTypes::Standard => self.handle_new_mining_job(m), - _ => Err(Error::UnexpectedMessage(MESSAGE_TYPE_NEW_MINING_JOB)), - }, - - NewExtendedMiningJob(m) => match channel_type { - SupportedChannelTypes::Extended - | SupportedChannelTypes::Group - | SupportedChannelTypes::GroupAndExtended => { - self.handle_new_extended_mining_job(m) - } - _ => Err(Error::UnexpectedMessage(MESSAGE_TYPE_NEW_EXTENDED_MINING_JOB)), - }, - - SetNewPrevHash(m) => self.handle_set_new_prev_hash(m), - - SetCustomMiningJobSuccess(m) => match (channel_type, work_selection) { - (SupportedChannelTypes::Extended, true) - | (SupportedChannelTypes::GroupAndExtended, true) => { - self.handle_set_custom_mining_job_success(m) - } - _ => Err(Error::UnexpectedMessage( - MESSAGE_TYPE_SET_CUSTOM_MINING_JOB_SUCCESS, - )), - }, - - SetCustomMiningJobError(m) => match (channel_type, work_selection) { - (SupportedChannelTypes::Extended, true) - | (SupportedChannelTypes::Group, true) - | (SupportedChannelTypes::GroupAndExtended, true) => { - self.handle_set_custom_mining_job_error(m) - } - _ => Err(Error::UnexpectedMessage( - MESSAGE_TYPE_SET_CUSTOM_MINING_JOB_ERROR, - )), - }, - - SetTarget(m) => self.handle_set_target(m), - - SetGroupChannel(m) => match channel_type { - SupportedChannelTypes::Group | SupportedChannelTypes::GroupAndExtended => { - self.handle_set_group_channel(m) - } - _ => Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_GROUP_CHANNEL)), - }, - - _ => Err(Error::UnexpectedMessage(0)), - } - } - fn handle_open_standard_mining_channel_success( &mut self, msg: OpenStandardMiningChannelSuccess, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_OPEN_STANDARD_MINING_CHANNEL_SUCCESS, + )) } fn handle_open_extended_mining_channel_success( @@ -259,7 +124,9 @@ where msg: OpenExtendedMiningChannelSuccess, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_OPEN_EXTENDED_MINING_CHANNEL_SUCCESS, + )) } fn handle_open_mining_channel_error( @@ -267,7 +134,9 @@ where msg: OpenMiningChannelError, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_OPEN_MINING_CHANNEL_ERROR, + )) } fn handle_update_channel_error( @@ -275,7 +144,7 @@ where msg: UpdateChannelError, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage(MESSAGE_TYPE_UPDATE_CHANNEL_ERROR)) } fn handle_close_channel( @@ -283,7 +152,7 @@ where msg: CloseChannel, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage(MESSAGE_TYPE_CLOSE_CHANNEL)) } fn handle_set_extranonce_prefix( @@ -291,7 +160,7 @@ where msg: SetExtranoncePrefix, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_EXTRANONCE_PREFIX)) } fn handle_submit_shares_success( @@ -299,7 +168,7 @@ where msg: SubmitSharesSuccess, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage(MESSAGE_TYPE_SUBMIT_SHARES_SUCCESS)) } fn handle_submit_shares_error( @@ -307,7 +176,7 @@ where msg: SubmitSharesError, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage(MESSAGE_TYPE_SUBMIT_SHARES_ERROR)) } fn handle_new_mining_job( @@ -315,7 +184,7 @@ where msg: NewMiningJob, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage(MESSAGE_TYPE_NEW_MINING_JOB)) } fn handle_new_extended_mining_job( @@ -323,15 +192,17 @@ where msg: NewExtendedMiningJob, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_NEW_EXTENDED_MINING_JOB, + )) } - fn handle_set_new_prev_hash( + fn handle_set_new_prev_hash_mining( &mut self, msg: SetNewPrevHash, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_NEW_PREV_HASH)) } fn handle_set_custom_mining_job_success( @@ -339,7 +210,9 @@ where msg: SetCustomMiningJobSuccess, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_SET_CUSTOM_MINING_JOB_SUCCESS, + )) } fn handle_set_custom_mining_job_error( @@ -347,17 +220,21 @@ where msg: SetCustomMiningJobError, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_SET_CUSTOM_MINING_JOB_ERROR, + )) } fn handle_set_target(&mut self, msg: SetTarget) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_TARGET)) } - fn handle_set_group_channel(&mut self, msg: SetGroupChannel) - -> Result>, Error> { - let _ = msg; - Ok(None) - } + fn handle_set_group_channel( + &mut self, + msg: SetGroupChannel, + ) -> Result>, 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 index f4c8236da3..6f4d478bca 100644 --- a/protocols/v2/roles-logic-sv2/src/handlers2/mod.rs +++ b/protocols/v2/roles-logic-sv2/src/handlers2/mod.rs @@ -1,7 +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 template_distribution; mod mining; +mod template_distribution; +pub trait Sv2Router: + ParseCommonMessagesFromUpstream + + ParseCommonMessagesFromDownstream + + ParseMiningMessagesFromUpstream + + ParseMiningMessagesFromDownstream + + ParseJobDeclarationMessagesFromUpstream + + ParseJobDeclarationMessagesFromDownstream + + ParseTemplateDistributionMessagesFromServer + + ParseTemplateDistributionMessagesFromClient +{ + fn handle_message( + &mut self, + message_type: u8, + payload: &mut [u8], + ) -> Result>, 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>, 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>, 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>, 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>, 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 index f9807de236..fa62da426e 100644 --- a/protocols/v2/roles-logic-sv2/src/handlers2/template_distribution.rs +++ b/protocols/v2/roles-logic-sv2/src/handlers2/template_distribution.rs @@ -7,58 +7,21 @@ use template_distribution_sv2::{ use core::convert::TryInto; use template_distribution_sv2::*; - - pub trait ParseTemplateDistributionMessagesFromServer { - fn handle_template_distribution_message( - &mut self, - message_type: u8, - payload: &mut [u8], - ) -> Result>, Error> { - let parsed: TemplateDistribution<'_> = (message_type, payload).try_into()?; - self.dispatch_template_distribution(parsed) - } - - fn dispatch_template_distribution( - &mut self, - message: TemplateDistribution<'_>, - ) -> Result>, Error> { - match message { - TemplateDistribution::NewTemplate(m) => self.handle_new_template(m), - TemplateDistribution::SetNewPrevHash(m) => self.handle_set_new_prev_hash(m), - TemplateDistribution::RequestTransactionDataSuccess(m) => { - self.handle_request_tx_data_success(m) - } - TemplateDistribution::RequestTransactionDataError(m) => { - self.handle_request_tx_data_error(m) - } - - TemplateDistribution::CoinbaseOutputConstraints(_) => { - Err(Error::UnexpectedMessage(MESSAGE_TYPE_COINBASE_OUTPUT_CONSTRAINTS)) - } - TemplateDistribution::RequestTransactionData(_) => { - Err(Error::UnexpectedMessage(MESSAGE_TYPE_REQUEST_TRANSACTION_DATA)) - } - TemplateDistribution::SubmitSolution(_) => { - Err(Error::UnexpectedMessage(MESSAGE_TYPE_SUBMIT_SOLUTION)) - } - } - } - fn handle_new_template( &mut self, msg: NewTemplate, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage(MESSAGE_TYPE_NEW_TEMPLATE)) } - fn handle_set_new_prev_hash( + fn handle_set_new_prev_hash_template_distribution( &mut self, msg: SetNewPrevHash, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_NEW_PREV_HASH)) } fn handle_request_tx_data_success( @@ -66,7 +29,9 @@ pub trait ParseTemplateDistributionMessagesFromServer { msg: RequestTransactionDataSuccess, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_REQUEST_TRANSACTION_DATA_SUCCESS, + )) } fn handle_request_tx_data_error( @@ -74,57 +39,21 @@ pub trait ParseTemplateDistributionMessagesFromServer { msg: RequestTransactionDataError, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_REQUEST_TRANSACTION_DATA_ERROR, + )) } } - pub trait ParseTemplateDistributionMessagesFromClient { - fn handle_template_distribution_message( - &mut self, - message_type: u8, - payload: &mut [u8], - ) -> Result>, Error> { - let parsed: TemplateDistribution<'_> = (message_type, payload).try_into()?; - self.dispatch_template_distribution(parsed) - } - - fn dispatch_template_distribution( - &mut self, - message: TemplateDistribution<'_>, - ) -> Result>, Error> { - match message { - 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(_) => { - Err(Error::UnexpectedMessage(MESSAGE_TYPE_NEW_TEMPLATE)) - } - TemplateDistribution::SetNewPrevHash(_) => { - Err(Error::UnexpectedMessage(MESSAGE_TYPE_SET_NEW_PREV_HASH)) - } - TemplateDistribution::RequestTransactionDataSuccess(_) => { - Err(Error::UnexpectedMessage(MESSAGE_TYPE_REQUEST_TRANSACTION_DATA_SUCCESS)) - } - TemplateDistribution::RequestTransactionDataError(_) => { - Err(Error::UnexpectedMessage(MESSAGE_TYPE_REQUEST_TRANSACTION_DATA_ERROR)) - } - } - } - fn handle_coinbase_out_data_size( &mut self, msg: CoinbaseOutputConstraints, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_COINBASE_OUTPUT_CONSTRAINTS, + )) } fn handle_request_tx_data( @@ -132,7 +61,9 @@ pub trait ParseTemplateDistributionMessagesFromClient { msg: RequestTransactionData, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage( + MESSAGE_TYPE_REQUEST_TRANSACTION_DATA, + )) } fn handle_request_submit_solution( @@ -140,6 +71,6 @@ pub trait ParseTemplateDistributionMessagesFromClient { msg: SubmitSolution, ) -> Result>, Error> { let _ = msg; - Ok(None) + Err(Error::UnexpectedMessage(MESSAGE_TYPE_SUBMIT_SOLUTION)) } -} \ No newline at end of file +} diff --git a/protocols/v2/roles-logic-sv2/src/lib.rs b/protocols/v2/roles-logic-sv2/src/lib.rs index cafd4a2596..f5c65cf2f6 100644 --- a/protocols/v2/roles-logic-sv2/src/lib.rs +++ b/protocols/v2/roles-logic-sv2/src/lib.rs @@ -21,9 +21,9 @@ 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 handlers2; pub mod utils; pub mod vardiff; pub use bitcoin;