Feature/backing tests

core/consensus/babe/impl/babe.hpp

@@ -71,7 +71,7 @@ namespace kagome::offchain {
 
 namespace kagome::parachain {
   class BitfieldStore;
-  class ParachainProcessorImpl;
+  class ParachainProcessor;
   struct BackedCandidatesSource;
 }  // namespace kagome::parachain
 

core/injector/application_injector.cpp

@@ -114,6 +114,7 @@
 #include "metrics/impl/metrics_watcher.hpp"
 #include "metrics/impl/prometheus/handler_impl.hpp"
 #include "metrics/metrics.hpp"
+#include "network/i_peer_view.hpp"
 #include "network/impl/block_announce_transmitter_impl.hpp"
 #include "network/impl/extrinsic_observer_impl.hpp"
 #include "network/impl/grandpa_transmitter_impl.hpp"
@@ -152,6 +153,7 @@
 #include "outcome/outcome.hpp"
 #include "parachain/approval/approval_distribution.hpp"
 #include "parachain/approval/approval_thread_pool.hpp"
+#include "parachain/availability/bitfield/signer.hpp"
 #include "parachain/availability/bitfield/store_impl.hpp"
 #include "parachain/availability/fetch/fetch_impl.hpp"
 #include "parachain/availability/recovery/recovery_impl.hpp"
@@ -164,6 +166,7 @@
 #include "parachain/pvf/workers.hpp"
 #include "parachain/validator/impl/parachain_observer_impl.hpp"
 #include "parachain/validator/parachain_processor.hpp"
+#include "parachain/validator/statement_distribution/i_statement_distribution.hpp"
 #include "parachain/validator/statement_distribution/statement_distribution.hpp"
 #include "runtime/binaryen/binaryen_memory_provider.hpp"
 #include "runtime/binaryen/instance_environment_factory.hpp"
@@ -784,12 +787,35 @@ namespace {
             di::bind<network::SyncProtocolObserver>.template to<network::SyncProtocolObserverImpl>(),
             di::bind<network::DisputeRequestObserver>.template to<dispute::DisputeCoordinatorImpl>(),
             di::bind<parachain::AvailabilityStore>.template to<parachain::AvailabilityStoreImpl>(),
+            di::bind<network::IPeerView>.template to<network::PeerView>(),
+            di::bind<parachain::IBitfieldSigner>.template to<parachain::BitfieldSigner>(),
             di::bind<parachain::Fetch>.template to<parachain::FetchImpl>(),
             di::bind<parachain::Recovery>.template to<parachain::RecoveryImpl>(),
+            di::bind<parachain::IValidatorSignerFactory>.template to<parachain::ValidatorSignerFactory>(),
             di::bind<parachain::BitfieldStore>.template to<parachain::BitfieldStoreImpl>(),
             di::bind<parachain::BackingStore>.template to<parachain::BackingStoreImpl>(),
-            di::bind<parachain::BackedCandidatesSource>.template to<parachain::ParachainProcessorImpl>(),
-            di::bind<network::CanDisconnect>.template to<parachain::statement_distribution::StatementDistribution>(),
+            di::bind<parachain::IProspectiveParachains>.template to<parachain::ProspectiveParachains>(),
+            bind_by_lambda<parachain::BackedCandidatesSource>(
+                [](const auto &injector) {
+                  return injector.template create<sptr<parachain::ThreadedParachainProcessorImpl>>();
+                }),
+            bind_by_lambda<parachain::ParachainStorage>(
+                [](const auto &injector) {
+                  return injector.template create<sptr<parachain::ThreadedParachainProcessorImpl>>();
+                }),
+            bind_by_lambda<parachain::ParachainProcessor>(
+                [](const auto &injector) {
+                  return injector.template create<sptr<parachain::ThreadedParachainProcessorImpl>>();
+                }),
+            di::bind<parachain::IPvfPrecheck>.template to<parachain::PvfPrecheck>(),
+            bind_by_lambda<network::CanDisconnect>(
+                [](const auto &injector) {
+                  return injector.template create<sptr<parachain::statement_distribution::StatementDistribution>>();
+                }),
+            bind_by_lambda<parachain::statement_distribution::IStatementDistribution>(
+                [](const auto &injector) {
+                  return injector.template create<sptr<parachain::statement_distribution::StatementDistribution>>();
+                }),
             di::bind<parachain::Pvf>.template to<parachain::PvfImpl>(),
             bind_by_lambda<parachain::SecureModeSupport>([config](const auto &) {
               auto support = parachain::SecureModeSupport::none();
@@ -1034,10 +1060,10 @@ namespace kagome::injector {
         .template create<sptr<parachain::ParachainObserver>>();
   }
 
-  std::shared_ptr<parachain::ParachainProcessorImpl>
+  std::shared_ptr<parachain::ParachainProcessor>
   KagomeNodeInjector::injectParachainProcessor() {
     return pimpl_->injector_
-        .template create<sptr<parachain::ParachainProcessorImpl>>();
+        .template create<sptr<parachain::ThreadedParachainProcessorImpl>>();
   }
 
   std::shared_ptr<parachain::statement_distribution::StatementDistribution>

core/injector/application_injector.hpp

@@ -59,12 +59,13 @@ namespace kagome {
 
   namespace parachain {
     class ParachainObserver;
-    class ParachainProcessorImpl;
+    class ParachainProcessor;
     class ApprovalDistribution;
 
     namespace statement_distribution {
       class StatementDistribution;
-    }
+      class IStatementDistribution;
+    }  // namespace statement_distribution
   }  // namespace parachain
 
   namespace runtime {
@@ -138,8 +139,7 @@ namespace kagome::injector {
     std::shared_ptr<network::SyncProtocolObserver> injectSyncObserver();
     std::shared_ptr<network::StateProtocolObserver> injectStateObserver();
     std::shared_ptr<parachain::ParachainObserver> injectParachainObserver();
-    std::shared_ptr<parachain::ParachainProcessorImpl>
-    injectParachainProcessor();
+    std::shared_ptr<parachain::ParachainProcessor> injectParachainProcessor();
     std::shared_ptr<parachain::statement_distribution::StatementDistribution>
     injectStatementDistribution();
     std::shared_ptr<parachain::ApprovalDistribution>

core/network/i_peer_view.hpp

@@ -0,0 +1,69 @@
+/**
+ * Copyright Quadrivium LLC
+ * All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#pragma once
+
+#include <memory>
+#include <unordered_map>
+
+#include <libp2p/peer/peer_id.hpp>
+
+#include "crypto/type_hasher.hpp"
+#include "network/types/collator_messages.hpp"
+#include "outcome/outcome.hpp"
+#include "primitives/event_types.hpp"
+#include "subscription/subscriber.hpp"
+#include "subscription/subscription_engine.hpp"
+
+namespace kagome::network {
+
+  using HashedBlockHeader = primitives::BlockHeader;
+  struct ExView {
+    View view;
+    HashedBlockHeader new_head;
+    std::vector<primitives::BlockHash> lost;
+  };
+
+  struct ExViewRef {
+    std::optional<std::reference_wrapper<const HashedBlockHeader>> new_head;
+    const std::vector<primitives::BlockHash> &lost;
+  };
+
+  /**
+   * Observable class for current heads and finalized block number tracking.
+   */
+  class IPeerView {
+   public:
+    enum struct EventType : uint32_t { kViewUpdated, kPeerRemoved };
+
+    using PeerId = libp2p::peer::PeerId;
+
+    using MyViewSubscriptionEngine = subscription::
+        SubscriptionEngine<EventType, std::monostate, network::ExView>;
+    using MyViewSubscriptionEnginePtr =
+        std::shared_ptr<MyViewSubscriptionEngine>;
+    using MyViewSubscriber = MyViewSubscriptionEngine::SubscriberType;
+    using MyViewSubscriberPtr = std::shared_ptr<MyViewSubscriber>;
+
+    using PeerViewSubscriptionEngine = subscription::
+        SubscriptionEngine<EventType, std::monostate, PeerId, network::View>;
+    using PeerViewSubscriptionEnginePtr =
+        std::shared_ptr<PeerViewSubscriptionEngine>;
+    using PeerViewSubscriber = PeerViewSubscriptionEngine::SubscriberType;
+    using PeerViewSubscriberPtr = std::shared_ptr<PeerViewSubscriber>;
+
+    virtual ~IPeerView() = default;
+
+    virtual size_t peersCount() const = 0;
+    virtual MyViewSubscriptionEnginePtr getMyViewObservable() = 0;
+    virtual PeerViewSubscriptionEnginePtr getRemoteViewObservable() = 0;
+
+    virtual void removePeer(const PeerId &peer_id) = 0;
+    virtual void updateRemoteView(const PeerId &peer_id,
+                                  network::View &&view) = 0;
+    virtual const View &getMyView() const = 0;
+  };
+
+}  // namespace kagome::network

core/network/impl/protocols/protocol_fetch_chunk.hpp

@@ -38,13 +38,12 @@ namespace kagome::network {
         NonCopyable,
         NonMovable {
    public:
-    FetchChunkProtocolImpl(
-        libp2p::Host &host,
-        const application::ChainSpec & /*chain_spec*/,
-        const blockchain::GenesisBlockHash &genesis_hash,
-        std::shared_ptr<parachain::ParachainProcessorImpl> pp,
-        std::shared_ptr<PeerManager> pm,
-        common::MainThreadPool &main_thread_pool)
+    FetchChunkProtocolImpl(libp2p::Host &host,
+                           const application::ChainSpec & /*chain_spec*/,
+                           const blockchain::GenesisBlockHash &genesis_hash,
+                           std::shared_ptr<parachain::ParachainStorage> pp,
+                           std::shared_ptr<PeerManager> pm,
+                           common::MainThreadPool &main_thread_pool)
         : RequestResponseProtocolImpl<
               FetchChunkRequest,
               FetchChunkResponse,
@@ -132,7 +131,7 @@ namespace kagome::network {
     }
 
     inline static const auto kFetchChunkProtocolName = "FetchChunkProtocol_v2"s;
-    std::shared_ptr<parachain::ParachainProcessorImpl> pp_;
+    std::shared_ptr<parachain::ParachainStorage> pp_;
     std::shared_ptr<PeerManager> pm_;
   };
 

core/network/impl/protocols/protocol_fetch_chunk_obsolete.hpp

@@ -42,7 +42,7 @@ namespace kagome::network {
         libp2p::Host &host,
         const application::ChainSpec & /*chain_spec*/,
         const blockchain::GenesisBlockHash &genesis_hash,
-        std::shared_ptr<parachain::ParachainProcessorImpl> pp,
+        std::shared_ptr<parachain::ParachainStorage> pp,
         common::MainThreadPool &main_thread_pool)
         : RequestResponseProtocolImpl<
               FetchChunkRequest,
@@ -117,7 +117,7 @@ namespace kagome::network {
     }
 
     inline static const auto kFetchChunkProtocolName = "FetchChunkProtocol_v1"s;
-    std::shared_ptr<parachain::ParachainProcessorImpl> pp_;
+    std::shared_ptr<parachain::ParachainStorage> pp_;
   };
 
 }  // namespace kagome::network

core/network/peer_view.hpp

@@ -5,20 +5,10 @@
  */
 #pragma once
 
-#include <memory>
-#include <unordered_map>
-
-#include <libp2p/peer/peer_id.hpp>
-
 #include "application/app_state_manager.hpp"
 #include "blockchain/block_tree.hpp"
-#include "crypto/type_hasher.hpp"
 #include "injector/lazy.hpp"
-#include "network/types/collator_messages.hpp"
-#include "outcome/outcome.hpp"
-#include "primitives/event_types.hpp"
-#include "subscription/subscriber.hpp"
-#include "subscription/subscription_engine.hpp"
+#include "network/i_peer_view.hpp"
 #include "utils/non_copyable.hpp"
 #include "utils/safe_object.hpp"
 
@@ -28,43 +18,14 @@ namespace kagome::blockchain {
 
 namespace kagome::network {
 
-  using HashedBlockHeader = primitives::BlockHeader;
-  struct ExView {
-    View view;
-    HashedBlockHeader new_head;
-    std::vector<primitives::BlockHash> lost;
-  };
-
-  struct ExViewRef {
-    std::optional<std::reference_wrapper<const HashedBlockHeader>> new_head;
-    const std::vector<primitives::BlockHash> &lost;
-  };
-
   /**
    * Observable class for current heads and finalized block number tracking.
    */
   class PeerView final : public NonCopyable,
                          public NonMovable,
+                         public IPeerView,
                          public std::enable_shared_from_this<PeerView> {
    public:
-    enum struct EventType : uint32_t { kViewUpdated, kPeerRemoved };
-
-    using PeerId = libp2p::peer::PeerId;
-
-    using MyViewSubscriptionEngine = subscription::
-        SubscriptionEngine<EventType, std::monostate, network::ExView>;
-    using MyViewSubscriptionEnginePtr =
-        std::shared_ptr<MyViewSubscriptionEngine>;
-    using MyViewSubscriber = MyViewSubscriptionEngine::SubscriberType;
-    using MyViewSubscriberPtr = std::shared_ptr<MyViewSubscriber>;
-
-    using PeerViewSubscriptionEngine = subscription::
-        SubscriptionEngine<EventType, std::monostate, PeerId, network::View>;
-    using PeerViewSubscriptionEnginePtr =
-        std::shared_ptr<PeerViewSubscriptionEngine>;
-    using PeerViewSubscriber = PeerViewSubscriptionEngine::SubscriberType;
-    using PeerViewSubscriberPtr = std::shared_ptr<PeerViewSubscriber>;
-
     PeerView(primitives::events::ChainSubscriptionEnginePtr chain_events_engine,
              std::shared_ptr<application::AppStateManager> app_state_manager,
              LazySPtr<blockchain::BlockTree> block_tree);
@@ -76,14 +37,13 @@ namespace kagome::network {
     bool prepare();
     void stop();
 
-    size_t peersCount() const;
-
-    MyViewSubscriptionEnginePtr getMyViewObservable();
-    PeerViewSubscriptionEnginePtr getRemoteViewObservable();
+    size_t peersCount() const override;
+    MyViewSubscriptionEnginePtr getMyViewObservable() override;
+    PeerViewSubscriptionEnginePtr getRemoteViewObservable() override;
 
-    void removePeer(const PeerId &peer_id);
-    void updateRemoteView(const PeerId &peer_id, network::View &&view);
-    auto &getMyView() const {
+    void removePeer(const PeerId &peer_id) override;
+    void updateRemoteView(const PeerId &peer_id, network::View &&view) override;
+    const View &getMyView() const override {
       return my_view_;
     }
 

core/parachain/CMakeLists.txt

@@ -32,6 +32,18 @@ target_link_libraries(backing_implicit_view
     outcome
     )
 
+add_library(parachain_errors
+    validator/i_parachain_processor.cpp
+    )
+
+target_link_libraries(parachain_errors
+    fmt::fmt
+    soralog::soralog
+    logger
+    Boost::boost
+    outcome
+    )
+
 add_library(validator_parachain
     availability/bitfield/signer.cpp
     availability/bitfield/store_impl.cpp
@@ -54,6 +66,7 @@ add_library(validator_parachain
     backing/store_impl.cpp
     backing/cluster.cpp
     validator/statement_distribution/statement_distribution.cpp
+    validator/parachain_storage.cpp
     )
 
 target_link_libraries(validator_parachain
@@ -68,6 +81,7 @@ target_link_libraries(validator_parachain
     runtime_common
     prospective_parachains
     backing_implicit_view
+    parachain_errors
     )
 
 add_library(kagome_pvf_worker

core/parachain/approval/approval_distribution.cpp

@@ -577,7 +577,7 @@ namespace kagome::parachain {
       std::shared_ptr<crypto::KeyStore> keystore,
       std::shared_ptr<crypto::Hasher> hasher,
       std::shared_ptr<network::PeerView> peer_view,
-      std::shared_ptr<ParachainProcessorImpl> parachain_processor,
+      std::shared_ptr<ParachainProcessor> parachain_processor,
       std::shared_ptr<crypto::Sr25519Provider> crypto_provider,
       std::shared_ptr<network::PeerManager> pm,
       std::shared_ptr<network::Router> router,

core/parachain/approval/approval_distribution.hpp

@@ -59,7 +59,7 @@ namespace kagome::consensus::babe {
 
 namespace kagome::parachain {
   class ApprovalThreadPool;
-  class ParachainProcessorImpl;
+  class ParachainProcessor;
   class Pvf;
 }  // namespace kagome::parachain
 
@@ -300,7 +300,7 @@ namespace kagome::parachain {
         std::shared_ptr<crypto::KeyStore> keystore,
         std::shared_ptr<crypto::Hasher> hasher,
         std::shared_ptr<network::PeerView> peer_view,
-        std::shared_ptr<ParachainProcessorImpl> parachain_processor,
+        std::shared_ptr<ParachainProcessor> parachain_processor,
         std::shared_ptr<crypto::Sr25519Provider> crypto_provider,
         std::shared_ptr<network::PeerManager> pm,
         std::shared_ptr<network::Router> router,
@@ -877,7 +877,7 @@ namespace kagome::parachain {
           StorePair<Hash, DistribBlockEntry>>
         store_;
 
-    std::shared_ptr<ParachainProcessorImpl> parachain_processor_;
+    std::shared_ptr<ParachainProcessor> parachain_processor_;
     std::shared_ptr<crypto::Sr25519Provider> crypto_provider_;
     std::shared_ptr<network::PeerManager> pm_;
     std::shared_ptr<network::Router> router_;