[ANN] EEL — Community-Driven Proof-of-Work Coin | 0x Addresses | Simple Mining

[eelbest]

EEL is an early community-driven Proof-of-Work cryptocurrency built around a simple idea: a coin made by people, for people.

The project is focused on transparency, simple mining, public verification, and organic community growth. EEL is not an ERC-20 token, not a meme launch, not a paid-hype project, and not a short-term promotional experiment.

Website:
https://eel.best

What is EEL?

EEL is a native Proof-of-Work project designed for users who want a simple and understandable cryptocurrency experience. The goal is to make mining and basic coin usage accessible without unnecessary DeFi, NFT, smart-contract, or token-allocation complexity.

Main features:

* Native Proof-of-Work coin
* Simple mining model
* 0x-style public addresses
* Public block explorer
* Linux and Windows miner available
* Transparent project information
* Community-first development approach
* No paid hype, no artificial promotion, no pump-style launch

EEL is still early, and the project is being improved step by step. The current focus is on stability, mining access, explorer usability, documentation, and building a real community around the project.

Official website:
https://eel.best

Twitter:
https://x.com/eelpow

The EEL project is open to real feedback, testing, mining, documentation help, and constructive discussion from people who are interested in independent Proof-of-Work projects.

Im open on questions and suggestions.

[eelbest]

Thanks for sharing EEL. The focus on simplicity and community-driven development is refreshing in the current crypto landscape. The 0x-style addresses and public verification align well with transparent principles. Will be watching this space.

Thanks for the kind words and for taking the time to check the project.

That is exactly the direction I want for EEL: simple, transparent, and community-driven. The goal is not hype, but a small Proof-of-Work chain that people can mine, inspect, test, and understand.

I appreciate every real comment, question, and suggestion at this early stage.
Small update:

The official EEL website has been updated.
https://eel.best

Recent changes:

* Explorer fixes are now live
* Block, transaction, and address views were improved
* Public chain data is easier to inspect
* Linux and Windows miner downloads are available
* Transfer reliability checks are currently being tested using normal on-chain transactions
* Recent transaction activity may be part of normal testing and explorer verification

The current focus is still:

* mining access
* explorer stability
* transaction handling
* public verification
* clear documentation
* organic community growth

EEL is still early, so feedback, testing, miner reports, and suggestions are welcome.

No paid promotion, no artificial hype, no pump-style launch. The project is being built step by step, by people and for people.

[eelbest]

Small EEL progress update:

The project is still being tested and improved step by step.

Recent work and checks:

* Explorer views are being monitored after the latest fixes
* Address, transaction, and balance display are being checked with normal on-chain activity
* Transfer handling is being tested with real transactions
* Mining access is still one of the main priorities
* Windows, Linux, and browser mining options are being kept visible on the website
* Documentation and user instructions are being improved gradually

It is good to see real chain activity and real transfer testing happening, even at this early stage. For me, this is more important than artificial hype: blocks, transactions, explorer data, and users actually testing the network.

EEL is still a small early Proof-of-Work project, but the goal stays the same:

* simple mining
* public verification
* 0x-style addresses
* transparent explorer data
* organic community growth
* no paid promotion or pump-style launch

Website:
https://eel.best

Twitter:
https://x.com/eelpow

Anyone interested in testing, mining, reporting issues, or giving feedback is welcome.

[Aytacerdem]

Excited about QoreChain! The combination of quantum-safe cryptography, Web3 capabilities, and the QOR token makes it a promising project for the future of secure and AI-native blockchain ecosystems.

[BoozyTalking]

Excited about QoreChain! The combination of quantum-safe cryptography, Web3 capabilities, and the QOR token makes it a promising project for the future of secure and AI-native blockchain ecosystems.

Hey Bot! You post in the wrong thread 

[eelbest]

Small EEL update:

First, I noticed one reply in this thread mentioned a different project. Just to keep this topic clear: this thread is only about EEL, a small native Proof-of-Work chain with 0x-style addresses, simple mining, and a public explorer.

EEL is still being tested and improved step by step.

Current focus:

* explorer stability
* block, transaction, and address readability
* balance display checks
* normal on-chain transfer testing
* browser, Windows, and Linux mining access
* clearer instructions for new users
* public verification of chain activity

