oracle_utils.cpp

#include <cstdlib>
#include <cinttypes>

#include "core/src/network_messages/common_def.h"
#include "core/src/network_messages/oracles.h"

#include "qpi_adapter.h"

#include "oracle_utils.h"
#include "logger.h"
#include "utils.h"
#include "structs.h"
#include "connection.h"
#include "key_utils.h"
#include "wallet_utils.h"
#include "contracts.h"


void printGetOracleQueryHelpAndExit()
{
    LOG("qubic-cli [...] -getoraclequery [QUERY_ID]\n");
    LOG("    Print the oracle query, metadata, and reply if available.\n");
    LOG("qubic-cli [...] -getoraclequery pending\n");
    LOG("    Print the query IDs for all pending queries.\n");
    LOG("qubic-cli [...] -getoraclequery pending+\n");
    LOG("    Print the oracle query, metadata, and reply if available for each query ID received by pending.\n");
    LOG("qubic-cli [...] -getoraclequery all [TICK]\n");
    LOG("    Print the query IDs of all queries started in the given tick.\n");
    LOG("qubic-cli [...] -getoraclequery all+ [TICK]\n");
    LOG("    Print the oracle query, metadata, and reply if available for each query ID received by all.\n");
    LOG("qubic-cli [...] -getoraclequery user [TICK]\n");
    LOG("    Print the query IDs of user queries started in the given tick.\n");
    LOG("qubic-cli [...] -getoraclequery user+ [TICK]\n");
    LOG("    Print the oracle query, metadata, and reply if available for each query ID received by user.\n");
    LOG("qubic-cli [...] -getoraclequery contract [TICK]\n");
    LOG("    Print the query IDs of contract one-time queries started in the given tick.\n");
    LOG("qubic-cli [...] -getoraclequery contract+ [TICK]\n");
    LOG("    Print the oracle query, metadata, and reply if available for each query ID received by contract.\n");
    LOG("qubic-cli [...] -getoraclequery subscription [TICK]\n");
    LOG("    Print the query IDs of contract subscription queries started in the given tick.\n");
    LOG("qubic-cli [...] -getoraclequery subscription+ [TICK]\n");
    LOG("    Print the oracle query, metadata, and reply if available for each query ID received by subscription.\n");
    LOG("qubic-cli [...] -getoraclequery stats\n");
    LOG("    Print the oracle query statistics of the core node.\n");
    LOG("qubic-cli [...] -getoraclequery revenue\n");
    LOG("    Print the current oracle revenue points of all computors.\n");
    exit(1);
}

void printMakeOracleUserQueryTransactionHelpAndExit()
{
    LOG("qubic-cli [...] -queryoracle [INTERFACE] [QUERY_STRING] [TIMEOUT_IN_SECONDS]\n\n");
    LOG("    Send an oracle user query transaction. [INTERFACE] and [QUERY_STRING] are mandatory parameters.\n");
    LOG("    [TIMEOUT_IN_SECONDS] is optional (the default value is 60 seconds).\n\n");
    LOG("    As [INTERFACE], you can currently chose one of following:\n");
    for (uint32_t idx = 0; idx < OI::oracleInterfacesCount; ++idx)
        LOG("        %s\n", oracleInterfaceToString(idx).c_str());
    LOG("\n");
    LOG("    The [QUERY_STRING] depends on the [INTERFACE]. Run the following to get help:\n");
    LOG("        qubic-cli [...] queryoracle [INTERFACE]\n");
    LOG("    For example:\n");
    LOG("        qubic-cli [...] queryoracle price\n");
    exit(1);
}

static std::vector<int64_t> receiveQueryIds(QCPtr qc, unsigned int reqType, long long reqTickOrId = 0)
{   
    struct {
        RequestResponseHeader header;
        RequestOracleData req;
    } packet;
    packet.header.setSize(sizeof(packet));
    packet.header.randomizeDejavu();
    packet.header.setType(RequestOracleData::type());
    memset(&packet.req, 0, sizeof(packet.req));
    packet.req.reqType = reqType;
    packet.req.reqTickOrId = reqTickOrId;

    qc->sendData((uint8_t*)&packet, packet.header.size());

    std::vector<int64_t> queryIds;

    uint8_t headerBuffer[sizeof(RequestResponseHeader)];
    auto header = (const RequestResponseHeader*)headerBuffer;
    int recvByte = qc->receiveData(headerBuffer, sizeof(RequestResponseHeader));

    std::vector<uint8_t> payloadBuffer(sizeof(RespondOracleData) + 128 * sizeof(int64_t));

    while (recvByte == sizeof(RequestResponseHeader))
    {
        if (header->dejavu() != packet.header.dejavu())
        {
            throw std::runtime_error("Unexpected dejavu!");
        }
        if (header->type() == RespondOracleData::type())
        {
            unsigned int payloadSize = header->size() - sizeof(RequestResponseHeader);
            if (payloadSize > payloadBuffer.size())
            {
                payloadBuffer.resize(payloadSize);
            }
            recvByte = qc->receiveAllDataOrThrowException(payloadBuffer.data(), payloadSize);
            auto resp = (RespondOracleData*)(payloadBuffer.data());
            if (resp->resType == RespondOracleData::respondQueryIds)
            {
                long long idsNumBytes = payloadSize - sizeof(RespondOracleData);
                if (idsNumBytes % 8 != 0)
                {
                    throw std::runtime_error("Malformatted RespondOracleData::respondQueryIds message!");

                }
                else if (idsNumBytes > 0)
                {
                    const uint8_t* queryIdBuffer = payloadBuffer.data() + sizeof(RespondOracleData);
                    queryIds.insert(queryIds.end(),
                        (int64_t*)queryIdBuffer, (int64_t*)(queryIdBuffer + idsNumBytes));
                }
            }
            else if (resp->resType == RespondOracleData::respondTickRange)
            {
                if (payloadSize != sizeof(RespondOracleData) + sizeof(RespondOracleDataValidTickRange))
                {
                    throw std::runtime_error("Malformatted RespondOracleData::respondTickRange message!");
                }
                const auto* tickRange = (RespondOracleDataValidTickRange*)(payloadBuffer.data() + sizeof(RespondOracleData));
                if (reqTickOrId < tickRange->firstTick)
                {
                    throw std::runtime_error("Data is not available, because tick is too old.");
                }
                else
                {
                    throw std::runtime_error("Data is not available yet. You need to wait. Current tick is " + std::to_string(tickRange->currentTick));
                }
            }
        }
        else if (header->type() == END_RESPOND)
        {
            return queryIds;
        }
        else
        {
            throw std::runtime_error("Unexpected packet type!");
        }
        recvByte = qc->receiveData(headerBuffer, sizeof(RequestResponseHeader));
    }

    throw ConnectionTimeout();
}

