celestia-rpc 1.0.0

A collection of traits for interacting with Celestia data availability nodes RPC
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

//! celestia-node rpc types and methods related to blobstream

use std::future::Future;
use std::marker::{Send, Sync};

use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64};
use celestia_types::MerkleProof;
use celestia_types::consts::HASH_SIZE;
use celestia_types::hash::Hash;
use jsonrpsee::core::RpcResult;
use jsonrpsee::core::client::{ClientT, Error};
use jsonrpsee::proc_macros::rpc;

use crate::custom_client_error;

mod rpc {
    use super::*;

    /// Blobstream RPC methods.
    #[rpc(client, server, namespace = "blobstream", namespace_separator = ".")]
    pub trait Blobstream {
        /// Collects the data roots over a provided ordered range of blocks, and then
        /// creates a new Merkle root of those data roots.
        ///
        /// The range is end exclusive.
        #[method(name = "GetDataRootTupleRoot")]
        async fn blobstream_get_data_root_tuple_root(
            &self,
            start: u64,
            end: u64,
        ) -> RpcResult<String>;

        /// Creates an inclusion proof, for the data root tuple of block height `height`,
        /// in the set of blocks defined by `start` and `end`.
        ///
        /// The range is end exclusive.
        #[method(name = "GetDataRootTupleInclusionProof")]
        async fn blobstream_get_data_root_tuple_inclusion_proof(
            &self,
            height: u64,
            start: u64,
            end: u64,
        ) -> RpcResult<MerkleProof>;
    }
}

/// Client implementation for the Blobstream RPC API.
// TODO: get rid of this after a release or two
// https://github.com/eigerco/lumina/issues/683
pub trait BlobstreamClient: ClientT {
    /// Collects the data roots over a provided ordered range of blocks, and then
    /// creates a new Merkle root of those data roots.
    ///
    /// The range is end exclusive.
    fn blobstream_get_data_root_tuple_root<'a, 'fut>(
        &'a self,
        start: u64,
        end: u64,
    ) -> impl Future<Output = Result<Hash, Error>> + Send + 'fut
    where
        'a: 'fut,
        Self: Sized + Sync + 'fut,
    {
        async move {
            let root = rpc::BlobstreamClient::blobstream_get_data_root_tuple_root(self, start, end)
                .await?;

            if root.len() == 2 * HASH_SIZE {
                root.parse::<Hash>().map_err(custom_client_error)
            } else {
                let decoded = BASE64.decode(&root).map_err(custom_client_error)?;
                Hash::try_from(decoded).map_err(custom_client_error)
            }
        }
    }

    /// Creates an inclusion proof, for the data root tuple of block height `height`,
    /// in the set of blocks defined by `start` and `end`.
    ///
    /// The range is end exclusive.
    fn blobstream_get_data_root_tuple_inclusion_proof<'a, 'fut>(
        &'a self,
        height: u64,
        start: u64,
        end: u64,
    ) -> impl Future<Output = Result<MerkleProof, Error>> + Send + 'fut
    where
        'a: 'fut,
        Self: Sized + Sync + 'fut,
    {
        rpc::BlobstreamClient::blobstream_get_data_root_tuple_inclusion_proof(
            self, height, start, end,
        )
    }
}

/// Server trait for Blobstream RPC endpoints.
pub trait BlobstreamServer: rpc::BlobstreamServer {}

impl<T> BlobstreamClient for T where T: ClientT {}

impl<T> BlobstreamServer for T where T: rpc::BlobstreamServer {}

pub use rpc::BlobstreamServer as BlobstreamRpcServer;