Recent transfer activity may include normal testing. I am using real on-chain transactions to check how transfers, balances, fees, and explorer history behave.

For me, this is more important than hype: the chain should be visible, testable, and understandable.

EEL is still early and experimental, but the direction is unchanged:

* native Proof-of-Work chain
* own blocks, balances, and transactions
* 0x-style addresses
* public explorer
* simple mining
* no ERC-20 contract
* no ICO
* no presale
* no paid-promotion campaign
* community-first growth

Website / explorer:
https://eel.best

X / Twitter:
https://x.com/eelpow

Feedback from miners, testers, and users is welcome. If you try the explorer, mining, wallet flow, or transfers, honest reports are useful.

[eelbest]

EEL COMMUNITY TESTING REQUEST
Mining, transfers and explorer verification

EEL is now at the stage where practical user testing is more useful than another general project update.

I would like to invite anyone interested in small independent Proof-of-Work projects to test one simple flow.

Website and public explorer:
https://eel.best

HOW TO TEST EEL

1. Open the official EEL website:

https://eel.best

2. Use an existing 0x-style wallet address or create a separate wallet specifically for testing.

3. Choose one of the available mining methods:

• Browser miner
• Windows miner
• Linux miner

4. Mine for a short period.

5. Check the mined balance and address history through the public explorer.

6. If possible, send a small test transaction to another EEL address and verify:

• whether the balance updates correctly
• whether the transaction appears in the explorer
• whether the fee is displayed clearly
• whether the transaction order and timestamp are correct
• whether the receiving address shows the transfer

WHAT FEEDBACK IS CURRENTLY MOST USEFUL?

• Operating system and browser used
• Selected mining method
• Whether mining started without errors
• Whether the balance appeared correctly
• Whether transfers confirmed successfully
• Whether explorer pages were clear on desktop and mobile
• Any error message, broken link, or confusing instruction
• Suggestions that would make the first experience easier

Even a short report such as:

Windows miner works, balance visible, transfer confirmed.

would already be useful.

Screenshots, transaction hashes, miner logs, and honest criticism are welcome.

CURRENT OBJECTIVE

EEL is still early and experimental. It should not be treated as an investment product, and there are no promises regarding price, exchange listings, or future value.

The current objective is much simpler:

• keep the chain running reliably
• make mining understandable
• make transfers verifiable
• make explorer data readable
• identify problems through real usage
• improve the project openly with community feedback

TRANSPARENCY NOTE

EEL is a native Proof-of-Work chain with its own:

• blocks
• balances
• transactions
• mining process

EEL is not:

• an ERC-20 token
• an ICO
• a presale
• a staking product
• an NFT or DeFi launch
• a paid-promotion campaign

The project uses familiar 0x-style addresses to make the wallet flow easier, but EEL is an independent chain.

OFFICIAL LINKS

Website / Explorer:
https://eel.best

X / Twitter:
https://x.com/eelpow

Mine it. Send it. Verify it.

[eelbest]

A quick EEL update for everyone following the project.

Over the last weeks we've been focused on improving the basics that actually matter: mining accessibility, explorer reliability, and overall user experience.

One thing we continue to hear from people is that they appreciate how simple EEL is. No complicated staking systems, no endless layers of features — just a Proof-of-Work network that anyone can explore, test, and mine.

If you haven't looked at EEL recently, now is a good time to check it out. Mining is available directly through the browser, as well as on Windows and Linux, making it easy to get started and see how the network works for yourself.

We're still early, still building, and still improving things step by step with community feedback.

If you're interested in small independent PoW projects, we'd love to hear your thoughts and experiences.

🌐 EEL: https://eel.best

Thanks to everyone who has been mining, testing, and supporting the project so far. Every block, transaction, and piece of feedback helps move EEL forward. ⚡

[febry22]

do you have discord server? there's no info about block time or blocks per day?

[sssergy2705]

Code:

