miden-node-rpc 0.17.0-rc.4

Miden node's front-end RPC server
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

use miden_node_proto::generated as proto;
use miden_node_tracing::{debug, miden_instrument, miden_span_record};
use miden_protocol::Word;
use tonic::Request;

use super::{RpcBackend, RpcService};
use crate::{COMPONENT, LOG_TARGET};

#[tonic::async_trait]
impl proto::server::miden_node_v1_node_service::GetNetworkNoteStatus for RpcService {
    type Input = miden_protocol::note::NoteId;
    type Output = proto::miden::node::v1::GetNetworkNoteStatusResponse;

    fn decode(
        request: proto::miden::node::v1::GetNetworkNoteStatusRequest,
    ) -> tonic::Result<Self::Input> {
        let note_id_digest: Word = request
            .note_id
            .as_ref()
            .ok_or_else(|| tonic::Status::invalid_argument("missing note ID"))?
            .id
            .as_ref()
            .ok_or_else(|| tonic::Status::invalid_argument("missing note ID digest"))?
            .try_into()
            .map_err(|_| tonic::Status::invalid_argument("invalid note ID digest"))?;
        Ok(miden_protocol::note::NoteId::from_raw(note_id_digest))
    }

    fn encode(
        output: Self::Output,
    ) -> tonic::Result<proto::miden::node::v1::GetNetworkNoteStatusResponse> {
        Ok(output)
    }

    #[miden_instrument(
        target = COMPONENT,
        name = "get_network_note_status",
        err,
    )]
    async fn handle(
        &self,
        request: Self::Input,
        metadata: &tonic::metadata::MetadataMap,
        _extensions: &tonic::codegen::http::Extensions,
    ) -> tonic::Result<Self::Output> {
        let original_accept_header = metadata.get(http::header::ACCEPT.as_str()).cloned();

        let note_id = request;
        miden_span_record!(note.id = note_id);

        debug!(
            target: LOG_TARGET,
            "Getting network note status",
            note.id = note_id
        );

        let mut forwarded_request = Request::new(proto::note::NoteId::from(note_id.as_word()));
        if let Some(accept) = original_accept_header {
            forwarded_request.metadata_mut().insert(http::header::ACCEPT.as_str(), accept);
        }

        let response = match &self.backend {
            RpcBackend::Sequencer { .. } => {
                let Some(ntx_builder) = &self.ntx_builder else {
                    return Err(tonic::Status::unavailable(
                        "Network transaction builder is not enabled",
                    ));
                };

                let response = ntx_builder
                    .clone()
                    .get_network_note_status(forwarded_request.map(|note_id| {
                        proto::miden::ntx_builder::v1::GetNetworkNoteStatusRequest {
                            note_id: Some(note_id),
                        }
                    }))
                    .await?
                    .into_inner();
                proto::miden::node::v1::GetNetworkNoteStatusResponse {
                    status: response.status,
                    last_error: response.last_error,
                    attempt_count: response.attempt_count,
                    last_attempt_block_num: response.last_attempt_block_num,
                }
            },
            RpcBackend::FullNode { source_rpc, .. } => source_rpc
                .as_ref()
                .clone()
                .get_network_note_status(forwarded_request.map(|note_id| {
                    proto::miden::node::v1::GetNetworkNoteStatusRequest { note_id: Some(note_id) }
                }))
                .await?
                .into_inner(),
        };

        Ok(response)
    }
}