refactor: Adapt project structure to Nix (#1)

* Move config to configs dir.

* wip

* wip

* junie refactor cmakelists and flake

* Refactor Nix, CMakeLists and codebase to enable proper nix building, and good IDE integration.

* Add src/ directory.

* Split into header and source files.

* Fix macOs SSL certs issue.

* Mac fixes

* Update Macos lib extension

---------

Co-authored-by: Daniel <sanchez.quiros.daniel@gmail.com>

.gitignore

@@ -3,18 +3,10 @@
 *.bak
 
 # CMake generated files
-Makefile
-CMakeFiles/
-CMakeCache.txt
-cmake_install.cmake
-cmake-build-debug
 .cache/
 build/
-
+target/
-# Artifacts
+result
-liblogos-blockchain-module.so
-liblogos-blockchain-module.log
 
 # Node
-logos_blockchain_db/
 resources/

CMakeLists.txt

@@ -4,160 +4,215 @@ project(logos-blockchain-module LANGUAGES CXX)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-option(COPY_PLUGIN_TO_SOURCE_DIR "Copy built plugin to repo root (dev convenience)" ON)
+# ---- Options ----
-option(LOGOS_BUILD_DEPS_BY_DEFAULT "Always stage+build Rust deps when building the plugin" OFF)
+option(LOGOS_MODULE_BUNDLE "Create local runtime bundle in target/." ON)
+set(LOGOS_CORE_ROOT "" CACHE PATH "Path to logos-core root directory.")
+set(LOGOS_BLOCKCHAIN_ROOT "" CACHE PATH "Path to logos-blockchain source root.")
+set(LOGOS_BLOCKCHAIN_LIB "" CACHE PATH "Path to prebuilt logos-blockchain lib.")
+set(LOGOS_BLOCKCHAIN_INCLUDE "" CACHE PATH "Path to prebuilt logos-blockchain include.")
 
-set(LOGOS_CPP_SDK_ROOT "" CACHE PATH "Path to logos-cpp-sdk root")
+set(HAS_LOGOS_CORE_ROOT FALSE)
-set(LOGOS_BLOCKCHAIN_ROOT "" CACHE PATH "Path to logos-blockchain source root")
+set(HAS_LOGOS_BLOCKCHAIN_ROOT FALSE)
+set(HAS_LOGOS_BLOCKCHAIN_LIB FALSE)
+set(HAS_LOGOS_BLOCKCHAIN_INCLUDE FALSE)
 
-if(LOGOS_CPP_SDK_ROOT STREQUAL "")
+if (DEFINED LOGOS_CORE_ROOT AND NOT "${LOGOS_CORE_ROOT}" STREQUAL "")
-  message(FATAL_ERROR "LOGOS_CPP_SDK_ROOT not set. Pass -DLOGOS_CPP_SDK_ROOT=/path/to/logos-cpp-sdk")
+    set(HAS_LOGOS_CORE_ROOT TRUE)
-endif()
-if(LOGOS_BLOCKCHAIN_ROOT STREQUAL "")
-  message(FATAL_ERROR "LOGOS_BLOCKCHAIN_ROOT not set. Pass -DLOGOS_BLOCKCHAIN_ROOT=/path/to/logos-blockchain")
 endif()
 
-find_package(Qt6 REQUIRED COMPONENTS Core)
+if (DEFINED LOGOS_BLOCKCHAIN_ROOT AND NOT "${LOGOS_BLOCKCHAIN_ROOT}" STREQUAL "")
+    set(HAS_LOGOS_BLOCKCHAIN_ROOT TRUE)
+endif()
+
+if(DEFINED LOGOS_BLOCKCHAIN_LIB AND NOT "${LOGOS_BLOCKCHAIN_LIB}" STREQUAL "")
+    set(HAS_LOGOS_BLOCKCHAIN_LIB TRUE)
+endif()
+
+if(DEFINED LOGOS_BLOCKCHAIN_INCLUDE AND NOT "${LOGOS_BLOCKCHAIN_INCLUDE}" STREQUAL "")
+    set(HAS_LOGOS_BLOCKCHAIN_INCLUDE TRUE)
+endif()
+
+if (NOT HAS_LOGOS_CORE_ROOT)
+    message(FATAL_ERROR "LOGOS_CORE_ROOT must be set to the logos-core root directory.")
+endif()
+
+if(HAS_LOGOS_BLOCKCHAIN_LIB AND HAS_LOGOS_BLOCKCHAIN_INCLUDE AND NOT HAS_LOGOS_BLOCKCHAIN_ROOT)
+    message(STATUS "Using prebuilt logos-blockchain.")
+    set(LOGOS_BLOCKCHAIN_PREBUILT TRUE)
+elseif(NOT HAS_LOGOS_BLOCKCHAIN_LIB AND NOT HAS_LOGOS_BLOCKCHAIN_INCLUDE AND HAS_LOGOS_BLOCKCHAIN_ROOT)
+    message(STATUS "Building logos-blockchain from source.")
+    set(LOGOS_BLOCKCHAIN_PREBUILT FALSE)
+else()
+    message(FATAL_ERROR "Either both LOGOS_BLOCKCHAIN_LIB and LOGOS_BLOCKCHAIN_INCLUDE must be set for prebuilt logos-blockchain, or only LOGOS_BLOCKCHAIN_ROOT must be set for building from source.")
+endif()
+
+# ---- Qt ----
+find_package(Qt6 REQUIRED COMPONENTS Core RemoteObjects)
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTOUIC ON)
 set(CMAKE_AUTORCC ON)
 
-# ---- writable stage (Nix store is read-only) ----
+# ---- Directories ----
-set(LOGOS_BLOCKCHAIN_WORKDIR     "${CMAKE_BINARY_DIR}/logos_blockchain_src")
+set(WORKSPACE_ROOT  "${CMAKE_BINARY_DIR}/workspace")
-set(LOGOS_BLOCKCHAIN_STAGE_STAMP "${LOGOS_BLOCKCHAIN_WORKDIR}/.staged")
+set(TARGET_DIR      "${CMAKE_SOURCE_DIR}/target")
+file(MAKE_DIRECTORY "${WORKSPACE_ROOT}" "${TARGET_DIR}")
 
-add_custom_command(
+# ---- Logos Core SDK ----
-        OUTPUT  "${LOGOS_BLOCKCHAIN_STAGE_STAMP}"
+set(SDK_LIB "${LOGOS_CORE_ROOT}/lib/liblogos_sdk.a")
-        COMMAND ${CMAKE_COMMAND} -E make_directory "${LOGOS_BLOCKCHAIN_WORKDIR}"
+set(SDK_INC "${LOGOS_CORE_ROOT}/include")
-        COMMAND ${CMAKE_COMMAND} -E copy_directory  "${LOGOS_BLOCKCHAIN_ROOT}" "${LOGOS_BLOCKCHAIN_WORKDIR}"
-        COMMAND ${CMAKE_COMMAND} -E touch "${LOGOS_BLOCKCHAIN_STAGE_STAMP}"
-        VERBATIM
-)
-add_custom_target(logos_blockchain_stage DEPENDS "${LOGOS_BLOCKCHAIN_STAGE_STAMP}")
-
-# ---- build + stage c-bindings (Rust) ----
-set(LOGOS_INSTALL_DIR "${CMAKE_BINARY_DIR}/logos_stage")
-file(MAKE_DIRECTORY "${LOGOS_INSTALL_DIR}/include" "${LOGOS_INSTALL_DIR}/lib")
-
-set(CARGO_TARGET_DIR "${CMAKE_BINARY_DIR}/cargo-target")
 
+# ---- OS Specifics ----
 if(APPLE)