#include <iostream>
#include <string>
#include <thread>
#include <vector>
#include <atomic>
#include <chrono>
#include <iomanip>
#include <sstream>
#include <cstring>
#include <cstdint>
#include <cmath>
#include <algorithm>
#include <mutex>
#include <queue>
#include <ctime>
#include <memory>
#include <curl/curl.h>
#include <openssl/sha.h>
#include <csignal>
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
const std::string DEFAULT_NODE = "https://eel.best";
const size_t DEFAULT_WORKERS = std::thread::hardware_concurrency() > 0 ? std::thread::hardware_concurrency() : 4;

std::atomic<uint64_t> total_hashes{0};
std::atomic<bool> stop_program{false};
std::atomic<bool> stop_mining{false};
std::atomic<bool> block_found{false};
std::atomic<uint64_t> found_nonce{0};
std::string found_hash = "";
std::atomic<uint64_t> blocks_found{0};
std::atomic<uint64_t> shares_accepted{0};
std::atomic<uint64_t> shares_stale{0};
std::atomic<uint64_t> shares_rejected{0};
std::atomic<int64_t> total_reward_milliEEL{0};
auto start_time = std::chrono::steady_clock::now();

std::mutex job_mutex;
std::string current_job_id = "";
std::string current_payload = "";
int current_difficulty = 0;
double current_reward = 0.0;
std::atomic<uint64_t> job_version{0};
std::atomic<bool> new_work_available{false};

std::unique_ptr<std::atomic<uint64_t>[]> thread_hashes;
std::unique_ptr<std::atomic<bool>[]> thread_active;

std::atomic<uint64_t> last_total_hashes{0};
auto last_hashrate_check = std::chrono::steady_clock::now();

std::mutex log_mutex;
std::queue<std::string> log_messages;
void add_log(const std::string& msg) {
    std::lock_guard<std::mutex> lock(log_mutex);
    auto now = std::chrono::system_clock::now();
    auto time_t_now = std::chrono::system_clock::to_time_t(now);
    std::stringstream ss;
    ss << "[" << std::put_time(std::localtime(&time_t_now), "%H:%M:%S") << "] " << msg;
    log_messages.push(ss.str());
    while (log_messages.size() > 6) {
        log_messages.pop();
    }
}

inline int u64_to_str(uint64_t val, char* str) {
    if (val == 0) { str[0] = '0'; str[1] = '\0'; return 1; }
    char temp[24];
    int pos = 0;
    while (val > 0) {
        temp[pos++] = (val % 10) + '0';
        val /= 10;
    }
    int len = pos;
    for (int i = 0; i < len; i++) str[i] = temp[len - 1 - i];
    str[len] = '\0';
    return len;
}

inline int count_leading_zeros(const uint8_t* hash) {
    int bits = 0;
    for (int i = 0; i < 32; i++) {
        uint8_t v = hash[i];
        if (v == 0) { bits += 8; continue; }
        if (v < 0x01) { bits += 8; break; } if (v < 0x02) { bits += 7; break; }
        if (v < 0x04) { bits += 6; break; } if (v < 0x08) { bits += 5; break; }
        if (v < 0x10) { bits += 4; break; } if (v < 0x20) { bits += 3; break; }
        if (v < 0x40) { bits += 2; break; } if (v < 0x80) { bits += 1; break; }
        break;
    }
    return bits;
}

std::string hash_to_hex(const uint8_t* hash) {
    std::ostringstream oss;
    for (int i = 0; i < 32; i++)
        oss << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
    return oss.str();
}

std::string format_duration(double seconds) {
    if (seconds < 60) return std::to_string((int)seconds) + "s";
    if (seconds < 3600) return std::to_string((int)(seconds / 60)) + "m " + std::to_string((int)(seconds) % 60) + "s";
    int hours = (int)(seconds / 3600);
    int mins = ((int)seconds % 3600) / 60;
    return std::to_string(hours) + "h " + std::to_string(mins) + "m";
}

size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* userp) {
    userp->append((char*)contents, size * nmemb);
    return size * nmemb;
}

std::string http_get(const std::string& url) {
    CURL* curl = curl_easy_init();
    std::string response;
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 8L);
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 4L);
        curl_easy_setopt(curl, CURLOPT_TCP_KEEPALIVE, 1L);
        CURLcode res = curl_easy_perform(curl);
        curl_easy_cleanup(curl);
        if (res != CURLE_OK) throw std::runtime_error("HTTP GET failed: " + std::string(curl_easy_strerror(res)));
    }
    return response;
}

