tycho-rpc 0.3.9

Public RPC service.
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
131
132
133
134
135
136
137
138
139
140
141
142

use std::sync::{Arc, OnceLock};

use arc_swap::ArcSwapOption;
use bytes::Bytes;
use tycho_types::boc::{Boc, BocRepr};
use tycho_types::cell::Cell;
use tycho_types::models::{Block, BlockId, BlockchainConfig};
use tycho_types::prelude::HashBytes;
use tycho_util::FastHasherState;

use super::extractor::{ProtoOkResponse, RawProtoOkResponse};
use super::make_response_block_id;
use super::protos::rpc::response;

pub struct ProtoEndpointCache {
    libraries: moka::sync::Cache<HashBytes, RawProtoOkResponse, FastHasherState>,
    key_block_proofs: moka::sync::Cache<u32, RawProtoOkResponse, FastHasherState>,
    latest_key_block: ArcSwapOption<RawProtoOkResponse>,
    blockchain_config: ArcSwapOption<RawProtoOkResponse>,
}

impl Default for ProtoEndpointCache {
    fn default() -> Self {
        Self {
            libraries: moka::sync::Cache::builder()
                .max_capacity(100)
                .build_with_hasher(Default::default()),
            key_block_proofs: moka::sync::Cache::builder()
                .max_capacity(10)
                .build_with_hasher(Default::default()),
            latest_key_block: Default::default(),
            blockchain_config: Default::default(),
        }
    }
}

impl ProtoEndpointCache {
    pub fn insert_library_cell_response(
        &self,
        hash_bytes: HashBytes,
        cell: Option<Cell>,
    ) -> RawProtoOkResponse {
        static EMPTY: OnceLock<RawProtoOkResponse> = OnceLock::new();

        match cell {
            None => EMPTY
                .get_or_init(|| {
                    make_cached(response::Result::GetLibraryCell(response::GetLibraryCell {
                        cell: None,
                    }))
                })
                .clone(),
            Some(cell) => {
                let res = make_cached(response::Result::GetLibraryCell(response::GetLibraryCell {
                    cell: Some(Bytes::from(Boc::encode(cell))),
                }));
                self.libraries.insert(hash_bytes, res.clone());
                res
            }
        }
    }

    pub fn get_library_cell_response(&self, hash: &HashBytes) -> Option<RawProtoOkResponse> {
        self.libraries.get(hash)
    }

    pub fn insert_key_block_proof_response(
        &self,
        seqno: u32,
        proof: Option<(BlockId, Bytes)>,
    ) -> RawProtoOkResponse {
        static EMPTY: OnceLock<RawProtoOkResponse> = OnceLock::new();

        match proof {
            None => EMPTY
                .get_or_init(|| {
                    make_cached(response::Result::GetKeyBlockProof(
                        response::GetKeyBlockProof { key_block: None },
                    ))
                })
                .clone(),
            Some((block_id, proof)) => {
                let res = make_cached(response::Result::GetKeyBlockProof(
                    response::GetKeyBlockProof {
                        key_block: Some(response::KeyBlockProof {
                            block_id: Some(make_response_block_id(block_id)),
                            proof,
                        }),
                    },
                ));
                self.key_block_proofs.insert(seqno, res.clone());
                res
            }
        }
    }

    pub fn get_key_block_proof_response(&self, seqno: u32) -> Option<RawProtoOkResponse> {
        self.key_block_proofs.get(&seqno)
    }

    pub fn load_latest_key_block(&self) -> arc_swap::Guard<Option<Arc<RawProtoOkResponse>>> {
        self.latest_key_block.load()
    }

    pub fn load_blockchain_config(&self) -> arc_swap::Guard<Option<Arc<RawProtoOkResponse>>> {
        self.blockchain_config.load()
    }

    pub fn handle_config(&self, global_id: i32, seqno: u32, config: &BlockchainConfig) {
        self.blockchain_config.store(match BocRepr::encode(config) {
            Ok(config) => Some(Arc::new(make_cached(
                response::Result::GetBlockchainConfig(response::GetBlockchainConfig {
                    global_id,
                    seqno,
                    config: config.into(),
                }),
            ))),
            Err(e) => {
                tracing::error!("failed to serialize blockchain config proto: {e:?}");
                None
            }
        });
    }

    pub fn handle_key_block(&self, block: &Block) {
        self.latest_key_block.store(match BocRepr::encode(block) {
            Ok(block) => Some(Arc::new(make_cached(response::Result::GetLatestKeyBlock(
                response::GetLatestKeyBlock {
                    block: block.into(),
                },
            )))),
            Err(e) => {
                tracing::error!("failed to serialize key block proto: {e:?}");
                None
            }
        });
    }
}

fn make_cached(res: response::Result) -> RawProtoOkResponse {
    ProtoOkResponse::new(res).into_raw()
}