static void receiveQueryInformation(QCPtr qc, int64_t queryId, RespondOracleDataQueryMetadata& metadata,
    std::vector<uint8_t>& query, std::vector<uint8_t>& reply, std::vector<uint16_t>& contractIndices)
{
    // send request
    struct {
        RequestResponseHeader header;
        RequestOracleData req;
    } request;
    request.header.setSize(sizeof(request));
    request.header.randomizeDejavu();
    request.header.setType(RequestOracleData::type());
    memset(&request.req, 0, sizeof(request.req));
    request.req.reqType = RequestOracleData::requestQueryAndResponse;
    request.req.reqTickOrId = queryId;
    qc->sendData((uint8_t*)&request, request.header.size());

    // reset output
    memset(&metadata, 0, sizeof(RespondOracleDataQueryMetadata));
    query.clear();
    reply.clear();
    contractIndices.clear();

    // prepare output buffers
    uint8_t headerBuffer[sizeof(RequestResponseHeader)];
    auto responseHeader = (const RequestResponseHeader*)headerBuffer;
    std::vector<uint8_t> payloadBuffer(2048);

    // receive query data
    int recvHeaderBytes = qc->receiveData(headerBuffer, sizeof(RequestResponseHeader));
    while (recvHeaderBytes == sizeof(RequestResponseHeader))
    {
        // get remaining part of the response
        const unsigned int responsePayloadSize = responseHeader->size() - sizeof(RequestResponseHeader);
        if (responsePayloadSize > payloadBuffer.size())
        {
            payloadBuffer.resize(responsePayloadSize);
        }
        qc->receiveAllDataOrThrowException(payloadBuffer.data(), responsePayloadSize);

        // only process if dejavu matches (response is to current request, skip otherwise)
        if (responseHeader->dejavu() == request.header.dejavu())
        {
            if (responseHeader->type() == RespondOracleData::type())
            {
                // Oracle data response
                if (responsePayloadSize < sizeof(RespondOracleData))
                {
                    throw std::runtime_error("Malformatted RespondOracleData reply");
                }
                auto respOracleData = (RespondOracleData*)payloadBuffer.data();
                auto responseInnerPayload = payloadBuffer.data() + sizeof(RespondOracleData);
                auto responseInnerPayloadSize = responsePayloadSize - sizeof(RespondOracleData);

                if (respOracleData->resType == RespondOracleData::respondQueryMetadata
                    && responsePayloadSize == sizeof(RespondOracleData) + sizeof(RespondOracleDataQueryMetadata))
                {
                    // Query metadata
                    metadata = *(RespondOracleDataQueryMetadata*)(responseInnerPayload);
                }
                else if (respOracleData->resType == RespondOracleData::respondQueryData)
                {
                    // Oracle query
                    query.insert(query.end(),
                        responseInnerPayload,
                        responseInnerPayload + responseInnerPayloadSize);
                }
                else if (respOracleData->resType == RespondOracleData::respondReplyData)
                {
                    // Oracle reply
                    reply.insert(reply.end(),
                        responseInnerPayload,
                        responseInnerPayload + responseInnerPayloadSize);
                }
                else if (respOracleData->resType == RespondOracleData::respondNotifiedSubscriberContracts)
                {
                    // Subscriber contract indices
                    contractIndices.insert(contractIndices.end(),
                        (uint16_t*)(responseInnerPayload),
                        (uint16_t*)(responseInnerPayload + responseInnerPayloadSize));
                }
                else
                {
                    throw std::runtime_error("Unexpected RespondOracleData message sub-type");
                }
            }
            else if (responseHeader->type() == END_RESPOND)
            {
                // End of output packages for this request
                if (metadata.queryId != queryId)
                    throw std::logic_error("Unknown query ID!");
                else
                    break;
            }

            // try to get next message header
            recvHeaderBytes = qc->receiveData(headerBuffer, sizeof(RequestResponseHeader));
        }
    }
    if (recvHeaderBytes < sizeof(RequestResponseHeader))
    {
        throw std::logic_error("Error receiving message header.");
    }
}

static const char* getOracleQueryTypeStr(uint8_t type)
{
    switch (type)
    {
    case ORACLE_QUERY_TYPE_CONTRACT_QUERY:
        return "contract one-time query";
    case ORACLE_QUERY_TYPE_CONTRACT_SUBSCRIPTION:
        return "contract subscription query";
    case ORACLE_QUERY_TYPE_USER_QUERY:
        return "user query";
    default:
        return "unknown";
    }
}

static const char* getOracleQueryStatusStr(uint8_t type)
{
    switch (type)
    {
    case ORACLE_QUERY_STATUS_PENDING:
        return "pending";
    case ORACLE_QUERY_STATUS_COMMITTED:
        return "committed";
    case ORACLE_QUERY_STATUS_SUCCESS:
        return "success";
    case ORACLE_QUERY_STATUS_UNRESOLVABLE:
        return "unresolvable";
    case ORACLE_QUERY_STATUS_TIMEOUT:
        return "timeout";
    default:
        return "unknown";
    }
}

static std::string getOracleQueryStatusFlagsStr(uint16_t flags)
{
    std::string str;
    if (flags & ORACLE_FLAG_REPLY_RECEIVED)
        str += "-> core node received valid reply from the oracle machine";
    if (flags & ORACLE_FLAG_INVALID_ORACLE)
        str += "\n\t- oracle machine reported that oracle (data source) in query was invalid";
    if (flags & ORACLE_FLAG_ORACLE_UNAVAIL)
        str += "\n\t- oracle machine reported that oracle (data source) isn't available at the moment";
    if (flags & ORACLE_FLAG_INVALID_TIME)
        str += "\n\t- oracle machine reported that time in query was invalid";
    if (flags & ORACLE_FLAG_INVALID_PLACE)
        str += "\n\t- oracle machine reported that place in query was invalid";
    if (flags & ORACLE_FLAG_INVALID_ARG)
        str += "\n\t- oracle machine reported that an argument in query was invalid";
    if (flags & ORACLE_FLAG_BAD_SIZE_REPLY)
        str += "\n\t- core node got reply of wrong size from the oracle machine";
    if (flags & ORACLE_FLAG_OM_DISAGREE)
        str += "\n\t- core node got different replies from oracle machine nodes";
    if (flags & ORACLE_FLAG_BAD_SIZE_REVEAL)
        str += "\n\t- weren't enough reply commit tx with the same digest before timeout (< 451)";

    return str;
}