std::string http_post(const std::string& url, const std::string& json_data) {
    CURL* curl = curl_easy_init();
    std::string response;
    if (curl) {
        struct curl_slist* headers = nullptr;
        headers = curl_slist_append(headers, "Content-Type: application/json");
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json_data.c_str());
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 8L);
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 4L);
        CURLcode res = curl_easy_perform(curl);
        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
        if (res != CURLE_OK) throw std::runtime_error("HTTP POST failed: " + std::string(curl_easy_strerror(res)));
    }
    return response;
}

std::string extract_json_string(const std::string& json, const std::string& key) {
    std::string search = "\"" + key + "\":";
    size_t pos = json.find(search);
    if (pos == std::string::npos) return "";
    pos += search.length();
    while (pos < json.length() && (json[pos] == ' ' || json[pos] == '\t')) pos++;
    if (json[pos] == '"') {
        pos++;
        size_t end = json.find('"', pos);
        return json.substr(pos, end - pos);
    }
    size_t end = json.find_first_of(",} \t\n\r", pos);
    return json.substr(pos, end - pos);
}

int extract_json_int(const std::string& json, const std::string& key) {
    std::string val = extract_json_string(json, key);
    if (val.empty()) return 0;
    return std::stoi(val);
}

double extract_json_double(const std::string& json, const std::string& key) {
    std::string val = extract_json_string(json, key);
    if (val.empty()) return 0.0;
    return std::stod(val);
}

void mine_thread(size_t thread_id, uint64_t start_nonce, uint64_t step, int difficulty, const SHA256_CTX& base_ctx) {
    thread_active[thread_id].store(true);
    uint64_t nonce = start_nonce;
    char nonce_str[24];
    uint8_t hash[32];
    const uint64_t BATCH_SIZE = 200000;
    uint64_t local_hashes = 0;
    while (!stop_mining.load(std::memory_order_relaxed)) {
        for (uint64_t i = 0; i < BATCH_SIZE; i++) {
            int len = u64_to_str(nonce, nonce_str);
            SHA256_CTX ctx = base_ctx;
            SHA256_Update(&ctx, nonce_str, len);
            SHA256_Final(hash, &ctx);
            int bits = count_leading_zeros(hash);
            if (bits >= difficulty) {
                found_nonce.store(nonce, std::memory_order_relaxed);
                found_hash = hash_to_hex(hash);
                block_found.store(true, std::memory_order_relaxed);
                stop_mining.store(true, std::memory_order_relaxed);
                thread_hashes[thread_id].fetch_add(local_hashes);
                total_hashes.fetch_add(local_hashes);
                thread_active[thread_id].store(false);
                return;
            }
            nonce += step;
        }
        local_hashes += BATCH_SIZE;
        thread_hashes[thread_id].fetch_add(BATCH_SIZE);
        total_hashes.fetch_add(BATCH_SIZE);
    }
    thread_hashes[thread_id].fetch_add(local_hashes);
    total_hashes.fetch_add(local_hashes);
    thread_active[thread_id].store(false);
}

void poll_new_work(const std::string& node, const std::string& address) {
    std::string last_job_id = "";
    while (!stop_program.load()) {
        try {
            std::string url = node + "/api/v1/mining/work?address=" + address + "&_=" + std::to_string(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count());
            std::string response = http_get(url);
            
            std::string new_id = extract_json_string(response, "job_id");
            if (new_id.empty()) new_id = extract_json_string(response, "jobId");
            
            if (!new_id.empty() && new_id != last_job_id) {
                std::lock_guard<std::mutex> lock(job_mutex);
                current_job_id = new_id;
                current_payload = extract_json_string(response, "payload");
                if (current_payload.empty()) current_payload = extract_json_string(response, "data");
                current_difficulty = extract_json_int(response, "difficulty");
                if (current_difficulty == 0) current_difficulty = extract_json_int(response, "target_bits");
                current_reward = extract_json_double(response, "reward");
                if (current_reward == 0) current_reward = extract_json_double(response, "block_reward");
                
                last_job_id = new_id;
                job_version.fetch_add(1, std::memory_order_relaxed);
                new_work_available.store(true, std::memory_order_relaxed);
                add_log("New job: " + new_id.substr(0, 8) + "... (Diff: " + std::to_string(current_difficulty) + ")");
            }
        } catch (...) {
        }
        std::this_thread::sleep_for(std::chrono::seconds(5)); 
    }
}


