Revert "fix(rpc): do not serve rpc while the node is syncing (#2985)" (#3059)

A node can be in syncing status as long as it is two blocks behind and this might happen just due to some network glitch. We can probably implement some sophisticated strategy for more fine-grained control, but for now it's better to revert it.

Author: bowenwang1996

chain/jsonrpc/client/src/lib.rs

@@ -183,6 +183,8 @@ jsonrpc_client!(pub struct JsonRpcClient {
     pub fn broadcast_tx_commit(&self, tx: String) -> RpcRequest<FinalExecutionOutcomeView>;
     pub fn status(&self) -> RpcRequest<StatusResponse>;
     #[allow(non_snake_case)]
+    pub fn EXPERIMENTAL_check_tx(&self, tx: String) -> RpcRequest<serde_json::Value>;
+    #[allow(non_snake_case)]
     pub fn EXPERIMENTAL_genesis_config(&self) -> RpcRequest<serde_json::Value>;
     pub fn health(&self) -> RpcRequest<()>;
     pub fn tx(&self, hash: String, account_id: String) -> RpcRequest<FinalExecutionOutcomeView>;

chain/jsonrpc/src/lib.rs

@@ -51,25 +51,6 @@ mod metrics;
 const JSON_PAYLOAD_MAX_SIZE: usize = 2 * 1024 * 1024;
 const QUERY_DATA_MAX_SIZE: usize = 10 * 1024;
 
-/// RPCs that should only be called when the node is synced
-const RPC_REQUIRES_SYNC: [&'static str; 15] = [
-    "broadcast_tx_async",
-    "EXPERIMENTAL_broadcast_tx_sync",
-    "broadcast_tx_commit",
-    "validators",
-    "query",
-    "health",
-    "tx",
-    "block",
-    "chunk",
-    "EXPERIMENTAL_changes",
-    "EXPERIMENTAL_changes_in_block",
-    "next_light_client_block",
-    "EXPERIMENTAL_light_client_proof",
-    "light_client_proof",
-    "gas_price",
-];
-
 #[derive(Serialize, Deserialize, Clone, Copy, Debug)]
 pub struct RpcPollingConfig {
     pub polling_interval: Duration,
@@ -150,7 +131,6 @@ pub enum ServerError {
     Timeout,
     Closed,
     InternalError,
-    IsSyncing,
 }
 
 impl Display for ServerError {
@@ -160,7 +140,6 @@ impl Display for ServerError {
             ServerError::Timeout => write!(f, "ServerError: Timeout"),
             ServerError::Closed => write!(f, "ServerError: Closed"),
             ServerError::InternalError => write!(f, "ServerError: Internal Error"),
-            ServerError::IsSyncing => write!(f, "ServerError: Node is syncing"),
         }
     }
 }
@@ -232,22 +211,11 @@ impl JsonRpcHandler {
             }
         }
 
-        if RPC_REQUIRES_SYNC.iter().find(|&&s| s == &request.method).is_some() {
-            match self.client_addr.send(Status { is_health_check: false }).await {
-                Ok(Ok(result)) => {
-                    if result.sync_info.syncing {
-                        return Err(ServerError::IsSyncing.into());
-                    }
-                }
-                Ok(Err(err)) => return Err(RpcError::new(-32_001, err, None)),
-                Err(_) => return Err(RpcError::server_error::<()>(None)),
-            }
-        }
-
         match request.method.as_ref() {
             "broadcast_tx_async" => self.send_tx_async(request.params).await,
             "EXPERIMENTAL_broadcast_tx_sync" => self.send_tx_sync(request.params).await,
             "broadcast_tx_commit" => self.send_tx_commit(request.params).await,
+            "EXPERIMENTAL_check_tx" => self.check_tx(request.params).await,
             "validators" => self.validators(request.params).await,
             "query" => self.query(request.params).await,
             "health" => self.health().await,
@@ -363,6 +331,10 @@ impl JsonRpcHandler {
         self.send_or_check_tx(params, false).await
     }
 
+    async fn check_tx(&self, params: Option<Value>) -> Result<Value, RpcError> {
+        self.send_or_check_tx(params, true).await
+    }
+
     async fn send_or_check_tx(
         &self,
         params: Option<Value>,

chain/jsonrpc/tests/rpc_transactions.rs

@@ -201,3 +201,28 @@ fn test_tx_status_missing_tx() {
         }
     });
 }
+
+#[test]
+fn test_check_invalid_tx() {
+    test_with_client!(test_utils::NodeType::Validator, client, async move {
+        let signer = InMemorySigner::from_seed("test1", KeyType::ED25519, "test1");
+        // invalid base hash
+        let tx = SignedTransaction::send_money(
+            1,
+            "test1".to_string(),
+            "test2".to_string(),
+            &signer,
+            100,
+            hash(&[1]),
+        );
+        let bytes = tx.try_to_vec().unwrap();
+        match client.EXPERIMENTAL_check_tx(to_base64(&bytes)).await {
+            Err(e) => {
+                let s = serde_json::to_string(&e.data.unwrap()).unwrap();
+                println!("{}", s);
+                assert_eq!(s, "{\"TxExecutionError\":{\"InvalidTxError\":\"Expired\"}}");
+            }
+            Ok(_) => panic!("transaction should not succeed"),
+        }
+    });
+}