davide/cpu-miner
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(c-miner): port miner pipeline to modular C implementation

Browse Source
This commit is contained in:
Davide Grilli
2026-03-30 01:07:19 +02:00
parent 9a0a170799
commit d2c118833b
18 changed files with 3299 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

323
mining_loop.c Normal file
View File

@@ -0,0 +1,323 @@
#include "mining_loop.h"
#include <pthread.h>
#include <stdarg.h>
#include <stdatomic.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include "block_builder.h"
#include "miner.h"
#include "rpc.h"
#include "types.h"
#include "utils.h"
typedef struct {
int event_fd;
int worker_idx;
int single_mode;
} StatusCtx;
typedef struct {
RpcClient rpc;
atomic_int *stop_flag;
atomic_int *new_block_flag;
int check_interval;
} WatchdogCtx;
static void emit_eventf(int fd, const char *fmt, ...) {
char line[512];
va_list ap;
int n;
if (fd < 0) {
return;
}
va_start(ap, fmt);
n = vsnprintf(line, sizeof(line), fmt, ap);
va_end(ap);
if (n > 0) {
size_t len = (size_t)n;
if (len > sizeof(line) - 1) {
len = sizeof(line) - 1;
}
write(fd, line, len);
}
}
static void status_callback(long long attempts, double hashrate_hz, void *ctx_ptr) {
StatusCtx *ctx = (StatusCtx *)ctx_ptr;
if (ctx->event_fd >= 0) {
emit_eventf(ctx->event_fd, "status %d %.6f %lld\n", ctx->worker_idx, hashrate_hz / 1000.0, attempts);
return;
}
if (ctx->single_mode) {
printf("\r[main] hashrate: %.2f kH/s | attempts: %lld", hashrate_hz / 1000.0, attempts);
fflush(stdout);
}
}
static void *watchdog_thread_main(void *arg) {
WatchdogCtx *ctx = (WatchdogCtx *)arg;
char *last_hash = NULL;
if (rpc_get_best_block_hash(&ctx->rpc, &last_hash) == 0) {
return NULL;
}
while (atomic_load(ctx->stop_flag) == 0) {
int i;
char *new_hash = NULL;
for (i = 0; i < ctx->check_interval; i++) {
if (atomic_load(ctx->stop_flag) != 0) {
break;
}
sleep(1);
}
if (atomic_load(ctx->stop_flag) != 0) {
break;
}
if (rpc_get_best_block_hash(&ctx->rpc, &new_hash)) {
if (new_hash != NULL && last_hash != NULL && strcmp(new_hash, last_hash) != 0) {
atomic_store(ctx->new_block_flag, 1);
atomic_store(ctx->stop_flag, 1);
free(last_hash);
last_hash = new_hash;
break;
}
free(new_hash);
}
}
free(last_hash);
return NULL;
}
int run_mining_loop(const MinerConfig *cfg, int worker_idx, const char *extranonce2, int event_fd) {
RpcClient rpc;
char *chain = NULL;
char *miner_script = NULL;
StatusCtx status_ctx;
rpc_init(&rpc, cfg);
if (rpc_test_connection(&rpc, &chain) == 0) {
fprintf(stderr, "[main] connessione RPC fallita\n");
return 1;
}
if (rpc_get_address_script_pubkey(&rpc, cfg->wallet_address, &miner_script) == 0) {
fprintf(stderr, "[main] impossibile leggere scriptPubKey per wallet\n");
free(chain);
return 1;
}
fprintf(stdout, "[main] chain=%s worker=%d extranonce2=%s\n", chain, worker_idx, extranonce2);
status_ctx.event_fd = event_fd;
status_ctx.worker_idx = worker_idx;
status_ctx.single_mode = (event_fd < 0) ? 1 : 0;
while (1) {
BlockTemplate tpl;
char *coinbase_hex = NULL;
char *coinbase_txid = NULL;
char *target_hex = NULL;
char *merkle_root = NULL;
uint8_t header80[80];
uint8_t header76[76];
atomic_int stop_flag;
atomic_int new_block_flag;
WatchdogCtx wctx;
pthread_t watchdog;
MineResult result;
char *header_hex = NULL;
char *block_hash = NULL;
char *serialized = NULL;
int witness_count = 0;
size_t i;
memset(&tpl, 0, sizeof(tpl));
if (rpc_get_block_template(&rpc, &tpl) == 0) {
fprintf(stderr, "[main] getblocktemplate fallita, retry in 5s\n");
sleep(5);
continue;
}
rpc_ensure_witness_data(&rpc, &tpl);
for (i = 0; i < tpl.tx_count; i++) {
if (is_segwit_tx(tpl.transactions[i].data)) {
witness_count++;
}
}
fprintf(stdout, "[main] template height=%d tx=%zu segwit=%d\n", tpl.height, tpl.tx_count, witness_count);
if (build_coinbase_transaction(
&tpl,
miner_script,
cfg->extranonce1,
extranonce2,
cfg->coinbase_message,
&coinbase_hex,
&coinbase_txid
) == 0) {
fprintf(stderr, "[main] build coinbase fallita\n");
block_template_free(&tpl);
sleep(1);
continue;
}
target_hex = calculate_target_hex(tpl.bits, cfg->difficulty_factor, chain);
merkle_root = calculate_merkle_root(coinbase_txid, tpl.transactions, tpl.tx_count);
if (target_hex == NULL || merkle_root == NULL) {
fprintf(stderr, "[main] target/merkle falliti\n");
free(coinbase_hex);
free(coinbase_txid);
free(target_hex);
free(merkle_root);
block_template_free(&tpl);
sleep(1);
continue;
}
if (build_block_header_bytes(
tpl.version,
tpl.previous_block_hash,
merkle_root,
(uint32_t)tpl.curtime,
tpl.bits,
0,
header80
) == 0) {
fprintf(stderr, "[main] build header fallito\n");
free(coinbase_hex);
free(coinbase_txid);
free(target_hex);
free(merkle_root);
block_template_free(&tpl);
sleep(1);
continue;
}
memcpy(header76, header80, 76);
atomic_init(&stop_flag, 0);
atomic_init(&new_block_flag, 0);
wctx.check_interval = cfg->check_interval;
wctx.stop_flag = &stop_flag;
wctx.new_block_flag = &new_block_flag;
rpc_init(&wctx.rpc, cfg);
pthread_create(&watchdog, NULL, watchdog_thread_main, &wctx);
if (mine_block(
header76,
target_hex,
cfg->nonce_mode,
cfg->batch,
cfg->timestamp_update_interval,
&stop_flag,
status_callback,
&status_ctx,
&result
) == 0) {
atomic_store(&stop_flag, 1);
pthread_join(watchdog, NULL);
if (status_ctx.single_mode) {
putchar('\n');
}
if (atomic_load(&new_block_flag) != 0) {
fprintf(stdout, "[main] nuovo best block: riavvio ciclo\n");
}
free(coinbase_hex);
free(coinbase_txid);
free(target_hex);
free(merkle_root);
block_template_free(&tpl);
continue;
}
atomic_store(&stop_flag, 1);
pthread_join(watchdog, NULL);
if (status_ctx.single_mode) {
putchar('\n');
}
header_hex = bytes_to_hex(result.header, 80);
if (header_hex == NULL) {
free(coinbase_hex);
free(coinbase_txid);
free(target_hex);
free(merkle_root);
block_template_free(&tpl);
sleep(1);
continue;
}
{
uint8_t dh[32];
uint8_t rev[32];
double_sha256(result.header, 80, dh);
memcpy(rev, dh, 32);
reverse_bytes(rev, 32);
block_hash = bytes_to_hex(rev, 32);
}
if (block_hash != NULL) {
fprintf(stdout, "[main] block trovato: %s\n", block_hash);
emit_eventf(event_fd, "found %d %.6f\n", worker_idx, result.hashrate_hz / 1000.0);
emit_eventf(event_fd, "hash %d %s\n", worker_idx, block_hash);
}
serialized = serialize_block(header_hex, coinbase_hex, tpl.transactions, tpl.tx_count);
if (serialized == NULL) {
fprintf(stderr, "[main] serializzazione blocco fallita\n");
free(block_hash);
free(header_hex);
free(coinbase_hex);
free(coinbase_txid);
free(target_hex);
free(merkle_root);
block_template_free(&tpl);
sleep(1);
continue;
}
rpc_submit_block(&rpc, serialized);
emit_eventf(event_fd, "submit %d\n", worker_idx);
free(serialized);
free(block_hash);
free(header_hex);
free(coinbase_hex);
free(coinbase_txid);
free(target_hex);
free(merkle_root);
block_template_free(&tpl);
sleep(1);
}
free(chain);
free(miner_script);
return 0;
}