void render_ui(const std::string& node, const std::string& address, size_t workers) {
    std::cout << "\033[H\033[2J"; 
    
    auto now = std::chrono::steady_clock::now();
    auto total_elapsed = std::chrono::duration<double>(now - start_time).count();
    

    auto elapsed_since_last = std::chrono::duration<double>(now - last_hashrate_check).count();
    uint64_t current_total = total_hashes.load();
    uint64_t hashes_delta = current_total - last_total_hashes.load();
    double hashrate = (hashes_delta / std::max(0.1, elapsed_since_last)) / 1e6;
    
    last_total_hashes.store(current_total);
    last_hashrate_check = now;
    
    int64_t reward_milli = total_reward_milliEEL.load();
    double total_rewards = reward_milli / 1000.0;
    std::cout << "================================================================================\n";
    std::cout << " EEL Miner v1.0 (sgminer-style) | Uptime: " << std::setw(8) << format_duration(total_elapsed) << " | Network: " << node << "\n";
    std::cout << "================================================================================\n";
    std::cout << " [SUMMARY]\n";
    std::cout << "  Hashrate : " << std::fixed << std::setprecision(2) << std::setw(8) << hashrate << " MH/s\n";
    std::cout << "  Difficulty: " << std::setw(8) << current_difficulty << "  |  Blocks Found: " << std::setw(4) << blocks_found.load() << "\n";
    std::cout << "  Accepted : " << std::setw(8) << shares_accepted.load() << "  |  Stale: " << std::setw(4) << shares_stale.load() << "  |  Rejected: " << std::setw(4) << shares_rejected.load() << "\n";
    std::cout << "  Total Reward: " << std::fixed << std::setprecision(4) << std::setw(8) << total_rewards << " EEL\n";
    std::cout << "--------------------------------------------------------------------------------\n";
    std::cout << " [DEVICES]\n";
    
    for (size_t i = 0; i < workers; i++) {
        bool active = thread_active[i].load();
        uint64_t hashes = thread_hashes[i].load();
        double t_hashrate = (hashes / std::max(1.0, total_elapsed)) / 1e6;
        std::string status = active ? "[OK]" : "[--]";
        std::cout << "  " << status << " Thread " << std::setw(2) << i << ": " << std::fixed << std::setprecision(2) << std::setw(8) << t_hashrate << " MH/s\n";
    }
    std::cout << "--------------------------------------------------------------------------------\n";
    std::cout << " [LOG]\n";
    {
        std::lock_guard<std::mutex> lock(log_mutex);
        std::queue<std::string> temp_queue = log_messages;
        while (!temp_queue.empty()) {
            std::cout << "  " << temp_queue.front() << "\n";
            temp_queue.pop();
        }
    }
    std::cout << "================================================================================\n";
    std::cout << std::flush;
}

void signal_handler(int) {
    stop_program.store(true);
    stop_mining.store(true);
    std::cout << "\n\033[H\033[2J";
    std::cout << "Miner stopped gracefully.\n";
    exit(0);
}

