rpcdaemon: rename json_rpc::JsonRpcValidator (#2114)

canepat · web-flow · commit ee93a914587b · 2024-06-19T00:04:29.000+02:00
diff --git a/docs/fuzzer.md b/docs/fuzzer.md
@@ -36,7 +36,7 @@ To help with analysing a single request you can run the diagnostic tool:
 ```
 
 ## Trophies
-1.	Various validation errors which led to the introduction of `JsonRpcValidator`
+1.	Various validation errors which led to the introduction of `rpc::json_rpc::Validator`
 2.	BlockNum accepting ill-formatted numbers, e.g. `5x5`
 3.	`{"jsonrpc":"2.0","id":1,"method":"eth_feeHistory","params":["0x1A","0x2",[95,99]]}` - triggers ASAN error
 
diff --git a/silkworm/rpc/daemon.cpp b/silkworm/rpc/daemon.cpp
@@ -247,7 +247,7 @@ Daemon::Daemon(DaemonSettings settings, std::optional<mdbx::env> chaindata_env)
     compatibility::set_erigon_json_api_compatibility_required(settings_.erigon_json_rpc_compatibility);
 
     // Load JSON RPC specification for Ethereum API
-    rpc::json_rpc::JsonRpcValidator::load_specification();
+    rpc::json_rpc::Validator::load_specification();
 }
 
 void Daemon::add_private_services() {
diff --git a/silkworm/rpc/json_rpc/request_handler.cpp b/silkworm/rpc/json_rpc/request_handler.cpp
@@ -119,7 +119,7 @@ nlohmann::json RequestHandler::prevalidate_and_parse(const std::string& request)
     return nlohmann::json::parse(request);
 }
 
-JsonRpcValidationResult RequestHandler::is_valid_jsonrpc(const nlohmann::json& request_json) {
+ValidationResult RequestHandler::is_valid_jsonrpc(const nlohmann::json& request_json) {
     return json_rpc_validator_.validate(request_json);
 }
 
diff --git a/silkworm/rpc/json_rpc/request_handler.hpp b/silkworm/rpc/json_rpc/request_handler.hpp
@@ -55,7 +55,7 @@ class RequestHandler : public rpc::RequestHandler {
 
   private:
     nlohmann::json prevalidate_and_parse(const std::string& request);
-    JsonRpcValidationResult is_valid_jsonrpc(const nlohmann::json& request_json);
+    ValidationResult is_valid_jsonrpc(const nlohmann::json& request_json);
 
     Task<void> handle_request(
         commands::RpcApiTable::HandleMethod handler,
@@ -73,7 +73,7 @@ class RequestHandler : public rpc::RequestHandler {
 
     const commands::RpcApiTable& rpc_api_table_;
 
-    JsonRpcValidator json_rpc_validator_;
+    Validator json_rpc_validator_;
 
     std::shared_ptr<InterfaceLog> ifc_log_;
 };
diff --git a/silkworm/rpc/json_rpc/validator.cpp b/silkworm/rpc/json_rpc/validator.cpp
@@ -31,7 +31,7 @@ static const std::string kRequestFieldParameters{"params"};
 static const std::string kRequestRequiredFields{
     kRequestFieldJsonRpc + "," + kRequestFieldId + "," + kRequestFieldMethod + "," + kRequestFieldParameters};
 
-void JsonRpcValidator::load_specification() {
+void Validator::load_specification() {
     const auto spec = nlohmann::json::parse(specification_json, nullptr, /*allow_exceptions=*/false);
     if (spec.contains("methods")) {
         for (const auto& method : spec["methods"]) {
@@ -43,15 +43,15 @@ void JsonRpcValidator::load_specification() {
     }
 }
 
-JsonRpcValidationResult JsonRpcValidator::validate(const nlohmann::json& request) {
+ValidationResult Validator::validate(const nlohmann::json& request) {
     if (auto valid_result{check_request_fields(request)}; !valid_result) {
         return valid_result;
     }
 
     return validate_params(request);
 }
 
-JsonRpcValidationResult JsonRpcValidator::check_request_fields(const nlohmann::json& request) {
+ValidationResult Validator::check_request_fields(const nlohmann::json& request) {
     // Expected fields: jsonrpc, id, method, params (optional)
     auto required_fields = 0b111;
 
@@ -87,7 +87,7 @@ JsonRpcValidationResult JsonRpcValidator::check_request_fields(const nlohmann::j
     return {};
 }
 
-JsonRpcValidationResult JsonRpcValidator::validate_params(const nlohmann::json& request) {
+ValidationResult Validator::validate_params(const nlohmann::json& request) {
     const auto& method = request.find(kRequestFieldMethod).value().get<std::string>();
     const auto& params_field = request.find(kRequestFieldParameters);
     const auto& params = params_field != request.end() ? params_field.value() : nlohmann::json::array();
@@ -128,7 +128,7 @@ JsonRpcValidationResult JsonRpcValidator::validate_params(const nlohmann::json&
     return {};
 }
 
-JsonRpcValidationResult JsonRpcValidator::validate_schema(const nlohmann::json& value, const nlohmann::json& schema) {
+ValidationResult Validator::validate_schema(const nlohmann::json& value, const nlohmann::json& schema) {
     if (schema.contains("type")) {
         if (auto result{validate_type(value, schema)}; !result) {
             return result;
@@ -140,7 +140,7 @@ JsonRpcValidationResult JsonRpcValidator::validate_schema(const nlohmann::json&
         schema_of_collection = schema.find("oneOf");
     }
 
-    JsonRpcValidationResult result;
+    ValidationResult result;
     if (schema_of_collection != schema.end()) {
         for (const auto& schema_of : schema_of_collection.value()) {
             result = validate_type(value, schema_of);
@@ -152,7 +152,7 @@ JsonRpcValidationResult JsonRpcValidator::validate_schema(const nlohmann::json&
     return result;
 }
 
-JsonRpcValidationResult JsonRpcValidator::validate_type(const nlohmann::json& value, const nlohmann::json& schema) {
+ValidationResult Validator::validate_type(const nlohmann::json& value, const nlohmann::json& schema) {
     const auto& schema_type = schema["type"].get<std::string>();
 
     if (schema_type == "string") {
@@ -172,7 +172,7 @@ JsonRpcValidationResult JsonRpcValidator::validate_type(const nlohmann::json& va
     }
 }
 
-JsonRpcValidationResult JsonRpcValidator::validate_string(const nlohmann::json& string, const nlohmann::json& schema) {
+ValidationResult Validator::validate_string(const nlohmann::json& string, const nlohmann::json& schema) {
     if (!string.is_string()) {
         return tl::make_unexpected("Invalid string: " + string.dump());
     }
@@ -213,12 +213,12 @@ JsonRpcValidationResult JsonRpcValidator::validate_string(const nlohmann::json&
     return {};
 }
 
-JsonRpcValidationResult JsonRpcValidator::validate_array(const nlohmann::json& array, const nlohmann::json& schema) {
+ValidationResult Validator::validate_array(const nlohmann::json& array, const nlohmann::json& schema) {
     if (!array.is_array() && !array.is_null() && array.empty()) {
         return tl::make_unexpected("Invalid array: " + array.dump());
     }
 
-    JsonRpcValidationResult result;
+    ValidationResult result;
     const auto& schema_items = schema["items"];
     for (const auto& item : array) {
         result = validate_schema(item, schema_items);
@@ -230,7 +230,7 @@ JsonRpcValidationResult JsonRpcValidator::validate_array(const nlohmann::json& a
     return result;
 }
 
-JsonRpcValidationResult JsonRpcValidator::validate_object(const nlohmann::json& object, const nlohmann::json& schema) {
+ValidationResult Validator::validate_object(const nlohmann::json& object, const nlohmann::json& schema) {
     if (!object.is_object()) {
         return tl::make_unexpected("Invalid object: " + object.dump());
     }
@@ -262,21 +262,21 @@ JsonRpcValidationResult JsonRpcValidator::validate_object(const nlohmann::json&
     return {};
 }
 
-JsonRpcValidationResult JsonRpcValidator::validate_boolean(const nlohmann::json& boolean) {
+ValidationResult Validator::validate_boolean(const nlohmann::json& boolean) {
     if (!boolean.is_boolean()) {
         return tl::make_unexpected("Invalid boolean: " + boolean.dump());
     }
     return {};
 }
 
-JsonRpcValidationResult JsonRpcValidator::validate_number(const nlohmann::json& number) {
+ValidationResult Validator::validate_number(const nlohmann::json& number) {
     if (!number.is_number()) {
         return tl::make_unexpected("Invalid number: " + number.dump());
     }
     return {};
 }
 
-JsonRpcValidationResult JsonRpcValidator::validate_null(const nlohmann::json& value) {
+ValidationResult Validator::validate_null(const nlohmann::json& value) {
     if (value.is_null()) {
         return {};
     }
diff --git a/silkworm/rpc/json_rpc/validator.hpp b/silkworm/rpc/json_rpc/validator.hpp
@@ -25,26 +25,26 @@
 
 namespace silkworm::rpc::json_rpc {
 
-using JsonRpcValidationResult = tl::expected<void, std::string>;
+using ValidationResult = tl::expected<void, std::string>;
 
-class JsonRpcValidator {
+class Validator {
   public:
     static void load_specification();
     static const std::string& openrpc_version() { return openrpc_version_; }
 
-    JsonRpcValidationResult validate(const nlohmann::json& request);
+    ValidationResult validate(const nlohmann::json& request);
 
   private:
-    JsonRpcValidationResult check_request_fields(const nlohmann::json& request);
-    JsonRpcValidationResult validate_params(const nlohmann::json& request);
-    JsonRpcValidationResult validate_schema(const nlohmann::json& value, const nlohmann::json& schema);
-    JsonRpcValidationResult validate_type(const nlohmann::json& value, const nlohmann::json& schema);
-    JsonRpcValidationResult validate_string(const nlohmann::json& string, const nlohmann::json& schema);
-    JsonRpcValidationResult validate_array(const nlohmann::json& array, const nlohmann::json& schema);
-    JsonRpcValidationResult validate_object(const nlohmann::json& object, const nlohmann::json& schema);
-    JsonRpcValidationResult validate_boolean(const nlohmann::json& boolean);
-    JsonRpcValidationResult validate_number(const nlohmann::json& number);
-    JsonRpcValidationResult validate_null(const nlohmann::json& value);
+    ValidationResult check_request_fields(const nlohmann::json& request);
+    ValidationResult validate_params(const nlohmann::json& request);
+    ValidationResult validate_schema(const nlohmann::json& value, const nlohmann::json& schema);
+    ValidationResult validate_type(const nlohmann::json& value, const nlohmann::json& schema);
+    ValidationResult validate_string(const nlohmann::json& string, const nlohmann::json& schema);
+    ValidationResult validate_array(const nlohmann::json& array, const nlohmann::json& schema);
+    ValidationResult validate_object(const nlohmann::json& object, const nlohmann::json& schema);
+    ValidationResult validate_boolean(const nlohmann::json& boolean);
+    ValidationResult validate_number(const nlohmann::json& number);
+    ValidationResult validate_null(const nlohmann::json& value);
 
     inline static std::string openrpc_version_;
     inline static std::map<std::string, nlohmann::json> method_specs_;
diff --git a/silkworm/rpc/json_rpc/validator_benchmark.cpp b/silkworm/rpc/json_rpc/validator_benchmark.cpp
@@ -21,7 +21,7 @@
 
 #include "validator.hpp"
 
-static silkworm::rpc::json_rpc::JsonRpcValidator validator{};
+static silkworm::rpc::json_rpc::Validator validator{};
 
 const nlohmann::json requests[2] = {
     {
diff --git a/silkworm/rpc/json_rpc/validator_test.cpp b/silkworm/rpc/json_rpc/validator_test.cpp
diff --git a/silkworm/rpc/test_util/api_test_database.hpp b/silkworm/rpc/test_util/api_test_database.hpp

Original file line number	Diff line number	Diff line change
`@@ -247,7 +247,7 @@ Daemon::Daemon(DaemonSettings settings, std::optional<mdbx::env> chaindata_env)`
`247`	`247`	`compatibility::set_erigon_json_api_compatibility_required(settings_.erigon_json_rpc_compatibility);`
`248`	`248`
`249`	`249`	`// Load JSON RPC specification for Ethereum API`
`250`		`- rpc::json_rpc::JsonRpcValidator::load_specification();`
	`250`	`+ rpc::json_rpc::Validator::load_specification();`
`251`	`251`	`}`
`252`	`252`
`253`	`253`	`void Daemon::add_private_services() {`
Original file line number	Diff line number	Diff line change
`@@ -119,7 +119,7 @@ nlohmann::json RequestHandler::prevalidate_and_parse(const std::string& request)`
`119`	`119`	`return nlohmann::json::parse(request);`
`120`	`120`	`}`
`121`	`121`
`122`		`-JsonRpcValidationResult RequestHandler::is_valid_jsonrpc(const nlohmann::json& request_json) {`
	`122`	`+ValidationResult RequestHandler::is_valid_jsonrpc(const nlohmann::json& request_json) {`
`123`	`123`	`return json_rpc_validator_.validate(request_json);`
`124`	`124`	`}`
`125`	`125`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ static const std::string kRequestFieldParameters{"params"};`
`31`	`31`	`static const std::string kRequestRequiredFields{`
`32`	`32`	`kRequestFieldJsonRpc + "," + kRequestFieldId + "," + kRequestFieldMethod + "," + kRequestFieldParameters};`
`33`	`33`
`34`		`-void JsonRpcValidator::load_specification() {`
	`34`	`+void Validator::load_specification() {`
`35`	`35`	`const auto spec = nlohmann::json::parse(specification_json, nullptr, /allow_exceptions=/false);`
`36`	`36`	`if (spec.contains("methods")) {`
`37`	`37`	`for (const auto& method : spec["methods"]) {`
`@@ -43,15 +43,15 @@ void JsonRpcValidator::load_specification() {`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`
`46`		`-JsonRpcValidationResult JsonRpcValidator::validate(const nlohmann::json& request) {`
	`46`	`+ValidationResult Validator::validate(const nlohmann::json& request) {`
`47`	`47`	`if (auto valid_result{check_request_fields(request)}; !valid_result) {`
`48`	`48`	`return valid_result;`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`return validate_params(request);`
`52`	`52`	`}`
`53`	`53`
`54`		`-JsonRpcValidationResult JsonRpcValidator::check_request_fields(const nlohmann::json& request) {`
	`54`	`+ValidationResult Validator::check_request_fields(const nlohmann::json& request) {`
`55`	`55`	`// Expected fields: jsonrpc, id, method, params (optional)`
`56`	`56`	`auto required_fields = 0b111;`
`57`	`57`
`@@ -87,7 +87,7 @@ JsonRpcValidationResult JsonRpcValidator::check_request_fields(const nlohmann::j`
`87`	`87`	`return {};`
`88`	`88`	`}`
`89`	`89`
`90`		`-JsonRpcValidationResult JsonRpcValidator::validate_params(const nlohmann::json& request) {`
	`90`	`+ValidationResult Validator::validate_params(const nlohmann::json& request) {`
`91`	`91`	`const auto& method = request.find(kRequestFieldMethod).value().get<std::string>();`
`92`	`92`	`const auto& params_field = request.find(kRequestFieldParameters);`
`93`	`93`	`const auto& params = params_field != request.end() ? params_field.value() : nlohmann::json::array();`
`@@ -128,7 +128,7 @@ JsonRpcValidationResult JsonRpcValidator::validate_params(const nlohmann::json&`
`128`	`128`	`return {};`
`129`	`129`	`}`
`130`	`130`
`131`		`-JsonRpcValidationResult JsonRpcValidator::validate_schema(const nlohmann::json& value, const nlohmann::json& schema) {`
	`131`	`+ValidationResult Validator::validate_schema(const nlohmann::json& value, const nlohmann::json& schema) {`
`132`	`132`	`if (schema.contains("type")) {`
`133`	`133`	`if (auto result{validate_type(value, schema)}; !result) {`
`134`	`134`	`return result;`
`@@ -140,7 +140,7 @@ JsonRpcValidationResult JsonRpcValidator::validate_schema(const nlohmann::json&`
`140`	`140`	`schema_of_collection = schema.find("oneOf");`
`141`	`141`	`}`
`142`	`142`
`143`		`- JsonRpcValidationResult result;`
	`143`	`+ ValidationResult result;`
`144`	`144`	`if (schema_of_collection != schema.end()) {`
`145`	`145`	`for (const auto& schema_of : schema_of_collection.value()) {`
`146`	`146`	`result = validate_type(value, schema_of);`
`@@ -152,7 +152,7 @@ JsonRpcValidationResult JsonRpcValidator::validate_schema(const nlohmann::json&`
`152`	`152`	`return result;`
`153`	`153`	`}`
`154`	`154`
`155`		`-JsonRpcValidationResult JsonRpcValidator::validate_type(const nlohmann::json& value, const nlohmann::json& schema) {`
	`155`	`+ValidationResult Validator::validate_type(const nlohmann::json& value, const nlohmann::json& schema) {`
`156`	`156`	`const auto& schema_type = schema["type"].get<std::string>();`
`157`	`157`
`158`	`158`	`if (schema_type == "string") {`
`@@ -172,7 +172,7 @@ JsonRpcValidationResult JsonRpcValidator::validate_type(const nlohmann::json& va`
`172`	`172`	`}`
`173`	`173`	`}`
`174`	`174`
`175`		`-JsonRpcValidationResult JsonRpcValidator::validate_string(const nlohmann::json& string, const nlohmann::json& schema) {`
	`175`	`+ValidationResult Validator::validate_string(const nlohmann::json& string, const nlohmann::json& schema) {`
`176`	`176`	`if (!string.is_string()) {`
`177`	`177`	`return tl::make_unexpected("Invalid string: " + string.dump());`
`178`	`178`	`}`
`@@ -213,12 +213,12 @@ JsonRpcValidationResult JsonRpcValidator::validate_string(const nlohmann::json&`
`213`	`213`	`return {};`
`214`	`214`	`}`
`215`	`215`
`216`		`-JsonRpcValidationResult JsonRpcValidator::validate_array(const nlohmann::json& array, const nlohmann::json& schema) {`
	`216`	`+ValidationResult Validator::validate_array(const nlohmann::json& array, const nlohmann::json& schema) {`
`217`	`217`	`if (!array.is_array() && !array.is_null() && array.empty()) {`
`218`	`218`	`return tl::make_unexpected("Invalid array: " + array.dump());`
`219`	`219`	`}`
`220`	`220`
`221`		`- JsonRpcValidationResult result;`
	`221`	`+ ValidationResult result;`
`222`	`222`	`const auto& schema_items = schema["items"];`
`223`	`223`	`for (const auto& item : array) {`
`224`	`224`	`result = validate_schema(item, schema_items);`
`@@ -230,7 +230,7 @@ JsonRpcValidationResult JsonRpcValidator::validate_array(const nlohmann::json& a`
`230`	`230`	`return result;`
`231`	`231`	`}`
`232`	`232`
`233`		`-JsonRpcValidationResult JsonRpcValidator::validate_object(const nlohmann::json& object, const nlohmann::json& schema) {`
	`233`	`+ValidationResult Validator::validate_object(const nlohmann::json& object, const nlohmann::json& schema) {`
`234`	`234`	`if (!object.is_object()) {`
`235`	`235`	`return tl::make_unexpected("Invalid object: " + object.dump());`
`236`	`236`	`}`
`@@ -262,21 +262,21 @@ JsonRpcValidationResult JsonRpcValidator::validate_object(const nlohmann::json&`
`262`	`262`	`return {};`
`263`	`263`	`}`
`264`	`264`
`265`		`-JsonRpcValidationResult JsonRpcValidator::validate_boolean(const nlohmann::json& boolean) {`
	`265`	`+ValidationResult Validator::validate_boolean(const nlohmann::json& boolean) {`
`266`	`266`	`if (!boolean.is_boolean()) {`
`267`	`267`	`return tl::make_unexpected("Invalid boolean: " + boolean.dump());`
`268`	`268`	`}`
`269`	`269`	`return {};`
`270`	`270`	`}`
`271`	`271`
`272`		`-JsonRpcValidationResult JsonRpcValidator::validate_number(const nlohmann::json& number) {`
	`272`	`+ValidationResult Validator::validate_number(const nlohmann::json& number) {`
`273`	`273`	`if (!number.is_number()) {`
`274`	`274`	`return tl::make_unexpected("Invalid number: " + number.dump());`
`275`	`275`	`}`
`276`	`276`	`return {};`
`277`	`277`	`}`
`278`	`278`
`279`		`-JsonRpcValidationResult JsonRpcValidator::validate_null(const nlohmann::json& value) {`
	`279`	`+ValidationResult Validator::validate_null(const nlohmann::json& value) {`
`280`	`280`	`if (value.is_null()) {`
`281`	`281`	`return {};`
`282`	`282`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@`
`21`	`21`
`22`	`22`	`#include "validator.hpp"`
`23`	`23`
`24`		`-static silkworm::rpc::json_rpc::JsonRpcValidator validator{};`
	`24`	`+static silkworm::rpc::json_rpc::Validator validator{};`
`25`	`25`
`26`	`26`	`const nlohmann::json requests[2] = {`
`27`	`27`	`{`