logos-blockchain/logos-blockchain-module
1
0
Fork 0
mirror of https://github.com/logos-blockchain/logos-blockchain-module.git synced 2026-07-14 02:59:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master' into feat/list-claimable-vouchers

Browse Source 
# Conflicts:
#	flake.lock
#	flake.nix
This commit is contained in:
Daniel 2026-06-18 15:46:11 +02:00
commit ea694d8b59
6 changed files with 718 additions and 437 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

936
flake.lock generated
View File

File diff suppressed because it is too large Load Diff

5
flake.nix
View File

@ -2,8 +2,9 @@
description = "Logos Blockchain Module - Qt6 Plugin";
inputs = {
logos-module-builder.url = "github:logos-co/logos-module-builder";
logos-blockchain.url = "github:logos-blockchain/logos-blockchain?rev=93b44bd9ff277546df240ca857a20003da953409"; # claimable vouchers C binding
logos-module-builder.url = "github:logos-co/logos-module-builder?ref=bc868bf47f9d797637ac78af814b0db718dde4b8";
# v0.1.3-rc.10-compatible + rust-rapidsnark nix fixes + cli commands + leader_claim C binding + config generation fixes
logos-blockchain.url = "github:logos-blockchain/logos-blockchain?ref=3dc81b4ec49ba977220f3ff432885258265aa986";
};
outputs = inputs@{ logos-module-builder, ... }:

129
src/logos_blockchain_module.cpp
View File

