Merge branch 'feature/grid_view' into feature/sessions_cache

.github/workflows/test.yml

@@ -170,8 +170,10 @@ jobs:
         env:
           # build only generated files, so clang-tidy will work correctly
           BUILD_FINAL_TARGET: generated
+        # run build for both WAVM and WasmEdge to download both, otherwise clang-tidy
+        # isn't able to find headers
         run: |
-          ./housekeeping/make_build.sh
+          ./housekeeping/make_build.sh 
           ./housekeeping/clang-tidy-diff.sh
 
   coverage-self-hosted:

cmake/dependencies.cmake

@@ -77,6 +77,7 @@ find_package(scale CONFIG REQUIRED)
 hunter_add_package(zstd)
 find_package(zstd CONFIG REQUIRED)
 
+
 if ("${WASM_COMPILER}" STREQUAL "WAVM")
   hunter_add_package(wavm)
   find_package(LLVM CONFIG REQUIRED)

core/application/app_configuration.hpp

@@ -207,8 +207,8 @@ namespace kagome::application {
      * List of telemetry endpoints specified via CLI argument or config file
      * @return a vector of parsed telemetry endpoints
      */
-    virtual const std::vector<telemetry::TelemetryEndpoint>
-        &telemetryEndpoints() const = 0;
+    virtual const std::vector<telemetry::TelemetryEndpoint> &
+    telemetryEndpoints() const = 0;
 
     /**
      * @return enum constant of the chosen sync method

core/application/chain_spec.hpp

@@ -6,9 +6,10 @@
 
 #pragma once
 
-#include <libp2p/peer/peer_info.hpp>
 #include <set>
 
+#include <libp2p/peer/peer_info.hpp>
+
 #include "crypto/ed25519_types.hpp"
 #include "crypto/sr25519_types.hpp"
 #include "primitives/block.hpp"
@@ -37,8 +38,8 @@ namespace kagome::application {
     virtual const std::vector<libp2p::multi::Multiaddress> &bootNodes()
         const = 0;
 
-    virtual const std::vector<std::pair<std::string, size_t>>
-        &telemetryEndpoints() const = 0;
+    virtual const std::vector<std::pair<std::string, size_t>> &
+    telemetryEndpoints() const = 0;
 
     virtual const std::string &protocolId() const = 0;
 

core/authority_discovery/publisher/address_publisher.hpp

@@ -8,8 +8,8 @@
 
 #include "application/app_state_manager.hpp"
 #include "blockchain/block_tree.hpp"
-#include "crypto/key_store/session_keys.hpp"
 #include "crypto/ed25519_provider.hpp"
+#include "crypto/key_store/session_keys.hpp"
 #include "crypto/sr25519_provider.hpp"
 #include "log/logger.hpp"
 #include "runtime/runtime_api/authority_discovery_api.hpp"

core/authorship/impl/block_builder_impl.hpp

@@ -72,10 +72,10 @@ namespace kagome::authorship {
 
     /**
      * Estimates the size of the block based on
-     * 
+     *
      * This function calculates the size of the block by encoding it
      * using the ScaleEncoderStream
-     * 
+     *
      * @return The estimated size of the block.
      */
     size_t estimateBlockSize() const override;

core/common/buffer_view.hpp

@@ -30,7 +30,7 @@ namespace kagome::common {
    public:
     using span::span;
 
-    BufferView(std::initializer_list<uint8_t>&&) = delete;
+    BufferView(std::initializer_list<uint8_t> &&) = delete;
 
     BufferView(const span &other) noexcept : span(other) {}
 

core/common/monadic_utils.hpp

@@ -51,7 +51,8 @@ namespace kagome::common {
             typename E,
             typename F,
             typename R = std::invoke_result_t<F, const T &>>
-  outcome::result<R, E> map_result(const outcome::result<T, E> &res, const F &f) {
+  outcome::result<R, E> map_result(const outcome::result<T, E> &res,
+                                   const F &f) {
     if (res.has_value()) {
       return outcome::result<R, E>{f(res.value())};
     }

core/common/optref.hpp

@@ -7,6 +7,9 @@
 #pragma once
 
 #include <type_traits>
+#include <optional>
+
+#include <boost/assert.hpp>
 
 namespace kagome {
   template <typename T>

core/common/outcome_throw.hpp

@@ -33,8 +33,10 @@ namespace kagome::common {
     boost::throw_exception(std::system_error(t.value(), t.category()));
   }
 
-  template<typename T, typename E>
-  void raise_on_err(const outcome::result<T, E>& res) {
-    if (res.has_error()) raise(res.error());
+  template <typename T, typename E>
+  void raise_on_err(const outcome::result<T, E> &res) {
+    if (res.has_error()) {
+      raise(res.error());
+    }
   }
 }  // namespace kagome::common

core/common/size_limited_containers.hpp

@@ -22,7 +22,7 @@ namespace kagome::common {
     template <typename Format, typename... Args>
     MaxSizeException(const Format &format, Args &&...args)
         : std::length_error(
-              fmt::vformat(format, fmt::make_format_args(args...))) {}
+            fmt::vformat(format, fmt::make_format_args(args...))) {}
   };
 
   template <typename BaseContainer, std::size_t MaxSize>

core/common/visitor.hpp

@@ -155,4 +155,4 @@ namespace kagome {
   constexpr decltype(auto) match_in_place(T &&t, Fs &&...fs) {
     return match(std::forward<T>(t), make_visitor(std::forward<Fs>(fs)...));
   }
-}  // namespace kagome::common
+}  // namespace kagome

core/consensus/babe/impl/babe_lottery_impl.cpp

@@ -9,8 +9,8 @@
 #include "consensus/babe/babe_config_repository.hpp"
 #include "consensus/babe/impl/prepare_transcript.hpp"
 #include "consensus/babe/impl/threshold_util.hpp"
-#include "crypto/key_store/session_keys.hpp"
 #include "crypto/hasher.hpp"
+#include "crypto/key_store/session_keys.hpp"
 #include "crypto/vrf_provider.hpp"
 
 namespace kagome::consensus::babe {

core/consensus/grandpa/voting_round.hpp

@@ -6,10 +6,10 @@
 
 #pragma once
 
+#include "common/optref.hpp"
 #include "common/tagged.hpp"
 #include "consensus/grandpa/movable_round_state.hpp"
 #include "consensus/grandpa/round_observer.hpp"
-#include "common/optref.hpp"
 
 namespace kagome::consensus::grandpa {
 

core/crypto/hasher/hasher_impl.cpp

@@ -34,7 +34,6 @@ namespace kagome::crypto {
 
   Hash128 HasherImpl::blake2b_128(common::BufferView data) const {
     return blake2b<16>(data);
-
   }
 
   Hash256 HasherImpl::twox_256(common::BufferView data) const {

core/crypto/key_store/session_keys.hpp

@@ -102,9 +102,7 @@ namespace kagome::crypto {
     using FnGetKeypair = outcome::result<typename T::Keypair> (
         KeySuiteStore<T>::*)(KeyType, const typename T::PublicKey &) const;
 
-    template <Suite T,
-              typename A,
-              typename Eq>
+    template <Suite T, typename A, typename Eq>
     KeypairWithIndexOpt<typename T::Keypair> find(
         KeypairWithIndexOpt<typename T::Keypair> &cache,
         KeyType type,

core/host_api/host_api.hpp

@@ -185,9 +185,10 @@ namespace kagome::host_api {
     ext_trie_blake2_256_ordered_root_version_2(
         runtime::WasmSpan values_data, runtime::WasmI32 state_version) = 0;
 
-    [[nodiscard]] virtual runtime::WasmPointer ext_trie_keccak_256_ordered_root_version_2(
+    [[nodiscard]] virtual runtime::WasmPointer
+    ext_trie_keccak_256_ordered_root_version_2(
         runtime::WasmSpan values_data, runtime::WasmI32 state_version) = 0;
-    
+
     // ------------------------- Memory extensions v1 --------------------------
     /**
      * @see Extension::ext_malloc

core/host_api/impl/host_api_factory_impl.hpp

@@ -8,10 +8,10 @@
 
 #include "host_api/host_api_factory.hpp"
 
-#include "crypto/key_store.hpp"
 #include "crypto/ecdsa_provider.hpp"
 #include "crypto/ed25519_provider.hpp"
 #include "crypto/hasher.hpp"
+#include "crypto/key_store.hpp"
 #include "crypto/secp256k1_provider.hpp"
 #include "crypto/sr25519_provider.hpp"
 #include "host_api/impl/offchain_extension.hpp"

core/host_api/impl/host_api_impl.hpp

@@ -105,7 +105,7 @@ namespace kagome::host_api {
 
     runtime::WasmPointer ext_trie_keccak_256_ordered_root_version_2(
         runtime::WasmSpan values_data, runtime::WasmI32 state_version) override;
-    
+
     // ------------------------Memory extensions v1-------------------------
     runtime::WasmPointer ext_allocator_malloc_version_1(
         runtime::WasmSize size) override;

core/host_api/impl/storage_extension.hpp

@@ -14,7 +14,7 @@
 #include "storage/trie/serialization/polkadot_codec.hpp"
 
 namespace kagome::crypto {
-    class Hasher;
+  class Hasher;
 }
 
 namespace kagome::runtime {

core/injector/get_peer_keypair.hpp

@@ -9,10 +9,12 @@
 #include <fstream>
 
 #include "application/app_configuration.hpp"
+#include "application/chain_spec.hpp"
 #include "common/bytestr.hpp"
 #include "common/outcome_throw.hpp"
-#include "crypto/key_store/key_store_impl.hpp"
 #include "crypto/ed25519_provider.hpp"
+#include "crypto/key_store.hpp"
+#include "crypto/random_generator.hpp"
 
 namespace kagome::injector {
   inline std::shared_ptr<libp2p::crypto::KeyPair> get_peer_keypair(

core/parachain/approval/approval_distribution.hpp

@@ -153,7 +153,7 @@ namespace kagome::parachain {
       }
 
       // Note that our assignment is triggered. No-op if already triggered.
-      MaybeCert trigger_our_assignment(network::Tick const tick_now) {
+      MaybeCert trigger_our_assignment(const network::Tick tick_now) {
         if (!our_assignment || our_assignment->triggered) {
           return std::nullopt;
         }

core/parachain/backing/grid_tracker.hpp

@@ -19,11 +19,7 @@
 
 template <>
 struct std::hash<std::pair<kagome::parachain::ValidatorIndex,
-                           kagome::network::vstaging::CompactStatement>>
-    : public __hash_base<
-          size_t,
-          std::pair<kagome::parachain::ValidatorIndex,
-                    kagome::network::vstaging::CompactStatement>> {
+                           kagome::network::vstaging::CompactStatement>> {
   size_t operator()(const std::pair<kagome::parachain::ValidatorIndex,
                                     kagome::network::vstaging::CompactStatement>
                         &__p) const noexcept {

core/parachain/pvf/pvf_worker_types.hpp

@@ -7,9 +7,9 @@
 #pragma once
 
 #include "common/buffer.hpp"
+#include "runtime/runtime_context.hpp"
 #include "scale/scale.hpp"
 #include "scale/tie.hpp"
-#include "runtime/runtime_context.hpp"
 
 namespace kagome::parachain {
 

core/runtime/binaryen/module/module_impl.hpp

@@ -51,7 +51,8 @@ namespace kagome::runtime::binaryen {
         std::shared_ptr<const ModuleFactory> module_factory,
         const common::Hash256 &code_hash);
 
-    outcome::result<std::shared_ptr<ModuleInstance>> instantiate() const override;
+    outcome::result<std::shared_ptr<ModuleInstance>> instantiate()
+        const override;
 
     ModuleImpl(std::unique_ptr<wasm::Module> &&module,
                std::shared_ptr<const ModuleFactory> module_factory,

core/runtime/common/runtime_execution_error.cpp

@@ -1,7 +1,7 @@
 /**
-* Copyright Quadrivium LLC All Rights Reserved.
-* SPDX-License-Identifier: Apache-2.0
-*/
+ * Copyright Quadrivium LLC All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
 
 #include "runtime/common/runtime_execution_error.hpp"
 

core/runtime/common/runtime_execution_error.hpp

@@ -1,7 +1,7 @@
 /**
-* Copyright Quadrivium LLC All Rights Reserved.
-* SPDX-License-Identifier: Apache-2.0
-*/
+ * Copyright Quadrivium LLC All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
 
 #pragma once
 

core/runtime/common/uncompress_code_if_needed.cpp

@@ -31,8 +31,8 @@ namespace kagome::runtime {
   // https://github.com/paritytech/substrate/blob/polkadot-v0.9.8/primitives/maybe-compressed-blob/src/lib.rs#L35
   constexpr size_t kCodeBlobBombLimit = 50 * 1024 * 1024;
 
-  outcome::result<void, UncompressError> uncompressCodeIfNeeded(common::BufferView buf,
-                                               common::Buffer &res) {
+  outcome::result<void, UncompressError> uncompressCodeIfNeeded(
+      common::BufferView buf, common::Buffer &res) {
     if (startsWith(buf, kZstdPrefix)) {
       auto zstd = buf.subspan(std::size(kZstdPrefix));
       // here we can check that blob is really ZSTD compressed

core/runtime/common/uncompress_code_if_needed.hpp

@@ -24,4 +24,4 @@ namespace kagome::runtime {
   inline auto format_as(UncompressError e) {
     return make_error_code(e);
   }
-}
+}  // namespace kagome::runtime

core/runtime/module_repository.hpp

@@ -28,7 +28,6 @@ namespace kagome::runtime {
    */
   class ModuleRepository {
    public:
-
     virtual ~ModuleRepository() = default;
 
     /**

core/runtime/runtime_api/core.hpp

@@ -11,8 +11,8 @@
 #include "primitives/block.hpp"
 #include "primitives/common.hpp"
 #include "primitives/version.hpp"
-#include "storage/changes_trie/changes_tracker.hpp"
 #include "runtime/runtime_context.hpp"
+#include "storage/changes_trie/changes_tracker.hpp"
 
 namespace kagome::runtime {
 

core/runtime/wasm_edge/module_factory_impl.hpp

@@ -43,8 +43,7 @@ namespace kagome::runtime::wasm_edge {
     };
     struct Config {
       Config(ExecType exec)
-          : exec{exec},
-            compiled_module_dir{"/tmp/kagome/wasm-edge"} {}
+          : exec{exec}, compiled_module_dir{"/tmp/kagome/wasm-edge"} {}
 
       ExecType exec;
       std::filesystem::path compiled_module_dir;

core/runtime/wavm/intrinsics/intrinsic_resolver_impl.hpp

@@ -31,7 +31,8 @@ namespace kagome::runtime::wavm {
 
   class IntrinsicResolverImpl final : public IntrinsicResolver {
    public:
-    IntrinsicResolverImpl(std::shared_ptr<CompartmentWrapper> compartment,
+    IntrinsicResolverImpl(
+        std::shared_ptr<CompartmentWrapper> compartment,
         std::shared_ptr<IntrinsicModuleInstance> module_instance);
 
     bool resolve(const std::string &moduleName,

core/runtime/wavm/module.cpp

@@ -103,8 +103,8 @@ namespace kagome::runtime::wavm {
         std::shared_ptr<IntrinsicModuleInstance>(
             intrinsic_module_->instantiate());
 
-    auto resolver =
-        std::make_shared<IntrinsicResolverImpl>(compartment_, new_intrinsic_module_instance);
+    auto resolver = std::make_shared<IntrinsicResolverImpl>(
+        compartment_, new_intrinsic_module_instance);
 
     auto internal_instance =
         WAVM::Runtime::instantiateModule(compartment_->getCompartment(),

core/scale/kagome_scale.hpp

@@ -47,9 +47,13 @@ namespace kagome::scale {
   template <typename F>
   constexpr void encode(const F &func, const network::BlocksResponse &b);
 
-  template <typename F, typename ElementType, size_t MaxSize, typename Allocator>
+  template <typename F,
+            typename ElementType,
+            size_t MaxSize,
+            typename Allocator>
   constexpr void encode(
-      const F &func, const common::SLVector<ElementType, MaxSize, Allocator> &c);
+      const F &func,
+      const common::SLVector<ElementType, MaxSize, Allocator> &c);
 
   template <typename F, typename T, typename Tag, typename Base>
   constexpr void encode(const F &func, const Tagged<T, Tag, Base> &c);
@@ -122,9 +126,13 @@ namespace kagome::scale {
     }
   }
 
-  template <typename F, typename ElementType, size_t MaxSize, typename Allocator>
+  template <typename F,
+            typename ElementType,
+            size_t MaxSize,
+            typename Allocator>
   constexpr void encode(
-      const F &func, const common::SLVector<ElementType, MaxSize, Allocator> &c) {
+      const F &func,
+      const common::SLVector<ElementType, MaxSize, Allocator> &c) {
     encode(func, static_cast<const std::vector<ElementType, Allocator> &>(c));
   }