Introduce preliminary rpc primitives for unified RPC error (paritytech#315)

* Introduce rpc primitives for unified RPC error

* Clean up

* .

* Trustee rpc error kind

* Nits

* .

* Update chainx_rpc.json

Author: liuchengxu

Cargo.lock

@@ -26,6 +26,7 @@ members = [
     "primitives/mining/common",
     "primitives/mining/staking",
     "primitives/protocol",
+    "primitives/rpc",
     "primitives/runtime",
     "rpc",
     "runtime",

Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "xp-rpc"
+version = "2.0.0-alpha.3"
+authors = ["The ChainX Authors"]
+edition = "2018"
+
+[dependencies]
+jsonrpc-core = "15.0.0"

primitives/rpc/Cargo.toml

@@ -0,0 +1,62 @@
+// Copyright 2019-2020 ChainX Project Authors. Licensed under GPL-3.0.
+
+use std::fmt::Debug;
+
+pub use jsonrpc_core::{Error, ErrorCode, Result};
+
+/// The call to runtime failed.
+pub const RUNTIME_ERROR: i64 = 1;
+
+/// The call related to trustee to runtime failed.
+const RUNTIME_TRUSTEE_ERROR: i64 = RUNTIME_ERROR + 100;
+
+/// Decode the generic trustee info failed.
+///
+/// TODO: these pallet-specific errors should be moved to its own rpc module
+/// when there are many of them.
+pub const RUNTIME_TRUSTEE_DECODE_ERROR: i64 = RUNTIME_TRUSTEE_ERROR + 1;
+
+/// The trustees are inexistent.
+pub const RUNTIME_TRUSTEE_INEXISTENT_ERROR: i64 = RUNTIME_TRUSTEE_ERROR + 2;
+
+/// The transaction was not decodable.
+pub const DECODE_ERROR: i64 = 10000;
+
+/// The bytes failed to be decoded as hex.
+pub const DECODE_HEX_ERROR: i64 = DECODE_ERROR + 1;
+
+/// Converts a runtime trap into an RPC error.
+pub fn runtime_error_into_rpc_err(err: impl Debug) -> Error {
+    Error {
+        code: ErrorCode::ServerError(RUNTIME_ERROR),
+        message: "Runtime trapped".into(),
+        data: Some(format!("{:?}", err).into()),
+    }
+}
+
+/// Converts a trustee runtime trap into an RPC error.
+pub fn trustee_decode_error_into_rpc_err(err: impl Debug) -> Error {
+    Error {
+        code: ErrorCode::ServerError(RUNTIME_TRUSTEE_DECODE_ERROR),
+        message: "Can not decode generic trustee session info".into(),
+        data: Some(format!("{:?}", err).into()),
+    }
+}
+
+/// Converts a trustee runtime trap into an RPC error.
+pub fn trustee_inexistent_rpc_err() -> Error {
+    Error {
+        code: ErrorCode::ServerError(RUNTIME_TRUSTEE_INEXISTENT_ERROR),
+        message: "Trustee does not exist".into(),
+        data: None,
+    }
+}
+
+/// Converts a hex decode error into an RPC error.
+pub fn hex_decode_error_into_rpc_err(err: impl Debug) -> Error {
+    Error {
+        code: ErrorCode::ServerError(DECODE_HEX_ERROR),
+        message: "Failed to decode hex".into(),
+        data: Some(format!("{:?}", err).into()),
+    }
+}

primitives/rpc/src/lib.rs

@@ -138,7 +138,7 @@
                     "isOptional": true
                 }
             ],