int main(int argc, char* argv[]) {
    std::string node = DEFAULT_NODE;
    std::string address = "";
    size_t workers = DEFAULT_WORKERS;
    for (int i = 1; i < argc; i++) {
        std::string arg = argv[i];
        if (arg == "--node" && i + 1 < argc) { node = argv[++i]; }
        else if (arg == "--address" && i + 1 < argc) { address = argv[++i]; }
        else if (arg == "--workers" && i + 1 < argc) { workers = std::stoull(argv[++i]); }
        else if (arg == "--help" || arg == "-h") {
            std::cout << "EEL sgminer-Style Miner\nUsage: ./miner --address 0xYOUR_ADDRESS [--workers 8]\n";
            return 0;
        }
    }
    if (address.empty() || address.substr(0, 2) != "0x" || address.length() != 42) {
        std::cerr << "Error: Invalid or missing 0x address.\n";
        return 1;
    }
    std::signal(SIGINT, signal_handler);
    curl_global_init(CURL_GLOBAL_ALL);
    
    thread_hashes = std::make_unique<std::atomic<uint64_t>[]>(workers);
    thread_active = std::make_unique<std::atomic<bool>[]>(workers);
    std::thread poller(poll_new_work, node, address);
    poller.detach();
    add_log("Miner started. Connecting to " + node + "...");
    add_log("Address: " + address);
    uint64_t last_version = 0;
    while (!stop_program.load()) {
        while (job_version.load(std::memory_order_relaxed) == last_version && !stop_program.load()) {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            render_ui(node, address, workers);
        }
        
        if (stop_program.load()) break;
        std::string job_id, payload;
        int diff;
        double reward;
        {
            std::lock_guard<std::mutex> lock(job_mutex);
            job_id = current_job_id;
            payload = current_payload;
            diff = current_difficulty;
            reward = current_reward;
        }
        if (job_id.empty() || payload.empty() || diff == 0) {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            continue;
        }
        last_version = job_version.load(std::memory_order_relaxed);
        new_work_available.store(false);
        SHA256_CTX base_ctx;
        SHA256_Init(&base_ctx);
        SHA256_Update(&base_ctx, payload.data(), payload.length());
        SHA256_Update(&base_ctx, "|", 1);
        stop_mining.store(false);
        block_found.store(false);
        found_nonce.store(0);
        found_hash = "";
        
        std::vector<std::thread> threads;
        for (size_t i = 0; i < workers; i++) {
            threads.emplace_back(mine_thread, i, i, workers, diff, base_ctx);
        }
        while (!block_found.load() && !new_work_available.load() && !stop_program.load()) {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            render_ui(node, address, workers);
        }
        stop_mining.store(true);
        for (auto& t : threads) if (t.joinable()) t.join();
        
        render_ui(node, address, workers);
        if (block_found.load() && found_nonce.load() != 0) {
            add_log("Solution found! Nonce: " + std::to_string(found_nonce.load()));
            
            std::string submit_url = node + "/api/v1/mining/submit";
            std::string json = "{\"job_id\":\"" + job_id + "\",\"nonce\":" + std::to_string(found_nonce.load()) + ",\"hash\":\"" + found_hash + "\",\"address\":\"" + address + "\"}";
            
            bool submitted = false;
            for (int retry = 0; retry < 3 && !submitted; retry++) {
                try {
                    if (retry > 0) {
                        add_log("Retrying submit (" + std::to_string(retry + 1) + "/3)...");
                        std::this_thread::sleep_for(std::chrono::seconds(1));
                    }
                    std::string res = http_post(submit_url, json);
                    
                    if (res.find("stale") != std::string::npos || res.find("chain advanced") != std::string::npos) {
                        shares_stale.fetch_add(1);
                        add_log("Share rejected: Stale job");
                        submitted = true; break;
                    }
                    
                    std::string status = extract_json_string(res, "status");
                    double block_reward = extract_json_double(res, "reward");
                    if (status == "accepted") {
                        shares_accepted.fetch_add(1);
                        blocks_found.fetch_add(1);
                        total_reward_milliEEL.fetch_add((int64_t)((block_reward > 0 ? block_reward : reward) * 1000));
                        add_log("Share ACCEPTED! Reward: +" + std::to_string(block_reward > 0 ? block_reward : reward) + " EEL");
                        submitted = true;
                    } else {
                        shares_rejected.fetch_add(1);
                        add_log("Share rejected: " + res);
                        submitted = true;
                    }
                } catch (const std::exception& e) {
                    add_log("Submit error: " + std::string(e.what()));
                }
            }
        } else if (new_work_available.load()) {
            add_log("Job rotated (network advanced).");
        }
        
        std::this_thread::sleep_for(std::chrono::milliseconds(200));
    }
    curl_global_cleanup();
    return 0;
}
#pragma GCC diagnostic pop

Code:

g++ -O3 -march=native -pthread miner.cpp -o miner -lcurl -lssl -lcrypto

Minor miner improvement.

Run it ./miner --address 0xaddress --workers 8