key generate-node-key

src/app/configurator.cpp

@@ -163,6 +163,8 @@ namespace lean::app {
     if (vm.contains("help")) {
       std::cout << "Lean-node version " << buildVersion() << '\n';
       std::cout << cli_options_ << '\n';
+      std::println(std::cout, "Other commands:");
+      std::println(std::cout, "  qlean key generate-node-key");
       return true;
     }
 

src/executable/CMakeLists.txt

@@ -29,12 +29,14 @@ if (MACOS_BIG_EXE_USE_DYLIB)
   target_link_libraries(lean_node ${LIBRARIES})
 
   add_executable(lean_node_dlopen dlopen.cpp)
-  set_target_properties(lean_node_dlopen PROPERTIES OUTPUT_NAME lean_node)
+  set_target_properties(lean_node_dlopen PROPERTIES OUTPUT_NAME qlean)
   set_target_properties(lean_node_dlopen PROPERTIES LINKER_LANGUAGE CXX)
+  add_dependencies(lean_node_dlopen lean_node)
 else ()
   add_executable(lean_node lean_node.cpp)
   target_link_libraries(lean_node ${LIBRARIES})
 endif ()
+set_target_properties(lean_node PROPERTIES OUTPUT_NAME qlean)
 add_dependencies(lean_node all_modules)
 
 #if (BACKWARD)

src/executable/cmd_key_generate_node_key.hpp

@@ -0,0 +1,24 @@
+/**
+ * Copyright Quadrivium LLC
+ * All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <memory>
+#include <print>
+
+#include <fmt/format.h>
+#include <libp2p/crypto/random_generator/boost_generator.hpp>
+#include <libp2p/crypto/secp256k1_provider/secp256k1_provider_impl.hpp>
+#include <libp2p/peer/peer_id_from.hpp>
+
+inline void cmdKeyGenerateNodeKey() {
+  libp2p::crypto::secp256k1::Secp256k1ProviderImpl secp256k1{
+      std::make_shared<libp2p::crypto::random::BoostRandomGenerator>()};
+  auto keypair = secp256k1.generate().value();
+  auto peer_id = libp2p::peerIdFromSecp256k1(keypair.public_key);
+  std::println("{}", fmt::format("{:0xx}", qtils::Hex{keypair.private_key}));
+  std::println("{}", peer_id.toBase58());
+}

src/executable/lean_node.cpp

@@ -15,6 +15,7 @@
 #include "app/application.hpp"
 #include "app/configuration.hpp"
 #include "app/configurator.hpp"
+#include "executable/cmd_key_generate_node_key.hpp"
 #include "injector/node_injector.hpp"
 #include "loaders/loader.hpp"
 #include "log/logger.hpp"
@@ -100,6 +101,12 @@ namespace {
 int main(int argc, const char **argv, const char **env) {
   soralog::util::setThreadName("lean-node");
 
+  auto getArg = [&](size_t i) {
+    return static_cast<ptrdiff_t>(i) < argc
+             ? std::make_optional(std::string_view{argv[i]})
+             : std::nullopt;
+  };
+
   qtils::FinalAction flush_std_streams_at_exit([] {
     std::cout.flush();
     std::cerr.flush();
@@ -117,6 +124,16 @@ int main(int argc, const char **argv, const char **env) {
     return EXIT_FAILURE;
   }
 
+  if (getArg(1) == "key") {
+    if (getArg(2) == "generate-node-key") {
+      cmdKeyGenerateNodeKey();
+      return EXIT_SUCCESS;
+    }
+    std::println(std::cerr, "Expected one of following commands:");
+    std::println(std::cerr, "  qlean key generate-node-key");
+    return EXIT_FAILURE;
+  }
+
   auto app_configurator =
       std::make_unique<lean::app::Configurator>(argc, argv, env);
 

src/modules/production/production.cpp

@@ -80,7 +80,7 @@ namespace lean::modules {
     SL_INFO(logger_,
             "New leaf {} appeared{}",
             msg->header.index(),
-            msg->best ? "; it's the new the best leaf" : "");
+            msg->best ? "; it's the new best leaf" : "");
   }
 
   void ProductionModuleImpl::on_block_finalized(

src/serde/serialization.hpp

@@ -10,9 +10,21 @@
 
 #include <qtils/byte_vec.hpp>
 #include <qtils/bytes.hpp>
+#include <qtils/enum_error_code.hpp>
 #include <sszpp/ssz++.hpp>
 
 namespace lean {
+  enum class SszError {
+    DecodeError,
+  };
+  Q_ENUM_ERROR_CODE(SszError) {
+    using E = decltype(e);
+    switch (e) {
+      case E::DecodeError:
+        return "ssz decode error";
+    }
+    abort();
+  }
 
   // template <typename T>
   //  qtils::ByteVec encode(const T &v) {
@@ -52,8 +64,10 @@ namespace lean {
     try {
       return ssz::deserialize<T>(
           reinterpret_cast<std::span<std::byte> &>(data));
-    } catch (...) {
-      return std::make_error_code(std::errc::invalid_argument);
+    } catch (const std::out_of_range &) {
+      return outcome::failure(SszError::DecodeError);
+    } catch (const std::invalid_argument &) {
+      return outcome::failure(SszError::DecodeError);
     }
   }
 
@@ -66,23 +80,23 @@ namespace lean {
   }
 
   template <size_t N>
-  std::array<uint8_t, N>& as_u8(std::array<std::byte, N>& v) {
-    return reinterpret_cast<std::array<uint8_t, N>&>(v);
+  std::array<uint8_t, N> &as_u8(std::array<std::byte, N> &v) {
+    return reinterpret_cast<std::array<uint8_t, N> &>(v);
   }
 
   template <size_t N>
-  std::array<std::byte, N>& as_byte(std::array<uint8_t, N>& v) {
-    return reinterpret_cast<std::array<std::byte, N>&>(v);
+  std::array<std::byte, N> &as_byte(std::array<uint8_t, N> &v) {
+    return reinterpret_cast<std::array<std::byte, N> &>(v);
   }
 
   template <size_t N>
-  std::array<uint8_t, N> as_u8(std::array<std::byte, N>&& v) {
-    return reinterpret_cast<std::array<uint8_t, N>&>(v);
+  std::array<uint8_t, N> as_u8(std::array<std::byte, N> &&v) {
+    return reinterpret_cast<std::array<uint8_t, N> &>(v);
   }
 
   template <size_t N>
-  std::array<std::byte, N> as_byte(std::array<uint8_t, N>&& v) {
-    return reinterpret_cast<std::array<std::byte, N>&>(v);
+  std::array<std::byte, N> as_byte(std::array<uint8_t, N> &&v) {
+    return reinterpret_cast<std::array<std::byte, N> &>(v);
   }