static void printQueryInformation(const RespondOracleDataQueryMetadata& metadata, const std::vector<uint8_t>& query,
    const std::vector<uint8_t>& reply, const std::vector<uint16_t>& contractIndices)
{
    LOG("Query ID: %" PRIi64 "\n", metadata.queryId);
    LOG("Type: %s (%" PRIu8 ")\n", getOracleQueryTypeStr(metadata.type), metadata.type);
    LOG("Status: %s (%" PRIu8 ")\n", getOracleQueryStatusStr(metadata.status), metadata.status);
    LOG("Status Flags: %" PRIu16 " %s\n", metadata.statusFlags, getOracleQueryStatusFlagsStr(metadata.statusFlags).c_str());
    LOG("Query Tick: %" PRIu32 "\n", metadata.queryTick);

    char queryingIdentity[128] = { 0 };
    getIdentityFromPublicKey(metadata.queryingEntity.m256i_u8, queryingIdentity, /*isLowerCase=*/false);
    LOG("Querying Entity: %s\n", queryingIdentity);

    LOG("Timeout: %s\n", toString(*(QPI::DateAndTime*)&metadata.timeout).c_str());
    LOG("Interface Index: %" PRIu32 "\n", metadata.interfaceIndex);
    if (metadata.type == ORACLE_QUERY_TYPE_CONTRACT_SUBSCRIPTION)
        LOG("Subscription ID: %" PRIi32 "\n", metadata.subscriptionId);
    if (contractIndices.size() > 0)
    {
        LOG("Notified subscriber contracts:");
        for (uint16_t contractIdx : contractIndices)
        {
            const char* name = getContractName(contractIdx, true);
            if (name)
                LOG(" %d=%s", (int)contractIdx, name);
            else
                LOG(" %d", (int)contractIdx);
        }
        LOG("\n");
    }
    if (metadata.status == ORACLE_QUERY_STATUS_SUCCESS)
    {
        LOG("Reveal Tick: %" PRIu32 "\n", metadata.revealTick);
    }
    else
    {
        LOG("Total Commits: %" PRIu16 "\n", metadata.totalCommits);
        LOG("Agreeing Commits: %" PRIu16 "\n", metadata.agreeingCommits);
    }

    std::string queryStr = oracleQueryToString(metadata.interfaceIndex, query);
    if (queryStr.find("error") != std::string::npos)
    {
        std::vector<char> hexQuery(2 * query.size() + 1, 0);
        byteToHex(query.data(), hexQuery.data(), static_cast<int>(query.size()));
        LOG("Query: %s %s\n", hexQuery.data(), queryStr.c_str());
    }
    else
    {
        LOG("Query: %s\n", queryStr.c_str());
    }

    if (reply.size() > 0)
    {
        std::string replyStr = oracleReplyToString(metadata.interfaceIndex, reply);
        if (replyStr.find("error") != std::string::npos)
        {
            std::vector<char> hexReply(2 * reply.size() + 1, 0);
            byteToHex(reply.data(), hexReply.data(), static_cast<int>(reply.size()));
            LOG("Reply: %s %s\n", hexReply.data(), replyStr.c_str());
        }
        else
        {
            LOG("Reply: %s\n", replyStr.c_str());
        }
    }
}

static void receiveQueryStats(QCPtr& qc, RespondOracleDataQueryStatistics& stats)
{
    struct {
        RequestResponseHeader header;
        RequestOracleData req;
    } packet;
    packet.header.setSize(sizeof(packet));
    packet.header.randomizeDejavu();
    packet.header.setType(RequestOracleData::type());
    memset(&packet.req, 0, sizeof(packet.req));
    packet.req.reqType = RequestOracleData::requestQueryStatistics;
    qc->sendData((uint8_t*)&packet, packet.header.size());

    constexpr unsigned long long responseSize = sizeof(RequestResponseHeader) + sizeof(RespondOracleData) + sizeof(RespondOracleDataQueryStatistics);
    uint8_t buffer[responseSize];
    int recvByte = qc->receiveData(buffer, responseSize);
    if (recvByte < sizeof(RequestResponseHeader) + sizeof(RespondOracleData))
    {
        throw std::logic_error("Connection closed.");
    }
    const auto* header = (RequestResponseHeader*)buffer;
    const auto* header2 = (RespondOracleData*)(buffer + sizeof(RequestResponseHeader));
    if (header->type() != RespondOracleData::type() || header2->resType != RespondOracleData::respondQueryStatistics)
    {
        throw std::logic_error("Unexpected response message.");
    }
    if (header->size() != responseSize)
    {
        LOG("WARNING: Unexpected response message size. Maybe the version of the core and qubic-cli do not match.\n");
    }
    memset(&stats, 0, sizeof(stats));
    const auto* receivedStats = (RespondOracleDataQueryStatistics*)(buffer + sizeof(RequestResponseHeader) + sizeof(RespondOracleData));
    unsigned int copySize = header->size() - sizeof(RequestResponseHeader) - sizeof(RespondOracleData);
    if (sizeof(stats) < copySize)
        copySize = sizeof(stats);
    memcpy(&stats, receivedStats, copySize);
}

