Error messages refactoring

Cargo.toml

@@ -30,6 +30,7 @@ members = [
     "test-utils/loadtester",
     "test-utils/state-viewer",
     "near/",
+    "tools/rpctypegen",
     "genesis-tools/genesis-csv-to-json",
     "genesis-tools/genesis-populate",
     "genesis-tools/keypair-generator",

chain/jsonrpc/Cargo.toml

@@ -33,3 +33,7 @@ near-client = { path = "../client" }
 near-network = { path = "../network" }
 near-pool = { path = "../pool" }
 near-jsonrpc-client = { path = "client" }
+near-rpc-error-macro = { path = "../../tools/rpctypegen" }
+
+[features]
+dump_errors_schema = ["near-rpc-error-macro/dump_errors_schema"]

chain/jsonrpc/src/lib.rs

@@ -24,11 +24,12 @@ pub use near_jsonrpc_client as client;
 use near_jsonrpc_client::{message, BlockId, ChunkId};
 use near_metrics::{Encoder, TextEncoder};
 use near_network::{NetworkClientMessages, NetworkClientResponses};
+use near_primitives::errors::{InvalidTxError, TxExecutionError};
 use near_primitives::hash::CryptoHash;
 use near_primitives::serialize::{from_base, from_base64, BaseEncode};
 use near_primitives::transaction::SignedTransaction;
 use near_primitives::types::AccountId;
-use near_primitives::views::{ExecutionErrorView, FinalExecutionStatus};
+use near_primitives::views::FinalExecutionStatus;
 use tokio::time::{delay_for, timeout};
 
 mod metrics;
@@ -118,15 +119,38 @@ fn parse_hash(params: Option<Value>) -> Result<CryptoHash, RpcError> {
     })
 }
 
-fn convert_mailbox_error(e: MailboxError) -> ExecutionErrorView {
-    ExecutionErrorView { error_message: e.to_string(), error_type: "MailBoxError".to_string() }
+/// A general Server Error
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone, near_rpc_error_macro::RpcError)]
+#[rpc_error_variant = "ServerError"]
+pub enum ServerError {
+    TxExecutionError(TxExecutionError),
+    Timeout,
+    Closed,
+}
+
+impl From<InvalidTxError> for ServerError {
+    fn from(e: InvalidTxError) -> ServerError {
+        ServerError::TxExecutionError(TxExecutionError::InvalidTxError(e))
+    }
+}
+
+impl From<MailboxError> for ServerError {
+    fn from(e: MailboxError) -> Self {
+        match e {
+            MailboxError::Closed => ServerError::Closed,
+            MailboxError::Timeout => ServerError::Timeout,
+        }
+    }
+}
+
+impl From<ServerError> for RpcError {
+    fn from(e: ServerError) -> RpcError {
+        RpcError::server_error(Some(e))
+    }
 }
 
 fn timeout_err() -> RpcError {
-    RpcError::server_error(Some(ExecutionErrorView {
-        error_message: "send_tx_commit has timed out".to_string(),
-        error_type: "TimeoutError".to_string(),
-    }))
+    RpcError::server_error(Some(ServerError::Timeout))
 }
 
 struct JsonRpcHandler {
@@ -205,20 +229,17 @@ impl JsonRpcHandler {
         let result = self
             .client_addr
             .send(NetworkClientMessages::Transaction(tx))
-            .map_err(|err| RpcError::server_error(Some(convert_mailbox_error(err))))
+            .map_err(|err| RpcError::server_error(Some(ServerError::from(err))))
             .await?;
         match result {
             NetworkClientResponses::ValidTx | NetworkClientResponses::RequestRouted => {
                 self.tx_polling(tx_hash, signer_account_id).await
             }
             NetworkClientResponses::InvalidTx(err) => {
-                Err(RpcError::server_error(Some(ExecutionErrorView::from(err))))
+                Err(RpcError::server_error(Some(ServerError::TxExecutionError(err.into()))))
             }
             NetworkClientResponses::NoResponse => {
-                Err(RpcError::server_error(Some(ExecutionErrorView {
-                    error_message: "send_tx_commit has timed out".to_string(),
-                    error_type: "TimeoutError".to_string(),
-                })))
+                Err(RpcError::server_error(Some(ServerError::Timeout)))
             }
             _ => unreachable!(),
         }

core/primitives/Cargo.toml

@@ -26,9 +26,12 @@ actix = "0.9.0"
 borsh = "0.2.10"
 
 near-crypto = { path = "../crypto" }
+near-vm-errors = { path = "../../runtime/near-vm-errors" }
+near-rpc-error-macro = { path = "../../tools/rpctypegen" }
 
 [features]
 default = ["jemallocator"]
+dump_errors_schema = ["near-rpc-error-macro/dump_errors_schema"]
 
 [dev-dependencies]
 bencher = "0.1.5"