pool_sv2 0.2.1

SV2 pool role
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use crate::{
    downstream::Downstream,
    error::{self, PoolError, PoolErrorKind},
};
use std::{convert::TryInto, sync::atomic::Ordering};
use stratum_apps::{
    stratum_core::{
        common_messages_sv2::{
            has_requires_std_job, has_work_selection, Protocol, SetupConnection,
            SetupConnectionError, SetupConnectionSuccess,
        },
        handlers_sv2::HandleCommonMessagesFromClientAsync,
        parsers_sv2::{AnyMessage, Tlv},
    },
    utils::types::Sv2Frame,
};
use tracing::info;

#[cfg_attr(not(test), hotpath::measure_all)]
impl HandleCommonMessagesFromClientAsync for Downstream {
    type Error = PoolError<error::Downstream>;

    fn get_negotiated_extensions_with_client(
        &self,
        _client_id: Option<usize>,
    ) -> Result<Vec<u16>, Self::Error> {
        Ok(self
            .downstream_data
            .super_safe_lock(|data| data.negotiated_extensions.clone()))
    }

    async fn handle_setup_connection(
        &mut self,
        client_id: Option<usize>,
        msg: SetupConnection<'_>,
        _tlv_fields: Option<&[Tlv]>,
    ) -> Result<(), Self::Error> {
        info!(
            "Received `SetupConnection`: version={}, flags={:b}",
            msg.min_version, msg.flags
        );

        let downstream_id = client_id.expect("downstream id should be present");

        if msg.protocol != Protocol::MiningProtocol {
            info!("Rejecting connection from {downstream_id}: SetupConnection asking for other protocols than mining protocol.");
            let response = SetupConnectionError {
                flags: 0,
                error_code: "unsupported-protocol"
                    .to_string()
                    .try_into()
                    .expect("error code must be valid string"),
            };
            let frame: Sv2Frame = AnyMessage::Common(response.into_static().into())
                .try_into()
                .map_err(PoolError::shutdown)?;
            self.downstream_channel
                .downstream_sender
                .send(frame)
                .await
                .map_err(|_| {
                    PoolError::disconnect(PoolErrorKind::ChannelErrorSender, downstream_id)
                })?;

            return Err(PoolError::disconnect(
                PoolErrorKind::UnsupportedProtocol,
                downstream_id,
            ));
        }

        self.requires_custom_work
            .store(has_work_selection(msg.flags), Ordering::SeqCst);
        self.requires_standard_jobs
            .store(has_requires_std_job(msg.flags), Ordering::SeqCst);

        // SetupConnection.Success.flags for Mining Protocol (server -> client):
        // Bit 0: REQUIRES_FIXED_VERSION (upstream won't accept version changes)
        // Bit 1: REQUIRES_EXTENDED_CHANNELS (upstream won't accept standard channels)
        //
        // When the downstream requests work selection, the pool requires extended channels,
        // since custom work (job declaration) uses extended channels.
        //
        // TODO: replace magic numbers with named constants once
        // https://github.com/stratum-mining/stratum/issues/2075 is resolved.
        let mut response_flags: u32 = 0;
        if has_work_selection(msg.flags) {
            response_flags |= 0x02; // REQUIRES_EXTENDED_CHANNELS
        }
        let response = SetupConnectionSuccess {
            used_version: 2,
            flags: response_flags,
        };
        let frame: Sv2Frame = AnyMessage::Common(response.into_static().into())
            .try_into()
            .map_err(PoolError::shutdown)?;
        self.downstream_channel
            .downstream_sender
            .send(frame)
            .await
            .map_err(|_| {
                PoolError::disconnect(PoolErrorKind::ChannelErrorSender, self.downstream_id)
            })?;

        Ok(())
    }
}