db: rename TKV Domain methods (#2530)

.github/workflows/run_integration_tests.sh

@@ -21,7 +21,6 @@ rm -rf ./mainnet/results/
 # ots_searchTransactionsBefore: new algo using TKV
 
 python3 ./run_tests.py --continue --blockchain mainnet --jwt "$2" --display-only-fail --json-diff --port 51515 --transport_type http,websocket -x \
-debug_accountAt,\
 debug_accountRange,\
 debug_traceBlockByHash/test_05,\
 debug_traceBlockByHash/test_08,\

cmd/dev/grpc_toolbox.cpp

@@ -848,18 +848,18 @@ int kv_seek() {
     return kv_seek(target, table_name, key_bytes.value());
 }
 
-Task<void> kv_domain_get_query(const std::shared_ptr<Service>& kv_service,
+Task<void> kv_get_latest_query(const std::shared_ptr<Service>& kv_service,
                                DomainPointQuery&& query,
                                const bool /*verbose*/) {
     try {
         auto tx = co_await kv_service->begin_transaction();
-        std::cout << "KV DomainGet -> " << query.table << " key=" << to_hex(query.key)
+        std::cout << "KV GetLatest -> " << query.table << " key=" << to_hex(query.key)
                   << " ts=" << (query.timestamp ? *query.timestamp : -1) << " [latest: " << !query.timestamp.has_value() << "]\n";
-        const auto result = co_await tx->domain_get(std::move(query));
-        std::cout << "KV DomainGet <- success: " << result.success << " value=" << to_hex(result.value) << "\n";
+        const auto result = co_await tx->get_latest(std::move(query));
+        std::cout << "KV GetLatest <- success: " << result.success << " value=" << to_hex(result.value) << "\n";
         co_await tx->close();
     } catch (const std::exception& e) {
-        std::cout << "KV DomainGet <- error: " << e.what() << "\n";
+        std::cout << "KV GetLatest <- error: " << e.what() << "\n";
     }
 }
 
@@ -931,15 +931,15 @@ Task<void> kv_history_range_query(const std::shared_ptr<Service>& kv_service,
     }
 }
 
-Task<void> kv_domain_range_query(const std::shared_ptr<Service>& kv_service,
-                                 DomainRangeQuery&& query,
-                                 const bool verbose) {
+Task<void> kv_range_as_of_query(const std::shared_ptr<Service>& kv_service,
+                                DomainRangeQuery&& query,
+                                const bool verbose) {
     try {
         auto tx = co_await kv_service->begin_transaction();
-        std::cout << "KV DomainRange -> " << query.table << " limit=" << query.limit << "\n";
-        auto paginated_result = co_await tx->domain_range(std::move(query));
+        std::cout << "KV RangeAsOf -> " << query.table << " limit=" << query.limit << "\n";
+        auto paginated_result = co_await tx->range_as_of(std::move(query));
         auto it = co_await paginated_result.begin();
-        std::cout << "KV DomainRange <- #keys and #values: ";
+        std::cout << "KV RangeAsOf <- #keys and #values: ";
         int count{0};
         std::vector<KeyValue> keys_and_values;
         while (const auto key_value = co_await it.next()) {
@@ -954,7 +954,7 @@ Task<void> kv_domain_range_query(const std::shared_ptr<Service>& kv_service,
         }
         co_await tx->close();
     } catch (const std::exception& e) {
-        std::cout << "KV DomainRange <- error: " << e.what() << "\n";
+        std::cout << "KV RangeAsOf <- error: " << e.what() << "\n";
     }
 }
 
@@ -1003,7 +1003,7 @@ int execute_temporal_kv_query(const std::string& target, KVQueryFunc<Q> query_fu
     return 0;
 }
 
-int kv_domain_get() {
+int kv_get_latest() {
     const auto target{absl::GetFlag(FLAGS_target)};
     if (target.empty() || !absl::StrContains(target, ":")) {
         std::cerr << "Parameter target is invalid: [" << target << "]\n";
@@ -1040,7 +1040,7 @@ int kv_domain_get() {
         .key = *key_bytes,
         .timestamp = timestamp > -1 ? std::make_optional(timestamp) : std::nullopt,
     };
-    return execute_temporal_kv_query(target, kv_domain_get_query, std::move(query), verbose);
+    return execute_temporal_kv_query(target, kv_get_latest_query, std::move(query), verbose);
 }
 
 int kv_history_seek() {
@@ -1160,7 +1160,7 @@ int kv_history_range() {
     return execute_temporal_kv_query(target, kv_history_range_query, std::move(query), verbose);
 }
 
-int kv_domain_range() {
+int kv_get_as_of() {
     const auto target{absl::GetFlag(FLAGS_target)};
     if (target.empty() || !absl::StrContains(target, ":")) {
         std::cerr << "Parameter target is invalid: [" << target << "]\n";
@@ -1215,7 +1215,7 @@ int kv_domain_range() {
         .ascending_order = true,
         .limit = limit,
     };
-    return execute_temporal_kv_query(target, kv_domain_range_query, std::move(query), verbose);
+    return execute_temporal_kv_query(target, kv_range_as_of_query, std::move(query), verbose);
 }
 
 int main(int argc, char* argv[]) {
@@ -1228,11 +1228,11 @@ int main(int argc, char* argv[]) {
         "\tkv_seek_async\t\t\tquery using SEEK the Erigon/Silkworm Key-Value (KV) remote interface to database\n"
         "\tkv_seek_async_callback\t\tquery using SEEK the Erigon/Silkworm Key-Value (KV) remote interface to database\n"
         "\tkv_seek_both\t\t\tquery using SEEK_BOTH the Erigon/Silkworm Key-Value (KV) remote interface to database\n"
-        "\tkv_domain_get\t\tquery the Erigon/Silkworm Key-Value (KV) remote interface to data storage using DOMAIN_GET\n"
+        "\tkv_get_latest\t\tquery the Erigon/Silkworm Key-Value (KV) remote interface to data storage using DOMAIN_GET\n"
         "\tkv_history_seek\t\tquery using HISTORY_SEEK the Erigon/Silkworm Key-Value (KV) remote interface to data storage\n"
         "\tkv_index_range\t\tquery using INDEX_RANGE the Erigon/Silkworm Key-Value (KV) remote interface to data storage\n"
         "\tkv_history_range\t\tquery using HISTORY_RANGE the Erigon/Silkworm Key-Value (KV) remote interface to data storage\n"
-        "\tkv_domain_range\t\tquery using DOMAIN_RANGE the Erigon/Silkworm Key-Value (KV) remote interface to data storage\n");
+        "\tkv_get_as_of\t\tquery using DOMAIN_RANGE the Erigon/Silkworm Key-Value (KV) remote interface to data storage\n");
     const auto positional_args = absl::ParseCommandLine(argc, argv);
     if (positional_args.size() < 2) {
         std::cerr << "No gRPC tool specified as first positional argument\n\n";
@@ -1264,8 +1264,8 @@ int main(int argc, char* argv[]) {
     if (tool == "kv_seek") {
         return kv_seek();
     }
-    if (tool == "kv_domain_get") {
-        return kv_domain_get();
+    if (tool == "kv_get_latest") {
+        return kv_get_latest();
     }
     if (tool == "kv_history_seek") {
         return kv_history_seek();
@@ -1276,8 +1276,8 @@ int main(int argc, char* argv[]) {
     if (tool == "kv_history_range") {
         return kv_history_range();
     }
-    if (tool == "kv_domain_range") {
-        return kv_domain_range();
+    if (tool == "kv_get_as_of") {
+        return kv_get_as_of();
     }
 
     std::cerr << "Unknown tool " << tool << " specified as first argument\n\n";

silkworm/db/kv/api/local_transaction.cpp

@@ -74,7 +74,7 @@ Task<TxnId> LocalTransaction::first_txn_num_in_block(BlockNum /*block_num*/) {
     throw std::logic_error{"not yet implemented"};
 }
 
-Task<DomainPointResult> LocalTransaction::domain_get(DomainPointQuery /*query*/) {
+Task<DomainPointResult> LocalTransaction::get_latest(DomainPointQuery /*query*/) {
     // TODO(canepat) implement using E3-like aggregator abstraction [tx_id_ must be changed]
     co_return DomainPointResult{};
 }
@@ -100,7 +100,7 @@ Task<PaginatedKeysValues> LocalTransaction::history_range(HistoryRangeQuery /*qu
     co_return api::PaginatedKeysValues{std::move(paginator)};
 }
 
-Task<PaginatedKeysValues> LocalTransaction::domain_range(DomainRangeQuery /*query*/) {
+Task<PaginatedKeysValues> LocalTransaction::range_as_of(DomainRangeQuery /*query*/) {
     // TODO(canepat) implement using E3-like aggregator abstraction [tx_id_ must be changed]
     auto paginator = [](api::PaginatedKeysValues::PageToken) mutable -> Task<api::PaginatedKeysValues::PageResult> {
         co_return api::PaginatedKeysValues::PageResult{};

silkworm/db/kv/api/local_transaction.hpp

@@ -61,8 +61,8 @@ class LocalTransaction : public BaseTransaction {
 
     Task<void> close() override;
 
-    // rpc DomainGet(DomainGetReq) returns (DomainGetReply);
-    Task<DomainPointResult> domain_get(DomainPointQuery query) override;
+    // rpc GetLatest(GetLatestReq) returns (GetLatestReply);
+    Task<DomainPointResult> get_latest(DomainPointQuery query) override;
 
     // rpc HistorySeek(HistorySeekReq) returns (HistorySeekReply);
     Task<HistoryPointResult> history_seek(HistoryPointQuery query) override;
@@ -73,8 +73,8 @@ class LocalTransaction : public BaseTransaction {
     // rpc HistoryRange(HistoryRangeReq) returns (Pairs);
     Task<PaginatedKeysValues> history_range(HistoryRangeQuery query) override;
 
-    // rpc DomainRange(DomainRangeReq) returns (Pairs);
-    Task<PaginatedKeysValues> domain_range(DomainRangeQuery query) override;
+    // rpc RangeAsOf(RangeAsOfReq) returns (Pairs);
+    Task<PaginatedKeysValues> range_as_of(DomainRangeQuery query) override;
 
   private:
     Task<std::shared_ptr<CursorDupSort>> get_cursor(const std::string& table, bool is_cursor_dup_sort);

silkworm/db/kv/api/transaction.hpp

@@ -72,8 +72,8 @@ class Transaction {
 
     /** Temporal Point Queries **/
 
-    // rpc DomainGet(DomainGetReq) returns (DomainGetReply);
-    virtual Task<DomainPointResult> domain_get(DomainPointQuery query) = 0;
+    // rpc GetLatest(GetLatestReq) returns (GetLatestReply);
+    virtual Task<DomainPointResult> get_latest(DomainPointQuery query) = 0;
 
     // rpc HistorySeek(HistorySeekReq) returns (HistorySeekReply);
     virtual Task<HistoryPointResult> history_seek(HistoryPointQuery query) = 0;
@@ -86,8 +86,8 @@ class Transaction {
     // rpc HistoryRange(HistoryRangeReq) returns (Pairs);
     virtual Task<PaginatedKeysValues> history_range(HistoryRangeQuery query) = 0;
 
-    // rpc DomainRange(DomainRangeReq) returns (Pairs);
-    virtual Task<PaginatedKeysValues> domain_range(DomainRangeQuery query) = 0;
+    // rpc RangeAsOf(RangeAsOfReq) returns (Pairs);
+    virtual Task<PaginatedKeysValues> range_as_of(DomainRangeQuery query) = 0;
 };
 
 }  // namespace silkworm::db::kv::api

silkworm/db/kv/grpc/client/endpoint/temporal_point.cpp

@@ -39,8 +39,8 @@ api::HistoryPointResult history_seek_result_from_response(const proto::HistorySe
     return result;
 }
 
-proto::DomainGetReq domain_get_request_from_query(const api::DomainPointQuery& query) {
-    proto::DomainGetReq request;
+proto::GetLatestReq domain_get_request_from_query(const api::DomainPointQuery& query) {
+    proto::GetLatestReq request;
     request.set_tx_id(query.tx_id);
     request.set_table(query.table);
     request.set_k(query.key.data(), query.key.size());
@@ -53,7 +53,7 @@ proto::DomainGetReq domain_get_request_from_query(const api::DomainPointQuery& q
     return request;
 }
 
-api::DomainPointResult domain_get_result_from_response(const proto::DomainGetReply& response) {
+api::DomainPointResult domain_get_result_from_response(const proto::GetLatestReply& response) {
     api::DomainPointResult result;
     result.success = response.ok();
     result.value = string_to_bytes(response.v());

silkworm/db/kv/grpc/client/endpoint/temporal_point.hpp

@@ -25,7 +25,7 @@ namespace silkworm::db::kv::grpc::client {
 ::remote::HistorySeekReq history_seek_request_from_query(const api::HistoryPointQuery&);
 api::HistoryPointResult history_seek_result_from_response(const ::remote::HistorySeekReply&);
 
-::remote::DomainGetReq domain_get_request_from_query(const api::DomainPointQuery&);
-api::DomainPointResult domain_get_result_from_response(const ::remote::DomainGetReply&);
+::remote::GetLatestReq domain_get_request_from_query(const api::DomainPointQuery&);
+api::DomainPointResult domain_get_result_from_response(const ::remote::GetLatestReply&);
 
 }  // namespace silkworm::db::kv::grpc::client

silkworm/db/kv/grpc/client/endpoint/temporal_point_test.cpp

@@ -62,7 +62,7 @@ TEST_CASE("history_get_result_from_response", "[node][remote][kv][grpc]") {
 }
 
 TEST_CASE("domain_get_request_from_query", "[node][remote][kv][grpc]") {
-    const Fixtures<api::DomainPointQuery, proto::DomainGetReq> fixtures{
+    const Fixtures<api::DomainPointQuery, proto::GetLatestReq> fixtures{
         {sample_domain_point_query(), sample_proto_domain_point_request()},
     };
     for (const auto& [query, expected_point_request] : fixtures) {
@@ -80,7 +80,7 @@ TEST_CASE("domain_get_request_from_query", "[node][remote][kv][grpc]") {
 }
 
 TEST_CASE("domain_get_result_from_response", "[node][remote][kv][grpc]") {
-    const Fixtures<proto::DomainGetReply, api::DomainPointResult> fixtures{
+    const Fixtures<proto::GetLatestReply, api::DomainPointResult> fixtures{
         {{}, {}},
         {sample_proto_domain_get_response(), sample_domain_point_result()},
     };

silkworm/db/kv/grpc/client/endpoint/temporal_range.cpp

@@ -71,8 +71,8 @@ api::HistoryRangeResult history_range_result_from_response(const proto::Pairs& r
     return result;
 }
 
-::remote::DomainRangeReq domain_range_request_from_query(const api::DomainRangeQuery& query) {
-    ::remote::DomainRangeReq request;
+::remote::RangeAsOfReq domain_range_request_from_query(const api::DomainRangeQuery& query) {
+    ::remote::RangeAsOfReq request;
     request.set_tx_id(query.tx_id);
     request.set_table(query.table);
     request.set_from_key(query.from_key.data(), query.from_key.size());

silkworm/db/kv/grpc/client/endpoint/temporal_range.hpp

@@ -28,7 +28,7 @@ api::IndexRangeResult index_range_result_from_response(const ::remote::IndexRang
 ::remote::HistoryRangeReq history_range_request_from_query(const api::HistoryRangeQuery&);
 api::HistoryRangeResult history_range_result_from_response(const ::remote::Pairs&);
 
-::remote::DomainRangeReq domain_range_request_from_query(const api::DomainRangeQuery&);
+::remote::RangeAsOfReq domain_range_request_from_query(const api::DomainRangeQuery&);
 api::DomainRangeResult domain_range_result_from_response(const ::remote::Pairs&);
 
 }  // namespace silkworm::db::kv::grpc::client

silkworm/db/kv/grpc/client/endpoint/temporal_range_test.cpp

@@ -104,7 +104,7 @@ TEST_CASE("history_range_result_from_response", "[node][remote][kv][grpc]") {
 }
 
 TEST_CASE("domain_range_request_from_query", "[node][remote][kv][grpc]") {
-    const Fixtures<api::DomainRangeQuery, proto::DomainRangeReq> fixtures{
+    const Fixtures<api::DomainRangeQuery, proto::RangeAsOfReq> fixtures{
         {{}, default_proto_domain_range_request()},
         {sample_domain_range_query(), sample_proto_domain_range_request()},
     };

silkworm/db/kv/grpc/client/remote_transaction.cpp

@@ -122,15 +122,15 @@ Task<TxnId> RemoteTransaction::first_txn_num_in_block(BlockNum block_num) {
     co_return min_txn_num + /*txn_index*/ 0;
 }
 
-Task<api::DomainPointResult> RemoteTransaction::domain_get(api::DomainPointQuery query) {
+Task<api::DomainPointResult> RemoteTransaction::get_latest(api::DomainPointQuery query) {
     try {
         query.tx_id = tx_id_;
         auto request = domain_get_request_from_query(query);
-        const auto reply = co_await rpc::unary_rpc(&Stub::AsyncDomainGet, stub_, std::move(request), grpc_context_);
+        const auto reply = co_await rpc::unary_rpc(&Stub::AsyncGetLatest, stub_, std::move(request), grpc_context_);
         auto result = domain_get_result_from_response(reply);
         co_return result;
     } catch (rpc::GrpcStatusError& gse) {
-        SILK_WARN << "KV::DomainGet RPC failed status=" << gse.status();
+        SILK_WARN << "KV::GetLatest RPC failed status=" << gse.status();
         throw boost::system::system_error{rpc::to_system_code(gse.status().error_code())};
     }
 }
@@ -184,18 +184,18 @@ Task<api::PaginatedKeysValues> RemoteTransaction::history_range(api::HistoryRang
     co_return api::PaginatedKeysValues{std::move(paginator)};
 }
 
-Task<api::PaginatedKeysValues> RemoteTransaction::domain_range(api::DomainRangeQuery query) {
+Task<api::PaginatedKeysValues> RemoteTransaction::range_as_of(api::DomainRangeQuery query) {
     auto paginator = [&, query = std::move(query)](api::PaginatedKeysValues::PageToken page_token) mutable -> Task<api::PaginatedKeysValues::PageResult> {
         query.tx_id = tx_id_;
         query.page_token = std::move(page_token);
         auto request = domain_range_request_from_query(query);
         try {
-            const auto reply = co_await rpc::unary_rpc(&Stub::AsyncDomainRange, stub_, std::move(request), grpc_context_);
+            const auto reply = co_await rpc::unary_rpc(&Stub::AsyncRangeAsOf, stub_, std::move(request), grpc_context_);
             auto result = history_range_result_from_response(reply);
 
             co_return api::PaginatedKeysValues::PageResult{std::move(result.keys), std::move(result.values), std::move(result.next_page_token)};
         } catch (rpc::GrpcStatusError& gse) {
-            SILK_WARN << "KV::DomainRange RPC failed status=" << gse.status();
+            SILK_WARN << "KV::RangeAsOf RPC failed status=" << gse.status();
             throw boost::system::system_error{rpc::to_system_code(gse.status().error_code())};
         }
     };

silkworm/db/kv/grpc/client/remote_transaction.hpp

@@ -62,8 +62,8 @@ class RemoteTransaction : public api::BaseTransaction {
 
     Task<void> close() override;
 
-    // rpc DomainGet(DomainGetReq) returns (DomainGetReply);
-    Task<api::DomainPointResult> domain_get(api::DomainPointQuery query) override;
+    // rpc GetLatest(GetLatestReq) returns (GetLatestReply);
+    Task<api::DomainPointResult> get_latest(api::DomainPointQuery query) override;
 
     // rpc HistorySeek(HistorySeekReq) returns (HistorySeekReply);
     Task<api::HistoryPointResult> history_seek(api::HistoryPointQuery query) override;
@@ -74,8 +74,8 @@ class RemoteTransaction : public api::BaseTransaction {
     // rpc HistoryRange(HistoryRangeReq) returns (Pairs);
     Task<api::PaginatedKeysValues> history_range(api::HistoryRangeQuery query) override;
 
-    // rpc DomainRange(DomainRangeReq) returns (Pairs);
-    Task<api::PaginatedKeysValues> domain_range(api::DomainRangeQuery query) override;
+    // rpc RangeAsOf(RangeAsOfReq) returns (Pairs);
+    Task<api::PaginatedKeysValues> range_as_of(api::DomainRangeQuery query) override;
 
   private:
     Task<std::shared_ptr<api::CursorDupSort>> get_cursor(const std::string& table, bool is_cursor_dup_sort);