mirror of
https://github.com/logos-blockchain/logos-blockchain-module.git
synced 2026-02-20 13:03:15 +00:00
275 lines
9.8 KiB
C++
275 lines
9.8 KiB
C++
#include "logos_blockchain_module.h"
|
|
#include "logos_api_client.h"
|
|
#include <QByteArray>
|
|
#include <QVariant>
|
|
|
|
// Define static member
|
|
LogosBlockchainModule* LogosBlockchainModule::s_instance = nullptr;
|
|
|
|
namespace {
|
|
// Use the C API type Hash (from logos_blockchain.h) to define address/hash byte size.
|
|
constexpr int kAddressBytes = static_cast<int>(sizeof(Hash));
|
|
constexpr int kAddressHexLen = kAddressBytes * 2;
|
|
|
|
// Parses kAddressHexLen hex chars (optional 0x prefix) to kAddressBytes. Returns empty QByteArray on error.
|
|
QByteArray parseAddressHex(const QString& addressHex) {
|
|
QString hex = addressHex.trimmed();
|
|
if (hex.startsWith(QStringLiteral("0x"), Qt::CaseInsensitive))
|
|
hex = hex.mid(2);
|
|
if (hex.length() != kAddressHexLen)
|
|
return {};
|
|
QByteArray bytes = QByteArray::fromHex(hex.toUtf8());
|
|
if (bytes.size() != kAddressBytes)
|
|
return {};
|
|
return bytes;
|
|
}
|
|
}
|
|
|
|
void LogosBlockchainModule::onNewBlockCallback(const char* block) {
|
|
if (s_instance) {
|
|
qInfo() << "Received new block: " << block;
|
|
QVariantList data;
|
|
data.append(QString::fromUtf8(block));
|
|
s_instance->emitEvent("newBlock", data);
|
|
// SAFETY:
|
|
// We are getting an owned pointer here which is freed after this callback is called, so there is not need to
|
|
// free the resrouce here as we are copying the data!
|
|
}
|
|
}
|
|
|
|
LogosBlockchainModule::LogosBlockchainModule() {
|
|
node = nullptr;
|
|
}
|
|
|
|
LogosBlockchainModule::~LogosBlockchainModule() {
|
|
s_instance = nullptr;
|
|
if (node) {
|
|
stop();
|
|
}
|
|
}
|
|
|
|
QString LogosBlockchainModule::name() const {
|
|
return "liblogos_blockchain_module";
|
|
}
|
|
|
|
QString LogosBlockchainModule::version() const {
|
|
return "1.0.0";
|
|
}
|
|
|
|
void LogosBlockchainModule::initLogos(LogosAPI* logosAPIInstance) {
|
|
logosAPI = logosAPIInstance;
|
|
if (logosAPI) {
|
|
client = logosAPI->getClient("liblogos_blockchain_module");
|
|
if (!client) {
|
|
qWarning() << "LogosBlockchainModule: Failed to get liblogos_blockchain_module client";
|
|
}
|
|
}
|
|
}
|
|
|
|
int LogosBlockchainModule::start(const QString& config_path, const QString& deployment) {
|
|
if (node) {
|
|
qWarning() << "Could not execute the operation: The node is already running.";
|
|
return 1;
|
|
}
|
|
|
|
// Set LOGOS_BLOCKCHAIN_CIRCUITS env variable
|
|
QString circuits_path = logosAPI->property("modulePath").toString().append(QString::fromUtf8("\\circuits"));
|
|
qputenv("LOGOS_BLOCKCHAIN_CIRCUITS", circuits_path.toUtf8());
|
|
qInfo() << "LOGOS_BLOCKCHAIN_CIRCUITS set to:" << circuits_path;
|
|
QString effective_config_path = config_path;
|
|
|
|
if (effective_config_path.isEmpty()) {
|
|
const char* env = std::getenv("LB_CONFIG_PATH");
|
|
if (env && *env) {
|
|
effective_config_path = QString::fromUtf8(env);
|
|
qInfo() << "Using config from LB_CONFIG_PATH:" << effective_config_path;
|
|
} else {
|
|
qCritical() << "Config path was not specified and LB_CONFIG_PATH is not set.";
|
|
return 2;
|
|
}
|
|
}
|
|
|
|
qInfo() << "Starting the node with the configuration file:" << effective_config_path;
|
|
qInfo() << "Using deployment:" << (deployment.isEmpty() ? "<default>" : deployment);
|
|
|
|
const QByteArray config_path_buffer = effective_config_path.toUtf8();
|
|
const char* config_path_ptr = effective_config_path.isEmpty() ? nullptr : config_path_buffer.constData();
|
|
|
|
const QByteArray deployment_buffer = deployment.toUtf8();
|
|
const char* deployment_ptr = deployment.isEmpty() ? nullptr : deployment_buffer.constData();
|
|
|
|
auto [value, error] = start_lb_node(config_path_ptr, deployment_ptr);
|
|
qInfo() << "Start node returned with value and error.";
|
|
if (!is_ok(&error)) {
|
|
qCritical() << "Failed to start the node. Error:" << error;
|
|
return 3;
|
|
}
|
|
|
|
node = value;
|
|
qInfo() << "The node was started successfully.";
|
|
|
|
// Subscribe to block events
|
|
if (!node) {
|
|
qWarning() << "Could not subcribe to block events: The node is not running.";
|
|
return 1;
|
|
}
|
|
|
|
s_instance = this;
|
|
subscribe_to_new_blocks(node, onNewBlockCallback);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int LogosBlockchainModule::stop() {
|
|
if (!node) {
|
|
qWarning() << "Could not execute the operation: The node is not running.";
|
|
return 1;
|
|
}
|
|
|
|
s_instance = nullptr; // Clear before stopping to prevent callbacks during shutdown
|
|
|
|
const OperationStatus status = stop_node(node);
|
|
if (is_ok(&status)) {
|
|
qInfo() << "The node was stopped successfully.";
|
|
} else {
|
|
qCritical() << "Could not stop the node. Error:" << status;
|
|
}
|
|
|
|
node = nullptr;
|
|
return 0;
|
|
}
|
|
|
|
QString LogosBlockchainModule::wallet_get_balance(const QString& addressHex) {
|
|
qDebug() << "wallet_get_balance: addressHex=" << addressHex;
|
|
if (!node) {
|
|
return QStringLiteral("Error: The node is not running.");
|
|
}
|
|
|
|
QByteArray bytes = parseAddressHex(addressHex);
|
|
if (bytes.isEmpty() || bytes.size() != kAddressBytes) {
|
|
return QStringLiteral("Error: Address must be 64 hex characters (32 bytes).");
|
|
}
|
|
|
|
auto [value, error] = get_balance(node,
|
|
reinterpret_cast<const uint8_t*>(bytes.constData()), nullptr);
|
|
if (!is_ok(&error)) {
|
|
return QStringLiteral("Error: Failed to get balance: ") + QString::number(error);
|
|
}
|
|
|
|
return QString::number(value);
|
|
}
|
|
|
|
QString LogosBlockchainModule::wallet_transfer_funds(
|
|
const QString& changePublicKey,
|
|
const QStringList& senderAddresses,
|
|
const QString& recipientAddress,
|
|
const QString& amount,
|
|
const QString& optionalTipHex
|
|
) {
|
|
if (!node) {
|
|
return QStringLiteral("Error: The node is not running.");
|
|
}
|
|
|
|
bool ok = false;
|
|
const quint64 amountVal = amount.trimmed().toULongLong(&ok);
|
|
if (!ok) {
|
|
return QStringLiteral("Error: Invalid amount (positive integer required).");
|
|
}
|
|
|
|
QByteArray changeBytes = parseAddressHex(changePublicKey);
|
|
if (changeBytes.isEmpty() || changeBytes.size() != kAddressBytes) {
|
|
return QStringLiteral("Error: Invalid changePublicKey (64 hex characters required).");
|
|
}
|
|
QByteArray recipientBytes = parseAddressHex(recipientAddress);
|
|
if (recipientBytes.isEmpty() || recipientBytes.size() != kAddressBytes) {
|
|
return QStringLiteral("Error: Invalid recipientAddress (64 hex characters required).");
|
|
}
|
|
if (senderAddresses.isEmpty()) {
|
|
return QStringLiteral("Error: At least one sender address required.");
|
|
}
|
|
QVector<QByteArray> fundingBytes;
|
|
for (const QString& hex : senderAddresses) {
|
|
QByteArray b = parseAddressHex(hex);
|
|
if (b.isEmpty() || b.size() != kAddressBytes) {
|
|
return QStringLiteral("Error: Invalid sender address (64 hex characters required).");
|
|
}
|
|
fundingBytes.append(b);
|
|
}
|
|
QVector<const uint8_t*> fundingPtrs;
|
|
for (const QByteArray& b : fundingBytes)
|
|
fundingPtrs.append(reinterpret_cast<const uint8_t*>(b.constData()));
|
|
|
|
QByteArray tipBytes;
|
|
const HeaderId* optional_tip = nullptr;
|
|
if (!optionalTipHex.isEmpty()) {
|
|
tipBytes = parseAddressHex(optionalTipHex);
|
|
if (tipBytes.isEmpty() || tipBytes.size() != kAddressBytes) {
|
|
return QStringLiteral("Error: Invalid optional tip (64 hex characters or empty).");
|
|
}
|
|
optional_tip = reinterpret_cast<const HeaderId*>(tipBytes.constData());
|
|
}
|
|
|
|
TransferFundsArguments args{};
|
|
args.optional_tip = optional_tip;
|
|
args.change_public_key = reinterpret_cast<const uint8_t*>(changeBytes.constData());
|
|
args.funding_public_keys = fundingPtrs.constData();
|
|
args.funding_public_keys_len = static_cast<size_t>(fundingPtrs.size());
|
|
args.recipient_public_key = reinterpret_cast<const uint8_t*>(recipientBytes.constData());
|
|
args.amount = amountVal;
|
|
|
|
auto [value, error] = transfer_funds(node, &args);
|
|
if (!is_ok(&error)) {
|
|
return QStringLiteral("Error: Failed to transfer funds: ") + QString::number(static_cast<int>(error));
|
|
}
|
|
// value is Hash (32 bytes); convert to hex string
|
|
QByteArray hashBytes(reinterpret_cast<const char*>(&value), kAddressBytes);
|
|
return QString::fromUtf8(hashBytes.toHex());
|
|
}
|
|
|
|
QString LogosBlockchainModule::wallet_transfer_funds(
|
|
const QString& changePublicKey,
|
|
const QString& senderAddress,
|
|
const QString& recipientAddress,
|
|
const QString& amount,
|
|
const QString& optionalTipHex)
|
|
{
|
|
return wallet_transfer_funds(changePublicKey, QStringList{senderAddress}, recipientAddress, amount, optionalTipHex);
|
|
}
|
|
|
|
QStringList LogosBlockchainModule::wallet_get_known_addresses() {
|
|
QStringList out;
|
|
if (!node) {
|
|
qWarning() << "Could not execute the operation: The node is not running.";
|
|
return out;
|
|
}
|
|
auto [value, error] = get_known_addresses(node);
|
|
if (!is_ok(&error)) {
|
|
qCritical() << "Failed to get known addresses. Error:" << error;
|
|
return out;
|
|
}
|
|
// Each address is kAddressBytes (32) byte
|
|
for (size_t i = 0; i < value.len; ++i) {
|
|
const uint8_t* ptr = value.addresses[i];
|
|
if (ptr) {
|
|
QByteArray addr(reinterpret_cast<const char*>(ptr), kAddressBytes);
|
|
out.append(QString::fromUtf8(addr.toHex()));
|
|
}
|
|
}
|
|
free_known_addresses(value);
|
|
qDebug() << "blockchain lib: known addresses, count=" << out.size()
|
|
<< "sample:" << (out.isEmpty() ? QLatin1String("(none)") : out.constFirst());
|
|
return out;
|
|
}
|
|
|
|
void LogosBlockchainModule::emitEvent(const QString& eventName, const QVariantList& data) {
|
|
if (!logosAPI) {
|
|
qWarning() << "LogosBlockchainModule: LogosAPI not available, cannot emit" << eventName;
|
|
return;
|
|
}
|
|
if (!client) {
|
|
qWarning() << "LogosBlockchainModule: Failed to get liblogos_blockchain_module client for event" << eventName;
|
|
return;
|
|
}
|
|
client->onEventResponse(this, eventName, data);
|
|
}
|