-  set(LOGOS_BLOCKCHAIN_EXT ".dylib")
+    set(DYLIB_EXT ".dylib")
 elseif(WIN32)
-  set(LOGOS_BLOCKCHAIN_EXT ".dll")
+    set(DYLIB_EXT ".dll")
+    set(IMPLIB_EXT ".lib")
 else()
-  set(LOGOS_BLOCKCHAIN_EXT ".so")
+    set(DYLIB_EXT ".so")
 endif()
 
-set(LOGOS_BLOCKCHAIN_C_SOURCE_DYLIB_NAME "liblib_logos_blockchain${LOGOS_BLOCKCHAIN_EXT}" CACHE STRING "Filename produced by cargo")
+# NOTE (Windows):
-set(LOGOS_BLOCKCHAIN_C_STAGED_DYLIB_NAME "lib_logos_blockchain${LOGOS_BLOCKCHAIN_EXT}"    CACHE STRING "Filename staged next to plugin")
+# Rust cdylib typically produces:
-set(LOGOS_BLOCKCHAIN_C_HEADER_NAME       "lib_logos_blockchain.h"                         CACHE STRING "Header in c-bindings crate root")
+#   - logos_blockchain.dll (runtime)
+#   - logos_blockchain.lib (import lib)
+# The Windows build hasn't been yet, so adjust accordingly if the DLL is named without the 'lib' prefix.
 
-set(LOGOS_BLOCKCHAIN_STAGED_DYLIB  "${LOGOS_INSTALL_DIR}/lib/${LOGOS_BLOCKCHAIN_C_STAGED_DYLIB_NAME}")
+# ---- Logos Blockchain (build OR consume) ----
-set(LOGOS_BLOCKCHAIN_STAGED_HEADER "${LOGOS_INSTALL_DIR}/include/${LOGOS_BLOCKCHAIN_C_HEADER_NAME}")
+if(LOGOS_BLOCKCHAIN_PREBUILT)
+    set(LOGOS_BLOCKCHAIN_DYLIB "${LOGOS_BLOCKCHAIN_LIB}/liblogos_blockchain${DYLIB_EXT}")
 
-set(PATCHELF_COMMANDS "")
+    if(WIN32)
-if(UNIX AND NOT APPLE AND NOT WIN32)
+        set(LOGOS_BLOCKCHAIN_IMPLIB "${LOGOS_BLOCKCHAIN_LIB}/logos_blockchain${IMPLIB_EXT}")
-  find_program(PATCHELF_EXE patchelf REQUIRED)
+    endif()
-  set(PATCHELF_COMMANDS
+
-          COMMAND ${PATCHELF_EXE} --set-soname "${LOGOS_BLOCKCHAIN_C_STAGED_DYLIB_NAME}" "${LOGOS_BLOCKCHAIN_STAGED_DYLIB}"
+    add_custom_target(logos_blockchain_libs)
-  )
+
+else()
+    find_program(CARGO_EXECUTABLE cargo REQUIRED)
+
+    set(CARGO_TARGET_DIR       "${WORKSPACE_ROOT}/logos-blockchain/target")
+    set(INTERNAL_STAGE         "${WORKSPACE_ROOT}/stage")
+    set(INTERNAL_STAGE_LIB     "${INTERNAL_STAGE}/lib")
+    set(INTERNAL_STAGE_INCLUDE "${INTERNAL_STAGE}/include")
+    file(MAKE_DIRECTORY "${CARGO_TARGET_DIR}" "${INTERNAL_STAGE_LIB}" "${INTERNAL_STAGE_INCLUDE}")
+
+    set(LOGOS_BLOCKCHAIN_LIB     "${INTERNAL_STAGE_LIB}")
+    set(LOGOS_BLOCKCHAIN_INCLUDE "${INTERNAL_STAGE_INCLUDE}")
+
+    set(LOGOS_BLOCKCHAIN_DYLIB  "${INTERNAL_STAGE_LIB}/liblogos_blockchain${DYLIB_EXT}")
+    set(LOGOS_BLOCKCHAIN_HEADER "${INTERNAL_STAGE_INCLUDE}/logos_blockchain.h")
+
+    add_custom_command(
+            OUTPUT "${LOGOS_BLOCKCHAIN_DYLIB}"
+            COMMAND ${CMAKE_COMMAND} -E env
+            CARGO_TARGET_DIR=${CARGO_TARGET_DIR}
+            ${CARGO_EXECUTABLE} build --release
+            --package logos-blockchain-c
+            --manifest-path "${LOGOS_BLOCKCHAIN_ROOT}/Cargo.toml"
+            COMMAND ${CMAKE_COMMAND} -E copy
+            "${CARGO_TARGET_DIR}/release/liblogos_blockchain${DYLIB_EXT}"
+            "${LOGOS_BLOCKCHAIN_DYLIB}"
+            DEPENDS "${LOGOS_BLOCKCHAIN_ROOT}/Cargo.toml"
+            VERBATIM
+    )
+
+    add_custom_command(
+            OUTPUT "${LOGOS_BLOCKCHAIN_HEADER}"
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different
+            "${LOGOS_BLOCKCHAIN_ROOT}/c-bindings/logos_blockchain.h"
+            "${LOGOS_BLOCKCHAIN_HEADER}"
+            DEPENDS "${LOGOS_BLOCKCHAIN_DYLIB}"
+            VERBATIM
+    )
+
+    add_custom_target(logos_blockchain_libs DEPENDS "${LOGOS_BLOCKCHAIN_DYLIB}" "${LOGOS_BLOCKCHAIN_HEADER}")
 endif()
 
