celestia-client 0.1.0

Celestia client combining RPC and gRPC functionality.
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

#![doc = include_str!("../README.md")]

#[cfg(all(target_arch = "wasm32", test))]
wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);

mod blob;
mod blobstream;
mod client;
mod fraud;
mod header;
mod share;
mod state;
#[cfg(test)]
mod test_utils;
mod utils;

/// API related types.
pub mod api {
    pub use crate::blob::BlobApi;
    pub use crate::blobstream::BlobstreamApi;
    pub use crate::fraud::FraudApi;
    pub use crate::header::HeaderApi;
    pub use crate::share::ShareApi;
    pub use crate::state::StateApi;

    /// Blob API related types.
    pub mod blob {
        #[doc(inline)]
        pub use celestia_rpc::blob::BlobsAtHeight;
    }

    /// Share API related types.
    pub mod share {
        #[doc(inline)]
        pub use celestia_rpc::share::{
            GetRangeResponse, GetRowResponse, RowSide, SampleCoordinates,
        };
    }

    /// Fraud API related types.
    pub mod fraud {
        #[doc(inline)]
        pub use celestia_rpc::fraud::{Proof, ProofType};
    }
}

/// TX related types.
pub mod tx {
    #[doc(inline)]
    pub use celestia_grpc::grpc::{GasEstimate, TxPriority};
    #[doc(inline)]
    pub use celestia_grpc::{DocSigner, IntoProtobufAny, SignDoc, TxConfig, TxInfo};
    #[doc(inline)]
    pub use k256::ecdsa::signature::{Error as SignatureError, Keypair};
    #[doc(inline)]
    pub use k256::ecdsa::{Signature, SigningKey, VerifyingKey};
}

/// Re-export of [`celestia-proto`].
///
/// [`celestia-proto`]: celestia_proto
#[doc(inline)]
pub use celestia_proto as proto;

/// Re-export of [`celestia-types`].
///
/// [`celestia-types`]: celestia_types
#[doc(inline)]
pub use celestia_types as types;

pub use crate::client::{Client, ClientBuilder};

/// Alias for a `Result` with the error type [`celestia_client::Error`].
///
/// [`celestia_client::Error`]: crate::Error
pub type Result<T, E = Error> = std::result::Result<T, E>;

/// Representation of all the errors that can occur when interacting with [`celestia_client`].
///
/// [`celestia_client`]: crate
#[derive(Debug, thiserror::Error)]
pub enum Error {
    /// Celestia RPC error.
    #[error("RPC error: {0}")]
    Rpc(#[from] celestia_rpc::Error),

    /// Celestia GRPC error.
    #[error("GRPC error: {0}")]
    Grpc(#[from] celestia_grpc::Error),

    /// Celestia types error.
    #[error("Celestia types error: {0}")]
    Types(#[from] celestia_types::Error),

    /// Client is in read-only mode.
    #[error("Client is constructed for read-only mode, operation not supported")]
    ReadOnlyMode,

    /// RPC chain-id and gGRPC chain-id missmatch.
    #[error("Chain id of RPC endpoint missmatch with chain id of gRPC endpoint")]
    ChainIdMissmatch,

    /// RPC authentication token is not supported.
    #[error("RPC authentication token is not supported")]
    AuthTokenNotSupported,

    /// Invalid height.
    #[error("Invalid height: {0}")]
    InvalidHeight(u64),

    /// Invalid private key.
    #[error("Invalid private key")]
    InvalidPrivateKey,

    /// RPC endpoint is not set.
    #[error("RPC endpoint not set")]
    RpcEndpointNotSet,

    /// Signer is not set.
    #[error("GRPC endpoint is set but singer is not")]
    SignerNotSet,

    /// GRPC endpoint is not set.
    #[error("Signer is set but GRPC endpoint is not")]
    GrpcEndpointNotSet,
}

impl From<jsonrpsee_core::ClientError> for Error {
    fn from(value: jsonrpsee_core::ClientError) -> Self {
        Error::Rpc(celestia_rpc::Error::JsonRpc(value))
    }
}

impl From<serde_json::Error> for Error {
    fn from(value: serde_json::Error) -> Self {
        jsonrpsee_core::ClientError::ParseError(value).into()
    }
}

impl Error {
    /// Helper that returns the logical error of a gRPC call.
    pub fn as_grpc_status(&self) -> Option<&tonic::Status> {
        match self {
            Error::Grpc(celestia_grpc::Error::TonicError(status)) => Some(&**status),
            _ => None,
        }
    }

    /// Helper that returns the logical error of an RPC call.
    pub fn as_rpc_call_error(&self) -> Option<&jsonrpsee_types::error::ErrorObjectOwned> {
        match self {
            Error::Rpc(celestia_rpc::Error::JsonRpc(jsonrpsee_core::ClientError::Call(e))) => {
                Some(e)
            }
            _ => None,
        }
    }
}