static void printQueryStats(const RespondOracleDataQueryStatistics& stats)
{
    const float revealPerSuccess = (stats.successfulCount) ? float(stats.revealTxCount) / stats.successfulCount : 0;
    LOG("successful:   % " PRIu64 " queries (takes %.3f ticks on average, %.1f reveal tx / success)\n", stats.successfulCount, float(stats.successAvgMilliTicksPerQuery) / 1000.0f, revealPerSuccess);
    LOG("timeout:      % " PRIu64 " queries in total (average timeout is %.3f ticks)\n", stats.timeoutCount, float(stats.timeoutAvgMilliTicksPerQuery) / 1000.0f);
    LOG("              % " PRIu64 " queries before OM reply\n", stats.timeoutNoReplyCount);
    LOG("              % " PRIu64 " queries before commit quorum\n", stats.timeoutNoCommitCount);
    LOG("              % " PRIu64 " queries before reveal\n", stats.timeoutNoRevealCount);
    LOG("unresolvable: % " PRIu64 " queries\n", stats.unresolvableCount);
    LOG("pending:      % " PRIu64 " queries in total\n", stats.pendingCount);
    LOG("              % " PRIu64 " queries before OM reply (takes %.3f ticks on average)\n", stats.pendingOracleMachineCount, float(stats.oracleMachineReplyAvgMilliTicksPerQuery) / 1000.0f);
    LOG("              % " PRIu64 " queries before commit quorum (takes %.3f ticks on average)\n", stats.pendingCommitCount, float(stats.commitAvgMilliTicksPerQuery) / 1000.0f);
    LOG("              % " PRIu64 " queries before reveal / success\n", stats.pendingRevealCount);
    LOG("total:        % " PRIu64 " contract one-time queries\n", stats.contractQueries);
    LOG("              % " PRIu64 " contract subscription queries\n", stats.subscriptionQueries);
    LOG("              % " PRIu64 " user queries\n", stats.userQueries);
    if (stats.oracleMachineRepliesDisagreeCount > 0)
    {
        LOG("OM issues:    % " PRIu64 " queries had OM replies that differ between OMs\n", stats.oracleMachineRepliesDisagreeCount);
    }
    if (stats.wrongKnowledgeProofCount > 0)
    {
        LOG("Core issues:  % " PRIu64 " commit tx had wrong knowledge proof\n", stats.wrongKnowledgeProofCount);
    }
}

static void receiveOracleRevenuePoints(QCPtr& qc, std::vector<uint64_t>& revenuePoints)
{
    struct {
        RequestResponseHeader header;
        RequestOracleData req;
    } packet;
    packet.header.setSize(sizeof(packet));
    packet.header.randomizeDejavu();
    packet.header.setType(RequestOracleData::type());
    memset(&packet.req, 0, sizeof(packet.req));
    packet.req.reqType = RequestOracleData::requestOracleRevenuePoints;
    qc->sendData((uint8_t*)&packet, packet.header.size());

    constexpr unsigned long long responseSize = sizeof(RequestResponseHeader) + sizeof(RespondOracleData) + 8 * 676;
    uint8_t buffer[responseSize];
    int recvByte = qc->receiveData(buffer, responseSize);
    if (recvByte != responseSize)
    {
        throw std::logic_error("Connection closed.");
    }
    const auto* header = (RequestResponseHeader*)buffer;
    const auto* header2 = (RespondOracleData*)(buffer + sizeof(RequestResponseHeader));
    if (header->type() != RespondOracleData::type() || header2->resType != RespondOracleData::respondOracleRevenuePoints)
    {
        throw std::logic_error("Unexpected response message.");
    }
    revenuePoints.resize(676);
    memcpy(revenuePoints.data(), buffer + sizeof(RequestResponseHeader) + sizeof(RespondOracleData), 8 * 676);
}

static void printOracleRevenuePoints(const std::vector<uint64_t>& revenuePoints)
{
    for (int i = 0; i < (int)revenuePoints.size(); ++i)
    {
        LOG("computor %d  ->  %" PRIu64 " oracle rev points\n", i, revenuePoints[i]);
    }
}

static bool parseTick(const char* tickStr, long long& tickFrom, long long& tickTo)
{
    char* writableTickStr = STRDUP(tickStr);
    std::string part1 = strtok2string(writableTickStr, "-");
    std::string part2 = strtok2string(NULL, "-");
    std::string part3 = strtok2string(NULL, "-");
    free(writableTickStr);
    if (!part3.empty())
    {
        LOG("Failed to parse tick string \"%s\"! Does not follow syntax N1-N2!", tickStr);
        return false;
    }

    bool okay = true;
    try
    {
        tickFrom = std::stoll(part1);
        if (tickFrom <= 0)
            okay = false;
        if (!part2.empty())
        {
            tickTo = std::stoll(part2);
            if (tickTo <= 0)
                okay = false;
        }
        else
            tickTo = tickFrom;
    }
    catch (std::exception e)
    {
        okay = false;
    }

    if (!okay)
    {
        LOG("Failed to parse tick string \"%s\"! Tick must be a positive number N or range N1-N2!", tickStr);
    }
    return okay;
}

void processGetOracleQueryWithTick(const char* nodeIp, const int nodePort, unsigned int reqType, const char* reqParam, bool getAllDetails)
{
    long long tickFrom = 0, tickTo = 0;
    if (!parseTick(reqParam, tickFrom, tickTo))
        return;

    const long long tickCount = tickTo - tickFrom + 1;
    if (tickCount < 1)
    {
        LOG("In range N1-N2, N2 should be greater than N2.");
        return;
    }
    if (tickCount > 10000)
    {
        LOG("Range of ticks is too large. Skipped for node performance reasons.");
        return;
    }

    // use longer 3 second timeout
    unsigned long timeoutMilliseconds = 3000;

    auto qc = make_qc(nodeIp, nodePort, timeoutMilliseconds);
    for (long long tick = tickFrom; tick <= tickTo; ++tick)
    {
        std::vector<int64_t> recQueryIds = receiveQueryIds(qc, reqType, tick);

        if (!getAllDetails)
        {
            LOG("Query IDs in tick %" PRIi64 ":\n", tick);
            for (const int64_t& id : recQueryIds)
            {
                LOG("- %" PRIi64 "\n", id);
            }
        }
        else
        {
            LOG("Number of query IDs in tick %" PRIi64 ": %d\n\n", tick, (int)recQueryIds.size());

            RespondOracleDataQueryMetadata metadata;
            std::vector<uint8_t> query, reply;
            std::vector<uint16_t> contractIndices;
            for (const int64_t& id : recQueryIds)
            {
                receiveQueryInformation(qc, id, metadata, query, reply, contractIndices);
                if (metadata.queryId == 0)
                {
                    LOG("Error getting query metadata! Stopping now.\n");
                    return;
                }
                printQueryInformation(metadata, query, reply, contractIndices);
                LOG("\n");
            }
        }
    }
}