-add_custom_command(
+# ---- Imported targets ----
-        OUTPUT "${LOGOS_BLOCKCHAIN_STAGED_DYLIB}"
+add_library(logos_blockchain_interface SHARED IMPORTED GLOBAL)
-        COMMAND ${CMAKE_COMMAND} -E make_directory "${CARGO_TARGET_DIR}"
+set_target_properties(logos_blockchain_interface PROPERTIES
-        COMMAND ${CMAKE_COMMAND} -E env
+        IMPORTED_LOCATION "${LOGOS_BLOCKCHAIN_DYLIB}"
-        CARGO_TERM_COLOR=always
+        INTERFACE_INCLUDE_DIRECTORIES "${LOGOS_BLOCKCHAIN_INCLUDE}"
-        CARGO_TARGET_DIR=${CARGO_TARGET_DIR}
-        cargo build --release --package logos-blockchain-c
-        COMMAND ${CMAKE_COMMAND} -E copy
-        "${CARGO_TARGET_DIR}/release/${LOGOS_BLOCKCHAIN_C_SOURCE_DYLIB_NAME}"
-        "${LOGOS_BLOCKCHAIN_STAGED_DYLIB}"
-        ${PATCHELF_COMMANDS}
-        DEPENDS "${LOGOS_BLOCKCHAIN_STAGE_STAMP}"
-        WORKING_DIRECTORY "${LOGOS_BLOCKCHAIN_WORKDIR}"
-        VERBATIM
 )
 
-add_custom_command(
+if(NOT LOGOS_BLOCKCHAIN_PREBUILT)
-        OUTPUT "${LOGOS_BLOCKCHAIN_STAGED_HEADER}"
+    add_dependencies(logos_blockchain_interface logos_blockchain_libs)
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different
+endif()
-        "${LOGOS_BLOCKCHAIN_WORKDIR}/c-bindings/${LOGOS_BLOCKCHAIN_C_HEADER_NAME}"
-        "${LOGOS_BLOCKCHAIN_STAGED_HEADER}"
-        DEPENDS "${LOGOS_BLOCKCHAIN_STAGED_DYLIB}"
-        VERBATIM
-)
 
-add_custom_target(logos_cargo_build DEPENDS "${LOGOS_BLOCKCHAIN_STAGED_DYLIB}" "${LOGOS_BLOCKCHAIN_STAGED_HEADER}")
+if(WIN32)
-
+    set_target_properties(logos_blockchain_interface PROPERTIES IMPORTED_IMPLIB "${LOGOS_BLOCKCHAIN_IMPLIB}")
-add_library(logos_blockchain_c SHARED IMPORTED GLOBAL)
+endif()
-set_target_properties(logos_blockchain_c PROPERTIES
-        IMPORTED_LOCATION             "${LOGOS_BLOCKCHAIN_STAGED_DYLIB}"
-        INTERFACE_INCLUDE_DIRECTORIES "${LOGOS_INSTALL_DIR}/include"
-)
-add_dependencies(logos_blockchain_c logos_cargo_build)
-
-# ---- logos-cpp-sdk ----
-add_library(logos_cpp_sdk INTERFACE)
-target_include_directories(logos_cpp_sdk INTERFACE
-        "${LOGOS_CPP_SDK_ROOT}/include/core"
-        "${LOGOS_CPP_SDK_ROOT}/include/cpp"
-        "${LOGOS_CPP_SDK_ROOT}/include"
-)
 
 add_library(logos_core STATIC IMPORTED)
 set_target_properties(logos_core PROPERTIES
-        IMPORTED_LOCATION "${LOGOS_CPP_SDK_ROOT}/lib/liblogos_sdk.a"
+        IMPORTED_LOCATION "${SDK_LIB}"
 )
 
-# ---- plugin ----
+add_library(logos_cpp_sdk INTERFACE)
-set(MODULE_ID "liblogos-blockchain-module")
+target_include_directories(logos_cpp_sdk INTERFACE "${SDK_INC}")
-set(PLUGIN_TARGET "${MODULE_ID}")
+
+# ---- Plugin ----
+set(PLUGIN_TARGET liblogos-blockchain-module)
 
 qt_add_plugin(${PLUGIN_TARGET} CLASS_NAME LogosBlockchainModule)
 
-# Keep the filename expected by the viewer/tooling (if you still want it this way)
 set_target_properties(${PLUGIN_TARGET} PROPERTIES
         OUTPUT_NAME "logos-blockchain-module"
+        LIBRARY_OUTPUT_DIRECTORY "${TARGET_DIR}"
 )
 
 target_sources(${PLUGIN_TARGET} PRIVATE
-        "${CMAKE_CURRENT_SOURCE_DIR}/library.cpp"
+        src/logos_blockchain_module.cpp
-        "${CMAKE_CURRENT_SOURCE_DIR}/metadata.json"
+        src/logos_blockchain_module.h
+        metadata.json
+)
+
+set_target_properties(${PLUGIN_TARGET} PROPERTIES
+        PUBLIC_HEADER "src/i_logos_blockchain_module.h"
+)
+
+target_include_directories(${PLUGIN_TARGET} PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/src
 )
 
 target_link_libraries(${PLUGIN_TARGET} PRIVATE
         Qt6::Core
-        logos_blockchain_c
+        Qt6::RemoteObjects
+        logos_blockchain_interface
         logos_cpp_sdk
         logos_core
 )
 
-target_compile_definitions(${PLUGIN_TARGET} PRIVATE USING_QT)
+add_dependencies(${PLUGIN_TARGET} logos_blockchain_libs)
-
-if(LOGOS_BUILD_DEPS_BY_DEFAULT)
-  add_dependencies(${PLUGIN_TARGET} logos_blockchain_stage logos_cargo_build)
-endif()
 
 if(APPLE)
-  set_target_properties(${PLUGIN_TARGET} PROPERTIES BUILD_RPATH "@loader_path" INSTALL_RPATH "@loader_path")
+    set_target_properties(${PLUGIN_TARGET} PROPERTIES
+            BUILD_RPATH "@loader_path"
+            INSTALL_RPATH "@loader_path"
+    )
 elseif(UNIX)
-  set_target_properties(${PLUGIN_TARGET} PROPERTIES BUILD_RPATH "$ORIGIN"      INSTALL_RPATH "$ORIGIN")
+    set_target_properties(${PLUGIN_TARGET} PROPERTIES
+            BUILD_RPATH "$ORIGIN"
+            INSTALL_RPATH "$ORIGIN"
+    )
 endif()
 
-add_custom_command(TARGET ${PLUGIN_TARGET} POST_BUILD
+# ---- Optional local bundle ----
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different
+if(LOGOS_MODULE_BUNDLE)
-        "${LOGOS_BLOCKCHAIN_STAGED_DYLIB}"
+    add_custom_command(TARGET ${PLUGIN_TARGET} POST_BUILD
-        "$<TARGET_FILE_DIR:${PLUGIN_TARGET}>/${LOGOS_BLOCKCHAIN_C_STAGED_DYLIB_NAME}"
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different
-        VERBATIM
+            "${LOGOS_BLOCKCHAIN_DYLIB}"
+            "${TARGET_DIR}/liblogos_blockchain${DYLIB_EXT}"
+            VERBATIM
+    )
+endif()
+
+# ---- Install ----
+install(TARGETS ${PLUGIN_TARGET}
+        LIBRARY DESTINATION lib
+        ARCHIVE DESTINATION lib
+        RUNTIME DESTINATION bin
+        PUBLIC_HEADER DESTINATION include
 )
-
+install(DIRECTORY "${LOGOS_BLOCKCHAIN_INCLUDE}/" DESTINATION include)
-if(COPY_PLUGIN_TO_SOURCE_DIR)
+install(FILES "${LOGOS_BLOCKCHAIN_DYLIB}" DESTINATION lib)
-  add_custom_command(TARGET ${PLUGIN_TARGET} POST_BUILD
-          COMMAND ${CMAKE_COMMAND} -E copy_if_different
-          "$<TARGET_FILE:${PLUGIN_TARGET}>"
-          "${CMAKE_SOURCE_DIR}/$<TARGET_FILE_NAME:${PLUGIN_TARGET}>"
-          VERBATIM
-  )
-endif()

flake.lock

@@ -1,25 +1,114 @@
 {
   "nodes": {
-    "logos-blockchain": {
+    "crane": {
-      "flake": false,
       "locked": {
-        "lastModified": 1768919760,
+        "lastModified": 1769737823,
-        "narHash": "sha256-YJ8VjYl8QgT7htdAsy38bgKzpYB2k4jn8Y820Swqbmg=",
+        "narHash": "sha256-DrBaNpZ+sJ4stXm+0nBX7zqZT9t9P22zbk6m5YhQxS4=",
+        "owner": "ipetkov",
+        "repo": "crane",
+        "rev": "b2f45c3830aa96b7456a4c4bc327d04d7a43e1ba",
+        "type": "github"
+      },
+      "original": {
+        "owner": "ipetkov",
+        "repo": "crane",
+        "type": "github"
+      }
+    },
+    "logos-blockchain": {
+      "inputs": {
+        "crane": "crane",
+        "logos-blockchain-circuits": "logos-blockchain-circuits",
+        "nixpkgs": "nixpkgs_2",
+        "rust-overlay": "rust-overlay"
+      },
+      "locked": {
+        "lastModified": 1769795993,
+        "narHash": "sha256-34W3vBr3Yk0PdRvA8pKciTY8TUX0AeHZ/hIWUxNI5XQ=",
         "owner": "logos-blockchain",
         "repo": "logos-blockchain",
-        "rev": "73d977aa5e9ffb2de8d7708b29be2f00636aa22b",
+        "rev": "ae3fb11f780645bc3fa76ece379e05c4b897d5a9",
         "type": "github"
       },
       "original": {
         "owner": "logos-blockchain",
+        "ref": "ci/circuits/integrate-binaries-on-tests-using-nix",
         "repo": "logos-blockchain",
         "type": "github"
       }
     },
-    "logos-cpp-sdk": {
+    "logos-blockchain-circuits": {
       "inputs": {
         "nixpkgs": "nixpkgs"
       },
+      "locked": {
+        "lastModified": 1769780029,
+        "narHash": "sha256-B2CYcJWuJIXAJaWgBcY4k0FTxo62mI8Hd9RqBECfq4o=",
+        "owner": "logos-blockchain",
+        "repo": "logos-blockchain-circuits",
+        "rev": "480b9bc4fddb4643f528d607f046f27610439a78",
+        "type": "github"
+      },
+      "original": {
+        "owner": "logos-blockchain",
+        "repo": "logos-blockchain-circuits",
+        "type": "github"
+      }
+    },
+    "logos-capability-module": {
+      "inputs": {
+        "logos-cpp-sdk": "logos-cpp-sdk",
+        "logos-liblogos": "logos-liblogos_2",
+        "nixpkgs": [
+          "logos-liblogos",
+          "logos-capability-module",
+          "logos-liblogos",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1767809111,
+        "narHash": "sha256-jehjsB+BpDJlVu3I7x+vFVOdXmy9MDmFTJtRqzFUONo=",
+        "owner": "logos-co",
+        "repo": "logos-capability-module",
+        "rev": "7b35383e0aa4e28a4633ed18a87efb57636939b1",
+        "type": "github"
+      },
+      "original": {
+        "owner": "logos-co",
+        "repo": "logos-capability-module",
+        "type": "github"
+      }
+    },
+    "logos-capability-module_2": {
+      "inputs": {
+        "logos-cpp-sdk": "logos-cpp-sdk_4",
+        "logos-liblogos": "logos-liblogos_3",
+        "nixpkgs": [
+          "logos-module-viewer",
+          "logos-capability-module",
+          "logos-liblogos",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1764708348,
+        "narHash": "sha256-UNyZJYZsYD1KfcKS4jQab0GWx8vxZScboo3y3JcFPv4=",
+        "owner": "logos-co",
+        "repo": "logos-capability-module",
+        "rev": "710992469b7650110e7bb5a000ae03a7e8864e66",
+        "type": "github"
+      },
+      "original": {
+        "owner": "logos-co",
+        "repo": "logos-capability-module",
+        "type": "github"
+      }
+    },
+    "logos-core": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_3"
+      },
       "locked": {
         "lastModified": 1767724329,
         "narHash": "sha256-UPkqxqxbKwU5Dmu00TnjiJVXUmfVylF3p1qziEuYwIE=",
@@ -34,9 +123,45 @@
         "type": "github"
       }
     },
+    "logos-cpp-sdk": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_4"
+      },
+      "locked": {
+        "lastModified": 1761230734,
+        "narHash": "sha256-CMRUwXH7pJZ1OI6bd/TDDDXKqQ1tQZHQEOOwK8TgYHI=",
+        "owner": "logos-co",
+        "repo": "logos-cpp-sdk",
+        "rev": "4b143922c190df00bb3835441c9f0075cb28283b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "logos-co",
+        "repo": "logos-cpp-sdk",
+        "type": "github"
+      }
+    },
     "logos-cpp-sdk_2": {
       "inputs": {
-        "nixpkgs": "nixpkgs_2"
+        "nixpkgs": "nixpkgs_5"
+      },
+      "locked": {
+        "lastModified": 1761230734,
+        "narHash": "sha256-CMRUwXH7pJZ1OI6bd/TDDDXKqQ1tQZHQEOOwK8TgYHI=",
+        "owner": "logos-co",
+        "repo": "logos-cpp-sdk",
+        "rev": "4b143922c190df00bb3835441c9f0075cb28283b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "logos-co",
+        "repo": "logos-cpp-sdk",
+        "type": "github"
+      }
+    },
+    "logos-cpp-sdk_3": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_6"
       },
       "locked": {
         "lastModified": 1764699992,
@@ -52,9 +177,118 @@
         "type": "github"
       }
     },
+    "logos-cpp-sdk_4": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_7"
+      },
+      "locked": {
+        "lastModified": 1761230734,
+        "narHash": "sha256-CMRUwXH7pJZ1OI6bd/TDDDXKqQ1tQZHQEOOwK8TgYHI=",
+        "owner": "logos-co",
+        "repo": "logos-cpp-sdk",
+        "rev": "4b143922c190df00bb3835441c9f0075cb28283b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "logos-co",
+        "repo": "logos-cpp-sdk",
+        "type": "github"
+      }
+    },
+    "logos-cpp-sdk_5": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_8"
+      },
+      "locked": {
+        "lastModified": 1761230734,
+        "narHash": "sha256-CMRUwXH7pJZ1OI6bd/TDDDXKqQ1tQZHQEOOwK8TgYHI=",
+        "owner": "logos-co",
+        "repo": "logos-cpp-sdk",
+        "rev": "4b143922c190df00bb3835441c9f0075cb28283b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "logos-co",
+        "repo": "logos-cpp-sdk",
+        "type": "github"
+      }
+    },
+    "logos-cpp-sdk_6": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_9"
+      },
+      "locked": {
+        "lastModified": 1764699992,
+        "narHash": "sha256-nCmK9C9F31cHvy6lWKR5WGl99aJbS3kIsROAoZ4OrwI=",
+        "owner": "logos-co",
+        "repo": "logos-cpp-sdk",
+        "rev": "5d0bbd0d1e00aad0532ffa7c8bf2c80f460a4f6d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "logos-co",
+        "repo": "logos-cpp-sdk",
+        "type": "github"
+      }
+    },
+    "logos-cpp-sdk_7": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_10"
+      },
+      "locked": {
+        "lastModified": 1764699992,
+        "narHash": "sha256-nCmK9C9F31cHvy6lWKR5WGl99aJbS3kIsROAoZ4OrwI=",
+        "owner": "logos-co",
+        "repo": "logos-cpp-sdk",
+        "rev": "5d0bbd0d1e00aad0532ffa7c8bf2c80f460a4f6d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "logos-co",
+        "repo": "logos-cpp-sdk",
+        "type": "github"
+      }
+    },
+    "logos-cpp-sdk_8": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_11"
+      },
+      "locked": {
+        "lastModified": 1761230734,
+        "narHash": "sha256-CMRUwXH7pJZ1OI6bd/TDDDXKqQ1tQZHQEOOwK8TgYHI=",
+        "owner": "logos-co",
+        "repo": "logos-cpp-sdk",
+        "rev": "4b143922c190df00bb3835441c9f0075cb28283b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "logos-co",
+        "repo": "logos-cpp-sdk",
+        "type": "github"
+      }
+    },
+    "logos-cpp-sdk_9": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_12"
+      },
+      "locked": {
+        "lastModified": 1761230734,
+        "narHash": "sha256-CMRUwXH7pJZ1OI6bd/TDDDXKqQ1tQZHQEOOwK8TgYHI=",
+        "owner": "logos-co",
+        "repo": "logos-cpp-sdk",
+        "rev": "4b143922c190df00bb3835441c9f0075cb28283b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "logos-co",
+        "repo": "logos-cpp-sdk",
+        "type": "github"
+      }
+    },
     "logos-liblogos": {
       "inputs": {
-        "logos-cpp-sdk": "logos-cpp-sdk_2",
+        "logos-capability-module": "logos-capability-module",
+        "logos-cpp-sdk": "logos-cpp-sdk_3",
         "nixpkgs": [
           "logos-liblogos",
           "logos-cpp-sdk",
@@ -62,11 +296,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1768343028,
+        "lastModified": 1769640265,
-        "narHash": "sha256-4LvsuZTDTlLtfMF4C69ls+lmkYJWD7LZitS04Mc+8UI=",
+        "narHash": "sha256-hwnkxGxY2V0N1U6iNW02gY7mfcPSg+KG2plZv/rEf9k=",
         "owner": "logos-co",
         "repo": "logos-liblogos",
-        "rev": "a76d33f5519af0ee12317c8f149eee2ac5d292a0",
+        "rev": "02dd00d6a000f3d45bcf0f36f849ff14da2e6d75",
         "type": "github"
       },
       "original": {
@@ -75,7 +309,205 @@
         "type": "github"
       }
     },
+    "logos-liblogos_2": {
+      "inputs": {
+        "logos-cpp-sdk": "logos-cpp-sdk_2",
+        "nixpkgs": [
+          "logos-liblogos",
+          "logos-capability-module",
+          "logos-liblogos",
+          "logos-cpp-sdk",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1761845775,
+        "narHash": "sha256-ulK8xq05ejK6qIgZ7WtWb/MJt2rk5BKfDA2z7mM3wq8=",
+        "owner": "logos-co",
+        "repo": "logos-liblogos",
+        "rev": "a92c2c1268bc70764c8f73c7bce07d21024f5af9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "logos-co",
+        "repo": "logos-liblogos",
+        "type": "github"
+      }
+    },
+    "logos-liblogos_3": {
+      "inputs": {
+        "logos-cpp-sdk": "logos-cpp-sdk_5",
+        "nixpkgs": [
+          "logos-module-viewer",
+          "logos-capability-module",
+          "logos-liblogos",
+          "logos-cpp-sdk",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1761845775,
+        "narHash": "sha256-ulK8xq05ejK6qIgZ7WtWb/MJt2rk5BKfDA2z7mM3wq8=",
+        "owner": "logos-co",
+        "repo": "logos-liblogos",
+        "rev": "a92c2c1268bc70764c8f73c7bce07d21024f5af9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "logos-co",
+        "repo": "logos-liblogos",
+        "type": "github"
+      }
+    },
+    "logos-liblogos_4": {
+      "inputs": {
+        "logos-cpp-sdk": "logos-cpp-sdk_7",
+        "nixpkgs": [
+          "logos-module-viewer",
+          "logos-liblogos",
+          "logos-cpp-sdk",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1764788130,
+        "narHash": "sha256-ieu55pelIMUO/m7fLXUS3JT6sNBBHva0lNc1GRH2hb0=",
+        "owner": "logos-co",
+        "repo": "logos-liblogos",
+        "rev": "3046aa6ac4392a705b2890adec405d7c9d8d4178",
+        "type": "github"
+      },
+      "original": {
+        "owner": "logos-co",
+        "repo": "logos-liblogos",
+        "type": "github"
+      }
+    },
+    "logos-liblogos_5": {
+      "inputs": {
+        "logos-cpp-sdk": "logos-cpp-sdk_9",
+        "nixpkgs": [
+          "logos-module-viewer",
+          "logos-package-manager",
+          "logos-liblogos",
+          "logos-cpp-sdk",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1761845775,
+        "narHash": "sha256-ulK8xq05ejK6qIgZ7WtWb/MJt2rk5BKfDA2z7mM3wq8=",
+        "owner": "logos-co",
+        "repo": "logos-liblogos",
+        "rev": "a92c2c1268bc70764c8f73c7bce07d21024f5af9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "logos-co",
+        "repo": "logos-liblogos",
+        "type": "github"
+      }
+    },
+    "logos-module-viewer": {
+      "inputs": {
+        "logos-capability-module": "logos-capability-module_2",
+        "logos-cpp-sdk": "logos-cpp-sdk_6",
+        "logos-liblogos": "logos-liblogos_4",
+        "logos-package-manager": "logos-package-manager",
+        "nixpkgs": [
+          "logos-module-viewer",
+          "logos-liblogos",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1765396385,
+        "narHash": "sha256-sxlpjSLOutqz71SFQIXUa3aY3KUZZe/pWL6+cuIRREs=",
+        "owner": "logos-co",
+        "repo": "logos-module-viewer",
+        "rev": "a4f97447fab84e3188a30e6824e077b80dba210e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "logos-co",
+        "repo": "logos-module-viewer",
+        "type": "github"
+      }
+    },
+    "logos-package-manager": {
+      "inputs": {
+        "logos-cpp-sdk": "logos-cpp-sdk_8",
+        "logos-liblogos": "logos-liblogos_5",
+        "nixpkgs": [
+          "logos-module-viewer",
+          "logos-package-manager",
+          "logos-liblogos",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1764708254,
+        "narHash": "sha256-od3z91MNlKo8tk/BEeB0qOl5X87uTGF8+zg9IMZoBAM=",
+        "owner": "logos-co",
+        "repo": "logos-package-manager",
+        "rev": "f3a375fce2a0ddeece8d1eae525f1eefae6b7931",
+        "type": "github"
+      },
+      "original": {
+        "owner": "logos-co",
+        "repo": "logos-package-manager",
+        "type": "github"
+      }
+    },
     "nixpkgs": {
+      "locked": {
+        "lastModified": 1769461804,
+        "narHash": "sha256-msG8SU5WsBUfVVa/9RPLaymvi5bI8edTavbIq3vRlhI=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "bfc1b8a4574108ceef22f02bafcf6611380c100d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_10": {
+      "locked": {
+        "lastModified": 1759036355,
+        "narHash": "sha256-0m27AKv6ka+q270dw48KflE0LwQYrO7Fm4/2//KCVWg=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "e9f00bd893984bc8ce46c895c3bf7cac95331127",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_11": {
+      "locked": {
+        "lastModified": 1759036355,
+        "narHash": "sha256-0m27AKv6ka+q270dw48KflE0LwQYrO7Fm4/2//KCVWg=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "e9f00bd893984bc8ce46c895c3bf7cac95331127",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_12": {
       "locked": {
         "lastModified": 1759036355,
         "narHash": "sha256-0m27AKv6ka+q270dw48KflE0LwQYrO7Fm4/2//KCVWg=",
@@ -92,6 +524,118 @@
       }
     },
     "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1769461804,
+        "narHash": "sha256-msG8SU5WsBUfVVa/9RPLaymvi5bI8edTavbIq3vRlhI=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "bfc1b8a4574108ceef22f02bafcf6611380c100d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_3": {
+      "locked": {
+        "lastModified": 1759036355,
+        "narHash": "sha256-0m27AKv6ka+q270dw48KflE0LwQYrO7Fm4/2//KCVWg=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "e9f00bd893984bc8ce46c895c3bf7cac95331127",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_4": {
+      "locked": {
+        "lastModified": 1759036355,
+        "narHash": "sha256-0m27AKv6ka+q270dw48KflE0LwQYrO7Fm4/2//KCVWg=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "e9f00bd893984bc8ce46c895c3bf7cac95331127",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_5": {
+      "locked": {
+        "lastModified": 1759036355,
+        "narHash": "sha256-0m27AKv6ka+q270dw48KflE0LwQYrO7Fm4/2//KCVWg=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "e9f00bd893984bc8ce46c895c3bf7cac95331127",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_6": {
+      "locked": {
+        "lastModified": 1759036355,
+        "narHash": "sha256-0m27AKv6ka+q270dw48KflE0LwQYrO7Fm4/2//KCVWg=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "e9f00bd893984bc8ce46c895c3bf7cac95331127",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_7": {
+      "locked": {
+        "lastModified": 1759036355,
+        "narHash": "sha256-0m27AKv6ka+q270dw48KflE0LwQYrO7Fm4/2//KCVWg=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "e9f00bd893984bc8ce46c895c3bf7cac95331127",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_8": {
+      "locked": {
+        "lastModified": 1759036355,
+        "narHash": "sha256-0m27AKv6ka+q270dw48KflE0LwQYrO7Fm4/2//KCVWg=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "e9f00bd893984bc8ce46c895c3bf7cac95331127",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_9": {
       "locked": {
         "lastModified": 1759036355,
         "narHash": "sha256-0m27AKv6ka+q270dw48KflE0LwQYrO7Fm4/2//KCVWg=",
@@ -110,13 +654,35 @@
     "root": {
       "inputs": {
         "logos-blockchain": "logos-blockchain",
-        "logos-cpp-sdk": "logos-cpp-sdk",
+        "logos-core": "logos-core",
         "logos-liblogos": "logos-liblogos",
+        "logos-module-viewer": "logos-module-viewer",
         "nixpkgs": [
           "logos-liblogos",
           "nixpkgs"
         ]
       }
+    },
+    "rust-overlay": {
+      "inputs": {
+        "nixpkgs": [
+          "logos-blockchain",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1769742225,
+        "narHash": "sha256-roSD/OJ3x9nF+Dxr+/bLClX3U8FP9EkCQIFpzxKjSUM=",
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "rev": "bcdd8d37594f0e201639f55889c01c827baf5c75",
+        "type": "github"
+      },
+      "original": {
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "type": "github"
+      }
     }
   },
   "root": "root",

flake.nix

@@ -1,34 +1,51 @@
 {
-  description = "Logos Blockchain Module - Qt6 Plugin (Nix)";
+  description = "Logos Blockchain Module - Qt6 Plugin";
 
   inputs = {
     nixpkgs.follows = "logos-liblogos/nixpkgs";
-    logos-liblogos.url = "github:logos-co/logos-liblogos";
-    logos-cpp-sdk.url = "github:logos-co/logos-cpp-sdk";
 
-    logos-blockchain = {
+    logos-liblogos.url = "github:logos-co/logos-liblogos";
-      url = "github:logos-blockchain/logos-blockchain";
+    logos-core.url = "github:logos-co/logos-cpp-sdk";
-      flake = false;
+
-    };
+    logos-blockchain.url = "github:logos-blockchain/logos-blockchain?ref=ci/circuits/integrate-binaries-on-tests-using-nix";
+
+    logos-module-viewer.url = "github:logos-co/logos-module-viewer";
   };
 
-  outputs = { self, nixpkgs, logos-liblogos, logos-cpp-sdk, logos-blockchain }:
+  outputs =
+    {
+      self,
+      nixpkgs,
+      logos-core,
+      logos-blockchain,
+      logos-module-viewer,
+      ...
+    }:
     let
-      systems = [ "aarch64-darwin" "x86_64-darwin" "aarch64-linux" "x86_64-linux" ];
+      lib = nixpkgs.lib;
-      forAllSystems = f: nixpkgs.lib.genAttrs systems (system: f {
+
-        pkgs = import nixpkgs { inherit system; };
+      systems = [
-        logosSdk = logos-cpp-sdk.packages.${system}.default;
+        "x86_64-linux"
-        logosBlockchainSrc = logos-blockchain;
+        "aarch64-linux"
-      });
+        "x86_64-darwin"
+        "aarch64-darwin"
+      ];
+
+      forAll = lib.genAttrs systems;
+
+      mkPkgs = system: import nixpkgs { inherit system; };
     in
     {
-      packages = forAllSystems ({ pkgs, logosSdk, logosBlockchainSrc }:
+      packages = forAll (
+        system:
         let
-          qt = pkgs.qt6;
+          pkgs = mkPkgs system;
           llvmPkgs = pkgs.llvmPackages;
-        in
+
-        {
+          logosCore = logos-core.packages.${system}.default;
-          default = pkgs.stdenv.mkDerivation {
+          logosBlockchainC = logos-blockchain.packages.${system}.logos-blockchain-c;
+
+          logosBlockchainModule = pkgs.stdenv.mkDerivation {
             pname = "logos-blockchain-module";
             version = "dev";
             src = ./.;
@@ -37,104 +54,93 @@
               pkgs.cmake
               pkgs.ninja
               pkgs.pkg-config
-              qt.wrapQtAppsHook
+              pkgs.qt6.wrapQtAppsHook
-              pkgs.patchelf
             ];
 
             buildInputs = [
-              qt.qtbase
+              pkgs.qt6.qtbase
-              qt.qttools
+              pkgs.qt6.qtremoteobjects
-
+              pkgs.qt6.qttools
-              pkgs.rustc
-              pkgs.cargo
-              pkgs.git
-
               llvmPkgs.clang
-              llvmPkgs.llvm
               llvmPkgs.libclang
-            ] ++ pkgs.lib.optionals pkgs.stdenv.isDarwin [
+              logosBlockchainC
+            ]
+            ++ lib.optionals pkgs.stdenv.isDarwin [
               pkgs.libiconv
+              pkgs.cacert
             ];
 
-            LOGOS_CPP_SDK_ROOT = "${logosSdk}";
-            LOGOS_BLOCKCHAIN_ROOT = "${logosBlockchainSrc}";
-
             LIBCLANG_PATH = "${llvmPkgs.libclang.lib}/lib";
             CLANG_PATH = "${llvmPkgs.clang}/bin/clang";
+            SSL_CERT_FILE = lib.optionalString pkgs.stdenv.isDarwin "${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt";
 
-            CARGO_HOME = "${"$"}TMPDIR/cargo-home";
+            cmakeFlags = [
+              "-DLOGOS_CORE_ROOT=${logosCore}"
+              "-DLOGOS_BLOCKCHAIN_LIB=${logosBlockchainC}/lib"
+              "-DLOGOS_BLOCKCHAIN_INCLUDE=${logosBlockchainC}/include"
+              "-DLOGOS_MODULE_BUNDLE=OFF"
+            ];
+        };
+        in
+        {
+          logos-blockchain-module = logosBlockchainModule;
+          default = logosBlockchainModule;
+        }
+      );
 
-            configurePhase = ''
+      apps = forAll (
-              runHook preConfigure
+        system:
-              cmake -S . -B build -G Ninja \
+        let
-                -DCMAKE_BUILD_TYPE=Release \
+          pkgs = mkPkgs system;
-                -DUNTITLED_USE_QT=ON \
+          logosBlockchainModule = self.packages.${system}.logos-blockchain-module;
-                -DLOGOS_CPP_SDK_ROOT="$LOGOS_CPP_SDK_ROOT" \
+          logosModuleViewer = logos-module-viewer.packages.${system}.default;
-                -DLOGOS_BLOCKCHAIN_ROOT="$LOGOS_BLOCKCHAIN_ROOT" \
+          extension =
-                -DCOPY_PLUGIN_TO_SOURCE_DIR=OFF
+                if pkgs.stdenv.isDarwin then "dylib"
-              runHook postConfigure
+                else if pkgs.stdenv.isWindows then "dll"
-            '';
+                else "so";
-
+        in
-            buildPhase = ''
+        {
-              runHook preBuild
+          default = {
-              cmake --build build --verbose
+            type = "app";
-              runHook postBuild
+            program =
-            '';
+              "${pkgs.writeShellScriptBin "inspect-module" ''
-
+                exec ${logosModuleViewer}/bin/logos-module-viewer \
-            installPhase = ''
+                  --module ${logosBlockchainModule}/lib/liblogos-blockchain-module.${extension}
-              runHook preInstall
+              ''}/bin/inspect-module";
-              mkdir -p $out/lib $out/include
-              install -m755 build/libblockchainmodulelib.* $out/lib/
-              install -m644 ${./library.h} $out/include/library.h
-              runHook postInstall
-            '';
           };
         }
       );
 
-      devShells = forAllSystems ({ pkgs, logosSdk, logosBlockchainSrc }:
+      devShells = forAll (
+        system:
         let
-          qt = pkgs.qt6;
+          pkgs = mkPkgs system;
-          llvmPkgs = pkgs.llvmPackages;
+          pkg = self.packages.${system}.default;
+          logosCore = logos-core.packages.${system}.default;
+          logosBlockchainC = logos-blockchain.packages.${system}.logos-blockchain-c;
         in
         {
           default = pkgs.mkShell {
-            nativeBuildInputs = [
+            inputsFrom = [ pkg ];
-              pkgs.cmake
-              pkgs.ninja
-              pkgs.pkg-config
-              pkgs.patchelf
-            ];
 
-            buildInputs = [
+            inherit (pkg)
-              qt.qtbase
+              LIBCLANG_PATH
-              qt.qttools
+              CLANG_PATH;
 
-              pkgs.rustc
+            LOGOS_CORE_ROOT = "${logosCore}";
-              pkgs.cargo
+            LOGOS_BLOCKCHAIN_LIB = "${logosBlockchainC}/lib";
-              pkgs.git
+            LOGOS_BLOCKCHAIN_INCLUDE = "${logosBlockchainC}/include";
-
-              llvmPkgs.clang
-              llvmPkgs.llvm
-              llvmPkgs.libclang
-            ];
 
             shellHook = ''
-              export LOGOS_CPP_SDK_ROOT="${logosSdk}"
+              BLUE='\e[1;34m'
-              export LOGOS_BLOCKCHAIN_ROOT="${logosBlockchainSrc}"
+              GREEN='\e[1;32m'
+              RESET='\e[0m'
 
-              export LIBCLANG_PATH="${llvmPkgs.libclang.lib}/lib"
+              echo -e "\n''${BLUE}=== Logos Blockchain Module Development Environment ===''${RESET}"
-              export CLANG_PATH="${llvmPkgs.clang}/bin/clang"
+              echo -e "''${GREEN}LOGOS_CORE_ROOT:''${RESET}       $LOGOS_CORE_ROOT"
-
+              echo -e "''${GREEN}LOGOS_BLOCKCHAIN_LIB:''${RESET}  $LOGOS_BLOCKCHAIN_LIB"
-              echo "Logos Blockchain Module dev environment"
+              echo -e "''${GREEN}LOGOS_BLOCKCHAIN_INCLUDE:''${RESET} $LOGOS_BLOCKCHAIN_INCLUDE"
-              echo "LOGOS_CPP_SDK_ROOT:    $LOGOS_CPP_SDK_ROOT"
+              echo -e "''${BLUE}---------------------------------------------------------''${RESET}"
-              echo "LOGOS_BLOCKCHAIN_ROOT: $LOGOS_BLOCKCHAIN_ROOT"
-              echo "LIBCLANG_PATH:         $LIBCLANG_PATH"
-              echo "CLANG_PATH:            $CLANG_PATH"
-              echo ""
-              echo "Build with:"
-              echo "  just clean"
-              echo "  just build"
             '';
           };
         }

justfile

@@ -1,44 +1,21 @@
 default: build
 
 configure:
-    test -n "${LOGOS_CPP_SDK_ROOT}" || (echo "LOGOS_CPP_SDK_ROOT not set" && exit 1)
-    test -n "${LOGOS_BLOCKCHAIN_ROOT}" || (echo "LOGOS_BLOCKCHAIN_ROOT not set" && exit 1)
     cmake -S . -B build -G Ninja \
-      -DLOGOS_CPP_SDK_ROOT="${LOGOS_CPP_SDK_ROOT}" \
+      ${LOGOS_CORE_ROOT:+-DLOGOS_CORE_ROOT="$LOGOS_CORE_ROOT"} \
-      -DLOGOS_BLOCKCHAIN_ROOT="${LOGOS_BLOCKCHAIN_ROOT}" \
+      ${LOGOS_BLOCKCHAIN_LIB:+-DLOGOS_BLOCKCHAIN_LIB="$LOGOS_BLOCKCHAIN_LIB"} \
-      -DCOPY_PLUGIN_TO_SOURCE_DIR=ON
+      ${LOGOS_BLOCKCHAIN_INCLUDE:+-DLOGOS_BLOCKCHAIN_INCLUDE="$LOGOS_BLOCKCHAIN_INCLUDE"}
 
-build:
+build: configure
     cmake --build build --parallel --target liblogos-blockchain-module
 
-update: clean-full
-    cmake --build build --parallel --target logos_blockchain_stage
-    cmake --build build --parallel --target logos_cargo_build
-    just build
-
 clean:
-    rm -f build/liblogos-blockchain-module.so
+    rm -rf build target
-    rm -f liblogos-blockchain-module.so
-    rm -f liblogos-blockchain-module.log
-    rm -rf logos_blockchain_db/
-
-clean-full: clean
-    rm -rf build
 
 rebuild: clean configure build
 
-run:
-    RUST_BACKTRACE=full RUST_LOG=trace ../logos-module-viewer/result/bin/logos-module-viewer --module liblogos-blockchain-module.so > liblogos-blockchain-module.log 2>&1
-
 nix:
-    nix develop .#
+    nix develop
 
-# View the log with unicode characters rendered
 unicode-logs file:
-    perl -pe 's/\\u([0-9A-Fa-f]{4})/chr(hex($1))/ge' {{ file }} | less -R
+    perl -pe 's/\\u([0-9A-Fa-f]{4})/chr(hex($1))/ge' {{file}} | less -R
-
-logs:
-    just unicode-logs liblogos-blockchain-module.log
-
-logs-tail:
-    tail -f liblogos-blockchain-module.log | perl -pe 's/\\u([0-9A-Fa-f]{4})/chr(hex($1))/ge'

library.cpp

@@ -1,113 +0,0 @@
-#include "library.h"
-
-#include <QtCore/QDebug>
-#include <iostream>
-#include <QCoreApplication>
-
-
-class LogosBlockchainModule : public LogosBlockchainModuleAPI {
-    Q_OBJECT
-    Q_PLUGIN_METADATA(IID LogosBlockchainModuleInterface_iid FILE "metadata.json")
-
-private:
-    LogosBlockchainNode* node = nullptr;
-
-public:
-    LogosBlockchainModule() = default;
-
-    ~LogosBlockchainModule() override {
-        if (node) stop();
-    }
-
-    [[nodiscard]] QString name() const override { return "liblogos-blockchain-module"; }
-    [[nodiscard]] QString version() const override { return "1.0.0"; }
-
-    Q_INVOKABLE void initLogos(LogosAPI* logosAPIInstance) override {
-        logosAPI = logosAPIInstance;
-    }
-
-    Q_INVOKABLE int start(const QString& config_path) override {
-        if (node) {
-            qWarning() << "Could not execute the operation: The node is already running.";
-            return 1;
-        }
-
-        // TODO: Ensure proper cleanup on SIGINT
-
-        const QByteArray path = config_path.toUtf8();
-        auto [value, error] = start_lb_node(path.constData());
-
-        if (!is_ok(&error)) {
-            qCritical() << "Failed to start the node. Error:" << error;
-            return 2;
-        }
-
-        node = value;
-        qInfo() << "The node was started successfully.";
-        return 0;
-    }
-
-    Q_INVOKABLE int stop() override {
-        if (!node) {
-            qWarning() << "Could not execute the operation: The node is not running.";
-            return 1;
-        }
-
-        const OperationStatus status = stop_node(node);
-        if (is_ok(&status)) {
-            qInfo() << "The node was stopped successfully.";
-        } else {
-            qCritical() << "Could not stop the node. Error:" << status;
-        }
-
-        node = nullptr;
-        return 0;
-    }
-
-    Q_INVOKABLE int subscribe() override {
-        if (!node) {
-            qWarning() << "Could not execute the operation: The node is not running.";
-            return 1;
-        }
-
-        subscribe_to_new_blocks(node, [](const char* block) {
-            std::cout << "Received new block: " << block << std::endl;
-        });
-
-        return 0;
-    }
-
-    Q_INVOKABLE int wallet_get_balance(const uint8_t* wallet_address, const HeaderId* optional_tip, BalanceResult* output_balance) override {
-        if (!node) {
-            qWarning() << "Could not execute the operation: The node is not running.";
-            return 1;
-        }
-
-        auto [value, error] = get_balance(node, wallet_address, optional_tip);
-        if (!is_ok(&error)) {
-            qCritical() << "Failed to get balance. Error:" << error;
-            return 1;
-        }
-
-        output_balance->value = value;
-        return 0;
-    }
-
-    Q_INVOKABLE int wallet_transfer_funds(const TransferFundsArguments* transfer_funds_arguments, Hash* output_hash) override {
-        if (!node) {
-            qWarning() << "Could not execute the operation: The node is not running.";
-            return 1;
-        }
-
-        auto [value, error] = transfer_funds(node, transfer_funds_arguments);
-        if (!is_ok(&error)) {
-            qCritical() << "Failed to transfer funds. Error:" << error;
-            return 1;
-        }
-
-        std::ranges::copy(value, *output_hash);
-        return 0;
-    }
-};
-
-#include "library.moc"

src/i_logos_blockchain_module.h

@@ -1,23 +1,22 @@
-#ifndef LOGOS_BLOCKCHAIN_MODULE_API_H
+#ifndef I_LOGOS_BLOCKCHAIN_MODULE_API_H
-#define LOGOS_BLOCKCHAIN_MODULE_API_H
+#define I_LOGOS_BLOCKCHAIN_MODULE_API_H
 
 #include <core/interface.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include <lib_logos_blockchain.h>
+#include <logos_blockchain.h>
 #ifdef __cplusplus
 }
 #endif
 
-class LogosBlockchainModuleAPI : public QObject, public PluginInterface {
+class ILogosBlockchainModule : public QObject, public PluginInterface {
-    Q_OBJECT
     Q_INTERFACES(PluginInterface)
 
 public:
     using QObject::QObject;
-    ~LogosBlockchainModuleAPI() override = default;
+    ~ILogosBlockchainModule() override = default;
 
     // Logos Core
     Q_INVOKABLE virtual void initLogos(LogosAPI* logosAPIInstance) = 0;
@@ -33,7 +32,7 @@ public:
         void eventResponse(const QString& eventName, const QVariantList& data);
 };
 
-#define LogosBlockchainModuleInterface_iid "org.logos.blockchaininterface"
+#define ILogosBlockchainModule_iid "org.logos.ilogosblockchainmodule"
-Q_DECLARE_INTERFACE(LogosBlockchainModuleAPI, LogosBlockchainModuleInterface_iid)
+Q_DECLARE_INTERFACE(ILogosBlockchainModule, ILogosBlockchainModule_iid)
 
 #endif

src/logos_blockchain_module.cpp

@@ -0,0 +1,113 @@
+#include "logos_blockchain_module.h"
+
+#include <QtCore/QDebug>
+#include <iostream>
+
+LogosBlockchainModule::LogosBlockchainModule() = default;
+
+LogosBlockchainModule::~LogosBlockchainModule() {
+    if (node) {
+        stop();
+    }
+}
+
+QString LogosBlockchainModule::name() const {
+    return "liblogos-blockchain-module";
+}
+
+QString LogosBlockchainModule::version() const {
+    return "1.0.0";
+}
+
+void LogosBlockchainModule::initLogos(LogosAPI* logosAPIInstance) {
+    logosAPI = logosAPIInstance;
+}
+
+int LogosBlockchainModule::start(const QString& config_path) {
+    if (node) {
+        qWarning() << "Could not execute the operation: The node is already running.";
+        return 1;
+    }
+
+    const QByteArray path = config_path.toUtf8();
+    const char* deployment = nullptr;
+
+    auto [value, error] = start_lb_node(path.constData(), deployment);
+    if (!is_ok(&error)) {
+        qCritical() << "Failed to start the node. Error:" << error;
+        return 2;
+    }
+
+    node = value;
+    qInfo() << "The node was started successfully.";
+    return 0;
+}
+
+int LogosBlockchainModule::stop() {
+    if (!node) {
+        qWarning() << "Could not execute the operation: The node is not running.";
+        return 1;
+    }
+
+    const OperationStatus status = stop_node(node);
+    if (is_ok(&status)) {
+        qInfo() << "The node was stopped successfully.";
+    } else {
+        qCritical() << "Could not stop the node. Error:" << status;
+    }
+
+    node = nullptr;
+    return 0;
+}
+
+int LogosBlockchainModule::subscribe() {
+    if (!node) {
+        qWarning() << "Could not execute the operation: The node is not running.";
+        return 1;
+    }
+
+    subscribe_to_new_blocks(node, [](const char* block) {
+        std::cout << "Received new block: " << block << std::endl;
+    });
+
+    return 0;
+}
+
+int LogosBlockchainModule::wallet_get_balance(
+    const uint8_t* wallet_address,
+    const HeaderId* optional_tip,
+    BalanceResult* output_balance
+) {
+    if (!node) {
+        qWarning() << "Could not execute the operation: The node is not running.";
+        return 1;
+    }
+
+    auto [value, error] = get_balance(node, wallet_address, optional_tip);
+    if (!is_ok(&error)) {
+        qCritical() << "Failed to get balance. Error:" << error;
+        return 1;
+    }
+
+    output_balance->value = value;
+    return 0;
+}
+
+int LogosBlockchainModule::wallet_transfer_funds(
+    const TransferFundsArguments* transfer_funds_arguments,
+    Hash* output_hash
+) {
+    if (!node) {
+        qWarning() << "Could not execute the operation: The node is not running.";
+        return 1;
+    }
+
+    auto [value, error] = transfer_funds(node, transfer_funds_arguments);
+    if (!is_ok(&error)) {
+        qCritical() << "Failed to transfer funds. Error:" << error;
+        return 1;
+    }
+
+    std::ranges::copy(value, *output_hash);
+    return 0;
+}

src/logos_blockchain_module.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "i_logos_blockchain_module.h"
+
+class LogosBlockchainModule final : public ILogosBlockchainModule {
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID ILogosBlockchainModule_iid FILE "../metadata.json")
+
+public:
+    LogosBlockchainModule();
+    ~LogosBlockchainModule() override;
+
+    [[nodiscard]] QString name() const override;
+    [[nodiscard]] QString version() const override;
+
+    Q_INVOKABLE void initLogos(LogosAPI*) override;
+    Q_INVOKABLE int start(const QString&) override;
+    Q_INVOKABLE int stop() override;
+    Q_INVOKABLE int subscribe() override;
+    Q_INVOKABLE int wallet_get_balance(const uint8_t*, const HeaderId*, BalanceResult*) override;
+    Q_INVOKABLE int wallet_transfer_funds(const TransferFundsArguments*, Hash*) override;
+
+private:
+    LogosBlockchainNode* node = nullptr;
+};