@ -82,10 +82,10 @@ namespace {
uint16_t blend_port_val;
std::string http_addr_data;
std::string external_address_data;
bool no_public_ip_check_val;
std::string custom_deployment_config_path_data;
Deployment deployment_val{};
std::string state_path_data;
bool ibd_val;
std::string log_filter_data;
std::string kms_file_data;
// The FFI struct with pointers into owned data
GenerateConfigArgs ffi_args{};
@ -150,39 +150,6 @@ namespace {
ffi_args.external_address = nullptr;
}
// no_public_ip_check (bool -> const bool*)
if (args.contains("no_public_ip_check") && args["no_public_ip_check"].is_boolean()) {
no_public_ip_check_val = args["no_public_ip_check"].get<bool>();
ffi_args.no_public_ip_check = &no_public_ip_check_val;
} else {
ffi_args.no_public_ip_check = nullptr;
}
// deployment (const struct Deployment*)
// Expected format: { "deployment": { "well_known_deployment": "devnet" } }
// OR: { "deployment": { "config_path": "/path/to/config" } }
if (args.contains("deployment") && args["deployment"].is_object()) {
const auto& deployment = args["deployment"];
if (deployment.contains("well_known_deployment") && deployment["well_known_deployment"].is_string()) {
deployment_val.deployment_type = DeploymentType::WellKnown;
const std::string wellknown = deployment["well_known_deployment"].get<std::string>();
if (wellknown == "devnet") {
deployment_val.well_known_deployment = WellKnownDeployment::Devnet;
}
deployment_val.custom_deployment_config_path = nullptr;
} else if (deployment.contains("config_path") && deployment["config_path"].is_string()) {
deployment_val.deployment_type = DeploymentType::Custom;
deployment_val.well_known_deployment = static_cast<WellKnownDeployment>(0);
custom_deployment_config_path_data = deployment["config_path"].get<std::string>();
deployment_val.custom_deployment_config_path = custom_deployment_config_path_data.c_str();
}
ffi_args.deployment = &deployment_val;
} else {
ffi_args.deployment = nullptr;
}
// state_path (string -> const char*)
if (args.contains("state_path") && args["state_path"].is_string()) {
state_path_data = args["state_path"].get<std::string>();
@ -190,6 +157,30 @@ namespace {
} else {
ffi_args.state_path = nullptr;
}
// ibd (bool -> const bool*)
if (args.contains("ibd") && args["ibd"].is_boolean()) {
ibd_val = args["ibd"].get<bool>();
ffi_args.ibd = &ibd_val;
} else {
ffi_args.ibd = nullptr;
}
// log_filter (string -> const char*)
if (args.contains("log_filter") && args["log_filter"].is_string()) {
log_filter_data = args["log_filter"].get<std::string>();
ffi_args.log_filter = log_filter_data.c_str();
} else {
ffi_args.log_filter = nullptr;
}
// kms_file (string -> const char*)
if (args.contains("kms_file") && args["kms_file"].is_string()) {
kms_file_data = args["kms_file"].get<std::string>();
ffi_args.kms_file = kms_file_data.c_str();
} else {
ffi_args.kms_file = nullptr;
}
}
};
} // namespace
@ -247,13 +238,13 @@ LogosBlockchainModule::~LogosBlockchainModule() {
// Lifecycle
int LogosBlockchainModule::generate_user_config(const std::string& json_args) {
std::string LogosBlockchainModule::generate_user_config(const std::string& json_args) {
json parsed_args;
try {
parsed_args = json::parse(json_args);
} catch (const json::parse_error& e) {
fprintf(stderr, "Failed to parse JSON args: %s\n", e.what());
return 1;
return "1";
}
const OwnedGenerateConfigArgs owned_args(parsed_args);
@ -261,16 +252,16 @@ int LogosBlockchainModule::generate_user_config(const std::string& json_args) {
const OperationStatus status = ::generate_user_config(owned_args.ffi_args);
if (!is_ok(&status)) {
fprintf(stderr, "Failed to generate user config. Error: %d\n", status);
return 1;
return "1";
}
return 0;
return "0";
}
int LogosBlockchainModule::start(const std::string& config_path, const std::string& deployment) {
std::string LogosBlockchainModule::start(const std::string& config_path, const std::string& deployment) {
if (node) {
fprintf(stderr, "Could not execute the operation: The node is already running.\n");
return 1;
return "1";
}
const char* module_path_env = std::getenv("LOGOS_MODULE_PATH");
@ -289,7 +280,7 @@ int LogosBlockchainModule::start(const std::string& config_path, const std::stri
fprintf(stderr, "Using config from LB_CONFIG_PATH: %s\n", effective_config_path.c_str());
} else {
fprintf(stderr, "Config path was not specified and LB_CONFIG_PATH is not set.\n");
return 3;
return "3";
}
}
@ -303,7 +294,7 @@ int LogosBlockchainModule::start(const std::string& config_path, const std::stri
fprintf(stderr, "Start node returned with value and error.\n");
if (!is_ok(&error)) {
fprintf(stderr, "Failed to start the node. Error: %d\n", error);
return 4;
return "4";
}
node = value;
@ -311,23 +302,23 @@ int LogosBlockchainModule::start(const std::string& config_path, const std::stri
if (!node) {
fprintf(stderr, "Could not subscribe to block events: The node is not running.\n");
return 4;
return "4";
}
s_instance = this;
const OperationStatus subscribe_status = subscribe_to_new_blocks(node, on_new_block_callback);
if (!is_ok(&subscribe_status)) {
fprintf(stderr, "Failed to subscribe to new blocks. Error: %d\n", subscribe_status);
return 5;
return "5";
}
return 0;
return "0";
}
int LogosBlockchainModule::stop() {
std::string LogosBlockchainModule::stop() {
if (!node) {
fprintf(stderr, "Could not execute the operation: The node is not running.\n");
return 1;
return "1";
}
s_instance = nullptr;
@ -340,36 +331,36 @@ int LogosBlockchainModule::stop() {
}
node = nullptr;
return 0;
return "0";
}
// Config management
int LogosBlockchainModule::update_user_config(const std::string& user_config_path, const std::string& keystore_path) {
std::string LogosBlockchainModule::update_user_config(const std::string& user_config_path, const std::string& keystore_path) {
const std::string config = localPathFromFileUrl(user_config_path);
const std::string keystore = localPathFromFileUrl(keystore_path);
const OperationStatus status = ::update_user_config(config.c_str(), keystore.c_str());
if (!is_ok(&status)) {
fprintf(stderr, "Failed to update user config. Error: %d\n", status);
return 1;
return "1";
}
return 0;
return "0";
}
int LogosBlockchainModule::migrate_user_config(const std::string& output_path, const std::string& keystore_path) {
std::string LogosBlockchainModule::migrate_user_config(const std::string& output_path, const std::string& keystore_path) {
const std::string output = localPathFromFileUrl(output_path);
const std::string keystore = localPathFromFileUrl(keystore_path);
const OperationStatus status = ::migrate_user_config(output.c_str(), keystore.c_str());
if (!is_ok(&status)) {
fprintf(stderr, "Failed to migrate user config. Error: %d\n", status);
return 1;
return "1";
}
return 0;
return "0";
}
int LogosBlockchainModule::migrate_user_config_0_1_2(
std::string LogosBlockchainModule::migrate_user_config_0_1_2(
const std::string& new_config_path,
const std::string& old_config_path,
const std::string& keystore_path
@ -382,12 +373,12 @@ int LogosBlockchainModule::migrate_user_config_0_1_2(
::migrate_user_config_0_1_2(new_config.c_str(), old_config.c_str(), keystore.c_str());
if (!is_ok(&status)) {
fprintf(stderr, "Failed to migrate 0.1.2 config. Error: %d\n", status);
return 1;
return "1";
}
return 0;
return "0";
}
int LogosBlockchainModule::participate(
std::string LogosBlockchainModule::participate(
const std::string& config_path,
const std::string& keystore_path,
const std::string& output_dir,
@ -402,9 +393,9 @@ int LogosBlockchainModule::participate(
::participate(config.c_str(), keystore.c_str(), output.c_str(), external_address_ptr);
if (!is_ok(&status)) {
fprintf(stderr, "Failed to generate participation data. Error: %d\n", status);
return 1;
return "1";
}
return 0;
return "0";
}
// Keystore
@ -438,7 +429,7 @@ std::string LogosBlockchainModule::generate_key(
return result;
}
int LogosBlockchainModule::add_key(
std::string LogosBlockchainModule::add_key(
const std::string& user_config_path,
const std::string& keystore_path,
const std::string& key_type,
@ -448,7 +439,7 @@ int LogosBlockchainModule::add_key(
KeyType type{};
if (!parse_key_type(key_type, type)) {
fprintf(stderr, "Invalid key_type (expected \"ed25519\" or \"zk\").\n");
return 1;
return "1";
}
const std::string config = localPathFromFileUrl(user_config_path);
@ -459,12 +450,12 @@ int LogosBlockchainModule::add_key(
::add_key(config.c_str(), keystore.c_str(), type, key_hex.c_str(), key_title_ptr);
if (!is_ok(&status)) {
fprintf(stderr, "Failed to add key. Error: %d\n", status);
return 1;
return "1";
}
return 0;
return "0";
}
int LogosBlockchainModule::remove_key(
std::string LogosBlockchainModule::remove_key(
const std::string& user_config_path,
const std::string& keystore_path,
const std::string& key_title
@ -475,9 +466,9 @@ int LogosBlockchainModule::remove_key(
const OperationStatus status = ::remove_key(config.c_str(), keystore.c_str(), key_title.c_str());
if (!is_ok(&status)) {
fprintf(stderr, "Failed to remove key. Error: %d\n", status);
return 1;
return "1";
}
return 0;
return "0";
}
// Identity

18
src/logos_blockchain_module.h
View File

@ -22,19 +22,19 @@ public:
// ---- Node ----
// Lifecycle
int generate_user_config(const std::string& json_args);
int start(const std::string& config_path, const std::string& deployment);
int stop();
std::string generate_user_config(const std::string& json_args);
std::string start(const std::string& config_path, const std::string& deployment);
std::string stop();
// Config management
int update_user_config(const std::string& user_config_path, const std::string& keystore_path);
int migrate_user_config(const std::string& output_path, const std::string& keystore_path);
int migrate_user_config_0_1_2(
std::string update_user_config(const std::string& user_config_path, const std::string& keystore_path);
std::string migrate_user_config(const std::string& output_path, const std::string& keystore_path);
std::string migrate_user_config_0_1_2(
const std::string& new_config_path,
const std::string& old_config_path,
const std::string& keystore_path
);
int participate(
std::string participate(
const std::string& config_path,
const std::string& keystore_path,
const std::string& output_dir,
@ -49,14 +49,14 @@ public:
const std::string& key_type,
const std::string& key_title
);
int add_key(
std::string add_key(
const std::string& user_config_path,
const std::string& keystore_path,
const std::string& key_type,
const std::string& key_hex,
const std::string& key_title
);
int remove_key(
std::string remove_key(
const std::string& user_config_path,
const std::string& keystore_path,
const std::string& key_title

16
tests/stubs/logos_blockchain.h
View File

@ -23,23 +23,12 @@ typedef struct LogosBlockchainNode LogosBlockchainNode;
// Operation status (0 = OK)
typedef int OperationStatus;
// Deployment enums
typedef enum { WellKnown, Custom } DeploymentType;
typedef enum { Devnet } WellKnownDeployment;
// Consensus state enum
typedef enum { Bootstrapping, Online } State;
// Key type for generate_key / add_key
typedef enum { Ed25519, Zk } KeyType;
// Deployment configuration
typedef struct {
DeploymentType deployment_type;
WellKnownDeployment well_known_deployment;
const char* custom_deployment_config_path;
} Deployment;
// Arguments for generate_user_config
typedef struct {
const char** initial_peers;
@ -49,9 +38,10 @@ typedef struct {
const uint16_t* blend_port;
const char* http_addr;
const char* external_address;
const bool* no_public_ip_check;
const Deployment* deployment;
const char* state_path;
const bool* ibd;
const char* log_filter;
const char* kms_file;
} GenerateConfigArgs;
// Arguments for transfer_funds

51
tests/test_blockchain.cpp
View File

@ -59,8 +59,8 @@ static LogosBlockchainModule* createStartedModule(LogosTestContext& t, TempDir&
t.mockCFunction("start_lb_node").returns(1);
t.mockCFunction("subscribe_to_new_blocks").returns(0);
int rc = module->start(tmpDir.filePath("config.json"), "");
if (rc != 0) {
std::string rc = module->start(tmpDir.filePath("config.json"), "");
if (rc != "0") {
delete module;
return nullptr;
}
@ -77,7 +77,7 @@ LOGOS_TEST(generate_user_config_returns_0_on_success) {
t.mockCFunction("generate_user_config").returns(0);
LOGOS_ASSERT_EQ(module.generate_user_config(R"({"output":"/tmp/test-config.json"})"), 0);
LOGOS_ASSERT_EQ(module.generate_user_config(R"({"output":"/tmp/test-config.json"})"), std::string("0"));
LOGOS_ASSERT(t.cFunctionCalled("generate_user_config"));
}
@ -87,7 +87,7 @@ LOGOS_TEST(generate_user_config_returns_1_on_failure) {
t.mockCFunction("generate_user_config").returns(1);
LOGOS_ASSERT_EQ(module.generate_user_config("{}"), 1);
LOGOS_ASSERT_EQ(module.generate_user_config("{}"), std::string("1"));
}
LOGOS_TEST(generate_user_config_from_json_string) {
@ -96,7 +96,7 @@ LOGOS_TEST(generate_user_config_from_json_string) {
t.mockCFunction("generate_user_config").returns(0);
LOGOS_ASSERT_EQ(module.generate_user_config(R"({"output":"/tmp/out.json"})"), 0);
LOGOS_ASSERT_EQ(module.generate_user_config(R"({"output":"/tmp/out.json"})"), std::string("0"));
LOGOS_ASSERT(t.cFunctionCalled("generate_user_config"));
}
@ -113,12 +113,13 @@ LOGOS_TEST(generate_user_config_with_all_fields) {
"blend_port": 9001,
"http_addr": "0.0.0.0:8080",
"external_address": "1.2.3.4",
"no_public_ip_check": true,
"deployment": { "well_known_deployment": "devnet" },
"state_path": "/tmp/state"
"state_path": "/tmp/state",
"ibd": true,
"log_filter": "warn,logos_blockchain=debug",
"kms_file": "/tmp/kms.yaml"
})";
LOGOS_ASSERT_EQ(module.generate_user_config(args), 0);
LOGOS_ASSERT_EQ(module.generate_user_config(args), std::string("0"));
}
// ============================================================================
@ -128,7 +129,7 @@ LOGOS_TEST(generate_user_config_with_all_fields) {
LOGOS_TEST(stop_without_node_returns_1) {
auto t = LogosTestContext("blockchain_module");
LogosBlockchainModule module;
LOGOS_ASSERT_EQ(module.stop(), 1);
LOGOS_ASSERT_EQ(module.stop(), std::string("1"));
}
LOGOS_TEST(wallet_get_balance_without_node_returns_error) {
@ -215,7 +216,7 @@ LOGOS_TEST(start_returns_1_when_already_running) {
auto* module = createStartedModule(t, tmpDir);
LOGOS_ASSERT_TRUE(module != nullptr);
LOGOS_ASSERT_EQ(module->start("/tmp/config.json", ""), 1);
LOGOS_ASSERT_EQ(module->start("/tmp/config.json", ""), std::string("1"));
delete module;
}
@ -225,7 +226,7 @@ LOGOS_TEST(stop_succeeds_with_running_node) {
auto* module = createStartedModule(t, tmpDir);
LOGOS_ASSERT_TRUE(module != nullptr);
LOGOS_ASSERT_EQ(module->stop(), 0);
LOGOS_ASSERT_EQ(module->stop(), std::string("0"));
LOGOS_ASSERT(t.cFunctionCalled("stop_node"));
delete module;
}
@ -810,7 +811,7 @@ LOGOS_TEST(update_user_config_returns_0_on_success) {
t.mockCFunction("update_user_config").returns(0);
LOGOS_ASSERT_EQ(module.update_user_config("/tmp/config.yaml", "/tmp/keystore.yaml"), 0);
LOGOS_ASSERT_EQ(module.update_user_config("/tmp/config.yaml", "/tmp/keystore.yaml"), std::string("0"));
LOGOS_ASSERT(t.cFunctionCalled("update_user_config"));
}
@ -820,7 +821,7 @@ LOGOS_TEST(update_user_config_returns_1_on_failure) {
t.mockCFunction("update_user_config").returns(1);
LOGOS_ASSERT_EQ(module.update_user_config("/tmp/config.yaml", "/tmp/keystore.yaml"), 1);
LOGOS_ASSERT_EQ(module.update_user_config("/tmp/config.yaml", "/tmp/keystore.yaml"), std::string("1"));
}
LOGOS_TEST(migrate_user_config_returns_0_on_success) {
@ -829,7 +830,7 @@ LOGOS_TEST(migrate_user_config_returns_0_on_success) {
t.mockCFunction("migrate_user_config").returns(0);
LOGOS_ASSERT_EQ(module.migrate_user_config("/tmp/out.yaml", "/tmp/keystore.yaml"), 0);
LOGOS_ASSERT_EQ(module.migrate_user_config("/tmp/out.yaml", "/tmp/keystore.yaml"), std::string("0"));
LOGOS_ASSERT(t.cFunctionCalled("migrate_user_config"));
}
@ -839,7 +840,7 @@ LOGOS_TEST(migrate_user_config_returns_1_on_failure) {
t.mockCFunction("migrate_user_config").returns(1);
LOGOS_ASSERT_EQ(module.migrate_user_config("/tmp/out.yaml", "/tmp/keystore.yaml"), 1);
LOGOS_ASSERT_EQ(module.migrate_user_config("/tmp/out.yaml", "/tmp/keystore.yaml"), std::string("1"));
}
LOGOS_TEST(migrate_user_config_0_1_2_returns_0_on_success) {
@ -848,7 +849,7 @@ LOGOS_TEST(migrate_user_config_0_1_2_returns_0_on_success) {
t.mockCFunction("migrate_user_config_0_1_2").returns(0);
LOGOS_ASSERT_EQ(module.migrate_user_config_0_1_2("/tmp/new.yaml", "/tmp/old.yaml", "/tmp/keystore.yaml"), 0);
LOGOS_ASSERT_EQ(module.migrate_user_config_0_1_2("/tmp/new.yaml", "/tmp/old.yaml", "/tmp/keystore.yaml"), std::string("0"));
LOGOS_ASSERT(t.cFunctionCalled("migrate_user_config_0_1_2"));
}
@ -858,7 +859,7 @@ LOGOS_TEST(migrate_user_config_0_1_2_returns_1_on_failure) {
t.mockCFunction("migrate_user_config_0_1_2").returns(1);
LOGOS_ASSERT_EQ(module.migrate_user_config_0_1_2("/tmp/new.yaml", "/tmp/old.yaml", "/tmp/keystore.yaml"), 1);
LOGOS_ASSERT_EQ(module.migrate_user_config_0_1_2("/tmp/new.yaml", "/tmp/old.yaml", "/tmp/keystore.yaml"), std::string("1"));
}
LOGOS_TEST(participate_returns_0_on_success) {
@ -867,7 +868,7 @@ LOGOS_TEST(participate_returns_0_on_success) {
t.mockCFunction("participate").returns(0);
LOGOS_ASSERT_EQ(module.participate("/tmp/config.yaml", "/tmp/keystore.yaml", "/tmp/out", ""), 0);
LOGOS_ASSERT_EQ(module.participate("/tmp/config.yaml", "/tmp/keystore.yaml", "/tmp/out", ""), std::string("0"));
LOGOS_ASSERT(t.cFunctionCalled("participate"));
}
@ -877,7 +878,7 @@ LOGOS_TEST(participate_returns_1_on_failure) {
t.mockCFunction("participate").returns(1);
LOGOS_ASSERT_EQ(module.participate("/tmp/config.yaml", "/tmp/keystore.yaml", "/tmp/out", "1.2.3.4"), 1);
LOGOS_ASSERT_EQ(module.participate("/tmp/config.yaml", "/tmp/keystore.yaml", "/tmp/out", "1.2.3.4"), std::string("1"));
}
// ============================================================================
@ -934,7 +935,7 @@ LOGOS_TEST(add_key_returns_0_on_success) {
t.mockCFunction("add_key").returns(0);
LOGOS_ASSERT_EQ(module.add_key("/tmp/config.yaml", "/tmp/keystore.yaml", "ed25519", VALID_HEX, ""), 0);
LOGOS_ASSERT_EQ(module.add_key("/tmp/config.yaml", "/tmp/keystore.yaml", "ed25519", VALID_HEX, ""), std::string("0"));
LOGOS_ASSERT(t.cFunctionCalled("add_key"));
}
@ -942,7 +943,7 @@ LOGOS_TEST(add_key_rejects_invalid_key_type) {
auto t = LogosTestContext("blockchain_module");
LogosBlockchainModule module;
LOGOS_ASSERT_EQ(module.add_key("/tmp/config.yaml", "/tmp/keystore.yaml", "bogus", VALID_HEX, ""), 1);
LOGOS_ASSERT_EQ(module.add_key("/tmp/config.yaml", "/tmp/keystore.yaml", "bogus", VALID_HEX, ""), std::string("1"));
LOGOS_ASSERT_FALSE(t.cFunctionCalled("add_key"));
}
@ -952,7 +953,7 @@ LOGOS_TEST(add_key_returns_1_on_failure) {
t.mockCFunction("add_key").returns(1);
LOGOS_ASSERT_EQ(module.add_key("/tmp/config.yaml", "/tmp/keystore.yaml", "zk", VALID_HEX, "title"), 1);
LOGOS_ASSERT_EQ(module.add_key("/tmp/config.yaml", "/tmp/keystore.yaml", "zk", VALID_HEX, "title"), std::string("1"));
}
LOGOS_TEST(remove_key_returns_0_on_success) {
@ -961,7 +962,7 @@ LOGOS_TEST(remove_key_returns_0_on_success) {
t.mockCFunction("remove_key").returns(0);
LOGOS_ASSERT_EQ(module.remove_key("/tmp/config.yaml", "/tmp/keystore.yaml", "my-key"), 0);
LOGOS_ASSERT_EQ(module.remove_key("/tmp/config.yaml", "/tmp/keystore.yaml", "my-key"), std::string("0"));
LOGOS_ASSERT(t.cFunctionCalled("remove_key"));
}
@ -971,7 +972,7 @@ LOGOS_TEST(remove_key_returns_1_on_failure) {
t.mockCFunction("remove_key").returns(1);
LOGOS_ASSERT_EQ(module.remove_key("/tmp/config.yaml", "/tmp/keystore.yaml", "my-key"), 1);
LOGOS_ASSERT_EQ(module.remove_key("/tmp/config.yaml", "/tmp/keystore.yaml", "my-key"), std::string("1"));
}
// ============================================================================