cfx_rpc_utils/error/
jsonrpsee_error_helpers.rs

1use crate::error::error_codes as codes;
2use alloy_rpc_types::error::EthRpcErrorCode;
3use cfx_types::H256;
4use jsonrpsee::types::error::{
5    ErrorObjectOwned, INTERNAL_ERROR_CODE, INTERNAL_ERROR_MSG,
6    INVALID_PARAMS_CODE, INVALID_REQUEST_CODE,
7};
8use serde::Serialize;
9use std::fmt;
10
11pub fn invalid_params_msg(param: &str) -> ErrorObjectOwned {
12    let data: Option<bool> = None;
13    invalid_params_rpc_err(format!("Invalid parameters: {}", param), data)
14}
15
16pub fn invalid_params<S: Serialize>(
17    param: &str, data: Option<S>,
18) -> ErrorObjectOwned {
19    invalid_params_rpc_err(format!("Invalid parameters: {}", param), data)
20}
21
22pub fn invalid_params_detail<T: fmt::Debug>(
23    param: &str, details: T,
24) -> ErrorObjectOwned {
25    ErrorObjectOwned::owned(
26        INVALID_PARAMS_CODE,
27        format!("Invalid parameters: {} {:?}", param, details),
28        Some(format!("{:?}", details)),
29    )
30}
31
32pub fn invalid_params_rpc_err<S: Serialize>(
33    msg: impl Into<String>, data: Option<S>,
34) -> ErrorObjectOwned {
35    ErrorObjectOwned::owned(INVALID_PARAMS_CODE, msg, data)
36}
37
38// code is -32000
39pub fn invalid_input_rpc_err(msg: impl Into<String>) -> ErrorObjectOwned {
40    rpc_err(EthRpcErrorCode::InvalidInput.code(), msg, None::<()>)
41}
42
43pub fn invalid_params_check<T, E: std::fmt::Display>(
44    param: &str, r: std::result::Result<T, E>,
45) -> Result<T, ErrorObjectOwned> {
46    match r {
47        Ok(t) => Ok(t),
48        Err(e) => {
49            Err(invalid_params(param.into(), Some(format!("{}", e))).into())
50        }
51    }
52}
53
54pub fn invalid_request_msg(param: &str) -> ErrorObjectOwned {
55    let data: Option<bool> = None;
56    ErrorObjectOwned::owned(INVALID_REQUEST_CODE, param, data)
57}
58
59pub fn internal_error() -> ErrorObjectOwned {
60    let data: Option<bool> = None;
61    ErrorObjectOwned::owned(INTERNAL_ERROR_CODE, INTERNAL_ERROR_MSG, data)
62}
63
64/// Constructs an internal JSON-RPC error.
65pub fn internal_error_with_data<S: Serialize>(data: S) -> ErrorObjectOwned {
66    rpc_err(INTERNAL_ERROR_CODE, INTERNAL_ERROR_MSG, Some(data))
67}
68
69pub fn call_execution_error(message: String, data: String) -> ErrorObjectOwned {
70    ErrorObjectOwned::owned(
71        codes::CALL_EXECUTION_ERROR as i32,
72        message,
73        Some(data),
74    )
75}
76
77pub fn geth_call_execution_error(
78    message: String, data: String,
79) -> ErrorObjectOwned {
80    ErrorObjectOwned::owned(
81        EthRpcErrorCode::ExecutionError.code(),
82        message,
83        Some(data),
84    )
85}
86
87pub fn request_rejected_in_catch_up_mode(
88    details: Option<String>,
89) -> ErrorObjectOwned {
90    ErrorObjectOwned::owned(
91        codes::REQUEST_REJECTED_IN_CATCH_UP as i32,
92        "Request rejected due to still in the catch up mode.",
93        details,
94    )
95}
96
97pub fn pivot_assumption_failed(expected: H256, got: H256) -> ErrorObjectOwned {
98    ErrorObjectOwned::owned(
99        codes::CONFLUX_PIVOT_CHAIN_UNSTABLE as i32,
100        "pivot chain assumption failed",
101        Some(format!(
102            "pivot assumption: {:?}, actual pivot hash: {:?}",
103            expected, got
104        )),
105    )
106}
107
108/// Constructs an internal JSON-RPC error with code and message
109pub fn rpc_error_with_code(
110    code: i32, msg: impl Into<String>,
111) -> ErrorObjectOwned {
112    rpc_err(code, msg, None::<()>)
113}
114
115pub fn unimplemented(details: Option<String>) -> ErrorObjectOwned {
116    ErrorObjectOwned::owned(
117        codes::UNSUPPORTED as i32,
118        "This API is not implemented yet",
119        details,
120    )
121}
122
123/// Constructs a JSON-RPC error, consisting of `code`, `message` and optional
124/// `data`.
125pub fn rpc_err<S: Serialize>(
126    code: i32, msg: impl Into<String>, data: Option<S>,
127) -> ErrorObjectOwned {
128    ErrorObjectOwned::owned(code, msg, data)
129}