void processGetOracleQuery(const char* nodeIp, const int nodePort, const char* requestType, const char* reqParam)
{
    if (strcasecmp(requestType, "") == 0)
        printGetOracleQueryHelpAndExit();

    if (strcasecmp(requestType, "pending") == 0)
    {
        auto qc = make_qc(nodeIp, nodePort);
        std::vector<int64_t> recQueryIds = receiveQueryIds(qc, RequestOracleData::requestPendingQueryIds);

        LOG("Pending query ids:\n");
        for (const int64_t& id : recQueryIds)
        {
            LOG("- %" PRIi64 "\n", id);
        }
    }
    else if (strcasecmp(requestType, "pending+") == 0)
    {
        auto qc = make_qc(nodeIp, nodePort);
        std::vector<int64_t> recQueryIds = receiveQueryIds(qc, RequestOracleData::requestPendingQueryIds);
        LOG("Number of pending query IDs: %d\n\n", (int)recQueryIds.size());

        RespondOracleDataQueryMetadata metadata;
        std::vector<uint8_t> query, reply;
        std::vector<uint16_t> contractIndices;
        for (const int64_t& id : recQueryIds)
        {
            receiveQueryInformation(qc, id, metadata, query, reply, contractIndices);
            printQueryInformation(metadata, query, reply, contractIndices);
            LOG("\n");
        }
    }
    else if (strcasecmp(requestType, "all") == 0)
    {
        processGetOracleQueryWithTick(nodeIp, nodePort,
            RequestOracleData::requestAllQueryIdsByTick, reqParam,
            /*getAllDetails=*/false);
    }
    else if (strcasecmp(requestType, "all+") == 0)
    {
        processGetOracleQueryWithTick(nodeIp, nodePort,
            RequestOracleData::requestAllQueryIdsByTick, reqParam,
            /*getAllDetails=*/true);
    }
    else if (strcasecmp(requestType, "user") == 0)
    {
        processGetOracleQueryWithTick(nodeIp, nodePort,
            RequestOracleData::requestUserQueryIdsByTick, reqParam,
            /*getAllDetails=*/false);
    }
    else if (strcasecmp(requestType, "user+") == 0)
    {
        processGetOracleQueryWithTick(nodeIp, nodePort,
            RequestOracleData::requestUserQueryIdsByTick, reqParam,
            /*getAllDetails=*/true);
    }
    else if (strcasecmp(requestType, "contract") == 0)
    {
        processGetOracleQueryWithTick(nodeIp, nodePort,
            RequestOracleData::requestContractDirectQueryIdsByTick, reqParam,
            /*getAllDetails=*/false);
    }
    else if (strcasecmp(requestType, "contract+") == 0)
    {
        processGetOracleQueryWithTick(nodeIp, nodePort,
            RequestOracleData::requestContractDirectQueryIdsByTick, reqParam,
            /*getAllDetails=*/true);
    }
    else if (strcasecmp(requestType, "subscription") == 0)
    {
        processGetOracleQueryWithTick(nodeIp, nodePort,
            RequestOracleData::requestContractSubscriptionQueryIdsByTick, reqParam,
            /*getAllDetails=*/false);
    }
    else if (strcasecmp(requestType, "subscription+") == 0)
    {
        processGetOracleQueryWithTick(nodeIp, nodePort,
            RequestOracleData::requestContractSubscriptionQueryIdsByTick, reqParam,
            /*getAllDetails=*/true);
    }
    else if (strcasecmp(requestType, "stats") == 0)
    {
        auto qc = make_qc(nodeIp, nodePort);
        RespondOracleDataQueryStatistics stats;
        receiveQueryStats(qc, stats);
        printQueryStats(stats);
    }
    else if (strcasecmp(requestType, "revenue") == 0)
    {
        auto qc = make_qc(nodeIp, nodePort);
        std::vector<uint64_t> computorRevenuePoints;
        receiveOracleRevenuePoints(qc, computorRevenuePoints);
        printOracleRevenuePoints(computorRevenuePoints);
    }
    else
    {
        // no known command, try to interpret param string as query id (8-byte int64_t number)
        int64_t queryId;
        try
        {
            queryId = std::stoll(std::string(requestType));
        }
        catch (std::exception e)
        {
            LOG("Expected query ID (unsigned integer), found unknown command %s!\n", requestType);
            return;
        }
        if (queryId <= 0)
        {
            LOG("Invalid query ID. Expected positive integer. Use commands such as \"user\" and \"contract\" to get a valid ID.\n");
            return;
        }

        auto qc = make_qc(nodeIp, nodePort);

        RespondOracleDataQueryMetadata metadata;
        std::vector<uint8_t> query, reply;
        std::vector<uint16_t> contractIndices;
        receiveQueryInformation(qc, queryId, metadata, query, reply, contractIndices);
        printQueryInformation(metadata, query, reply, contractIndices);
    }
}

