thruput-node-supervisor 0.43.0

Local node supervisor for Thruput development
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
123
124
125
126
127
128
129
130

//! Stub backend planes that answer `NotImplemented`.
//!
//! The supervisor serves submit, chain, and read methods through real
//! hogd-dev adapters. This stub stands in only for the read plane when
//! its backing services are not connected, so those methods
//! fail with a stable wire error instead of a transport error.
//!
//! Wire-error strings carry only the JSON-RPC method name, so the public
//! protocol surface is stable. The "not connected" context goes to
//! `tracing::warn!` at supervisor startup, not into the wire error.

use async_trait::async_trait;
use thruput_json_rpc_server::native::{
    read::{NativeBlockPlane, NativeHistoryPlane, NativeStatePlane, StateKey},
    transaction::{NativeReadError, NativeTransactionReadPlane},
};
use thruput_json_rpc_server::{RpcRequestContext, RpcServerError};
use thruput_json_rpc_types::{
    ContractAddress,
    transaction::{TransactionStatus, TxHash},
};
use thruput_json_rpc_types::{requests as input, responses as out};

use crate::airdrop::FundingStatusPlane;

/// Backend that returns `NotImplemented` for unwired planes.
#[derive(Debug, Clone, Copy, Default)]
pub(crate) struct StubBackend;

impl StubBackend {
    pub(crate) fn new() -> Self {
        Self
    }
}

#[async_trait]
impl FundingStatusPlane for StubBackend {
    async fn funding_status(
        &self,
        _context: RpcRequestContext,
        _tx_hash: TxHash,
    ) -> Result<TransactionStatus, RpcServerError> {
        Err(RpcServerError::NotImplemented("transactionStatus".into()))
    }
}

#[async_trait]
impl NativeBlockPlane for StubBackend {
    #[tracing::instrument(skip_all)]
    async fn native_block(
        &self,
        _context: RpcRequestContext,
        _height: thruput_json_rpc_types::BlockHeight,
    ) -> Result<out::BlockResult, RpcServerError> {
        Err(RpcServerError::NotImplemented("getBlockByHeight".into()))
    }
}

#[async_trait]
impl NativeHistoryPlane for StubBackend {
    #[tracing::instrument(skip_all)]
    async fn native_events(
        &self,
        _context: RpcRequestContext,
        _request: input::EventQuery,
    ) -> Result<out::EventPage, RpcServerError> {
        Err(RpcServerError::NotImplemented("getEvents".into()))
    }
    #[tracing::instrument(skip_all)]
    async fn native_root_transactions(
        &self,
        _context: RpcRequestContext,
        _request: input::RootAddressQuery,
    ) -> Result<out::TransactionRefPage, RpcServerError> {
        Err(RpcServerError::NotImplemented(
            "getTransactionsByRootAddress".into(),
        ))
    }
    #[tracing::instrument(skip_all)]
    async fn native_block_transactions(
        &self,
        _context: RpcRequestContext,
        _request: input::BlockPageRequest,
    ) -> Result<out::BlockTransactionPage, RpcServerError> {
        Err(RpcServerError::NotImplemented(
            "getTransactionsByBlock".into(),
        ))
    }
}

#[async_trait]
impl NativeStatePlane for StubBackend {
    #[tracing::instrument(skip_all)]
    async fn native_storage(
        &self,
        _context: RpcRequestContext,
        _address: ContractAddress,
        _key: StateKey,
    ) -> Result<out::StorageResult, RpcServerError> {
        Err(RpcServerError::NotImplemented("getStorage".into()))
    }
    #[tracing::instrument(skip_all)]
    async fn native_registered_auth(
        &self,
        _context: RpcRequestContext,
        _address: ContractAddress,
    ) -> Result<out::RegisteredAuthResult, RpcServerError> {
        Err(RpcServerError::NotImplemented("getRegisteredAuth".into()))
    }
}

#[async_trait]
impl NativeTransactionReadPlane for StubBackend {
    #[tracing::instrument(skip_all)]
    async fn native_receipt(
        &self,
        _context: RpcRequestContext,
        _hash: TxHash,
    ) -> Result<Option<out::TransactionReceipt>, NativeReadError> {
        Err(RpcServerError::NotImplemented("getTransactionReceipt".into()).into())
    }
    #[tracing::instrument(skip_all)]
    async fn native_status(
        &self,
        _context: RpcRequestContext,
        _hash: TxHash,
    ) -> Result<out::TransactionStatus, NativeReadError> {
        Err(RpcServerError::NotImplemented("getTransactionStatus".into()).into())
    }
}