-            "type": "()"
+            "type": "bool"
         },
         "trusteeMultisigs": {
             "description": "Return the trustee multisig address for all chain.",

scripts/chainx-js/res/chainx_rpc.json

@@ -18,6 +18,9 @@ sp-api = "2.0.0"
 sp-blockchain = "2.0.0"
 sp-runtime = "2.0.0"
 
+# ChainX primitives
+xp-rpc = { path = "../../../primitives/rpc" }
+
 # ChainX pallets
 xpallet-support = { path = "../../support" }
 

xpallets/assets/rpc/Cargo.toml

@@ -1,20 +1,22 @@
 // Copyright 2019-2020 ChainX Project Authors. Licensed under GPL-3.0.
 
 use std::collections::BTreeMap;
-use std::fmt::{Debug, Display};
+use std::fmt::Display;
 use std::str::FromStr;
 use std::sync::Arc;
 
 use codec::Codec;
-use jsonrpc_core::{Error, ErrorCode, Result};
 use jsonrpc_derive::rpc;
 
+use sp_api::ProvideRuntimeApi;
 use sp_blockchain::HeaderBackend;
 use sp_runtime::{
     generic::BlockId,
     traits::{Block as BlockT, Zero},
 };
 
+use xp_rpc::{runtime_error_into_rpc_err, Result};
+
 use xpallet_support::RpcBalance;
 
 use xpallet_assets_rpc_runtime_api::{
@@ -29,7 +31,7 @@ pub struct Assets<C, B> {
 impl<C, B> Assets<C, B> {
     /// Create new `Contracts` with the given reference to the client.
     pub fn new(client: Arc<C>) -> Self {
-        Assets {
+        Self {
             client,
             _marker: Default::default(),
         }
@@ -60,9 +62,7 @@ where
 impl<C, Block, AccountId, Balance> XAssetsApi<<Block as BlockT>::Hash, AccountId, Balance>
     for Assets<C, Block>
 where
-    C: sp_api::ProvideRuntimeApi<Block>,
-    C: HeaderBackend<Block>,
-    C: Send + Sync + 'static,
+    C: Send + Sync + 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block>,
     C::Api: XAssetsRuntimeApi<Block, AccountId, Balance>,
     Block: BlockT,
     AccountId: Clone + Display + Codec,
@@ -129,13 +129,3 @@ where
             .map_err(runtime_error_into_rpc_err)
     }
 }
-
-const RUNTIME_ERROR: i64 = 1;
-/// Converts a runtime trap into an RPC error.
-fn runtime_error_into_rpc_err(err: impl Debug) -> Error {
-    Error {
-        code: ErrorCode::ServerError(RUNTIME_ERROR),
-        message: "Runtime trapped".into(),
-        data: Some(format!("{:?}", err).into()),
-    }
-}

xpallets/assets/rpc/src/lib.rs

@@ -19,6 +19,9 @@ sp-api = "2.0.0"
 sp-blockchain = "2.0.0"
 sp-runtime = "2.0.0"
 
+# ChainX primitives
+xp-rpc = { path = "../../../../primitives/rpc" }
+
 # ChainX pallets
 xpallet-support = { path = "../../../support" }
 

xpallets/dex/spot/rpc/Cargo.toml

@@ -9,14 +9,15 @@ use std::str::FromStr;
 use std::sync::Arc;
 
 use codec::Codec;
-use jsonrpc_core::{Error as RpcError, ErrorCode, Result};
 use jsonrpc_derive::rpc;
 use serde::{Deserialize, Serialize};
 
 use sp_api::ProvideRuntimeApi;
 use sp_blockchain::HeaderBackend;
 use sp_runtime::{generic::BlockId, traits::Block as BlockT};
 
+use xp_rpc::{runtime_error_into_rpc_err, Result};
+
 use xpallet_support::{RpcBalance, RpcPrice};
 
 use xpallet_dex_spot_rpc_runtime_api::{
@@ -217,30 +218,3 @@ pub struct Page<T> {
     pub page_size: u32,
     pub data: T,
 }
-
-/// Error type of this RPC api.
-pub enum Error {
-    /// The transaction was not decodable.
-    DecodeError,
-    /// The call to runtime failed.
-    RuntimeError,
-}
-
-impl From<Error> for i64 {
-    fn from(e: Error) -> i64 {
-        match e {
-            Error::RuntimeError => 1,
-            Error::DecodeError => 2,
-        }
-    }
-}
-
-const RUNTIME_ERROR: i64 = 1;
-/// Converts a runtime trap into an RPC error.
-fn runtime_error_into_rpc_err(err: impl Debug) -> RpcError {
-    RpcError {
-        code: ErrorCode::ServerError(RUNTIME_ERROR),
-        message: "Runtime trapped".into(),
-        data: Some(format!("{:?}", err).into()),
-    }
-}

xpallets/dex/spot/rpc/src/lib.rs

@@ -19,6 +19,9 @@ sp-api = "2.0.0"
 sp-blockchain = "2.0.0"
 sp-runtime = "2.0.0"
 
+# ChainX primitives
+xp-rpc = { path = "../../../../primitives/rpc" }
+
 # ChainX pallets
 xpallet-support = { path = "../../../support" }