static void receiveSubscriptionInformation(QCPtr qc, int64_t subscriptionId, RespondOracleDataSubscription& subscription,
    std::vector<uint8_t>& initialQuery, std::vector<RespondOracleDataSubscriber>& subscribers)
{
    // send request
    struct {
        RequestResponseHeader header;
        RequestOracleData req;
    } request;
    request.header.setSize(sizeof(request));
    request.header.randomizeDejavu();
    request.header.setType(RequestOracleData::type());
    memset(&request.req, 0, sizeof(request.req));
    request.req.reqType = RequestOracleData::requestSubscription;
    request.req.reqTickOrId = subscriptionId;
    qc->sendData((uint8_t*)&request, request.header.size());

    // reset output
    memset(&subscription, 0, sizeof(subscription));
    initialQuery.clear();
    subscribers.clear();

    // prepare output buffers
    uint8_t headerBuffer[sizeof(RequestResponseHeader)];
    auto responseHeader = (const RequestResponseHeader*)headerBuffer;
    std::vector<uint8_t> payloadBuffer(2048);

    // receive query data
    int recvHeaderBytes = qc->receiveData(headerBuffer, sizeof(RequestResponseHeader));
    while (recvHeaderBytes == sizeof(RequestResponseHeader))
    {
        // get remaining part of the response
        const unsigned int responsePayloadSize = responseHeader->size() - sizeof(RequestResponseHeader);
        if (responsePayloadSize > payloadBuffer.size())
        {
            payloadBuffer.resize(responsePayloadSize);
        }
        qc->receiveAllDataOrThrowException(payloadBuffer.data(), responsePayloadSize);

        // only process if dejavu matches (response is to current request, skip otherwise)
        if (responseHeader->dejavu() == request.header.dejavu())
        {
            if (responseHeader->type() == RespondOracleData::type())
            {
                // Oracle data response
                if (responsePayloadSize < sizeof(RespondOracleData))
                {
                    throw std::runtime_error("Malformatted RespondOracleData reply");
                }
                auto respOracleData = (RespondOracleData*)payloadBuffer.data();
                auto responseInnerPayload = payloadBuffer.data() + sizeof(RespondOracleData);
                auto responseInnerPayloadSize = responsePayloadSize - sizeof(RespondOracleData);

                if (respOracleData->resType == RespondOracleData::respondSubscription
                    && responsePayloadSize == sizeof(RespondOracleData) + sizeof(RespondOracleDataSubscription))
                {
                    // Subscription
                    subscription = *(RespondOracleDataSubscription*)(responseInnerPayload);
                }
                else if (respOracleData->resType == RespondOracleData::respondQueryData)
                {
                    // Initial oracle query
                    initialQuery.insert(initialQuery.end(),
                        responseInnerPayload,
                        responseInnerPayload + responseInnerPayloadSize);
                }
                else if (respOracleData->resType == RespondOracleData::respondSubscriber)
                {
                    // Add subscriber
                    subscribers.push_back(*(RespondOracleDataSubscriber*)(responseInnerPayload));
                }
                else
                {
                    throw std::runtime_error("Unexpected RespondOracleData message sub-type");
                }
            }
            else if (responseHeader->type() == END_RESPOND)
            {
                // End of output packages for this request
                if (subscription.subscriptionId != subscriptionId)
                    throw std::logic_error("Unknown subscription ID!");
                else
                    break;
            }

            // try to get next message header
            recvHeaderBytes = qc->receiveData(headerBuffer, sizeof(RequestResponseHeader));
        }
    }
    if (recvHeaderBytes < sizeof(RequestResponseHeader))
    {
        throw std::logic_error("Error receiving message header.");
    }
}

static void printSubscriptionInformation(RespondOracleDataSubscription& subscription,
    std::vector<uint8_t>& initialQuery, std::vector<RespondOracleDataSubscriber>& subscribers)
{
    LOG("Subscription ID: %" PRIi32 "\n", subscription.subscriptionId);
    LOG("Interface Index: %" PRIu32 "\n", subscription.interfaceIndex);
    std::string queryStr = oracleQueryToString(subscription.interfaceIndex, initialQuery);
    if (queryStr.find("error") != std::string::npos)
    {
        std::vector<char> hexQuery(2 * initialQuery.size() + 1, 0);
        byteToHex(initialQuery.data(), hexQuery.data(), static_cast<int>(initialQuery.size()));
        LOG("Initial query: %s %s\n", hexQuery.data(), queryStr.c_str());
    }
    else
    {
        LOG("Initial query: %s\n", queryStr.c_str());
    }
    LOG("Generated queries: %" PRIu32 "\n", subscription.generatedQueriesCount);
    LOG("Last pending query ID: %" PRIi64 "\n", subscription.lastPendingQueryId);
    LOG("Last revealed query ID: %" PRIi64 "\n", subscription.lastRevealedQueryId);
    LOG("Current subscriber contracts:\n");
    for (const auto& subscriber : subscribers)
    {
        const char* name = getContractName(subscriber.contractIndex, true);
        if (name)
            LOG("\t- %d=%s", (int)subscriber.contractIndex, name);
        else
            LOG("\t- %d", (int)subscriber.contractIndex);
        LOG(", period %d minute(s), next query %s\n", (int)subscriber.notificationPeriodMinutes, toString(*(QPI::DateAndTime*)&subscriber.nextQueryTimestamp).c_str());
    }
}

static std::vector<int32_t> receiveSubscriptionIds(QCPtr qc, unsigned int reqType, long long reqTickOrId = 0)
{
    struct {
        RequestResponseHeader header;
        RequestOracleData req;
    } packet;
    packet.header.setSize(sizeof(packet));
    packet.header.randomizeDejavu();
    packet.header.setType(RequestOracleData::type());
    memset(&packet.req, 0, sizeof(packet.req));
    packet.req.reqType = reqType;
    packet.req.reqTickOrId = reqTickOrId;

    qc->sendData((uint8_t*)&packet, packet.header.size());

    std::vector<int32_t> subscriptionIds;

    uint8_t headerBuffer[sizeof(RequestResponseHeader)];
    auto header = (const RequestResponseHeader*)headerBuffer;
    int recvByte = qc->receiveData(headerBuffer, sizeof(RequestResponseHeader));

    std::vector<uint8_t> payloadBuffer(sizeof(RespondOracleData) + 256 * sizeof(int32_t));

    while (recvByte == sizeof(RequestResponseHeader))
    {
        if (header->dejavu() != packet.header.dejavu())
        {
            throw std::runtime_error("Unexpected dejavu!");
        }
        if (header->type() == RespondOracleData::type())
        {
            unsigned int payloadSize = header->size() - sizeof(RequestResponseHeader);
            if (payloadSize > payloadBuffer.size())
            {
                payloadBuffer.resize(payloadSize);
            }
            recvByte = qc->receiveAllDataOrThrowException(payloadBuffer.data(), payloadSize);
            auto resp = (RespondOracleData*)(payloadBuffer.data());
            if (resp->resType == RespondOracleData::respondSubscriptionIds)
            {
                long long idsNumBytes = payloadSize - sizeof(RespondOracleData);
                if (idsNumBytes % 4 != 0)
                {
                    throw std::runtime_error("Malformatted RespondOracleData::respondSubscriptionIds message!");
                }
                else if (idsNumBytes > 0)
                {
                    const uint8_t* subscriptionIdBuffer = payloadBuffer.data() + sizeof(RespondOracleData);
                    subscriptionIds.insert(subscriptionIds.end(),
                        (int32_t*)subscriptionIdBuffer, (int32_t*)(subscriptionIdBuffer + idsNumBytes));
                }
            }
        }
        else if (header->type() == END_RESPOND)
        {
            return subscriptionIds;
        }
        else
        {
            throw std::runtime_error("Unexpected packet type!");
        }
        recvByte = qc->receiveData(headerBuffer, sizeof(RequestResponseHeader));
    }

    throw ConnectionTimeout();
}

int32_t getSubscriptionIdFromString(const char* s)
{
    int64_t subscriptionId = -1;
    try
    {
        subscriptionId = std::stoull(s);
    }
    catch (...)
    {
        subscriptionId = -1;
    }
    if (subscriptionId < 0 || subscriptionId > 0x7fffffffll)
    {
        LOG("Error: Invalid subscription ID!\n");
        return -1;
    }
    return (int32_t)subscriptionId;
}


