feature: block production

.github/workflows/build_and_test.yaml

@@ -57,11 +57,11 @@ jobs:
         uses: actions/cache/restore@v4
         with:
           path: ${{ env.CACHE_PATH }}
-          key: jam-${{ runner.os }}-${{ github.job }}-${{ env.CACHE_VERSION }}-${{ github.run_id }}
+          key: lean-${{ runner.os }}-${{ github.job }}-${{ env.CACHE_VERSION }}-${{ github.run_id }}
           restore-keys: |
-            jam-${{ runner.os }}-${{ github.job }}-${{ env.CACHE_VERSION }}
-            jam-${{ runner.os }}-${{ github.job }}
-            jam-${{ runner.os }}
+            lean-${{ runner.os }}-${{ github.job }}-${{ env.CACHE_VERSION }}
+            lean-${{ runner.os }}-${{ github.job }}
+            lean-${{ runner.os }}
 
       - name: "Basic init"
         run: |

CMakeLists.txt

@@ -28,7 +28,7 @@ message(STATUS "Boost_DIR: ${Boost_DIR}")
 find_package(Python3 REQUIRED)
 
 find_package(PkgConfig REQUIRED)
-pkg_check_modules(libb2 REQUIRED IMPORTED_TARGET GLOBAL libb2)
+#pkg_check_modules(libb2 REQUIRED IMPORTED_TARGET GLOBAL libb2)
 
 find_package(Boost CONFIG REQUIRED COMPONENTS algorithm outcome program_options property_tree)
 find_package(fmt CONFIG REQUIRED)

docker/ci-docker

@@ -9,7 +9,7 @@
 
 
 # paths
-PROJECT=/cpp-jam
+PROJECT=/cpp-lean
 VENV=$PROJECT.venv
 BUILD=$PROJECT.build
 VCPKG=/vcpkg

docker/ci-docker-run

@@ -5,5 +5,5 @@ LOCAL=$PWD
 [[ -d $LOCAL/docker ]]
 
 docker run --rm -it \
-  -v $LOCAL:/cpp-jam \
-  ubuntu:24.04 /cpp-jam/docker/ci-docker
+  -v $LOCAL:/cpp-lean \
+  ubuntu:24.04 /cpp-lean/docker/ci-docker

example/config.yaml

@@ -27,13 +27,14 @@ logging:
       level: trace
       is_fallback: true
       children:
-        - name: jam
+        - name: lean
           children:
             - name: modules
               children:
                 - name: example_module
                 - name: synchronizer_module
                 - name: networking_module
+                - name: production_module
             - name: injector
             - name: application
             - name: rpc

src/app/CMakeLists.txt

