feat: add missing ffi impl wrappers (#57)

* Update and simplify join blend method

* Update and simplify join blend method

* Update refs from latest ffi

* Fix commit version

CMakeLists.txt

@@ -9,7 +9,7 @@ endif()
 
 # Universal module — generated_code/ is picked up automatically by LogosModule.cmake
 logos_module(
-    NAME liblogos_blockchain_module
+    NAME blockchain_module
     SOURCES
         src/logos_blockchain_module.h
         src/logos_blockchain_module.cpp

flake.nix

@@ -2,9 +2,8 @@
   description = "Logos Blockchain Module - Qt6 Plugin";
 
   inputs = {
-    logos-module-builder.url = "github:logos-co/logos-module-builder?ref=38ddf92c1f240f4e420d300a1fbabb1609d5db01";
-    # https://github.com/logos-blockchain/logos-blockchain/commit/58d71393cb7c5e8d425f54b09f2f28e0d9905fdc
-    logos-blockchain.url = "github:logos-blockchain/logos-blockchain?ref=58d71393cb7c5e8d425f54b09f2f28e0d9905fdc";
+    logos-module-builder.url = "github:logos-co/logos-module-builder/0.2.4";
+    logos-blockchain.url = "github:logos-blockchain/logos-blockchain?ref=133570d58a141629a0c751fdf4412a66898acac2";
   };
 
   outputs = inputs@{ logos-module-builder, ... }:

justfile

@@ -7,7 +7,7 @@ configure:
     cmake -S . -B build -G Ninja -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
 
 build: configure
-    cmake --build build --parallel --target liblogos_blockchain_module_module_plugin
+    cmake --build build --parallel --target blockchain_module_module_plugin
 
 clean:
     rm -rf build result

metadata.json

@@ -1,7 +1,7 @@
 {
-  "name": "liblogos_blockchain_module",
+  "name": "blockchain_module",
   "display_name": "Blockchain Module",
-  "version": "1.0.0",
+  "version": "0.0.999",
   "description": "Logos blockchain node for logos-core",
   "author": "Logos Blockchain Team",
   "type": "core",
@@ -11,16 +11,16 @@
     "impl_class": "LogosBlockchainModule"
   },
   "category": "blockchain",
-  "main": "liblogos_blockchain_module_plugin",
+  "main": "blockchain_module_plugin",
   "dependencies": [],
   "capabilities": [],
   "include": [
     "liblogos_blockchain.dylib",
     "liblogos_blockchain.so",
     "liblogos_blockchain.dll",
-    "liblogos_blockchain_module_plugin.dylib",
-    "liblogos_blockchain_module_plugin.so",
-    "liblogos_blockchain_module_plugin.dll"
+    "blockchain_module_plugin.dylib",
+    "blockchain_module_plugin.so",
+    "blockchain_module_plugin.dll"
   ],
 
   "nix": {

src/logos_blockchain_module.cpp

@@ -17,6 +17,19 @@ using json = nlohmann::json;
 // Define static member
 LogosBlockchainModule* LogosBlockchainModule::s_instance = nullptr;
 
+namespace operation_status {
+    // Takes the Rust-allocated message out of an OperationStatus and frees it.
+    std::string take_message(OperationStatus& status) {
+        std::string message;
+        if (status.message) {
+            message = status.message;
+            (void)free_cstring(status.message);
+            status.message = nullptr;
+        }
+        return message;
+    }
+} // namespace operation_status
+
 // Shorthands for building StdLogosResult values.
 namespace result {
     StdLogosResult ok() {
@@ -31,6 +44,13 @@ namespace result {
     StdLogosResult err(std::string message) {
         return {false, {}, std::move(message)};
     }
+
+    StdLogosResult from_operation_status(OperationStatus& status) {
+        if (is_ok(&status)) {
+            return ok();
+        }
+        return err(operation_status::take_message(status));
+    }
 } // namespace result
 
 namespace {
@@ -124,7 +144,7 @@ namespace {
         std::string state_path_data;
         std::string storage_path_data;
         std::string logs_path_data;
-        bool ibd_val;
+        bool skip_ibd_val;
         std::string log_filter_data;
         std::string kms_file_data;
 
@@ -215,12 +235,12 @@ namespace {
                 ffi_args.logs_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;
+            // skip_ibd (bool -> const bool*)
+            if (args.contains("skip_ibd") && args["skip_ibd"].is_boolean()) {
+                skip_ibd_val = args["skip_ibd"].get<bool>();
+                ffi_args.skip_ibd = &skip_ibd_val;
             } else {
-                ffi_args.ibd = nullptr;
+                ffi_args.skip_ibd = nullptr;
             }
 
             // log_filter (string -> const char*)
@@ -243,15 +263,45 @@ namespace {
 } // namespace
 
 void LogosBlockchainModule::on_new_block_callback(const char* block) {
-    if (s_instance) {
-        fprintf(stderr, "Received new block: %s\n", block);
-        json j;
-        j["block"] = std::string(block);
-        s_instance->newBlock(j.dump());
-        // SAFETY:
-        // We are getting an owned pointer here which is freed after this callback is called, so there is no need to
-        // free the resource here as we are copying the data!
+    if (!s_instance || !block) {
+        return;
     }
+    fprintf(stderr, "Received new block: %s\n", block);
+    json j;
+    j["block"] = std::string(block);
+    s_instance->newBlock(j.dump());
+    // SAFETY:
+    // We are getting an owned pointer here which is freed after this callback is called, so there is no need to
+    // free the resource here as we are copying the data!
+}
+
+// The stream callbacks pass the FFI's JSON through unwrapped (it is already a
+// complete JSON document with the node's HTTP stream schema). A NULL pointer
+// means the stream ended; it is forwarded as the JSON literal `null` so
+// termination stays in-band on the same event.
+
+void LogosBlockchainModule::on_processed_block_callback(const char* event) {
+    if (!s_instance) {
+        return;
+    }
+    if (!event) {
+        fprintf(stderr, "Processed block stream ended.\n");
+        s_instance->processedBlock("null");
+        return;
+    }
+    s_instance->processedBlock(std::string(event));
+}
+
+void LogosBlockchainModule::on_lib_block_callback(const char* event) {
+    if (!s_instance) {
+        return;
+    }
+    if (!event) {
+        fprintf(stderr, "LIB block stream ended.\n");
+        s_instance->libBlock("null");
+        return;
+    }
+    s_instance->libBlock(std::string(event));
 }
 
 LogosBlockchainModule::LogosBlockchainModule() {
@@ -269,7 +319,7 @@ LogosBlockchainModule::~LogosBlockchainModule() {
 
 // Lifecycle
 
-StdLogosResult LogosBlockchainModule::generate_user_config(const std::string& json_args) {
+StdLogosResult LogosBlockchainModule::generate_user_config(const std::string& json_args) const {
     json parsed_args;
     try {
         parsed_args = json::parse(json_args);
@@ -287,8 +337,7 @@ StdLogosResult LogosBlockchainModule::generate_user_config(const std::string& js
     // standalone callers omit the flag and keep their own paths (or the node
     // defaults). Any path the caller set explicitly is left untouched.
     bool use_persistence_paths = false;
-    if (const auto it = parsed_args.find("use_persistence_paths");
-        it != parsed_args.end() && it->is_boolean()) {
+    if (const auto it = parsed_args.find("use_persistence_paths"); it != parsed_args.end() && it->is_boolean()) {
         use_persistence_paths = it->get<bool>();
     }
     parsed_args.erase("use_persistence_paths"); // not an FFI field
@@ -299,9 +348,8 @@ StdLogosResult LogosBlockchainModule::generate_user_config(const std::string& js
             const fs::path base(persistence);
             // Only fill a path the caller didn't pin (non-empty string wins).
             const auto set_if_absent = [&parsed_args](const char* key, const std::string& value) {
-                const bool provided = parsed_args.contains(key)
-                    && parsed_args[key].is_string()
-                    && !parsed_args[key].get<std::string>().empty();
+                const bool provided = parsed_args.contains(key) && parsed_args[key].is_string() &&
+                                      !parsed_args[key].get<std::string>().empty();
                 if (!provided)
                     parsed_args[key] = value;
             };
@@ -316,8 +364,8 @@ StdLogosResult LogosBlockchainModule::generate_user_config(const std::string& js
             // as relative to the base; a missing output defaults to
             // "<base>/user_config.yaml".
             fs::path output_rel = "user_config.yaml";
-            if (parsed_args.contains("output") && parsed_args["output"].is_string()
-                && !parsed_args["output"].get<std::string>().empty()) {
+            if (parsed_args.contains("output") && parsed_args["output"].is_string() &&
+                !parsed_args["output"].get<std::string>().empty()) {
                 const fs::path given(localPathFromFileUrl(parsed_args["output"].get<std::string>()));
                 const fs::path rel = given.relative_path();
                 output_rel = rel.empty() ? given.filename() : rel;
@@ -334,7 +382,8 @@ StdLogosResult LogosBlockchainModule::generate_user_config(const std::string& js
         } else {
             fprintf(
                 stderr,
-                "generate_user_config: use_persistence_paths requested but no instance persistence path is set; leaving paths unchanged.\n"
+                "generate_user_config: use_persistence_paths requested but no instance persistence path is set; "
+                "leaving paths unchanged.\n"
             );
         }
     }
@@ -349,10 +398,9 @@ StdLogosResult LogosBlockchainModule::generate_user_config(const std::string& js
 
     const OwnedGenerateConfigArgs owned_args(parsed_args);
 
-    const OperationStatus status = ::generate_user_config(owned_args.ffi_args);
+    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 result::err("Failed to generate user config.");
+        return result::err(operation_status::take_message(status));
     }
 
     return result::ok(resolved_output);
@@ -384,28 +432,27 @@ StdLogosResult LogosBlockchainModule::start(const std::string& config_path, cons
     const char* deployment_ptr = deployment_path.empty() ? nullptr : deployment_path.c_str();
 
     auto [value, error] = start_lb_node(config_path_ptr, deployment_ptr);
-    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 result::err("Failed to start the node.");
+        return result::err(operation_status::take_message(error));
     }
 
     node = value;
-    fprintf(stderr, "The node was started successfully.\n");
 
     if (!node) {
-        fprintf(stderr, "Could not subscribe to block events: The node is not running.\n");
         return result::err("Could not subscribe to block events: the node is not running.");
     }
 
     s_instance = this;
-    const OperationStatus subscribe_status = subscribe_to_new_blocks(node, on_new_block_callback);
+    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 result::err("Failed to subscribe to new blocks.");
+        return result::err(operation_status::take_message(subscribe_status));
     }
-
-    return result::ok();
+    OperationStatus processed_status = subscribe_to_processed_blocks(node, on_processed_block_callback);
+    if (!is_ok(&processed_status)) {
+        return result::err(operation_status::take_message(processed_status));
+    }
+    OperationStatus lib_status = subscribe_to_lib_blocks(node, on_lib_block_callback);
+    return result::from_operation_status(lib_status);
 }
 
 StdLogosResult LogosBlockchainModule::stop() {
@@ -416,11 +463,9 @@ StdLogosResult LogosBlockchainModule::stop() {
 
     s_instance = nullptr;
 
-    const OperationStatus status = stop_node(node);
-    if (is_ok(&status)) {
-        fprintf(stderr, "The node was stopped successfully.\n");
-    } else {
-        fprintf(stderr, "Could not stop the node. Error: %d\n", status);
+    OperationStatus status = shutdown_node(node);
+    if (!is_ok(&status)) {
+        fprintf(stderr, "Could not stop the node: %s\n", operation_status::take_message(status).c_str());
     }
 
     node = nullptr;
@@ -436,12 +481,8 @@ StdLogosResult LogosBlockchainModule::update_user_config(
     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 result::err("Failed to update user config.");
-    }
-    return result::ok();
+    OperationStatus status = ::update_user_config(config.c_str(), keystore.c_str());
+    return result::from_operation_status(status);
 }
 
 StdLogosResult LogosBlockchainModule::migrate_user_config(
@@ -451,12 +492,8 @@ StdLogosResult LogosBlockchainModule::migrate_user_config(
     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 result::err("Failed to migrate user config.");
-    }
-    return result::ok();
+    OperationStatus status = ::migrate_user_config(output.c_str(), keystore.c_str());
+    return result::from_operation_status(status);
 }
 
 StdLogosResult LogosBlockchainModule::migrate_user_config_0_1_2(
@@ -468,13 +505,8 @@ StdLogosResult LogosBlockchainModule::migrate_user_config_0_1_2(
     const std::string old_config = localPathFromFileUrl(old_config_path);
     const std::string keystore = localPathFromFileUrl(keystore_path);
 
-    const OperationStatus status =
-        ::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 result::err("Failed to migrate 0.1.2 config.");
-    }
-    return result::ok();
+    OperationStatus status = ::migrate_user_config_0_1_2(new_config.c_str(), old_config.c_str(), keystore.c_str());
+    return result::from_operation_status(status);
 }
 
 StdLogosResult LogosBlockchainModule::participate(
@@ -488,13 +520,8 @@ StdLogosResult LogosBlockchainModule::participate(
     const std::string output = localPathFromFileUrl(output_dir);
     const char* external_address_ptr = external_address.empty() ? nullptr : external_address.c_str();
 
-    const OperationStatus status =
-        ::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 result::err("Failed to generate participation data.");
-    }
-    return result::ok();
+    OperationStatus status = ::participate(config.c_str(), keystore.c_str(), output.c_str(), external_address_ptr);
+    return result::from_operation_status(status);
 }
 
 // Keystore
@@ -516,14 +543,13 @@ StdLogosResult LogosBlockchainModule::generate_key(
 
     auto [value, error] = ::generate_key(config.c_str(), keystore.c_str(), type, key_title_ptr);
     if (!is_ok(&error)) {
-        fprintf(stderr, "Failed to generate key. Error: %d\n", error);
-        return result::err("Failed to generate key: " + std::to_string(error));
+        return result::err(operation_status::take_message(error));
     }
 
     const std::string out(value);
-    const OperationStatus free_status = free_cstring(value);
+    OperationStatus free_status = free_cstring(value);
     if (!is_ok(&free_status)) {
-        fprintf(stderr, "Failed to free key id string. Error: %d\n", free_status);
+        fprintf(stderr, "Failed to free key id string: %s\n", operation_status::take_message(free_status).c_str());
     }
     return result::ok(out);
 }
@@ -545,12 +571,8 @@ StdLogosResult LogosBlockchainModule::add_key(
     const std::string keystore = localPathFromFileUrl(keystore_path);
     const char* key_title_ptr = key_title.empty() ? nullptr : key_title.c_str();
 
-    const OperationStatus status = ::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 result::err("Failed to add key.");
-    }
-    return result::ok();
+    OperationStatus status = ::add_key(config.c_str(), keystore.c_str(), type, key_hex.c_str(), key_title_ptr);
+    return result::from_operation_status(status);
 }
 
 StdLogosResult LogosBlockchainModule::remove_key(
@@ -561,12 +583,8 @@ StdLogosResult LogosBlockchainModule::remove_key(
     const std::string config = localPathFromFileUrl(user_config_path);
     const std::string keystore = localPathFromFileUrl(keystore_path);
 
-    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 result::err("Failed to remove key.");
-    }
-    return result::ok();
+    OperationStatus status = ::remove_key(config.c_str(), keystore.c_str(), key_title.c_str());
+    return result::from_operation_status(status);
 }
 
 // Identity
@@ -576,14 +594,13 @@ StdLogosResult LogosBlockchainModule::get_peer_id(const std::string& config_path
 
     auto [value, error] = ::get_peer_id(config.c_str());
     if (!is_ok(&error)) {
-        fprintf(stderr, "Failed to get peer id. Error: %d\n", error);
-        return result::err("Failed to get peer id: " + std::to_string(error));
+        return result::err(operation_status::take_message(error));
     }
 
     const std::string out(value);
-    const OperationStatus free_status = free_cstring(value);
+    OperationStatus free_status = free_cstring(value);
     if (!is_ok(&free_status)) {
-        fprintf(stderr, "Failed to free peer id string. Error: %d\n", free_status);
+        fprintf(stderr, "Failed to free peer id string: %s\n", operation_status::take_message(free_status).c_str());
     }
     return result::ok(out);
 }
@@ -603,7 +620,7 @@ StdLogosResult LogosBlockchainModule::wallet_get_balance(const std::string& addr
 
     auto [value, error] = get_balance(node, bytes.data(), nullptr);
     if (!is_ok(&error)) {
-        return result::err("Failed to get balance: " + std::to_string(error));
+        return result::err(operation_status::take_message(error));
     }
 
     return result::ok(std::to_string(value));
@@ -671,7 +688,7 @@ StdLogosResult LogosBlockchainModule::wallet_transfer_funds(
 
     auto [value, error] = transfer_funds(node, &args);
     if (!is_ok(&error)) {
-        return result::err("Failed to transfer funds: " + std::to_string(error));
+        return result::err(operation_status::take_message(error));
     }
     return result::ok(bytes_to_hex(reinterpret_cast<const uint8_t*>(&value), ADDRESS_BYTES));
 }
@@ -683,8 +700,7 @@ StdLogosResult LogosBlockchainModule::wallet_get_known_addresses() const {
     }
     auto [value, error] = get_known_addresses(node);
     if (!is_ok(&error)) {
-        fprintf(stderr, "Failed to get known addresses. Error: %d\n", error);
-        return result::err("Failed to get known addresses: " + std::to_string(error));
+        return result::err(operation_status::take_message(error));
     }
     std::vector<std::string> out;
     for (size_t i = 0; i < value.len; ++i) {
@@ -694,9 +710,9 @@ StdLogosResult LogosBlockchainModule::wallet_get_known_addresses() const {
             out.push_back(bytes_to_hex(ptr, ADDRESS_BYTES));
         }
     }
-    const OperationStatus free_status = free_known_addresses(value);
+    OperationStatus free_status = free_known_addresses(value);
     if (!is_ok(&free_status)) {
-        fprintf(stderr, "Failed to free known addresses. Error: %d\n", free_status);
+        fprintf(stderr, "Failed to free known addresses: %s\n", operation_status::take_message(free_status).c_str());
     }
     fprintf(
         stderr,
@@ -732,7 +748,7 @@ StdLogosResult LogosBlockchainModule::wallet_get_notes(
 
     auto [value, error] = get_wallet_notes(node, address_bytes.data(), optional_tip);
     if (!is_ok(&error)) {
-        return result::err("Failed to get wallet notes: " + std::to_string(error));
+        return result::err(operation_status::take_message(error));
     }
 
     json obj;
@@ -748,9 +764,9 @@ StdLogosResult LogosBlockchainModule::wallet_get_notes(
     }
     obj["notes"] = std::move(notes);
 
-    const OperationStatus free_status = free_wallet_notes(value);
+    OperationStatus free_status = free_wallet_notes(value);
     if (!is_ok(&free_status)) {
-        fprintf(stderr, "Failed to free wallet notes. Error: %d\n", free_status);
+        fprintf(stderr, "Failed to free wallet notes: %s\n", operation_status::take_message(free_status).c_str());
     }
     return result::ok(obj.dump());
 }
@@ -762,7 +778,7 @@ StdLogosResult LogosBlockchainModule::leader_claim() const {
 
     auto [value, error] = ::leader_claim(node);
     if (!is_ok(&error)) {
-        return result::err("Failed to claim leader rewards: " + std::to_string(error));
+        return result::err(operation_status::take_message(error));
     }
 
     return result::ok(bytes_to_hex(reinterpret_cast<const uint8_t*>(&value), TX_HASH_BYTES));
@@ -827,7 +843,7 @@ StdLogosResult LogosBlockchainModule::channel_deposit(
 
     auto [value, error] = ::channel_deposit(node, &args);
     if (!is_ok(&error)) {
-        return result::err("Failed to deposit into channel: " + std::to_string(error));
+        return result::err(operation_status::take_message(error));
     }
     return result::ok(bytes_to_hex(reinterpret_cast<const uint8_t*>(&value), ADDRESS_BYTES));
 }
@@ -923,11 +939,36 @@ StdLogosResult LogosBlockchainModule::channel_deposit_with_notes(
 
     auto [value, error] = ::channel_deposit_with_notes(node, &args);
     if (!is_ok(&error)) {
-        return result::err("Failed to deposit into channel: " + std::to_string(error));
+        return result::err(operation_status::take_message(error));
     }
     return result::ok(bytes_to_hex(reinterpret_cast<const uint8_t*>(&value), ADDRESS_BYTES));
 }
 
+StdLogosResult LogosBlockchainModule::get_channel_state(const std::string& channel_id_hex) const {
+    if (!node) {
+        return result::err("The node is not running.");
+    }
+
+    const std::vector<uint8_t> bytes = parse_address_hex(channel_id_hex);
+    if (bytes.empty() || static_cast<int>(bytes.size()) != ADDRESS_BYTES) {
+        return result::err("Invalid channel_id (64 hex characters required).");
+    }
+
+    auto [value, error] = ::get_channel_state(node, bytes.data());
+    if (!is_ok(&error)) {
+        return result::err(operation_status::take_message(error));
+    }
+
+    std::string out(value);
+    OperationStatus free_status = free_cstring(value);
+    if (!is_ok(&free_status)) {
+        fprintf(
+            stderr, "Failed to free channel state string: %s\n", operation_status::take_message(free_status).c_str()
+        );
+    }
+    return result::ok(std::move(out));
+}
+
 StdLogosResult LogosBlockchainModule::wallet_get_claimable_vouchers() const {
     if (!node) {
         return result::err("The node is not running.");
@@ -935,7 +976,7 @@ StdLogosResult LogosBlockchainModule::wallet_get_claimable_vouchers() const {
 
     auto [value, error] = get_claimable_vouchers(node, nullptr);
     if (!is_ok(&error)) {
-        return result::err("Failed to get claimable vouchers: " + std::to_string(error));
+        return result::err(operation_status::take_message(error));
     }
 
     json obj;
@@ -950,34 +991,58 @@ StdLogosResult LogosBlockchainModule::wallet_get_claimable_vouchers() const {
         });
     }
 
-    const OperationStatus free_status = free_claimable_vouchers(value);
+    OperationStatus free_status = free_claimable_vouchers(value);
     if (!is_ok(&free_status)) {
-        fprintf(stderr, "Failed to free claimable vouchers. Error: %d\n", free_status);
+        fprintf(stderr, "Failed to free claimable vouchers: %s\n", operation_status::take_message(free_status).c_str());
     }
 
     return result::ok(obj.dump());
 }
 
+StdLogosResult LogosBlockchainModule::wallet_fund_tx(const std::string& request_json) const {
+    if (!node) {
+        return result::err("The node is not running.");
+    }
+
+    auto [value, error] = ::wallet_fund_tx(node, request_json.c_str());
+    if (!is_ok(&error)) {
+        return result::err(operation_status::take_message(error));
+    }
+
+    std::string out(value);
+    OperationStatus free_status = free_cstring(value);
+    if (!is_ok(&free_status)) {
+        fprintf(stderr, "Failed to free funded tx string: %s\n", operation_status::take_message(free_status).c_str());
+    }
+    return result::ok(std::move(out));
+}
+
+// Transactions
+
+StdLogosResult LogosBlockchainModule::submit_signed_transaction(const std::string& signed_tx_json) const {
+    if (!node) {
+        return result::err("The node is not running.");
+    }
+
+    auto [value, error] = ::submit_signed_transaction(node, signed_tx_json.c_str());
+    if (!is_ok(&error)) {
+        return result::err(operation_status::take_message(error));
+    }
+    return result::ok(bytes_to_hex(reinterpret_cast<const uint8_t*>(&value), TX_HASH_BYTES));
+}
+
 // Blend
 
 StdLogosResult LogosBlockchainModule::blend_join_as_core_node(
-    const std::string& provider_id_hex,
-    const std::string& zk_id_hex,
-    const std::string& locked_note_id_hex,
-    const std::vector<std::string>& locators
+    const std::string& locator,
+    const std::string& locked_note_id_hex
 ) const {
     if (!node) {
         return result::err("The node is not running.");
     }
 
-    const std::vector<uint8_t> provider_id_bytes = parse_address_hex(provider_id_hex);
-    if (provider_id_bytes.empty() || static_cast<int>(provider_id_bytes.size()) != ADDRESS_BYTES) {
-        return result::err("Invalid provider_id_hex (64 hex characters required).");
-    }
-
-    const std::vector<uint8_t> zk_id_bytes = parse_address_hex(zk_id_hex);
-    if (zk_id_bytes.empty() || static_cast<int>(zk_id_bytes.size()) != ADDRESS_BYTES) {
-        return result::err("Invalid zk_id_hex (64 hex characters required).");
+    if (locator.empty()) {
+        return result::err("Invalid locator (must not be empty).");
     }
 
     const std::vector<uint8_t> locked_note_id_bytes = parse_address_hex(locked_note_id_hex);
@@ -985,23 +1050,9 @@ StdLogosResult LogosBlockchainModule::blend_join_as_core_node(
         return result::err("Invalid locked_note_id_hex (64 hex characters required).");
     }
 
-    // locators_ptrs holds raw pointers into the std::strings (valid as long as `locators` lives).
-    std::vector<const char*> locators_ptrs;
-    locators_ptrs.reserve(locators.size());
-    for (const std::string& locator : locators) {
-        locators_ptrs.push_back(locator.c_str());
-    }
-
-    auto [value, error] = ::blend_join_as_core_node(
-        node,
-        provider_id_bytes.data(),
-        zk_id_bytes.data(),
-        locked_note_id_bytes.data(),
-        locators_ptrs.data(),
-        locators_ptrs.size()
-    );
+    auto [value, error] = ::blend_join_as_core_node(node, locator.c_str(), locked_note_id_bytes.data());
     if (!is_ok(&error)) {
-        return result::err("Failed to join as core node: " + std::to_string(error));
+        return result::err(operation_status::take_message(error));
     }
 
     std::string declaration_id = bytes_to_hex(reinterpret_cast<const uint8_t*>(&value), sizeof(value));
@@ -1023,14 +1074,13 @@ StdLogosResult LogosBlockchainModule::get_block(const std::string& header_id_hex
 
     auto [value, error] = ::get_block(node, reinterpret_cast<const HeaderId*>(bytes.data()));
     if (!is_ok(&error)) {
-        fprintf(stderr, "Failed to get block. Error: %d\n", error);
-        return result::err("Failed to get block: " + std::to_string(error));
+        return result::err(operation_status::take_message(error));
     }
 
     std::string out(value);
-    const OperationStatus free_status = free_cstring(value);
+    OperationStatus free_status = free_cstring(value);
     if (!is_ok(&free_status)) {
-        fprintf(stderr, "Failed to free block string. Error: %d\n", free_status);
+        fprintf(stderr, "Failed to free block string: %s\n", operation_status::take_message(free_status).c_str());
     }
     return result::ok(std::move(out));
 }
@@ -1042,14 +1092,13 @@ StdLogosResult LogosBlockchainModule::get_blocks(const uint64_t from_slot, const
 
     auto [value, error] = ::get_blocks(node, from_slot, to_slot);
     if (!is_ok(&error)) {
-        fprintf(stderr, "Failed to get blocks. Error: %d\n", error);
-        return result::err("Failed to get blocks: " + std::to_string(error));
+        return result::err(operation_status::take_message(error));
     }
 
     std::string out(value);
-    const OperationStatus free_status = free_cstring(value);
+    OperationStatus free_status = free_cstring(value);
     if (!is_ok(&free_status)) {
-        fprintf(stderr, "Failed to free blocks string. Error: %d\n", free_status);
+        fprintf(stderr, "Failed to free blocks string: %s\n", operation_status::take_message(free_status).c_str());
     }
     return result::ok(std::move(out));
 }
@@ -1066,14 +1115,13 @@ StdLogosResult LogosBlockchainModule::get_transaction(const std::string& tx_hash
 
     auto [value, error] = ::get_transaction(node, reinterpret_cast<const TxHash*>(bytes.data()));
     if (!is_ok(&error)) {
-        fprintf(stderr, "Failed to get transaction. Error: %d\n", error);
-        return result::err("Failed to get transaction: " + std::to_string(error));
+        return result::err(operation_status::take_message(error));
     }
 
     std::string out(value);
-    const OperationStatus free_status = free_cstring(value);
+    OperationStatus free_status = free_cstring(value);
     if (!is_ok(&free_status)) {
-        fprintf(stderr, "Failed to free transaction string. Error: %d\n", free_status);
+        fprintf(stderr, "Failed to free transaction string: %s\n", operation_status::take_message(free_status).c_str());
     }
     return result::ok(std::move(out));
 }
@@ -1087,20 +1135,80 @@ StdLogosResult LogosBlockchainModule::get_cryptarchia_info() const {
 
     auto [value, error] = ::get_cryptarchia_info(node);
     if (!is_ok(&error)) {
-        fprintf(stderr, "Failed to get cryptarchia info. Error: %d\n", error);
-        return result::err("Failed to get cryptarchia info: " + std::to_string(error));
+        return result::err(operation_status::take_message(error));
     }
 
     json obj;
     obj["lib"] = bytes_to_hex(reinterpret_cast<const uint8_t*>(value->lib), ADDRESS_BYTES);
+    obj["lib_slot"] = static_cast<int64_t>(value->lib_slot);
     obj["tip"] = bytes_to_hex(reinterpret_cast<const uint8_t*>(value->tip), ADDRESS_BYTES);
     obj["slot"] = static_cast<int64_t>(value->slot);
     obj["height"] = static_cast<int64_t>(value->height);
-    obj["mode"] = (value->mode == State::Online) ? "Online" : "Bootstrapping";
+    switch (value->mode) {
+    case State::Online:
+        obj["mode"] = "Online";
+        break;
+    case State::NotStarted:
+        obj["mode"] = "NotStarted";
+        break;
+    default:
+        obj["mode"] = "Bootstrapping";
+        break;
+    }
 
-    const OperationStatus free_status = free_cryptarchia_info(value);
+    OperationStatus free_status = free_cryptarchia_info(value);
     if (!is_ok(&free_status)) {
-        fprintf(stderr, "Failed to free cryptarchia info. Error: %d\n", free_status);
+        fprintf(stderr, "Failed to free cryptarchia info: %s\n", operation_status::take_message(free_status).c_str());
+    }
+    return result::ok(obj.dump());
+}
+
+StdLogosResult LogosBlockchainModule::get_block_events(const std::string& header_id_hex) const {
+    if (!node) {
+        return result::err("The node is not running.");
+    }
+
+    const std::vector<uint8_t> bytes = parse_address_hex(header_id_hex);
+    if (bytes.empty() || static_cast<int>(bytes.size()) != ADDRESS_BYTES) {
+        return result::err("Header ID must be 64 hex characters (32 bytes).");
+    }
+
+    auto [value, error] = ::get_block_events(node, reinterpret_cast<const HeaderId*>(bytes.data()));
+    if (!is_ok(&error)) {
+        return result::err(operation_status::take_message(error));
+    }
+
+    std::string out(value);
+    OperationStatus free_status = free_cstring(value);
+    if (!is_ok(&free_status)) {
+        fprintf(
+            stderr, "Failed to free block events string: %s\n", operation_status::take_message(free_status).c_str()
+        );
+    }
+    return result::ok(std::move(out));
+}
+
+// Time
+
+StdLogosResult LogosBlockchainModule::get_time_info() const {
+    if (!node) {
+        return result::err("The node is not running.");
+    }
+
+    auto [value, error] = ::get_time_info(node);
+    if (!is_ok(&error)) {
+        return result::err(operation_status::take_message(error));
+    }
+
+    json obj;
+    obj["slot_duration_ms"] = static_cast<int64_t>(value->slot_duration_ms);
+    obj["genesis_time_unix_ms"] = value->genesis_time_unix_ms;
+    obj["current_slot"] = static_cast<int64_t>(value->current_slot);
+    obj["current_epoch"] = value->current_epoch;
+
+    OperationStatus free_status = free_time_info(value);
+    if (!is_ok(&free_status)) {
+        fprintf(stderr, "Failed to free time info: %s\n", operation_status::take_message(free_status).c_str());
     }
     return result::ok(obj.dump());
 }

src/logos_blockchain_module.h

@@ -34,7 +34,7 @@ public:
     // state/storage/logs path always wins; output is always re-anchored under the
     // base when flagged. On success the result value is the path the config was
     // written to — pass it straight to start().
-    [[nodiscard]] StdLogosResult generate_user_config(const std::string& json_args);
+    [[nodiscard]] StdLogosResult generate_user_config(const std::string& json_args) const;
     [[nodiscard]] static StdLogosResult update_user_config(
         const std::string& user_config_path,
         const std::string& keystore_path
@@ -99,6 +99,16 @@ public:
     ) const;
     [[nodiscard]] StdLogosResult leader_claim() const;
     [[nodiscard]] StdLogosResult wallet_get_claimable_vouchers() const;
+    // Funds an unsigned transaction: request_json is passed through to the
+    // node's wallet fund endpoint (same JSON schema as the HTTP `/wallet/fund`
+    // request body); returns the funded transaction as JSON.
+    [[nodiscard]] StdLogosResult wallet_fund_tx(const std::string& request_json) const;
+
+    // Transactions
+    // Submits a signed transaction: signed_tx_json is passed through to the
+    // node (same JSON schema as the HTTP `/mantle/transact` request body);
+    // returns the transaction hash hex on success.
+    [[nodiscard]] StdLogosResult submit_signed_transaction(const std::string& signed_tx_json) const;
 
     // Channel
     // Amount-based deposit: the binding selects funding notes itself (splitting a
@@ -128,12 +138,15 @@ public:
         const std::string& optional_tip_hex
     ) const;
 
+    // State of the channel with the given 32-byte channel ID, as JSON (same
+    // schema as the node's `/mantle/channel/{id}` HTTP endpoint). Fails with a
+    // not-found error when the channel does not exist yet.
+    [[nodiscard]] StdLogosResult get_channel_state(const std::string& channel_id_hex) const;
+
     // Blend
     [[nodiscard]] StdLogosResult blend_join_as_core_node(
-        const std::string& provider_id_hex,
-        const std::string& zk_id_hex,
-        const std::string& locked_note_id_hex,
-        const std::vector<std::string>& locators
+        const std::string& locator,
+        const std::string& locked_note_id_hex
     ) const;
 
     // Explorer
@@ -143,6 +156,13 @@ public:
 
     // Cryptarchia
     [[nodiscard]] StdLogosResult get_cryptarchia_info() const;
+    // Events emitted by the block with the given 32-byte header ID, as JSON.
+    [[nodiscard]] StdLogosResult get_block_events(const std::string& header_id_hex) const;
+
+    // Time
+    // Consensus time info as JSON:
+    //   { slot_duration_ms, genesis_time_unix_ms, current_slot, current_epoch }
+    [[nodiscard]] StdLogosResult get_time_info() const;
 
     // clang-format off
 // Clang-format only handles public/private/protected, so it miss-indents this section.
@@ -152,6 +172,19 @@ logos_events:
     // blockJson is the full block serialized as JSON.
     // ReSharper disable once CppFunctionIsNotImplemented
     void newBlock(const std::string& blockJson);
+    // Fired per processed block. eventJson carries the block plus the chain
+    // state after processing it (same schema as the node's
+    // `/cryptarchia/blocks/stream` HTTP endpoint; transaction ids at
+    // `transactions[].mantle_tx.hash`). When the stream ends, fired exactly
+    // once with the JSON literal `null` — restart the node subscription (via
+    // stop/start) to keep receiving events.
+    // ReSharper disable once CppFunctionIsNotImplemented
+    void processedBlock(const std::string& eventJson);
+    // Fired per newly finalized (LIB) block. blockInfoJson uses the same
+    // schema as the node's `/cryptarchia/lib/stream` HTTP endpoint. When the
+    // stream ends, fired exactly once with the JSON literal `null`.
+    // ReSharper disable once CppFunctionIsNotImplemented
+    void libBlock(const std::string& blockInfoJson);
     // clang-format on
 
 private:
@@ -160,6 +193,10 @@ private:
     // Static instance for C callback (C API doesn't support user data)
     static LogosBlockchainModule* s_instance;
 
-    // C-compatible callback function
+    // C-compatible callback functions. The stream callbacks receive NULL
+    // exactly once when their stream ends; that is forwarded as the JSON
+    // literal `null` on the corresponding event.
     static void on_new_block_callback(const char* block);
+    static void on_processed_block_callback(const char* event);
+    static void on_lib_block_callback(const char* event);
 };

tests/event_stubs.cpp

@@ -12,6 +12,23 @@
 
 #include "logos_blockchain_module.h"
 
+// Recorded payloads of the most recent stream events, so tests can assert what
+// the trampolines forwarded (including the `null` end-of-stream sentinel).
+std::string g_lastNewBlockEventJson;
+std::string g_lastProcessedBlockEventJson;
+std::string g_lastLibBlockEventJson;
+
 void LogosBlockchainModule::newBlock(const std::string& blockJson) {
+    g_lastNewBlockEventJson = blockJson;
     emitEventImpl_("newBlock", nullptr);
 }
+
+void LogosBlockchainModule::processedBlock(const std::string& eventJson) {
+    g_lastProcessedBlockEventJson = eventJson;
+    emitEventImpl_("processedBlock", nullptr);
+}
+
+void LogosBlockchainModule::libBlock(const std::string& blockInfoJson) {
+    g_lastLibBlockEventJson = blockInfoJson;
+    emitEventImpl_("libBlock", nullptr);
+}

tests/mocks/mock_logos_blockchain.cpp

@@ -16,6 +16,12 @@ std::string g_lastGeneratedStatePath;
 std::string g_lastGeneratedStoragePath;
 std::string g_lastGeneratedLogsPath;
 
+// Captures the callbacks passed to the subscription calls so tests can drive
+// the streams (including the NULL end-of-stream sentinel).
+BlockCallback g_lastNewBlockCallback = nullptr;
+BlockCallback g_lastProcessedBlockCallback = nullptr;
+BlockCallback g_lastLibBlockCallback = nullptr;
+
 static char s_fakeNode = 0;
 static CryptarchiaInfo s_fakeCryptarchiaInfo = {};
 
@@ -27,10 +33,17 @@ static uint8_t s_mockAddr3[32];
 static uint8_t* s_mockAddrs[] = { s_mockAddr0, s_mockAddr1, s_mockAddr2, s_mockAddr3 };
 static ClaimableVoucher s_mockClaimableVouchers[4];
 
+static OperationStatus make_status(int code) {
+    OperationStatus s;
+    s.code = static_cast<OperationStatusCode>(code);
+    s.message = code != 0 ? strdup("mock error") : nullptr;
+    return s;
+}
+
 extern "C" {
 
 bool is_ok(const OperationStatus* status) {
-    return status && *status == 0;
+    return status && status->code == OperationStatusCode_Ok;
 }
 
 OperationStatus generate_user_config(GenerateConfigArgs args) {
@@ -39,7 +52,7 @@ OperationStatus generate_user_config(GenerateConfigArgs args) {
     g_lastGeneratedStatePath = args.state_path ? args.state_path : "<null>";
     g_lastGeneratedStoragePath = args.storage_path ? args.storage_path : "<null>";
     g_lastGeneratedLogsPath = args.logs_path ? args.logs_path : "<null>";
-    return LOGOS_CMOCK_RETURN(int, "generate_user_config");
+    return make_status(LOGOS_CMOCK_RETURN(int, "generate_user_config"));
 }
 
 NodeResult start_lb_node(const char* config_path, const char* deployment) {
@@ -47,23 +60,23 @@ NodeResult start_lb_node(const char* config_path, const char* deployment) {
     int ok = LOGOS_CMOCK_RETURN(int, "start_lb_node");
     NodeResult result;
     result.value = ok ? reinterpret_cast<LogosBlockchainNode*>(&s_fakeNode) : nullptr;
-    result.error = ok ? 0 : 1;
+    result.error = make_status(ok ? 0 : 1);
     return result;
 }
 
-OperationStatus stop_node(LogosBlockchainNode* node) {
-    LOGOS_CMOCK_RECORD("stop_node");
-    return 0;
+OperationStatus shutdown_node(LogosBlockchainNode* node) {
+    LOGOS_CMOCK_RECORD("shutdown_node");
+    return make_status(0);
 }
 
 OperationStatus update_user_config(const char* user_config_path, const char* keystore_path) {
     LOGOS_CMOCK_RECORD("update_user_config");
-    return LOGOS_CMOCK_RETURN(int, "update_user_config");
+    return make_status(LOGOS_CMOCK_RETURN(int, "update_user_config"));
 }
 
 OperationStatus migrate_user_config(const char* output_path, const char* keystore_path) {
     LOGOS_CMOCK_RECORD("migrate_user_config");
-    return LOGOS_CMOCK_RETURN(int, "migrate_user_config");
+    return make_status(LOGOS_CMOCK_RETURN(int, "migrate_user_config"));
 }
 
 OperationStatus migrate_user_config_0_1_2(
@@ -72,7 +85,7 @@ OperationStatus migrate_user_config_0_1_2(
     const char* keystore_path)
 {
     LOGOS_CMOCK_RECORD("migrate_user_config_0_1_2");
-    return LOGOS_CMOCK_RETURN(int, "migrate_user_config_0_1_2");
+    return make_status(LOGOS_CMOCK_RETURN(int, "migrate_user_config_0_1_2"));
 }
 
 OperationStatus participate(
@@ -82,7 +95,7 @@ OperationStatus participate(
     const char* external_address)
 {
     LOGOS_CMOCK_RECORD("participate");
-    return LOGOS_CMOCK_RETURN(int, "participate");
+    return make_status(LOGOS_CMOCK_RETURN(int, "participate"));
 }
 
 StringResult generate_key(
@@ -95,7 +108,7 @@ StringResult generate_key(
     StringResult result;
     const char* id = LOGOS_CMOCK_RETURN_STRING("generate_key");
     result.value = id ? strdup(id) : nullptr;
-    result.error = LOGOS_CMOCK_RETURN(int, "generate_key_error");
+    result.error = make_status(LOGOS_CMOCK_RETURN(int, "generate_key_error"));
     return result;
 }
 
@@ -107,7 +120,7 @@ OperationStatus add_key(
     const char* key_title)
 {
     LOGOS_CMOCK_RECORD("add_key");
-    return LOGOS_CMOCK_RETURN(int, "add_key");
+    return make_status(LOGOS_CMOCK_RETURN(int, "add_key"));
 }
 
 OperationStatus remove_key(
@@ -116,7 +129,7 @@ OperationStatus remove_key(
     const char* key_title)
 {
     LOGOS_CMOCK_RECORD("remove_key");
-    return LOGOS_CMOCK_RETURN(int, "remove_key");
+    return make_status(LOGOS_CMOCK_RETURN(int, "remove_key"));
 }
 
 StringResult get_peer_id(const char* config_path) {
@@ -124,20 +137,33 @@ StringResult get_peer_id(const char* config_path) {
     StringResult result;
     const char* id = LOGOS_CMOCK_RETURN_STRING("get_peer_id");
     result.value = id ? strdup(id) : nullptr;
-    result.error = LOGOS_CMOCK_RETURN(int, "get_peer_id_error");
+    result.error = make_status(LOGOS_CMOCK_RETURN(int, "get_peer_id_error"));
     return result;
 }
 
 OperationStatus subscribe_to_new_blocks(LogosBlockchainNode* node, BlockCallback callback) {
     LOGOS_CMOCK_RECORD("subscribe_to_new_blocks");
-    return LOGOS_CMOCK_RETURN(int, "subscribe_to_new_blocks");
+    g_lastNewBlockCallback = callback;
+    return make_status(LOGOS_CMOCK_RETURN(int, "subscribe_to_new_blocks"));
+}
+
+OperationStatus subscribe_to_processed_blocks(LogosBlockchainNode* node, BlockCallback callback) {
+    LOGOS_CMOCK_RECORD("subscribe_to_processed_blocks");
+    g_lastProcessedBlockCallback = callback;
+    return make_status(LOGOS_CMOCK_RETURN(int, "subscribe_to_processed_blocks"));
+}
+
+OperationStatus subscribe_to_lib_blocks(LogosBlockchainNode* node, BlockCallback callback) {
+    LOGOS_CMOCK_RECORD("subscribe_to_lib_blocks");
+    g_lastLibBlockCallback = callback;
+    return make_status(LOGOS_CMOCK_RETURN(int, "subscribe_to_lib_blocks"));
 }
 
 BalanceResult get_balance(LogosBlockchainNode* node, const uint8_t* address, const void* reserved) {
     LOGOS_CMOCK_RECORD("get_balance");
     BalanceResult result;
     result.value = static_cast<uint64_t>(LOGOS_CMOCK_RETURN(int, "get_balance_value"));
-    result.error = LOGOS_CMOCK_RETURN(int, "get_balance_error");
+    result.error = make_status(LOGOS_CMOCK_RETURN(int, "get_balance_error"));
     return result;
 }
 
@@ -145,7 +171,7 @@ TransferHashResult transfer_funds(LogosBlockchainNode* node, const TransferFunds
     LOGOS_CMOCK_RECORD("transfer_funds");
     TransferHashResult result;
     memset(result.value, 0xAB, sizeof(Hash));
-    result.error = LOGOS_CMOCK_RETURN(int, "transfer_funds_error");
+    result.error = make_status(LOGOS_CMOCK_RETURN(int, "transfer_funds_error"));
     return result;
 }
 
@@ -153,7 +179,7 @@ FfiLeaderClaimResult leader_claim(LogosBlockchainNode* node) {
     LOGOS_CMOCK_RECORD("leader_claim");
     FfiLeaderClaimResult result;
     memset(result.value, 0xEF, sizeof(TxHash));
-    result.error = LOGOS_CMOCK_RETURN(int, "leader_claim_error");
+    result.error = make_status(LOGOS_CMOCK_RETURN(int, "leader_claim_error"));
     return result;
 }
 
@@ -161,7 +187,7 @@ KnownAddressesResult get_known_addresses(LogosBlockchainNode* node) {
     LOGOS_CMOCK_RECORD("get_known_addresses");
     KnownAddressesResult result;
     int err = LOGOS_CMOCK_RETURN(int, "get_known_addresses_error");
-    result.error = err;
+    result.error = make_status(err);
     if (err == 0) {
         int count = LOGOS_CMOCK_RETURN(int, "get_known_addresses_count");
         if (count > 4) count = 4;
@@ -180,14 +206,14 @@ KnownAddressesResult get_known_addresses(LogosBlockchainNode* node) {
 
 OperationStatus free_known_addresses(KnownAddresses addrs) {
     LOGOS_CMOCK_RECORD("free_known_addresses");
-    return 0;
+    return make_status(0);
 }
 
 FfiClaimableVouchersResult get_claimable_vouchers(LogosBlockchainNode* node, const HeaderId* optional_tip) {
     LOGOS_CMOCK_RECORD("get_claimable_vouchers");
     FfiClaimableVouchersResult result;
     int err = LOGOS_CMOCK_RETURN(int, "get_claimable_vouchers_error");
-    result.error = err;
+    result.error = make_status(err);
     if (err == 0) {
         int count = LOGOS_CMOCK_RETURN(int, "get_claimable_vouchers_count");
         if (count > 4) count = 4;
@@ -208,7 +234,16 @@ FfiClaimableVouchersResult get_claimable_vouchers(LogosBlockchainNode* node, con
 
 OperationStatus free_claimable_vouchers(ClaimableVouchers vouchers) {
     LOGOS_CMOCK_RECORD("free_claimable_vouchers");
-    return 0;
+    return make_status(0);
+}
+
+StringResult get_channel_state(LogosBlockchainNode* node, const uint8_t* channel_id) {
+    LOGOS_CMOCK_RECORD("get_channel_state");
+    StringResult result;
+    const char* json = LOGOS_CMOCK_RETURN_STRING("get_channel_state");
+    result.value = json ? strdup(json) : nullptr;
+    result.error = make_status(LOGOS_CMOCK_RETURN(int, "get_channel_state_error"));
+    return result;
 }
 
 // Wallet-notes mock storage (up to 4 notes)
@@ -223,7 +258,7 @@ FfiWalletNotesResult get_wallet_notes(
     FfiWalletNotesResult result;
     memset(&result.value, 0, sizeof(WalletNotes));
     int err = LOGOS_CMOCK_RETURN(int, "get_wallet_notes_error");
-    result.error = err;
+    result.error = make_status(err);
     if (err == 0) {
         int count = LOGOS_CMOCK_RETURN(int, "get_wallet_notes_count");
         if (count > 4) count = 4;
@@ -241,14 +276,31 @@ FfiWalletNotesResult get_wallet_notes(
 
 OperationStatus free_wallet_notes(WalletNotes notes) {
     LOGOS_CMOCK_RECORD("free_wallet_notes");
-    return 0;
+    return make_status(0);
+}
+
+StringResult wallet_fund_tx(LogosBlockchainNode* node, const char* request_json) {
+    LOGOS_CMOCK_RECORD("wallet_fund_tx");
+    StringResult result;
+    const char* json = LOGOS_CMOCK_RETURN_STRING("wallet_fund_tx");
+    result.value = json ? strdup(json) : nullptr;
+    result.error = make_status(LOGOS_CMOCK_RETURN(int, "wallet_fund_tx_error"));
+    return result;
+}
+
+SubmitTransactionResult submit_signed_transaction(LogosBlockchainNode* node, const char* signed_tx_json) {
+    LOGOS_CMOCK_RECORD("submit_signed_transaction");
+    SubmitTransactionResult result;
+    memset(result.value, 0xFA, sizeof(Hash));
+    result.error = make_status(LOGOS_CMOCK_RETURN(int, "submit_signed_transaction_error"));
+    return result;
 }
 
 FfiChannelDepositResult channel_deposit(LogosBlockchainNode* node, const ChannelDepositArguments* arguments) {
     LOGOS_CMOCK_RECORD("channel_deposit");
     FfiChannelDepositResult result;
     memset(result.value, 0xBC, sizeof(Hash));
-    result.error = LOGOS_CMOCK_RETURN(int, "channel_deposit_error");
+    result.error = make_status(LOGOS_CMOCK_RETURN(int, "channel_deposit_error"));
     return result;
 }
 
@@ -259,22 +311,19 @@ FfiChannelDepositResult channel_deposit_with_notes(
     LOGOS_CMOCK_RECORD("channel_deposit_with_notes");
     FfiChannelDepositResult result;
     memset(result.value, 0xDE, sizeof(Hash));
-    result.error = LOGOS_CMOCK_RETURN(int, "channel_deposit_with_notes_error");
+    result.error = make_status(LOGOS_CMOCK_RETURN(int, "channel_deposit_with_notes_error"));
     return result;
 }
 
 BlendHashResult blend_join_as_core_node(
     LogosBlockchainNode* node,
-    const uint8_t* provider_id,
-    const uint8_t* zk_id,
-    const uint8_t* locked_note_id,
-    const char** locators,
-    size_t locators_count)
+    const char* locator,
+    const uint8_t* locked_note_id)
 {
     LOGOS_CMOCK_RECORD("blend_join_as_core_node");
     BlendHashResult result;
     memset(result.value, 0xCD, sizeof(Hash));
-    result.error = LOGOS_CMOCK_RETURN(int, "blend_join_as_core_node_error");
+    result.error = make_status(LOGOS_CMOCK_RETURN(int, "blend_join_as_core_node_error"));
     return result;
 }
 
@@ -283,7 +332,7 @@ StringResult get_block(LogosBlockchainNode* node, const HeaderId* header_id) {
     StringResult result;
     const char* json = LOGOS_CMOCK_RETURN_STRING("get_block");
     result.value = json ? strdup(json) : nullptr;
-    result.error = LOGOS_CMOCK_RETURN(int, "get_block_error");
+    result.error = make_status(LOGOS_CMOCK_RETURN(int, "get_block_error"));
     return result;
 }
 
@@ -292,7 +341,7 @@ StringResult get_blocks(LogosBlockchainNode* node, uint64_t from_slot, uint64_t
     StringResult result;
     const char* json = LOGOS_CMOCK_RETURN_STRING("get_blocks");
     result.value = json ? strdup(json) : nullptr;
-    result.error = LOGOS_CMOCK_RETURN(int, "get_blocks_error");
+    result.error = make_status(LOGOS_CMOCK_RETURN(int, "get_blocks_error"));
     return result;
 }
 
@@ -301,7 +350,7 @@ StringResult get_transaction(LogosBlockchainNode* node, const TxHash* tx_hash) {
     StringResult result;
     const char* json = LOGOS_CMOCK_RETURN_STRING("get_transaction");
     result.value = json ? strdup(json) : nullptr;
-    result.error = LOGOS_CMOCK_RETURN(int, "get_transaction_error");
+    result.error = make_status(LOGOS_CMOCK_RETURN(int, "get_transaction_error"));
     return result;
 }
 
@@ -309,25 +358,54 @@ CryptarchiaInfoResult get_cryptarchia_info(LogosBlockchainNode* node) {
     LOGOS_CMOCK_RECORD("get_cryptarchia_info");
     CryptarchiaInfoResult result;
     memset(&s_fakeCryptarchiaInfo, 0, sizeof(s_fakeCryptarchiaInfo));
+    s_fakeCryptarchiaInfo.lib_slot = static_cast<uint64_t>(LOGOS_CMOCK_RETURN(int, "cryptarchia_lib_slot"));
     s_fakeCryptarchiaInfo.slot = static_cast<uint64_t>(LOGOS_CMOCK_RETURN(int, "cryptarchia_slot"));
     s_fakeCryptarchiaInfo.height = static_cast<uint64_t>(LOGOS_CMOCK_RETURN(int, "cryptarchia_height"));
     s_fakeCryptarchiaInfo.mode = static_cast<State>(LOGOS_CMOCK_RETURN(int, "cryptarchia_mode"));
     memset(s_fakeCryptarchiaInfo.lib, 0xEE, 32);
     memset(s_fakeCryptarchiaInfo.tip, 0xFF, 32);
     result.value = &s_fakeCryptarchiaInfo;
-    result.error = LOGOS_CMOCK_RETURN(int, "get_cryptarchia_info_error");
+    result.error = make_status(LOGOS_CMOCK_RETURN(int, "get_cryptarchia_info_error"));
     return result;
 }
 
 OperationStatus free_cryptarchia_info(CryptarchiaInfo* info) {
     LOGOS_CMOCK_RECORD("free_cryptarchia_info");
-    return 0;
+    return make_status(0);
+}
+
+StringResult get_block_events(LogosBlockchainNode* node, const HeaderId* header_id) {
+    LOGOS_CMOCK_RECORD("get_block_events");
+    StringResult result;
+    const char* json = LOGOS_CMOCK_RETURN_STRING("get_block_events");
+    result.value = json ? strdup(json) : nullptr;
+    result.error = make_status(LOGOS_CMOCK_RETURN(int, "get_block_events_error"));
+    return result;
+}
+
+static TimeInfo s_fakeTimeInfo = {};
+
+TimeInfoResult get_time_info(LogosBlockchainNode* node) {
+    LOGOS_CMOCK_RECORD("get_time_info");
+    TimeInfoResult result;
+    s_fakeTimeInfo.slot_duration_ms = static_cast<uint64_t>(LOGOS_CMOCK_RETURN(int, "time_slot_duration_ms"));
+    s_fakeTimeInfo.genesis_time_unix_ms = static_cast<int64_t>(LOGOS_CMOCK_RETURN(int, "time_genesis_time_unix_ms"));
+    s_fakeTimeInfo.current_slot = static_cast<uint64_t>(LOGOS_CMOCK_RETURN(int, "time_current_slot"));
+    s_fakeTimeInfo.current_epoch = static_cast<uint32_t>(LOGOS_CMOCK_RETURN(int, "time_current_epoch"));
+    result.value = &s_fakeTimeInfo;
+    result.error = make_status(LOGOS_CMOCK_RETURN(int, "get_time_info_error"));
+    return result;
+}
+
+OperationStatus free_time_info(TimeInfo* info) {
+    LOGOS_CMOCK_RECORD("free_time_info");
+    return make_status(0);
 }
 
 OperationStatus free_cstring(char* s) {
     LOGOS_CMOCK_RECORD("free_cstring");
     free(s);
-    return 0;
+    return make_status(0);
 }
 
 } // extern "C"

tests/stubs/logos_blockchain.h

@@ -21,11 +21,31 @@ typedef Hash NoteId;
 // Opaque node handle
 typedef struct LogosBlockchainNode LogosBlockchainNode;
 
-// Operation status (0 = OK)
-typedef int OperationStatus;
+// Operation status code (0 = OK)
+typedef enum OperationStatusCode {
+    OperationStatusCode_Ok = 0,
+    OperationStatusCode_NotFound = 1,
+    OperationStatusCode_NullPointer = 2,
+    OperationStatusCode_RelayError = 3,
+    OperationStatusCode_ChannelSendError = 4,
+    OperationStatusCode_ChannelReceiveError = 5,
+    OperationStatusCode_ServiceError = 6,
+    OperationStatusCode_RuntimeError = 7,
+    OperationStatusCode_DynError = 8,
+    OperationStatusCode_InitializationError = 9,
+    OperationStatusCode_StopError = 10,
+    OperationStatusCode_ConfigurationError = 11,
+    OperationStatusCode_ValidationError = 12,
+} OperationStatusCode;
+
+// Operation status: code + Rust-allocated error message (free with free_cstring).
+typedef struct {
+    OperationStatusCode code;
+    char* message;
+} OperationStatus;
 
 // Consensus state enum
-typedef enum { Bootstrapping, Online } State;
+typedef enum { Bootstrapping, Online, NotStarted } State;
 
 // Key type for generate_key / add_key
 typedef enum { Ed25519, Zk } KeyType;
@@ -42,7 +62,7 @@ typedef struct {
     const char* state_path;
     const char* storage_path;
     const char* logs_path;
-    const bool* ibd;
+    const bool* skip_ibd;
     const char* log_filter;
     const char* kms_file;
 } GenerateConfigArgs;
@@ -114,12 +134,21 @@ typedef struct {
 // Cryptarchia consensus info
 typedef struct {
     uint8_t lib[32];
+    uint64_t lib_slot;
     uint8_t tip[32];
     uint64_t slot;
     uint64_t height;
     State mode;
 } CryptarchiaInfo;
 
+// Time service info
+typedef struct {
+    uint64_t slot_duration_ms;
+    int64_t genesis_time_unix_ms;
+    uint64_t current_slot;
+    uint32_t current_epoch;
+} TimeInfo;
+
 // Result types (C++ structured bindings decompose these)
 typedef struct { LogosBlockchainNode* value; OperationStatus error; } NodeResult;
 typedef struct { uint64_t value; OperationStatus error; } BalanceResult;
@@ -132,6 +161,8 @@ typedef struct { ClaimableVouchers value; OperationStatus error; } FfiClaimableV
 typedef struct { Hash value; OperationStatus error; } BlendHashResult;
 typedef struct { char* value; OperationStatus error; } StringResult;
 typedef struct { CryptarchiaInfo* value; OperationStatus error; } CryptarchiaInfoResult;
+typedef struct { TimeInfo* value; OperationStatus error; } TimeInfoResult;
+typedef struct { Hash value; OperationStatus error; } SubmitTransactionResult;
 
 // Block event callback
 typedef void (*BlockCallback)(const char* block_json);
@@ -142,8 +173,12 @@ bool is_ok(const OperationStatus* status);
 // Lifecycle
 OperationStatus generate_user_config(GenerateConfigArgs args);
 NodeResult start_lb_node(const char* config_path, const char* deployment);
-OperationStatus stop_node(LogosBlockchainNode* node);
+OperationStatus shutdown_node(LogosBlockchainNode* node);
 OperationStatus subscribe_to_new_blocks(LogosBlockchainNode* node, BlockCallback callback);
+// Streams: each event is a JSON C string; the callback is invoked exactly once
+// with NULL when the stream ends.
+OperationStatus subscribe_to_processed_blocks(LogosBlockchainNode* node, BlockCallback callback);
+OperationStatus subscribe_to_lib_blocks(LogosBlockchainNode* node, BlockCallback callback);
 
 // Config management
 OperationStatus update_user_config(const char* user_config_path, const char* keystore_path);
@@ -189,6 +224,10 @@ FfiWalletNotesResult get_wallet_notes(
     const uint8_t* wallet_address,
     const HeaderId* optional_tip);
 OperationStatus free_wallet_notes(WalletNotes notes);
+StringResult wallet_fund_tx(LogosBlockchainNode* node, const char* request_json);
+
+// Transactions
+SubmitTransactionResult submit_signed_transaction(LogosBlockchainNode* node, const char* signed_tx_json);
 
 // Channel
 FfiChannelDepositResult channel_deposit(LogosBlockchainNode* node, const ChannelDepositArguments* arguments);
@@ -197,15 +236,13 @@ FfiChannelDepositResult channel_deposit_with_notes(
     const ChannelDepositWithNotesArguments* arguments);
 FfiClaimableVouchersResult get_claimable_vouchers(LogosBlockchainNode* node, const HeaderId* optional_tip);
 OperationStatus free_claimable_vouchers(ClaimableVouchers vouchers);
+StringResult get_channel_state(LogosBlockchainNode* node, const uint8_t* channel_id);
 
 // Blend
 BlendHashResult blend_join_as_core_node(
     LogosBlockchainNode* node,
-    const uint8_t* provider_id,
-    const uint8_t* zk_id,
-    const uint8_t* locked_note_id,
-    const char** locators,
-    size_t locators_count);
+    const char* locator,
+    const uint8_t* locked_note_id);
 
 // Explorer
 StringResult get_block(LogosBlockchainNode* node, const HeaderId* header_id);
@@ -215,6 +252,11 @@ StringResult get_transaction(LogosBlockchainNode* node, const TxHash* tx_hash);
 // Cryptarchia
 CryptarchiaInfoResult get_cryptarchia_info(LogosBlockchainNode* node);
 OperationStatus free_cryptarchia_info(CryptarchiaInfo* info);
+StringResult get_block_events(LogosBlockchainNode* node, const HeaderId* header_id);
+
+// Time
+TimeInfoResult get_time_info(LogosBlockchainNode* node);
+OperationStatus free_time_info(TimeInfo* info);
 
 // Memory management
 OperationStatus free_cstring(char* s);

tests/test_blockchain.cpp

@@ -292,7 +292,7 @@ LOGOS_TEST(wallet_get_known_addresses_without_node_returns_error) {
 LOGOS_TEST(blend_join_as_core_node_without_node_returns_error) {
     auto t = LogosTestContext("blockchain_module");
     LogosBlockchainModule module;
-    StdLogosResult result = module.blend_join_as_core_node(VALID_HEX, VALID_HEX, VALID_HEX, {"locator1"});
+    StdLogosResult result = module.blend_join_as_core_node("locator1", VALID_HEX);
     LOGOS_ASSERT_FALSE(result.success);
     LOGOS_ASSERT_TRUE(contains(result.error, "not running"));
 }
@@ -321,6 +321,42 @@ LOGOS_TEST(get_cryptarchia_info_without_node_returns_error) {
     LOGOS_ASSERT_FALSE(module.get_cryptarchia_info().success);
 }
 
+LOGOS_TEST(get_block_events_without_node_returns_error) {
+    auto t = LogosTestContext("blockchain_module");
+    LogosBlockchainModule module;
+    LOGOS_ASSERT_FALSE(module.get_block_events(VALID_HEX).success);
+}
+
+LOGOS_TEST(get_time_info_without_node_returns_error) {
+    auto t = LogosTestContext("blockchain_module");
+    LogosBlockchainModule module;
+    LOGOS_ASSERT_FALSE(module.get_time_info().success);
+}
+
+LOGOS_TEST(get_channel_state_without_node_returns_error) {
+    auto t = LogosTestContext("blockchain_module");
+    LogosBlockchainModule module;
+    StdLogosResult result = module.get_channel_state(VALID_HEX);
+    LOGOS_ASSERT_FALSE(result.success);
+    LOGOS_ASSERT_TRUE(contains(result.error, "not running"));
+}
+
+LOGOS_TEST(wallet_fund_tx_without_node_returns_error) {
+    auto t = LogosTestContext("blockchain_module");
+    LogosBlockchainModule module;
+    StdLogosResult result = module.wallet_fund_tx("{}");
+    LOGOS_ASSERT_FALSE(result.success);
+    LOGOS_ASSERT_TRUE(contains(result.error, "not running"));
+}
+
+LOGOS_TEST(submit_signed_transaction_without_node_returns_error) {
+    auto t = LogosTestContext("blockchain_module");
+    LogosBlockchainModule module;
+    StdLogosResult result = module.submit_signed_transaction("{}");
+    LOGOS_ASSERT_FALSE(result.success);
+    LOGOS_ASSERT_TRUE(contains(result.error, "not running"));
+}
+
 // ============================================================================
 // Node lifecycle (start / stop)
 // ============================================================================
@@ -334,9 +370,36 @@ LOGOS_TEST(start_succeeds_with_mocked_dependencies) {
     LOGOS_ASSERT_TRUE(module != nullptr);
     LOGOS_ASSERT(t.cFunctionCalled("start_lb_node"));
     LOGOS_ASSERT(t.cFunctionCalled("subscribe_to_new_blocks"));
+    LOGOS_ASSERT(t.cFunctionCalled("subscribe_to_processed_blocks"));
+    LOGOS_ASSERT(t.cFunctionCalled("subscribe_to_lib_blocks"));
     delete module;
 }
 
+LOGOS_TEST(start_fails_when_processed_blocks_subscription_fails) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    LogosBlockchainModule module;
+
+    t.mockCFunction("start_lb_node").returns(1);
+    t.mockCFunction("subscribe_to_new_blocks").returns(0);
+    t.mockCFunction("subscribe_to_processed_blocks").returns(1);
+
+    LOGOS_ASSERT_FALSE(module.start(tmpDir.filePath("config.json"), "").success);
+}
+
+LOGOS_TEST(start_fails_when_lib_blocks_subscription_fails) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    LogosBlockchainModule module;
+
+    t.mockCFunction("start_lb_node").returns(1);
+    t.mockCFunction("subscribe_to_new_blocks").returns(0);
+    t.mockCFunction("subscribe_to_processed_blocks").returns(0);
+    t.mockCFunction("subscribe_to_lib_blocks").returns(1);
+
+    LOGOS_ASSERT_FALSE(module.start(tmpDir.filePath("config.json"), "").success);
+}
+
 LOGOS_TEST(start_returns_1_when_already_running) {
     auto t = LogosTestContext("blockchain_module");
     TempDir tmpDir;
@@ -354,7 +417,7 @@ LOGOS_TEST(stop_succeeds_with_running_node) {
     LOGOS_ASSERT_TRUE(module != nullptr);
 
     LOGOS_ASSERT_TRUE(module->stop().success);
-    LOGOS_ASSERT(t.cFunctionCalled("stop_node"));
+    LOGOS_ASSERT(t.cFunctionCalled("shutdown_node"));
     delete module;
 }
 
@@ -475,27 +538,15 @@ LOGOS_TEST(wallet_transfer_funds_rejects_invalid_optional_tip) {
 
 // blend_join_as_core_node validation
 
-LOGOS_TEST(blend_join_rejects_invalid_provider_id) {
+LOGOS_TEST(blend_join_rejects_empty_locator) {
     auto t = LogosTestContext("blockchain_module");
     TempDir tmpDir;
     auto* module = createStartedModule(t, tmpDir);
     LOGOS_ASSERT_TRUE(module != nullptr);
 
-    StdLogosResult result = module->blend_join_as_core_node("short", VALID_HEX, VALID_HEX, {});
+    StdLogosResult result = module->blend_join_as_core_node("", VALID_HEX);
     LOGOS_ASSERT_FALSE(result.success);
-    LOGOS_ASSERT_TRUE(contains(result.error, "provider_id"));
-    delete module;
-}
-
-LOGOS_TEST(blend_join_rejects_invalid_zk_id) {
-    auto t = LogosTestContext("blockchain_module");
-    TempDir tmpDir;
-    auto* module = createStartedModule(t, tmpDir);
-    LOGOS_ASSERT_TRUE(module != nullptr);
-
-    StdLogosResult result = module->blend_join_as_core_node(VALID_HEX, "short", VALID_HEX, {});
-    LOGOS_ASSERT_FALSE(result.success);
-    LOGOS_ASSERT_TRUE(contains(result.error, "zk_id"));
+    LOGOS_ASSERT_TRUE(contains(result.error, "locator"));
     delete module;
 }
 
@@ -505,7 +556,7 @@ LOGOS_TEST(blend_join_rejects_invalid_locked_note_id) {
     auto* module = createStartedModule(t, tmpDir);
     LOGOS_ASSERT_TRUE(module != nullptr);
 
-    StdLogosResult result = module->blend_join_as_core_node(VALID_HEX, VALID_HEX, "short", {});
+    StdLogosResult result = module->blend_join_as_core_node("locator1", "short");
     LOGOS_ASSERT_FALSE(result.success);
     LOGOS_ASSERT_TRUE(contains(result.error, "locked_note_id"));
     delete module;
@@ -537,6 +588,30 @@ LOGOS_TEST(get_transaction_rejects_invalid_hex) {
     delete module;
 }
 
+LOGOS_TEST(get_block_events_rejects_invalid_hex) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    auto* module = createStartedModule(t, tmpDir);
+    LOGOS_ASSERT_TRUE(module != nullptr);
+
+    StdLogosResult result = module->get_block_events("tooshort");
+    LOGOS_ASSERT_FALSE(result.success);
+    LOGOS_ASSERT_TRUE(contains(result.error, "64 hex"));
+    delete module;
+}
+
+LOGOS_TEST(get_channel_state_rejects_invalid_hex) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    auto* module = createStartedModule(t, tmpDir);
+    LOGOS_ASSERT_TRUE(module != nullptr);
+
+    StdLogosResult result = module->get_channel_state("bad");
+    LOGOS_ASSERT_FALSE(result.success);
+    LOGOS_ASSERT_TRUE(contains(result.error, "channel_id"));
+    delete module;
+}
+
 // ============================================================================
 // 0x prefix handling
 // ============================================================================
@@ -662,7 +737,6 @@ LOGOS_TEST(leader_claim_returns_error_on_ffi_failure) {
 
     StdLogosResult result = module->leader_claim();
     LOGOS_ASSERT_FALSE(result.success);
-    LOGOS_ASSERT_TRUE(contains(result.error, "Failed to claim leader rewards"));
     delete module;
 }
 
@@ -707,7 +781,7 @@ LOGOS_TEST(channel_deposit_returns_error_on_ffi_failure) {
 
     StdLogosResult result = module->channel_deposit(VALID_HEX, VALID_HEX, "100", "", "");
     LOGOS_ASSERT_FALSE(result.success);
-    LOGOS_ASSERT_TRUE(contains(result.error, "Failed to deposit into channel"));
+    LOGOS_ASSERT_TRUE(contains(result.error, "mock error"));
     delete module;
 }
 
@@ -829,7 +903,7 @@ LOGOS_TEST(wallet_get_notes_returns_error_on_ffi_failure) {
 
     StdLogosResult result = module->wallet_get_notes(VALID_HEX, "");
     LOGOS_ASSERT_FALSE(result.success);
-    LOGOS_ASSERT_TRUE(contains(result.error, "Failed to get wallet notes"));
+    LOGOS_ASSERT_TRUE(contains(result.error, "mock error"));
     delete module;
 }
 
@@ -874,7 +948,7 @@ LOGOS_TEST(channel_deposit_with_notes_returns_error_on_ffi_failure) {
     StdLogosResult result = module->channel_deposit_with_notes(
         VALID_HEX, {VALID_HEX}, "", VALID_HEX, {VALID_HEX}, "0", "");
     LOGOS_ASSERT_FALSE(result.success);
-    LOGOS_ASSERT_TRUE(contains(result.error, "Failed to deposit into channel"));
+    LOGOS_ASSERT_TRUE(contains(result.error, "mock error"));
     delete module;
 }
 
@@ -1022,7 +1096,105 @@ LOGOS_TEST(wallet_get_claimable_vouchers_returns_error_on_ffi_failure) {
 
     StdLogosResult result = module->wallet_get_claimable_vouchers();
     LOGOS_ASSERT_FALSE(result.success);
-    LOGOS_ASSERT_TRUE(contains(result.error, "Failed to get claimable vouchers"));
+    LOGOS_ASSERT_TRUE(contains(result.error, "mock error"));
+    delete module;
+}
+
+LOGOS_TEST(wallet_fund_tx_returns_json_on_success) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    auto* module = createStartedModule(t, tmpDir);
+    LOGOS_ASSERT_TRUE(module != nullptr);
+
+    t.mockCFunction("wallet_fund_tx").returns(R"({"mantle_tx":{"ops":[]}})");
+    t.mockCFunction("wallet_fund_tx_error").returns(0);
+
+    StdLogosResult result = module->wallet_fund_tx(R"({"tx":{},"funding_keys":[]})");
+    LOGOS_ASSERT_TRUE(result.success);
+    LOGOS_ASSERT_TRUE(contains(result.value.get<std::string>(), "mantle_tx"));
+    LOGOS_ASSERT(t.cFunctionCalled("wallet_fund_tx"));
+    LOGOS_ASSERT(t.cFunctionCalled("free_cstring"));
+    delete module;
+}
+
+LOGOS_TEST(wallet_fund_tx_returns_error_on_ffi_failure) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    auto* module = createStartedModule(t, tmpDir);
+    LOGOS_ASSERT_TRUE(module != nullptr);
+
+    t.mockCFunction("wallet_fund_tx_error").returns(1);
+
+    StdLogosResult result = module->wallet_fund_tx("{}");
+    LOGOS_ASSERT_FALSE(result.success);
+    LOGOS_ASSERT_TRUE(contains(result.error, "mock error"));
+    delete module;
+}
+
+// Transactions
+
+LOGOS_TEST(submit_signed_transaction_returns_tx_hash) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    auto* module = createStartedModule(t, tmpDir);
+    LOGOS_ASSERT_TRUE(module != nullptr);
+
+    t.mockCFunction("submit_signed_transaction_error").returns(0);
+
+    StdLogosResult result = module->submit_signed_transaction("{}");
+    LOGOS_ASSERT_TRUE(result.success);
+    // Mock fills hash with 0xFA -> hex "fafa...fa" (64 chars)
+    std::string hash = result.value.get<std::string>();
+    LOGOS_ASSERT_EQ(static_cast<int>(hash.length()), 64);
+    LOGOS_ASSERT_TRUE(hash.substr(0, 2) == "fa");
+    LOGOS_ASSERT(t.cFunctionCalled("submit_signed_transaction"));
+    delete module;
+}
+
+LOGOS_TEST(submit_signed_transaction_returns_error_on_ffi_failure) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    auto* module = createStartedModule(t, tmpDir);
+    LOGOS_ASSERT_TRUE(module != nullptr);
+
+    t.mockCFunction("submit_signed_transaction_error").returns(1);
+
+    StdLogosResult result = module->submit_signed_transaction("{}");
+    LOGOS_ASSERT_FALSE(result.success);
+    LOGOS_ASSERT_TRUE(contains(result.error, "mock error"));
+    delete module;
+}
+
+// Channel state
+
+LOGOS_TEST(get_channel_state_returns_json_on_success) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    auto* module = createStartedModule(t, tmpDir);
+    LOGOS_ASSERT_TRUE(module != nullptr);
+
+    t.mockCFunction("get_channel_state").returns(R"({"tip":"abc","inscriptions":[]})");
+    t.mockCFunction("get_channel_state_error").returns(0);
+
+    StdLogosResult result = module->get_channel_state(VALID_HEX);
+    LOGOS_ASSERT_TRUE(result.success);
+    LOGOS_ASSERT_TRUE(contains(result.value.get<std::string>(), "inscriptions"));
+    LOGOS_ASSERT(t.cFunctionCalled("get_channel_state"));
+    LOGOS_ASSERT(t.cFunctionCalled("free_cstring"));
+    delete module;
+}
+
+LOGOS_TEST(get_channel_state_returns_error_on_ffi_failure) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    auto* module = createStartedModule(t, tmpDir);
+    LOGOS_ASSERT_TRUE(module != nullptr);
+
+    t.mockCFunction("get_channel_state_error").returns(1);
+
+    StdLogosResult result = module->get_channel_state(VALID_HEX);
+    LOGOS_ASSERT_FALSE(result.success);
+    LOGOS_ASSERT_TRUE(contains(result.error, "mock error"));
     delete module;
 }
 
@@ -1036,8 +1208,7 @@ LOGOS_TEST(blend_join_as_core_node_returns_declaration_id) {
 
     t.mockCFunction("blend_join_as_core_node_error").returns(0);
 
-    std::vector<std::string> locators = {"locator1", "locator2"};
-    StdLogosResult result = module->blend_join_as_core_node(VALID_HEX, VALID_HEX, VALID_HEX, locators);
+    StdLogosResult result = module->blend_join_as_core_node("locator1", VALID_HEX);
     LOGOS_ASSERT_TRUE(result.success);
     // Mock fills hash with 0xCD -> hex "cdcd...cd" (64 chars)
     std::string declarationId = result.value.get<std::string>();
@@ -1055,7 +1226,7 @@ LOGOS_TEST(blend_join_as_core_node_returns_error_on_ffi_failure) {
 
     t.mockCFunction("blend_join_as_core_node_error").returns(1);
 
-    StdLogosResult result = module->blend_join_as_core_node(VALID_HEX, VALID_HEX, VALID_HEX, {});
+    StdLogosResult result = module->blend_join_as_core_node("locator1", VALID_HEX);
     LOGOS_ASSERT_FALSE(result.success);
     delete module;
 }
@@ -1160,6 +1331,7 @@ LOGOS_TEST(get_cryptarchia_info_returns_json_on_success) {
     LOGOS_ASSERT_TRUE(module != nullptr);
 
     t.mockCFunction("get_cryptarchia_info_error").returns(0);
+    t.mockCFunction("cryptarchia_lib_slot").returns(90);
     t.mockCFunction("cryptarchia_slot").returns(100);
     t.mockCFunction("cryptarchia_height").returns(50);
     t.mockCFunction("cryptarchia_mode").returns(1); // Online
@@ -1174,11 +1346,26 @@ LOGOS_TEST(get_cryptarchia_info_returns_json_on_success) {
     LOGOS_ASSERT_TRUE(contains(json, "Online"));
     LOGOS_ASSERT_TRUE(contains(json, "lib"));
     LOGOS_ASSERT_TRUE(contains(json, "tip"));
+    LOGOS_ASSERT_TRUE(contains(json, "\"lib_slot\":90"));
     LOGOS_ASSERT(t.cFunctionCalled("get_cryptarchia_info"));
     LOGOS_ASSERT(t.cFunctionCalled("free_cryptarchia_info"));
     delete module;
 }
 
+LOGOS_TEST(get_cryptarchia_info_not_started_mode) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    auto* module = createStartedModule(t, tmpDir);
+    LOGOS_ASSERT_TRUE(module != nullptr);
+
+    t.mockCFunction("get_cryptarchia_info_error").returns(0);
+    t.mockCFunction("cryptarchia_mode").returns(2); // NotStarted
+
+    StdLogosResult result = module->get_cryptarchia_info();
+    LOGOS_ASSERT_TRUE(contains(result.value.get<std::string>(), "NotStarted"));
+    delete module;
+}
+
 LOGOS_TEST(get_cryptarchia_info_bootstrapping_mode) {
     auto t = LogosTestContext("blockchain_module");
     TempDir tmpDir;
@@ -1205,6 +1392,147 @@ LOGOS_TEST(get_cryptarchia_info_returns_error_on_ffi_failure) {
     delete module;
 }
 
+LOGOS_TEST(get_block_events_returns_json_on_success) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    auto* module = createStartedModule(t, tmpDir);
+    LOGOS_ASSERT_TRUE(module != nullptr);
+
+    t.mockCFunction("get_block_events").returns(R"([{"type":"inscription"}])");
+    t.mockCFunction("get_block_events_error").returns(0);
+
+    StdLogosResult result = module->get_block_events(VALID_HEX);
+    LOGOS_ASSERT_TRUE(result.success);
+    LOGOS_ASSERT_TRUE(contains(result.value.get<std::string>(), "inscription"));
+    LOGOS_ASSERT(t.cFunctionCalled("get_block_events"));
+    LOGOS_ASSERT(t.cFunctionCalled("free_cstring"));
+    delete module;
+}
+
+LOGOS_TEST(get_block_events_returns_error_on_ffi_failure) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    auto* module = createStartedModule(t, tmpDir);
+    LOGOS_ASSERT_TRUE(module != nullptr);
+
+    t.mockCFunction("get_block_events_error").returns(1);
+
+    LOGOS_ASSERT_FALSE(module->get_block_events(VALID_HEX).success);
+    delete module;
+}
+
+// Time
+
+LOGOS_TEST(get_time_info_returns_json_on_success) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    auto* module = createStartedModule(t, tmpDir);
+    LOGOS_ASSERT_TRUE(module != nullptr);
+
+    t.mockCFunction("get_time_info_error").returns(0);
+    t.mockCFunction("time_slot_duration_ms").returns(2000);
+    t.mockCFunction("time_genesis_time_unix_ms").returns(1700000);
+    t.mockCFunction("time_current_slot").returns(1234);
+    t.mockCFunction("time_current_epoch").returns(7);
+
+    StdLogosResult result = module->get_time_info();
+    LOGOS_ASSERT_TRUE(result.success);
+    std::string json = result.value.get<std::string>();
+    LOGOS_ASSERT_TRUE(contains(json, "\"slot_duration_ms\":2000"));
+    LOGOS_ASSERT_TRUE(contains(json, "\"genesis_time_unix_ms\":1700000"));
+    LOGOS_ASSERT_TRUE(contains(json, "\"current_slot\":1234"));
+    LOGOS_ASSERT_TRUE(contains(json, "\"current_epoch\":7"));
+    LOGOS_ASSERT(t.cFunctionCalled("get_time_info"));
+    LOGOS_ASSERT(t.cFunctionCalled("free_time_info"));
+    delete module;
+}
+
+LOGOS_TEST(get_time_info_returns_error_on_ffi_failure) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    auto* module = createStartedModule(t, tmpDir);
+    LOGOS_ASSERT_TRUE(module != nullptr);
+
+    t.mockCFunction("get_time_info_error").returns(1);
+
+    LOGOS_ASSERT_FALSE(module->get_time_info().success);
+    delete module;
+}
+
+// ============================================================================
+// Stream events (trampolines drive logos_events; end of stream = JSON null)
+// ============================================================================
+
+// Captured by the mock subscribe calls (mock_logos_blockchain.cpp).
+extern BlockCallback g_lastNewBlockCallback;
+extern BlockCallback g_lastProcessedBlockCallback;
+extern BlockCallback g_lastLibBlockCallback;
+// Recorded by the event stubs (event_stubs.cpp).
+extern std::string g_lastNewBlockEventJson;
+extern std::string g_lastProcessedBlockEventJson;
+extern std::string g_lastLibBlockEventJson;
+
+LOGOS_TEST(processed_block_stream_forwards_json_and_null_sentinel) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    auto* module = createStartedModule(t, tmpDir);
+    LOGOS_ASSERT_TRUE(module != nullptr);
+    LOGOS_ASSERT_TRUE(g_lastProcessedBlockCallback != nullptr);
+
+    g_lastProcessedBlockEventJson.clear();
+    g_lastProcessedBlockCallback(R"({"header_id":"abc","transactions":[]})");
+    LOGOS_ASSERT_EQ(g_lastProcessedBlockEventJson, std::string(R"({"header_id":"abc","transactions":[]})"));
+
+    g_lastProcessedBlockCallback(nullptr);
+    LOGOS_ASSERT_EQ(g_lastProcessedBlockEventJson, std::string("null"));
+    delete module;
+}
+
+LOGOS_TEST(lib_block_stream_forwards_json_and_null_sentinel) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    auto* module = createStartedModule(t, tmpDir);
+    LOGOS_ASSERT_TRUE(module != nullptr);
+    LOGOS_ASSERT_TRUE(g_lastLibBlockCallback != nullptr);
+
+    g_lastLibBlockEventJson.clear();
+    g_lastLibBlockCallback(R"({"header_id":"def","slot":9})");
+    LOGOS_ASSERT_EQ(g_lastLibBlockEventJson, std::string(R"({"header_id":"def","slot":9})"));
+
+    g_lastLibBlockCallback(nullptr);
+    LOGOS_ASSERT_EQ(g_lastLibBlockEventJson, std::string("null"));
+    delete module;
+}
+
+// The legacy new-block stream never sends NULL, but the trampoline must not
+// crash if it ever does (regression test for the added guard).
+LOGOS_TEST(new_block_callback_ignores_null_pointer) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    auto* module = createStartedModule(t, tmpDir);
+    LOGOS_ASSERT_TRUE(module != nullptr);
+    LOGOS_ASSERT_TRUE(g_lastNewBlockCallback != nullptr);
+
+    g_lastNewBlockEventJson.clear();
+    g_lastNewBlockCallback(nullptr);
+    LOGOS_ASSERT_EQ(g_lastNewBlockEventJson, std::string());
+    delete module;
+}
+
+// Stream events are not delivered after the module stops (s_instance cleared).
+LOGOS_TEST(stream_events_not_delivered_after_stop) {
+    auto t = LogosTestContext("blockchain_module");
+    TempDir tmpDir;
+    auto* module = createStartedModule(t, tmpDir);
+    LOGOS_ASSERT_TRUE(module != nullptr);
+    LOGOS_ASSERT_TRUE(module->stop().success);
+
+    g_lastProcessedBlockEventJson.clear();
+    g_lastProcessedBlockCallback(R"({"header_id":"abc"})");
+    LOGOS_ASSERT_EQ(g_lastProcessedBlockEventJson, std::string());
+    delete module;
+}
+
 // ============================================================================
 // Config management (operate on file paths, no running node required)
 // ============================================================================