kaspa-grpc-server 0.0.4

Kaspa gRPC server
Documentation 
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use super::{handler::RequestHandler, handler_trait::Handler, interface::Interface, method::Method};
use crate::{
    connection::{Connection, IncomingRoute},
    connection_handler::ServerContext,
    error::GrpcServerError,
};
use kaspa_grpc_core::protowire::{kaspad_request::Payload, *};
use kaspa_grpc_core::{ops::KaspadPayloadOps, protowire::NotifyFinalityConflictResponseMessage};
use kaspa_notify::{scope::FinalityConflictResolvedScope, subscriber::SubscriptionManager};
use kaspa_rpc_macros::build_grpc_server_interface;

pub struct Factory {}

impl Factory {
    pub fn new_handler(
        rpc_op: KaspadPayloadOps,
        incoming_route: IncomingRoute,
        server_context: ServerContext,
        interface: &Interface,
        connection: Connection,
    ) -> Box<dyn Handler> {
        Box::new(RequestHandler::new(rpc_op, incoming_route, server_context, interface, connection))
    }

    pub fn new_interface(server_ctx: ServerContext) -> Interface {
        // The array as last argument in the macro call below must exactly match the full set of
        // KaspadPayloadOps variants.
        let mut interface = build_grpc_server_interface!(
            server_ctx.clone(),
            ServerContext,
            Connection,
            KaspadRequest,
            KaspadResponse,
            KaspadPayloadOps,
            [
                SubmitBlock,
                GetBlockTemplate,
                GetCurrentNetwork,
                GetBlock,
                GetBlocks,
                GetInfo,
                Shutdown,
                GetPeerAddresses,
                GetSink,
                GetMempoolEntry,
                GetMempoolEntries,
                GetConnectedPeerInfo,
                AddPeer,
                SubmitTransaction,
                GetSubnetwork,
                GetVirtualChainFromBlock,
                GetBlockCount,
                GetBlockDagInfo,
                ResolveFinalityConflict,
                GetHeaders,
                GetUtxosByAddresses,
                GetBalanceByAddress,
                GetBalancesByAddresses,
                GetSinkBlueScore,
                Ban,
                Unban,
                EstimateNetworkHashesPerSecond,
                GetMempoolEntriesByAddresses,
                GetCoinSupply,
                Ping,
                GetMetrics,
                GetServerInfo,
                GetSyncStatus,
                NotifyBlockAdded,
                NotifyNewBlockTemplate,
                NotifyFinalityConflict,
                NotifyUtxosChanged,
                NotifySinkBlueScoreChanged,
                NotifyPruningPointUtxoSetOverride,
                NotifyVirtualDaaScoreChanged,
                NotifyVirtualChainChanged,
                StopNotifyingUtxosChanged,
                StopNotifyingPruningPointUtxoSetOverride,
            ]
        );

        // Manually reimplementing the NotifyFinalityConflictRequest method so subscription
        // gets mirrored to FinalityConflictResolved notifications as well.
        let method: Method<ServerContext, Connection, KaspadRequest, KaspadResponse> =
            Method::new(|server_ctx: ServerContext, connection: Connection, request: KaspadRequest| {
                Box::pin(async move {
                    let mut response: KaspadResponse = match request.payload {
                        Some(Payload::NotifyFinalityConflictRequest(ref request)) => {
                            match kaspa_rpc_core::NotifyFinalityConflictRequest::try_from(request) {
                                Ok(request) => {
                                    let id = connection.get_or_register_listener_id();
                                    let command = request.command;
                                    let result =
                                        server_ctx.notifier.clone().execute_subscribe_command(id, request.into(), command).await.and(
                                            server_ctx
                                                .notifier
                                                .clone()
                                                .execute_subscribe_command(
                                                    id,
                                                    FinalityConflictResolvedScope::default().into(),
                                                    command,
                                                )
                                                .await,
                                        );
                                    NotifyFinalityConflictResponseMessage::from(result).into()
                                }
                                Err(err) => NotifyFinalityConflictResponseMessage::from(err).into(),
                            }
                        }
                        _ => {
                            return Err(GrpcServerError::InvalidRequestPayload);
                        }
                    };
                    response.id = request.id;
                    Ok(response)
                })
            });
        interface.replace_method(KaspadPayloadOps::NotifyFinalityConflict, method);

        interface
    }
}