Feat: Updating classes to new design. Stripping runtime mentions

GeniusVentures · Feb 29, 2024 · 900e0e6 · 900e0e6
1 parent 1b1f076
commit 900e0e6
Show file tree

Hide file tree

Showing 22 changed files with 232 additions and 21 deletions.
diff --git a/app/CMakeLists.txt b/app/CMakeLists.txt
@@ -36,6 +36,10 @@ add_executable (sgns_demo
       dummy_sync_protocol_client
       production_synchronizer
       block_validator
+      sr25519_provider
+      epoch_storage
+      authority_manager
+      proposer
       p2p::p2p_basic_host
       p2p::p2p_default_network
       p2p::p2p_peer_repository

diff --git a/app/integration/AuthorityUpdateObserverFactory.hpp b/app/integration/AuthorityUpdateObserverFactory.hpp
@@ -0,0 +1,63 @@
+/**
+ * @file       AuthorityUpdateObserverFactory.hpp
+ * @brief      
+ * @date       2024-02-29
+ * @author     Henrique A. Klein ([email protected])
+ */
+#ifndef _AUTHORITY_UPDATE_OBSERVER_FACTORY_HPP_
+#define _AUTHORITY_UPDATE_OBSERVER_FACTORY_HPP_
+
+#include "verification/authority/impl/authority_manager_impl.hpp"
+#include "integration/CComponentFactory.hpp"
+#include "application/app_state_manager.hpp"
+#include "blockchain/block_tree.hpp"
+#include "storage/buffer_map_types.hpp"
+
+class AuthorityUpdateObserverFactory
+{
+public:
+    static std::shared_ptr<sgns::authority::AuthorityUpdateObserver> create()
+    {
+        auto component_factory = SINGLETONINSTANCE( CComponentFactory );
+        auto result            = component_factory->GetComponent( "AppStateManager", boost::none );
+        if ( !result )
+        {
+            throw std::runtime_error( "Initialize AppStateManager first" );
+        }
+
+        auto app_state_manager = std::dynamic_pointer_cast<sgns::application::AppStateManager>( result.value() );
+
+        result = component_factory->GetComponent( "ProductionConfiguration", boost::none );
+        if ( !result )
+        {
+            throw std::runtime_error( "Initialize ProductionConfiguration first" );
+        }
+
+        auto prod_config = std::dynamic_pointer_cast<sgns::primitives::ProductionConfiguration>( result.value() );
+
+        result = component_factory->GetComponent( "BlockTree", boost::none );
+        if ( !result )
+        {
+            throw std::runtime_error( "Initialize BlockTree first" );
+        }
+
+        auto block_tree = std::dynamic_pointer_cast<sgns::blockchain::BlockTree>( result.value() );
+
+        result = component_factory->GetComponent( "BufferStorage", boost::make_optional(std::string("rocksdb")) );
+        if ( !result )
+        {
+            throw std::runtime_error( "Initialize BufferStorage first" );
+        }
+
+        auto buff_storage = std::dynamic_pointer_cast<sgns::storage::BufferStorage>( result.value() );
+
+        return std::make_shared<sgns::authority::AuthorityManagerImpl>( //
+            app_state_manager,                                          //
+            prod_config,                                                //
+            block_tree,                                                 //
+            buff_storage                                                //
+        );
+    }
+};
+
+#endif
diff --git a/app/integration/EpochStorageFactory.hpp b/app/integration/EpochStorageFactory.hpp
@@ -0,0 +1,32 @@
+/**
+ * @file       EpochStorageFactory.hpp
+ * @brief      
+ * @date       2024-02-29
+ * @author     Henrique A. Klein ([email protected])
+ */
+#ifndef _EPOCH_STORAGE_HPP_
+#define _EPOCH_STORAGE_HPP_
+#include "verification/production/impl/epoch_storage_impl.hpp"
+#include "integration/CComponentFactory.hpp"
+#include "storage/buffer_map_types.hpp"
+
+class EpochStorageFactory
+{
+public:
+    static std::shared_ptr<sgns::verification::EpochStorage> create()
+    {
+        auto component_factory = SINGLETONINSTANCE( CComponentFactory );
+
+        auto result = component_factory->GetComponent( "BufferStorage", boost::make_optional(std::string("rocksdb")));
+
+        if ( !result )
+        {
+            throw std::runtime_error( "Initialize BufferStorage first" );
+        }
+        auto buffer_storage = std::dynamic_pointer_cast<sgns::storage::BufferStorage>( result.value() );
+
+        return std::make_shared<sgns::verification::EpochStorageImpl>( buffer_storage );
+    }
+};
+
+#endif
diff --git a/app/integration/ProposerFactory.hpp b/app/integration/ProposerFactory.hpp
@@ -0,0 +1,40 @@
+/**
+ * @file       ProposerFactory.hpp
+ * @brief      
+ * @date       2024-02-29
+ * @author     Henrique A. Klein ([email protected])
+ */
+#ifndef _PROPOSER_FACTORY_HPP_
+#define _PROPOSER_FACTORY_HPP_
+
+#include "authorship/impl/proposer_impl.hpp"
+#include "integration/CComponentFactory.hpp"
+#include "transaction_pool/transaction_pool.hpp"
+
+class ProposerFactory
+{
+public:
+    static std::shared_ptr<sgns::authorship::Proposer> create()
+    {
+        //TODO - Removed runtime::BlockBuilder because of binaryen dependecy
+        auto component_factory = SINGLETONINSTANCE( CComponentFactory );
+
+        auto result = component_factory->GetComponent( "BlockBuilderFactory", boost::none );
+        if ( !result )
+        {
+            throw std::runtime_error( "Initialize BlockBuilderFactory first" );
+        }
+        auto block_builder_factory = std::dynamic_pointer_cast<sgns::authorship::BlockBuilderFactory>( result.value() );
+
+        result = component_factory->GetComponent( "TransactionPool", boost::none );
+        if ( !result )
+        {
+            throw std::runtime_error( "Initialize TransactionPool first" );
+        }
+        auto transaction_pool = std::dynamic_pointer_cast<sgns::transaction_pool::TransactionPool>( result.value() );
+
+        return std::make_shared<sgns::authorship::ProposerImpl>( block_builder_factory, transaction_pool);
+    }
+};
+
+#endif
diff --git a/app/integration/SR25519ProviderFactory.hpp b/app/integration/SR25519ProviderFactory.hpp
@@ -0,0 +1,23 @@
+/**
+ * @file       SR25519ProviderFactory.hpp
+ * @brief      
+ * @date       2024-02-28
+ * @author     Henrique A. Klein ([email protected])
+ */
+#ifndef _SR25519_PROVIDER_FACTORY_HPP_
+#define _SR25519_PROVIDER_FACTORY_HPP_
+
+#include "crypto/sr25519/sr25519_provider_impl.hpp"
+#include "crypto/random_generator/boost_generator.hpp"
+
+class SR25519ProviderFactory
+{
+public:
+static std::shared_ptr<sgns::crypto::SR25519Provider> create()
+{
+    return std::make_shared<sgns::crypto::SR25519ProviderImpl>(std::make_shared<sgns::crypto::BoostRandomGenerator>());
+}
+};
+
+#endif
+
diff --git a/src/application/impl/validating_node_application.cpp b/src/application/impl/validating_node_application.cpp
@@ -25,6 +25,10 @@
 #include "integration/ProductionSynchronizerFactory.hpp"
 #include "integration/OwnPeerInfoFactory.hpp"
 #include "integration/BlockValidatorFactory.hpp"
+#include "integration/SR25519ProviderFactory.hpp"
+#include "integration/EpochStorageFactory.hpp"
+#include "integration/AuthorityUpdateObserverFactory.hpp"
+#include "integration/ProposerFactory.hpp"
 
 #include "storage/trie/supergenius_trie/supergenius_trie_factory_impl.hpp"
 #include "storage/trie/serialization/supergenius_codec.hpp"
@@ -72,13 +76,17 @@ namespace sgns::application
         component_factory->Register( BlockStorageFactory::create(), "BlockStorage", boost::none );
         component_factory->Register( ExtrinsicGossiperFactory::create(), "ExtrinsicGossiper", boost::none );
         component_factory->Register( PoolModeratorFactory::create(), "PoolModerator", boost::none );
+        component_factory->Register( ProposerFactory::create(), "Proposer", boost::none );
         component_factory->Register( TranscationPoolFactory::create(), "TransactionPool", boost::none );
         component_factory->Register( AuthorApiFactory::create(), "AuthorApi", boost::none );
         component_factory->Register( ExtrinsicObserverFactory::create(), "ExtrinsicObserver", boost::none );
         component_factory->Register( BlockTreeFactory::create(), "BlockTree", boost::none );
+        component_factory->Register( ProductionConfigurationFactory::create(), "ProductionConfiguration", boost::none );
+        component_factory->Register( AuthorityUpdateObserverFactory::create(), "AuthorityUpdateObserver", boost::none );
+        component_factory->Register( EpochStorageFactory::create(), "EpochStorage", boost::none );
+        component_factory->Register( SR25519ProviderFactory::create(), "SR25519Provider", boost::none );
         component_factory->Register( BlockValidatorFactory::create(), "BlockValidator", boost::none );
         component_factory->Register( OwnPeerInfoFactory::create(app_config->p2p_port()), "OwnPeerInfo", boost::none );
-        component_factory->Register( ProductionConfigurationFactory::create(), "ProductionConfiguration", boost::none );
         component_factory->Register( ProductionSynchronizerFactory::create(), "ProductionSynchronizer", boost::none );
         component_factory->Register( BlockExecutorFactory::create(), "BlockExecutor", boost::none );
         component_factory->Register( ProductionFactory::create(*io_context_), "Production", boost::none );

diff --git a/src/authorship/impl/proposer_impl.cpp b/src/authorship/impl/proposer_impl.cpp
@@ -5,14 +5,14 @@ namespace sgns::authorship {
 
   ProposerImpl::ProposerImpl(
       std::shared_ptr<BlockBuilderFactory> block_builder_factory,
-      std::shared_ptr<transaction_pool::TransactionPool> transaction_pool,
-      std::shared_ptr<runtime::BlockBuilder> r_block_builder)
+      std::shared_ptr<transaction_pool::TransactionPool> transaction_pool/*,
+      std::shared_ptr<runtime::BlockBuilder> r_block_builder*/)
       : block_builder_factory_{std::move(block_builder_factory)},
-        transaction_pool_{std::move(transaction_pool)},
-        r_block_builder_{std::move(r_block_builder)} {
+        transaction_pool_{std::move(transaction_pool)}/*,
+        r_block_builder_{std::move(r_block_builder)}*/ {
     BOOST_ASSERT(block_builder_factory_);
     BOOST_ASSERT(transaction_pool_);
-    BOOST_ASSERT(r_block_builder_);
+    //BOOST_ASSERT(r_block_builder_);
   }
 
   outcome::result<primitives::Block> ProposerImpl::propose(
@@ -23,22 +23,25 @@ namespace sgns::authorship {
         block_builder),
         block_builder_factory_->create(parent_block_id, inherent_digest));
 
-    auto inherent_xts_res =
+
+    //TODO - Removed binaryen stuff (inherent_extrinsics). Replace with something else
+    /**auto inherent_xts_res =
         r_block_builder_->inherent_extrinsics(inherent_data);
     if (! inherent_xts_res) {
       logger_->error("BlockBuilder->inherent_extrinsics failed with error: {}",
                      inherent_xts_res.error().message());
       return inherent_xts_res.error();
     }
     auto inherent_xts = inherent_xts_res.value();
+    */
 
     auto log_push_error = [this](const primitives::Extrinsic &xt,
                                  std::string_view message) {
       logger_->warn("Extrinsic {} was not added to the block. Reason: {}",
                     xt.data.toHex(),
                     message);
     };
-
+    /*
     for (const auto &xt : inherent_xts) {
       logger_->debug("Adding inherent extrinsic: {}", xt.data.toHex());
       auto inserted_res = block_builder->pushExtrinsic(xt);
@@ -47,6 +50,7 @@ namespace sgns::authorship {
         return inserted_res.error();
       }
     }
+    */
 
     const auto &ready_txs = transaction_pool_->getReadyTransactions();
 

diff --git a/src/authorship/impl/proposer_impl.hpp b/src/authorship/impl/proposer_impl.hpp
@@ -17,18 +17,22 @@ namespace sgns::authorship {
 
     ProposerImpl(
         std::shared_ptr<BlockBuilderFactory> block_builder_factory,
-        std::shared_ptr<transaction_pool::TransactionPool> transaction_pool,
-        std::shared_ptr<runtime::BlockBuilder> r_block_builder);
+        std::shared_ptr<transaction_pool::TransactionPool> transaction_pool);
 
     outcome::result<primitives::Block> propose(
         const primitives::BlockId &parent_block_id,
         const primitives::InherentData &inherent_data,
         const primitives::Digest &inherent_digest) override;
 
+    std::string GetName() override
+    {
+      return "ProposerImpl";
+    }
+
    private:
     std::shared_ptr<BlockBuilderFactory> block_builder_factory_;
     std::shared_ptr<transaction_pool::TransactionPool> transaction_pool_;
-    std::shared_ptr<runtime::BlockBuilder> r_block_builder_;
+    //std::shared_ptr<runtime::BlockBuilder> r_block_builder_;
     base::Logger logger_ = base::createLogger("Proposer");
   };
 

diff --git a/src/authorship/proposer.hpp b/src/authorship/proposer.hpp
@@ -8,13 +8,14 @@
 #include "primitives/block_id.hpp"
 #include "primitives/digest.hpp"
 #include "primitives/inherent_data.hpp"
+#include "integration/IComponent.hpp"
 
 namespace sgns::authorship {
 
   /**
    * Create block to further proposal for verification
    */
-  class Proposer {
+  class Proposer : public IComponent {
    public:
     virtual ~Proposer() = default;
 

diff --git a/src/crypto/sr25519/sr25519_provider_impl.hpp b/src/crypto/sr25519/sr25519_provider_impl.hpp
@@ -32,6 +32,10 @@ namespace sgns::crypto {
         const SR25519Signature &signature,
         gsl::span<const uint8_t> message,
         const SR25519PublicKey &public_key) const override;
+    std::string GetName() override
+    {
+      return "SR25519ProviderImpl";
+    }
 
    private:
     std::shared_ptr<CSPRNG> generator_;

diff --git a/src/verification/authority/authority_update_observer.hpp b/src/verification/authority/authority_update_observer.hpp
@@ -4,9 +4,10 @@
 #include <outcome/outcome.hpp>
 
 #include "primitives/digest.hpp"
+#include "integration/IComponent.hpp"
 
 namespace sgns::authority {
-  class AuthorityUpdateObserver {
+  class AuthorityUpdateObserver : public IComponent {
    public:
     virtual ~AuthorityUpdateObserver() = default;
 

diff --git a/src/verification/authority/impl/authority_manager_impl.hpp b/src/verification/authority/impl/authority_manager_impl.hpp
@@ -70,6 +70,11 @@ namespace sgns::authority {
 
     outcome::result<void> onFinalize(
         const primitives::BlockInfo &block) override;
+
+    std::string GetName() override
+    {
+        return "AuthorityManagerImpl";
+    }
 
    private:
     base::Logger log_;

diff --git a/src/verification/production/epoch_storage.hpp b/src/verification/production/epoch_storage.hpp
@@ -7,12 +7,13 @@
 
 #include "verification/production/common.hpp"
 #include "verification/production/types/next_epoch_descriptor.hpp"
+#include "integration/IComponent.hpp"
 
 namespace sgns::verification {
   /**
    * Allows to store epochs
    */
-  struct EpochStorage {
+  struct EpochStorage : public IComponent {
     virtual ~EpochStorage() = default;
 
     /**

diff --git a/src/verification/production/impl/epoch_storage_impl.hpp b/src/verification/production/impl/epoch_storage_impl.hpp
@@ -29,6 +29,10 @@ namespace sgns::verification {
     outcome::result<NextEpochDescriptor> getEpochDescriptor(
         EpochIndex epoch_number) const override;
 
+    std::string GetName() override
+    {
+      return "EpochStorageImpl";
+    }
    private:
     std::shared_ptr<storage::BufferStorage> storage_;
   };

diff --git a/src/verification/validation/block_validator.hpp b/src/verification/validation/block_validator.hpp
@@ -6,12 +6,13 @@
 #include <outcome/outcome.hpp>
 #include "verification/production/types/epoch.hpp"
 #include "primitives/block.hpp"
+#include "integration/IComponent.hpp"
 
 namespace sgns::verification {
   /**
    * Validator of the blocks
    */
-  class BlockValidator {
+  class BlockValidator : public IComponent {
    public:
     virtual ~BlockValidator() = default;