Refactor: adapt for updated qtils and scale

cmake/Hunter/config.cmake

@@ -105,6 +105,13 @@ hunter_config(
     KEEP_PACKAGE_SOURCES
 )
 
+hunter_config(
+    libp2p
+    URL  https://github.com/libp2p/cpp-libp2p/archive/5d0013db9850a1c23dfe9ef6673077959b2d784f.tar.gz
+    SHA1 bf1b740a60e621cd156fb8754b423750fc7070ed
+    KEEP_PACKAGE_SOURCES
+)
+
 hunter_config(
     soralog
     VERSION 0.2.4
@@ -118,3 +125,19 @@ hunter_config(
     KEEP_PACKAGE_SOURCES
 )
 
+hunter_config(
+    scale
+    #  VERSION 2.0.0
+    URL  https://github.com/qdrvm/scale-codec-cpp/archive/refs/tags/v2.0.0.tar.gz
+    SHA1 a83f0a034693809b948451ff774aeb58462a0f96
+    KEEP_PACKAGE_SOURCES
+)
+
+hunter_config(
+    qtils
+    URL  https://github.com/qdrvm/qtils/archive/6d02006f7c0fe44958acbfe53016fa81f1ac0bf5.tar.gz
+    SHA1 b37b32a882788eb8f2c796098b5bf3a19cf00fe3
+    CMAKE_ARGS
+      FORMAT_ERROR_WITH_FULLTYPE=ON
+    KEEP_PACKAGE_SOURCES
+)

core/api/jrpc/value_converter.hpp

@@ -24,7 +24,7 @@
 #include "primitives/rpc_methods.hpp"
 #include "primitives/runtime_dispatch_info.hpp"
 #include "primitives/version.hpp"
-#include "scale/scale.hpp"
+#include "scale/kagome_scale.hpp"
 
 namespace kagome::api {
 
@@ -98,19 +98,19 @@ namespace kagome::api {
   }
 
   inline jsonrpc::Value makeValue(const primitives::Balance &val) {
-    jsonrpc::Value ret((*val).str());
+    jsonrpc::Value ret(val.str());
     return ret;
   }
 
   inline jsonrpc::Value makeValue(const primitives::Weight &val) {
     jStruct data;
-    data["ref_time"] = static_cast<int64_t>(*val.ref_time);
-    data["proof_size"] = static_cast<int64_t>(*val.proof_size);
+    data["ref_time"] = static_cast<int64_t>(val.ref_time);
+    data["proof_size"] = static_cast<int64_t>(val.proof_size);
     return data;
   }
 
   inline jsonrpc::Value makeValue(const primitives::OldWeight &val) {
-    jsonrpc::Value ret(static_cast<int64_t>(*val));
+    jsonrpc::Value ret(static_cast<int64_t>(val));
     return ret;
   }
 

core/api/service/author/impl/author_api_impl.cpp

@@ -20,7 +20,7 @@
 #include "crypto/sr25519_types.hpp"
 #include "primitives/transaction.hpp"
 #include "runtime/runtime_api/session_keys_api.hpp"
-#include "scale/scale_decoder_stream.hpp"
+#include "scale/kagome_scale.hpp"
 #include "subscription/subscriber.hpp"
 #include "transaction_pool/transaction_pool.hpp"
 

core/api/service/child_state/requests/get_keys.cpp

@@ -6,7 +6,7 @@
 
 #include "api/service/child_state/requests/get_keys.hpp"
 
-#include "scale/scale.hpp"
+#include "scale/kagome_scale.hpp"
 
 namespace kagome::api::child_state::request {
 

core/api/service/child_state/requests/get_keys_paged.cpp

@@ -6,7 +6,7 @@
 
 #include "api/service/child_state/requests/get_keys_paged.hpp"
 
-#include "scale/scale.hpp"
+#include "scale/kagome_scale.hpp"
 
 namespace kagome::api::child_state::request {
 

core/api/service/state/requests/call.cpp

@@ -6,7 +6,7 @@
 
 #include "api/service/state/requests/call.hpp"
 
-#include "scale/scale.hpp"
+#include "scale/kagome_scale.hpp"
 
 namespace kagome::api::state::request {
 

core/api/service/state/requests/get_keys_paged.cpp

@@ -6,7 +6,7 @@
 
 #include "api/service/state/requests/get_keys_paged.hpp"
 
-#include "scale/scale.hpp"
+#include "scale/kagome_scale.hpp"
 
 namespace kagome::api::state::request {
 

core/api/service/state/requests/get_storage_size.hpp

@@ -24,7 +24,7 @@ namespace kagome::api::state::request {
     GetStorageSize &operator=(GetStorageSize &&) = default;
 
     explicit GetStorageSize(std::shared_ptr<StateApi> api)
-        : api_(std::move(api)) {};
+        : api_(std::move(api)){};
     ~GetStorageSize() = default;
 
     outcome::result<void> init(const jsonrpc::Request::Parameters &params);

core/api/service/system/impl/system_api_impl.cpp

@@ -12,7 +12,7 @@
 
 #include "blockchain/block_tree.hpp"
 #include "primitives/ss58_codec.hpp"
-#include "scale/scale.hpp"
+#include "scale/kagome_scale.hpp"
 #include "transaction_pool/transaction_pool.hpp"
 
 namespace kagome::api {

core/api/service/system/requests/peers.hpp

@@ -9,6 +9,7 @@
 #include "api/service/base_request.hpp"
 
 #include "account_next_index.hpp"
+#include "api/jrpc/value_converter.hpp"
 #include "api/service/system/system_api.hpp"
 #include "chain.hpp"
 #include "chain_type.hpp"
@@ -40,10 +41,10 @@ namespace kagome::api::system::request {
           jsonrpc::Value::Struct peer;
           peer.emplace("PeerId", peer_id.toBase58());
           peer.emplace("roles",
-                       status.get().roles.flags.authority ? "AUTHORITY"
-                       : status.get().roles.flags.full    ? "FULL"
-                       : status.get().roles.flags.light   ? "LIGHT"
-                                                          : "NONE");
+                       status.get().roles.isAuthority() ? "AUTHORITY"
+                       : status.get().roles.isFull()    ? "FULL"
+                       : status.get().roles.isLight()   ? "LIGHT"
+                                                        : "NONE");
           peer.emplace("bestHash", makeValue(status.get().best_block.hash));
           peer.emplace("bestNumber", makeValue(status.get().best_block.number));
 

core/application/impl/app_configuration_impl.cpp

@@ -83,12 +83,7 @@ namespace {
   const uint32_t def_ws_max_connections = 500;
   const uint16_t def_p2p_port = 30363;
   const bool def_dev_mode = false;
-  const kagome::network::Roles def_roles = [] {
-    kagome::network::Roles roles;
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
-    roles.flags.full = 1;
-    return roles;
-  }();
+  const kagome::network::Roles def_roles{kagome::network::Roles::Full};
   const auto def_sync_method = kagome::application::SyncMethod::Full;
   const auto def_runtime_exec_method =
       kagome::application::AppConfiguration::RuntimeExecutionMethod::Compile;
@@ -178,11 +173,12 @@ namespace {
 
   static constexpr std::array<std::string_view,
                               1 + KAGOME_WASM_COMPILER_WASM_EDGE>
-      interpreters{
+      interpreters {
 #if KAGOME_WASM_COMPILER_WASM_EDGE == 1
-          "WasmEdge",
+    "WasmEdge",
 #endif
-          "Binaryen"};
+        "Binaryen"
+  };
 
   static const std::string interpreters_str =
       fmt::format("[{}]", fmt::join(interpreters, ", "));
@@ -444,10 +440,7 @@ namespace kagome::application {
     bool validator_mode = false;
     load_bool(val, "validator", validator_mode);
     if (validator_mode) {
-      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
-      roles_.flags.full = 0;
-      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
-      roles_.flags.authority = 1;
+      roles_ = kagome::network::Roles::Authority;
     }
 
     load_ms(val, "log", logger_tuning_config_);
@@ -1000,10 +993,7 @@ namespace kagome::application {
           }
         }
 
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
-        roles_.flags.full = 0;
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
-        roles_.flags.authority = 1;
+        roles_ = network::Roles::Authority;
         p2p_port_ = def_p2p_port;
         rpc_host_ = def_rpc_host;
         openmetrics_http_host_ = def_openmetrics_http_host;
@@ -1024,10 +1014,7 @@ namespace kagome::application {
         node_name_ = name;
         dev_mnemonic_phrase_ = dev;
         // if dev account is passed node is considered as validator
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
-        roles_.flags.full = 0;
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
-        roles_.flags.authority = 1;
+        roles_ = network::Roles::Authority;
       }
     }
 
@@ -1055,10 +1042,7 @@ namespace kagome::application {
     });
 
     if (vm.end() != vm.find("validator")) {
-      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
-      roles_.flags.full = 0;
-      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
-      roles_.flags.authority = 1;
+      roles_ = network::Roles::Authority;
     }
 
     find_argument<std::string>(

core/application/impl/kagome_application_impl.cpp

@@ -109,8 +109,7 @@ namespace kagome::application {
                                             "The roles the node is running as");
       auto metric_node_roles =
           metrics_registry->registerGaugeMetric(nodeRolesMetricName);
-      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-union-access)
-      metric_node_roles->set(app_config_->roles().value);
+      metric_node_roles->set(app_config_->roles().value());
 
       constexpr auto buildInfoMetricName = "kagome_build_info";
       metrics_registry->registerGaugeFamily(

core/application/modes/precompile_wasm.cpp

@@ -78,7 +78,8 @@ namespace kagome::application::mode {
       auto code_hash = hasher_->blake2b_256(bytes);
       OUTCOME_TRY(config,
                   parachain::sessionParams(*parachain_api_, block.hash));
-      OUTCOME_TRY(module_factory_->precompile(code_hash, bytes, config.context_params));
+      OUTCOME_TRY(
+          module_factory_->precompile(code_hash, bytes, config.context_params));
     }
     return outcome::success();
   }

core/authority_discovery/publisher/address_publisher.cpp

@@ -172,7 +172,7 @@ namespace kagome::authority_discovery {
       PB_SPAN_ADD(record, addresses, address.getBytesAddress());
     }
     if (now) {
-      TimestampScale time{now->count()};
+      Timestamp time{now->count()};
       OUTCOME_TRY(encoded_time, scale::encode(time));
       PB_SPAN_SET(*record.mutable_creation_time(), timestamp, encoded_time);
     }

core/authority_discovery/query/audi_store_impl.cpp

@@ -11,16 +11,18 @@
 namespace kagome::authority_discovery {
 
   AudiStoreImpl::AudiStoreImpl(std::shared_ptr<storage::SpacedStorage> storage)
-      : space_{storage->getSpace(storage::Space::kAudiPeers)} {
+      : log_(
+          log::createLogger("AuthorityDiscoveryStore", "authority_discovery")),
+        space_{storage->getSpace(storage::Space::kAudiPeers)} {
     BOOST_ASSERT(space_ != nullptr);
   }
 
   void AudiStoreImpl::store(const primitives::AuthorityDiscoveryId &authority,
                             const AuthorityPeerInfo &data) {
     auto encoded = scale::encode(data);
 
-    if (not encoded) {
-      SL_ERROR(log_, "Failed to encode PeerInfo");
+    if (encoded.has_error()) {
+      SL_ERROR(log_, "Failed to encode AuthorityPeerInfo: {}", encoded.error());
       return;
     }
 
@@ -51,8 +53,8 @@ namespace kagome::authority_discovery {
 
     auto decoded = scale::decode<AuthorityPeerInfo>(res.value().value());
 
-    if (not decoded) {
-      SL_ERROR(log_, "Failed to decode PeerInfo");
+    if (decoded.has_error()) {
+      SL_ERROR(log_, "Failed to decode AuthorityPeerInfo: {}", decoded.error());
       return std::nullopt;
     }
 

core/authority_discovery/query/audi_store_impl.hpp

@@ -39,8 +39,8 @@ namespace kagome::authority_discovery {
                                      const AuthorityPeerInfo &)> f) override;
 
    private:
-    std::shared_ptr<storage::BufferStorage> space_;
     log::Logger log_;
+    std::shared_ptr<storage::BufferStorage> space_;
   };
 
 }  // namespace kagome::authority_discovery

core/authority_discovery/query/authority_peer_info.hpp

@@ -10,15 +10,12 @@
 #include "authority_discovery/timestamp.hpp"
 #include "common/buffer.hpp"
 #include "scale/libp2p_types.hpp"
-#include "scale/tie.hpp"
 
 namespace kagome::authority_discovery {
   struct AuthorityPeerInfo {
-    SCALE_TIE(3);
-
     common::Buffer raw{};
-    std::optional<TimestampScale> time{};
-    ::scale::PeerInfoSerializable peer{};
+    std::optional<Timestamp> time{};
+    scale::PeerInfoSerializable peer{};
   };
 
 }  // namespace kagome::authority_discovery

core/authority_discovery/query/query_impl.cpp

@@ -309,10 +309,10 @@ namespace kagome::authority_discovery {
     std::optional<Timestamp> time{};
     if (record.has_creation_time()) {
       OUTCOME_TRY(tmp,
-                  scale::decode<TimestampScale>(
+                  scale::decode<Timestamp>(
                       qtils::str2byte(record.creation_time().timestamp())));
-      time = *tmp;
-      if (it and it->time and time <= it->time->number) {
+      time = tmp;
+      if (it and it->time and time <= it->time) {
         SL_TRACE(log_, "lookup: outdated record for authority {}", authority);
         return outcome::success();
       }
@@ -365,14 +365,12 @@ namespace kagome::authority_discovery {
     if (not audi_store_->contains(authority)) {
       metric_known_authorities_count->inc();
     }
-    audi_store_->store(
-        authority,
-        AuthorityPeerInfo{
-            .raw = std::move(signed_record_pb),
-            .time = time.has_value() ? std::make_optional(TimestampScale{*time})
-                                     : std::nullopt,
-            .peer = peer,
-        });
+    audi_store_->store(authority,
+                       AuthorityPeerInfo{
+                           .raw = std::move(signed_record_pb),
+                           .time = time,
+                           .peer = peer,
+                       });
 
     validation_protocol_.get()->reserve(peer.id, true);
 

core/authority_discovery/timestamp.hpp

@@ -6,9 +6,8 @@
 
 #pragma once
 
-#include "scale/big_fixed_integers.hpp"
+#include <scale/kagome_scale.hpp>
 
 namespace kagome::authority_discovery {
-  using Timestamp = ::scale::uint128_t;
-  using TimestampScale = ::scale::Fixed<Timestamp>;
+  using Timestamp = scale::uint128_t;
 }  // namespace kagome::authority_discovery

core/authorship/impl/block_builder_impl.cpp

@@ -104,20 +104,13 @@ namespace kagome::authorship {
   }
 
   size_t BlockBuilderImpl::estimateBlockSize() const {
-    scale::ScaleEncoderStream s(true);
-    for (const auto &xt : extrinsics_) {
-      s << xt;
-    }
-    return estimatedBlockHeaderSize() + s.size();
+    auto size = scale::encoded_size(extrinsics_).value();
+    return estimatedBlockHeaderSize() + size;
   }
 
   size_t BlockBuilderImpl::estimatedBlockHeaderSize() const {
-    static std::optional<size_t> size = std::nullopt;
-    if (not size) {
-      scale::ScaleEncoderStream s(true);
-      s << block_header_;
-      size = s.size();
-    }
-    return size.value();
+    static const size_t size =
+        scale::encoded_size(primitives::BlockHeader{}).value();
+    return size;
   }
 }  // namespace kagome::authorship