starknet_devnet_server/rpc_core/
response.rs

1use serde::{Deserialize, Serialize};
2
3use crate::rpc_core::error::RpcError;
4use crate::rpc_core::request::{Id, Version};
5
6/// Response of a _single_ rpc call
7#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
8#[serde(deny_unknown_fields)]
9pub struct RpcResponse {
10    // JSON RPC version
11    jsonrpc: Version,
12    #[serde(skip_serializing_if = "Option::is_none")]
13    id: Option<Id>,
14    #[serde(flatten)]
15    pub(crate) result: ResponseResult,
16}
17
18impl RpcResponse {
19    pub fn new(id: Id, content: impl Into<ResponseResult>) -> Self {
20        RpcResponse { jsonrpc: Version::V2, id: Some(id), result: content.into() }
21    }
22
23    pub fn invalid_request(id: Id) -> Self {
24        Self::new(id, RpcError::invalid_request())
25    }
26
27    pub fn from_rpc_error(e: RpcError, id: Id) -> Self {
28        Self { jsonrpc: Version::V2, id: Some(id), result: ResponseResult::Error(e) }
29    }
30}
31
32/// Represents the result of a call either success or error
33#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
34#[serde(deny_unknown_fields)]
35pub enum ResponseResult {
36    #[serde(rename = "result")]
37    Success(serde_json::Value),
38    #[serde(rename = "error")]
39    Error(RpcError),
40}
41
42impl ResponseResult {
43    pub fn error(error: RpcError) -> Self {
44        ResponseResult::Error(error)
45    }
46}
47
48impl From<RpcError> for ResponseResult {
49    fn from(err: RpcError) -> Self {
50        ResponseResult::error(err)
51    }
52}
53/// Synchronous response
54#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
55#[serde(deny_unknown_fields)]
56#[serde(untagged)]
57pub enum Response {
58    /// single json rpc response
59    Single(RpcResponse),
60    /// batch of several responses
61    Batch(Vec<RpcResponse>),
62}
63
64impl Response {
65    /// Creates new [Response] with the given [Error]
66    pub fn error(error: RpcError) -> Self {
67        RpcResponse::new(Id::Null, ResponseResult::Error(error)).into()
68    }
69}
70
71impl From<RpcError> for Response {
72    fn from(err: RpcError) -> Self {
73        Response::error(err)
74    }
75}
76
77impl From<RpcResponse> for Response {
78    fn from(resp: RpcResponse) -> Self {
79        Response::Single(resp)
80    }
81}