snarkos-aot 0.1.0

Ahead of time utilities for SnarkVM, and a wrapper around the SnarkOS node for more options
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

#![allow(dead_code)]

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

use snarkvm::ledger::store::{helpers::rocksdb::BlockDB, BlockStorage};
use snops_common::{
    define_rpc_mux,
    rpc::{
        agent::{
            node::{NodeService, NodeServiceRequest, NodeServiceResponse},
            AgentNodeServiceRequest, AgentNodeServiceResponse,
        },
        error::AgentError,
    },
    state::snarkos_status::SnarkOSLiteBlock,
};
use tarpc::context;

use crate::{
    cli::{make_env_filter, ReloadHandler},
    runner::rpc::get_block_info_for_height,
    Network,
};

define_rpc_mux!(child;
    AgentNodeServiceRequest => AgentNodeServiceResponse;
    NodeServiceRequest => NodeServiceResponse;
);

#[derive(Clone)]
pub struct NodeRpcServer<N: Network> {
    pub log_level_handler: ReloadHandler,
    pub block_db: Arc<RwLock<Option<BlockDB<N>>>>,
}

impl<N: Network> NodeService for NodeRpcServer<N> {
    async fn status(self, _: context::Context) -> Result<(), AgentError> {
        Ok(())
    }

    async fn set_log_level(self, _: context::Context, verbosity: u8) -> Result<(), AgentError> {
        self.log_level_handler
            .modify(|filter| *filter = make_env_filter(verbosity))
            .map_err(|_| AgentError::FailedToChangeLogLevel)?;

        Ok(())
    }

    async fn find_transaction(
        self,
        _: context::Context,
        tx_id: String,
    ) -> Result<Option<String>, AgentError> {
        let block_guard = self.block_db.read();
        let Ok(Some(block_db)) = block_guard.as_deref() else {
            return Err(AgentError::NodeClientNotReady);
        };

        let tx_id: N::TransactionID = tx_id
            .parse()
            .map_err(|_| AgentError::InvalidTransactionId)?;

        block_db
            .find_block_hash(&tx_id)
            .map_err(|_| AgentError::FailedToMakeRequest)
            .map(|hash| hash.map(|hash| hash.to_string()))
    }

    async fn get_block_lite(
        self,
        _: context::Context,
        block_hash: String,
    ) -> Result<Option<SnarkOSLiteBlock>, AgentError> {
        let block_guard = self.block_db.read();
        let Ok(Some(block_db)) = block_guard.as_deref() else {
            return Err(AgentError::NodeClientNotReady);
        };

        let hash: N::BlockHash = block_hash
            .parse()
            .map_err(|_| AgentError::InvalidBlockHash)?;

        let Some(height) = block_db
            .get_block_height(&hash)
            .map_err(|_| AgentError::FailedToMakeRequest)?
        else {
            return Ok(None);
        };

        let Some(info) = get_block_info_for_height(block_db, height) else {
            return Ok(None);
        };

        let Some(transactions) = block_db
            .get_block_transactions(&hash)
            .map_err(|_| AgentError::FailedToMakeRequest)?
        else {
            return Ok(None);
        };

        // convert snarkVM transactions into transaction ids
        let tx_ids = transactions.iter().map(|tx| tx.id().to_string()).collect();

        Ok(Some(SnarkOSLiteBlock {
            info,
            transactions: tx_ids,
        }))
    }
}