void printGetOracleSubscriptionHelpAndExit()
{
    LOG("qubic-cli [...] -getoraclesubscription [SUBSCRIPTION_ID]\n");
    LOG("    Print information about a specific subsriptions, including subscribed contracts.\n");
    LOG("qubic-cli [...] -getoraclesubscription active\n");
    LOG("    Print the subscription IDs of all active subscriptions.\n");
    LOG("qubic-cli [...] -getoraclesubscription active+\n");
    LOG("    Print information about all active subscriptions.\n");
    LOG("qubic-cli [...] -getoraclesubscription contract [CONTRACT_INDEX_OR_NAME]\n");
    LOG("    Print the subscription IDs of all active subscriptions that the contract is subscribed to.\n");
    LOG("qubic-cli [...] -getoraclesubscription contract+ [CONTRACT_INDEX_OR_NAME]\n");
    LOG("    Print information about all active subscriptions that the contract is subscribed to.\n");
    exit(1);
}

void processGetMultipleOracleSubscriptions(const char* nodeIp, const int nodePort, unsigned int reqType, const char* reqParam, bool getAllDetails)
{
    auto qc = make_qc(nodeIp, nodePort);

    int64_t param = 0;
    if (reqType == RequestOracleData::requestActiveContractSubscriptions)
    {
        param = getContractIndex(reqParam);
    }

    std::vector<int32_t> subIds = receiveSubscriptionIds(qc, reqType, param);

    if (!getAllDetails)
    {
        LOG("Subscription IDs:\n");
        for (const int32_t& id : subIds)
        {
            LOG("- %" PRIi32 "\n", id);
        }
    }
    else
    {
        LOG("Number of subscription IDs: %d\n\n", (int)subIds.size());

        RespondOracleDataSubscription subscription;
        std::vector<uint8_t> query;
        std::vector<RespondOracleDataSubscriber> subscribers;

        for (const int32_t& id : subIds)
        {
            receiveSubscriptionInformation(qc, id, subscription, query, subscribers);
            if (subscription.lastPendingQueryId == 0)
            {
                LOG("Error getting subscription! Stopping now.\n");
                return;
            }
            printSubscriptionInformation(subscription, query, subscribers);
            LOG("\n");
        }
    }
}

void processGetOracleSubscription(const char* nodeIp, const int nodePort, const char* requestType, const char* reqParam)
{
    if (strlen(requestType) == 0)
        printGetOracleSubscriptionHelpAndExit();

    if (strcasecmp(requestType, "active") == 0)
    {
        processGetMultipleOracleSubscriptions(nodeIp, nodePort,
            RequestOracleData::requestActiveSubscriptions, reqParam,
            /*getAllDetails=*/false);
    }
    else if (strcasecmp(requestType, "active+") == 0)
    {
        processGetMultipleOracleSubscriptions(nodeIp, nodePort,
            RequestOracleData::requestActiveSubscriptions, reqParam,
            /*getAllDetails=*/true);
    }
    else if (strcasecmp(requestType, "contract") == 0)
    {
        processGetMultipleOracleSubscriptions(nodeIp, nodePort,
            RequestOracleData::requestActiveContractSubscriptions, reqParam,
            /*getAllDetails=*/false);
    }
    else if (strcasecmp(requestType, "contract+") == 0)
    {
        processGetMultipleOracleSubscriptions(nodeIp, nodePort,
            RequestOracleData::requestActiveContractSubscriptions, reqParam,
            /*getAllDetails=*/true);
    }
    else
    {
        int64_t subscriptionId = getSubscriptionIdFromString(requestType);
        if (subscriptionId < 0)
            return;

        RespondOracleDataSubscription subscription;
        std::vector<uint8_t> query;
        std::vector<RespondOracleDataSubscriber> subscribers;
        receiveSubscriptionInformation(make_qc(nodeIp, nodePort), (int32_t)subscriptionId, subscription, query, subscribers);
        printSubscriptionInformation(subscription, query, subscribers);
    }
}

static uint32_t getTimeoutInSeconds(const char* timeoutSecondsString)
{
    uint64_t timeoutSeconds = 60;
    if (strcasecmp(timeoutSecondsString, "") == 0)
    {
        LOG("No timeout specified. Using default timeout of 60 seconds.\n");
    }
    else
    {
        try
        {
            timeoutSeconds = std::stoull(timeoutSecondsString);
        }
        catch (...)
        {
            timeoutSeconds = 0;
        }
        if (timeoutSeconds == 0 || timeoutSeconds > 600)
        {
            LOG("Error: Invalid timeout! Please use a value between 1 and 600.\n");
            return UINT32_MAX;
        }
    }
    return (uint32_t)timeoutSeconds;
}

void makeOracleUserQueryTransaction(
    const char* nodeIp, int nodePort, const char* seed,
    const char* oracleInterfaceString,
    const char* queryString,
    const char* timeoutSecondsString,
    uint32_t scheduledTickOffset)
{
    if (strcasecmp(oracleInterfaceString, "") == 0)
        printMakeOracleUserQueryTransactionHelpAndExit();

    const uint32_t interfaceIndex = stringToOracleInterface(oracleInterfaceString);
    if (interfaceIndex >= OI::oracleInterfacesCount)
    {
        LOG("Unknown oracle interface \"%s\"!\nSupported options are:\n", oracleInterfaceString);
        for (uint32_t idx = 0; idx < OI::oracleInterfacesCount; ++idx)
            LOG("\t%s\n", oracleInterfaceToString(idx).c_str());
        return;
    }

    if (strcasecmp(queryString, "") == 0)
    {
        LOG("[QUERY_STRING] in %s oracle:\n", oracleInterfaceToString(interfaceIndex).c_str());
        printOracleQueryParamHelp(interfaceIndex);
        return;
    }

    std::vector<uint8_t> queryData = parseOracleQueryParams(interfaceIndex, queryString);
    if (queryData.size() == 0)
    {
        LOG("Error parsing [QUERY_STRING] \"%s\".\n", queryString);
        return;
    }

    uint32_t timeoutSeconds = getTimeoutInSeconds(timeoutSecondsString);
    if (timeoutSeconds == UINT32_MAX)
        return;

    // get oracle query fee
    OI::initOracleInterfaces();
    int64_t fee = OI::getOracleQueryFeeFunc[interfaceIndex](queryData.data());
    LOG("Fee for oracle query: %" PRIi64 "\n", fee);

    // build tx input data
    const int txInputSize = 8 + (int)queryData.size();
    std::vector<uint8_t> txInputData(txInputSize);
    *(uint32_t*)(txInputData.data()) = interfaceIndex;
    *(uint32_t*)(txInputData.data() + 4) = (uint32_t)timeoutSeconds * 1000; // timeout in milliseconds
    memcpy(txInputData.data() + 8, queryData.data(), queryData.size());

    // send transaction
    char destinationPublicKey[32] = {0};
    uint32_t scheduledTick = 0;
    makeCustomTransaction(nodeIp, nodePort, seed, destinationPublicKey,
        10, // TODO: define tx types as enum in core and use here
        fee, txInputSize, txInputData.data(), scheduledTickOffset, &scheduledTick);

    // TODO: print command to check directly
    LOG("\n\nYou may run the following command for checking the query:\n");
    LOG("qubic-cli [...] -getoraclequery user+ %u\n", scheduledTick);

    // TODO: add "my/my+ [TICK]" command that uses a future core command for filtering queries based on seed
    // (send tick + 4 bytes of public key to core for filtering oracle IDs)
}