@@ -59,6 +59,7 @@ target_link_libraries(chain_spec
     logger
     Boost::property_tree
     app_configuration
+    sszpp
 )
 
 add_library(application SHARED
@@ -69,3 +70,14 @@ target_link_libraries(application
     app_configuration
     metrics
 )
+
+add_library(timeline SHARED
+    impl/timeline_impl.cpp
+)
+target_link_libraries(timeline
+    qtils::qtils
+    logger
+    sszpp
+#    app_configuration
+#    metrics
+)

src/app/chain_spec.hpp

@@ -11,7 +11,7 @@
 
 #include <qtils/byte_vec.hpp>
 
-#include "lean_types/types.hpp"
+#include "types/types.hpp"
 
 namespace lean {
 

src/app/impl/application_impl.cpp

@@ -12,6 +12,7 @@
 #include "app/configuration.hpp"
 #include "app/impl/watchdog.hpp"
 #include "app/state_manager.hpp"
+#include "app/timeline.hpp"
 #include "clock/clock.hpp"
 #include "log/logger.hpp"
 #include "metrics/histogram_timer.hpp"
@@ -33,13 +34,15 @@ namespace lean::app {
       qtils::SharedRef<Watchdog> watchdog,
       qtils::SharedRef<metrics::Exposer> metrics_exposer,
       qtils::SharedRef<clock::SystemClock> system_clock,
+      qtils::SharedRef<Timeline> timeline,
       std::shared_ptr<SeHolder>)
       : logger_(logsys->getLogger("Application", "application")),
         app_config_(std::move(config)),
         state_manager_(std::move(state_manager)),
         watchdog_(std::move(watchdog)),
         metrics_exposer_(std::move(metrics_exposer)),
         system_clock_(std::move(system_clock)),
+        timeline_(std::move(timeline)),
         metrics_registry_(metrics::createRegistry()) {
     // Metric for exposing name and version of node
     metrics::GaugeHelper(

src/app/impl/application_impl.hpp

@@ -19,6 +19,7 @@ namespace lean {
 }  // namespace lean
 
 namespace lean::app {
+  class Timeline;
   class Configuration;
   class StateManager;
 }  // namespace lean::app
@@ -82,6 +83,7 @@ namespace lean::app {
                     qtils::SharedRef<Watchdog> watchdog,
                     qtils::SharedRef<metrics::Exposer> metrics_exposer,
                     qtils::SharedRef<clock::SystemClock> system_clock,
+                    qtils::SharedRef<Timeline> timeline,
                     std::shared_ptr<SeHolder>);
 
     void run() override;
@@ -93,6 +95,7 @@ namespace lean::app {
     qtils::SharedRef<Watchdog> watchdog_;
     qtils::SharedRef<metrics::Exposer> metrics_exposer_;
     qtils::SharedRef<clock::SystemClock> system_clock_;
+    qtils::SharedRef<Timeline> timeline_;
 
     // Metrics
     std::unique_ptr<metrics::Registry> metrics_registry_;

src/app/impl/chain_spec_impl.cpp

@@ -12,6 +12,8 @@
 
 #include <app/configuration.hpp>
 
+#include "types/block_header.hpp"
+
 OUTCOME_CPP_DEFINE_CATEGORY(lean::app, ChainSpecImpl::Error, e) {
   using E = lean::app::ChainSpecImpl::Error;
   switch (e) {
@@ -68,11 +70,16 @@ namespace lean::app {
 
   outcome::result<void> ChainSpecImpl::loadGenesis(
       const boost::property_tree::ptree &tree) {
-    OUTCOME_TRY(
-        genesis_header_hex,
-        ensure("genesis_header", tree.get_child_optional("genesis_header")));
-    OUTCOME_TRY(genesis_header_encoded,
-                qtils::ByteVec::fromHex(genesis_header_hex.data()));
+    // OUTCOME_TRY(
+    //     genesis_header_hex,
+    //     ensure("genesis_header", tree.get_child_optional("genesis_header")));
+    // OUTCOME_TRY(genesis_header_encoded,
+    //             qtils::ByteVec::fromHex(genesis_header_hex.data()));
+
+    BlockHeader header;
+    header.proposer_index = -1ull;
+    OUTCOME_TRY(genesis_header_encoded, encode(header));
+
     genesis_header_ = std::move(genesis_header_encoded);
     return outcome::success();
   }

src/app/impl/timeline_impl.cpp

@@ -0,0 +1,97 @@
+/**
+ * Copyright Quadrivium LLC
+ * All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+
+#include "timeline_impl.hpp"
+
+#include <utility>
+
+#include "app/state_manager.hpp"
+#include "clock/clock.hpp"
+#include "log/logger.hpp"
+#include "modules/shared/prodution_types.tmp.hpp"
+#include "se/impl/subscription_manager.hpp"
+#include "se/subscription.hpp"
+#include "se/subscription_fwd.hpp"
+#include "types/config.hpp"
+#include "types/constants.hpp"
+
+namespace lean::app {
+
+  TimelineImpl::TimelineImpl(qtils::SharedRef<log::LoggingSystem> logsys,
+                             qtils::SharedRef<StateManager> state_manager,
+                             qtils::SharedRef<Subscription> se_manager,
+                             qtils::SharedRef<clock::SystemClock> clock,
+                             qtils::SharedRef<Config> config)
+      : logger_(logsys->getLogger("Timeline", "application")),
+        state_manager_(std::move(state_manager)),
+        config_(std::move(config)),
+        clock_(std::move(clock)),
+        se_manager_(std::move(se_manager)) {
+    state_manager_->takeControl(*this);
+  }
+
+  void TimelineImpl::prepare() {
+    on_slot_started_ =
+        se::SubscriberCreator<qtils::Empty,
+                              std::shared_ptr<const messages::SlotStarted>>::
+            create<EventTypes::SlotStarted>(
+                *se_manager_,
+                SubscriptionEngineHandlers::kTest,
+                [this](auto &,
+                       std::shared_ptr<const messages::SlotStarted> msg) {
+                  on_slot_started(std::move(msg));
+                });
+  }
+
+  void TimelineImpl::start() {
+    auto now = clock_->nowMsec();
+    auto next_slot = (now - config_->genesis_time) / SLOT_DURATION_MS + 1;
+    auto time_to_next_slot =
+        config_->genesis_time + SLOT_DURATION_MS * next_slot - now;
+    if (time_to_next_slot < SLOT_DURATION_MS / 2) {
+      ++next_slot;
+      time_to_next_slot += SLOT_DURATION_MS;
+    }
+    SL_INFO(logger_,
+            "Starting timeline. Next slot is {}, starts in {}ms",
+            next_slot,
+            time_to_next_slot);
+    se_manager_->notifyDelayed(
+        std::chrono::milliseconds(time_to_next_slot),
+        EventTypes::SlotStarted,
+        std::make_shared<const messages::SlotStarted>(next_slot, 0, false));
+  }
+
+  void TimelineImpl::stop() {
+    stopped_ = true;
+  }
+
+  void TimelineImpl::on_slot_started(
+      std::shared_ptr<const messages::SlotStarted> msg) {
+    if (stopped_) [[unlikely]] {
+      SL_INFO(logger_, "Timeline is stopped on slot {}", msg->slot);
+      return;
+    }
+
+    auto now = clock_->nowMsec();
+    auto next_slot = (now - config_->genesis_time) / SLOT_DURATION_MS + 1;
+    auto time_to_next_slot =
+        config_->genesis_time + SLOT_DURATION_MS * next_slot - now;
+    if (time_to_next_slot < SLOT_DURATION_MS / 2) {
+      ++next_slot;
+      time_to_next_slot += SLOT_DURATION_MS;
+    }
+
+    SL_INFO(logger_, "Next slot is {} in {}ms", msg->slot, time_to_next_slot);
+
+    se_manager_->notifyDelayed(
+        std::chrono::milliseconds(time_to_next_slot),
+        EventTypes::SlotStarted,
+        std::make_shared<const messages::SlotStarted>(msg->slot + 1, 0, false));
+  }
+
+}  // namespace lean::app

src/app/impl/timeline_impl.hpp

@@ -0,0 +1,66 @@
+/**
+ * Copyright Quadrivium LLC
+ * All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <qtils/empty.hpp>
+#include <qtils/shared_ref.hpp>
+
+#include "app/timeline.hpp"
+#include "se/subscription_fwd.hpp"
+
+namespace lean::messages {
+  struct SlotStarted;
+}
+namespace lean {
+  struct Config;
+}
+namespace lean::log {
+  class LoggingSystem;
+}
+namespace lean::clock {
+  class SystemClock;
+}
+namespace soralog {
+  class Logger;
+}
+namespace lean::app {
+  class Configuration;
+  class StateManager;
+}
+
+namespace lean::app {
+
+  class TimelineImpl final : public Timeline {
+   public:
+    TimelineImpl(qtils::SharedRef<log::LoggingSystem> logsys,
+                 qtils::SharedRef<StateManager> state_manager,
+                 qtils::SharedRef<Subscription> se_manager,
+                 qtils::SharedRef<clock::SystemClock> clock,
+                 qtils::SharedRef<Config> config);
+
+    void prepare();
+    void start();
+    void stop();
+
+   private:
+    void on_slot_started(std::shared_ptr<const messages::SlotStarted> msg);
+
+    qtils::SharedRef<soralog::Logger> logger_;
+    qtils::SharedRef<StateManager> state_manager_;
+    qtils::SharedRef<Config> config_;
+    qtils::SharedRef<clock::SystemClock> clock_;
+    qtils::SharedRef<Subscription> se_manager_;
+
+    bool stopped_ = false;
+
+    std::shared_ptr<
+        BaseSubscriber<qtils::Empty,
+                       std::shared_ptr<const messages::SlotStarted>>>
+        on_slot_started_;
+  };
+
+}  // namespace lean::app

src/app/timeline.hpp

@@ -0,0 +1,17 @@
+/**
+ * Copyright Quadrivium LLC
+ * All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include "utils/ctor_limiters.hpp"
+
+namespace lean::app {
+
+  class Timeline : NonCopyable, NonMovable {
+    //
+  };
+
+}  // namespace lean::app

src/blockchain/CMakeLists.txt

@@ -9,6 +9,11 @@ add_library(blockchain
     impl/block_storage_impl.cpp
     impl/block_storage_error.cpp
     impl/block_storage_initializer.cpp
+    impl/block_tree_error.cpp
+    impl/block_tree_impl.cpp
+    impl/block_tree_initializer.cpp
+    impl/cached_tree.cpp
+    impl/genesis_block_header_impl.cpp
 )
 target_link_libraries(blockchain
     Boost::boost