void printMakePriceOracleContractTransactionHelpAndExit()
{
    LOG("qubic-cli [...] -querypriceviacontract query [CONTRACT] [QUERY_STRING] [TIMEOUT_IN_SECONDS]\n\n");
    LOG("qubic-cli [...] -querypriceviacontract subscribe [CONTRACT] [QUERY_STRING] [PERIOD_IN_MINUTES]\n\n");
    LOG("qubic-cli [...] -querypriceviacontract unsubscribe [CONTRACT] [SUBSCRIPTION_ID]\n\n");
    LOG("\tAs [CONTRACT], you may use \"QUTIL\" at the moment (and \"TESTEXC\" if test contracts are enabled in the net.\n");
    LOG("\tTo get help about [QUERY_STRING], leave it empty.\n");
    LOG("\t[TIMEOUT_IN_SECONDS] is optional. Default is 60 seconds.\n");

    exit(1);
}

void makePriceOracleContractTransaction(
    const char* nodeIp, int nodePort, const char* seed,
    const char* commandString,
    uint32_t contractIndex,
    const char* queryStringOrSubscriptionId,
    const char* timeString,
    uint32_t scheduledTickOffset)
{
    if (strcasecmp(commandString, "query") == 0)
    {
        std::vector<uint8_t> queryData = parseOracleQueryParams(0, queryStringOrSubscriptionId);
        if (queryData.size() != sizeof(OI::Price::OracleQuery))
        {
            LOG("Error parsing [QUERY_STRING] \"%s\".\n", queryStringOrSubscriptionId);
            return;
        }

        uint32_t timeoutSeconds = getTimeoutInSeconds(timeString);
        if (timeoutSeconds == UINT32_MAX)
            return;

        // get oracle query fee
        OI::initOracleInterfaces();
        int64_t fee = OI::getOracleQueryFeeFunc[0](queryData.data());
        LOG("Fee for oracle query: %" PRIi64 "\n", fee);

        // build input data
        queryData.resize(queryData.size() + 4);
        *(uint32_t*)(queryData.data() + sizeof(OI::Price::OracleQuery)) = timeoutSeconds * 1000;
        
        uint32_t scheduledTick = 0;
        makeContractTransaction(nodeIp, nodePort, seed, contractIndex, 100, fee, (int)queryData.size(), queryData.data(),
            scheduledTickOffset, nullptr, &scheduledTick);

        LOG("\n\nYou may run the following command for checking the query:\n");
        LOG("qubic-cli [...] -getoraclequery contract+ %u\n", scheduledTick);
    }
    else if (strcasecmp(commandString, "subscribe") == 0)
    {
        std::vector<uint8_t> queryData = parseOracleQueryParams(0, queryStringOrSubscriptionId);
        if (queryData.size() != sizeof(OI::Price::OracleQuery))
        {
            LOG("Error parsing [QUERY_STRING] \"%s\".\n", queryStringOrSubscriptionId);
            return;
        }

        uint64_t periodInMinutes = 0;
        try
        {
            periodInMinutes = std::stoull(timeString);
        }
        catch (...)
        {
            periodInMinutes = 0;
        }
        if (periodInMinutes == 0 || periodInMinutes > 1440)
        {
            LOG("Error: Invalid subscription period! Please use a value between 1 and 1440 (minutes).\n");
            return;
        }
        uint32_t periodInMilliseconds = (uint32_t)periodInMinutes * 60000;

        // get oracle subscription fee
        OI::initOracleInterfaces();
        int64_t fee = OI::Price::getSubscriptionFee(*(OI::Price::OracleQuery*)queryData.data(), periodInMilliseconds);
        LOG("Fee for oracle subscription: %" PRIi64 "\n", fee);

        // build full input data
        queryData.resize(queryData.size() + 5);
        *(uint32_t*)(queryData.data() + sizeof(OI::Price::OracleQuery)) = periodInMilliseconds;
        *(queryData.data() + sizeof(OI::Price::OracleQuery) + 4) = true;

        uint32_t scheduledTick = 0;
        makeContractTransaction(nodeIp, nodePort, seed, contractIndex, 101, fee, (int)queryData.size(), queryData.data(),
            scheduledTickOffset, nullptr, &scheduledTick);

        LOG("\n\nYou may run the following command for checking the subscription after some time:\n");
        LOG("qubic-cli [...] -getoraclesubscription contract+ %u\n", (unsigned int)contractIndex);
    }
    else if (strcasecmp(commandString, "unsubscribe") == 0)
    {
        int32_t subscriptionId = getSubscriptionIdFromString(queryStringOrSubscriptionId);
        if (subscriptionId < 0)
            return;

        makeContractTransaction(nodeIp, nodePort, seed, contractIndex, 102, 0, 4, &subscriptionId,
            scheduledTickOffset, nullptr);

        LOG("\n\nYou may run the following command for checking the unsubscribe after some time:\n");
        LOG("qubic-cli [...] -getoraclesubscription %d\n", subscriptionId);
    }
    else
    {
        printMakePriceOracleContractTransactionHelpAndExit();
    }
}