Merge PR #6 (large refactor), preserving main's fixes (#9)

* Add Linux GUI installer via Wine * Fix launcher creation and add BTF_RELAY env var support * Pool server, Linux GUI, unified binary, README update * Root Makefile: make linux / make windows, cleaner README * Remove headless.cpp * Fix XPM color count mismatch causing toolbar image errors on Linux * XPM icons: same code on Windows and Linux, no ifdefs around image loading * Fix GTK icon crash and Linux printf format * btfrv: 10s socket timeout on relay connects * Faster peer discovery: more dials per pass, shorter backoff and sleep * Parallel btf peer connections * Fix GetMyExternalIP - was disabled, now uses modern IP echo services * Fix tunnel disconnect on idle and restore external IP detection * Filter stale Nostr descriptors * Sort peers by freshness, fresh first * Pool: add .btf Stratum listener — miners connect via rendezvous, no port forwarding needed * btf pool: self-replacing listeners, one per relay, no queuing between miners * Mining modes: solo/operator/participant — pool server on-demand, participant Stratum client * Status bar: show external IP and .btf address * README: clean rewrite, concept-first, minimal * make linux produces AppImage * make linux produces AppImage * Pool dashboard: connect instructions, tabs, share bars * Perf fixes: GetMyExternalIP threaded, btf listener counted * Perf fixes: GetMyExternalIP threaded, btf listener counted * Fix pool payouts: defer until coinbase maturity * Pool: clean mode switching, IP warning * Pool: clean mode switching * Fix gPoolRunning: remove static * AppImage: use real icon from bitcoin.ico * Fix exit crash; Mining menu * Fix exit crash; Mining menu * Fix exit crash; Mining menu * Fix exit crash; Mining menu * Fix exit crash; Mining menu * Windows build: use mingw32-make * Windows build: simpler make invocation * Add deps-windows target * Windows build fixes * Windows build fixes * Windows makefile: fix obj dir * Windows: output to repo root * Windows: bundle DLLs into zip * Replace wxWidgets with ImGui+GLFW: same build on Linux and Windows * Fix %I64d that slipped back through rebase (main.h, net.h) * MinGW: add _mkdir shim for non-MSVC Windows; fix %I64d * Fix gPoolRunning extern outside ifndef _WIN32 * Remove -lboost_system: boost is header-only in this codebase * Status bar: copy buttons for IP and .btf address * Windows: add app icon via windres, strip wx stuff from rc file * Clean GUI: single Options menu item, bigger font, better spacing, cleaner options dialog; update README * GUI: embed Roboto font at 16px for clear readability on all platforms * Windows: windres depends on obj dir target * Fix balance hidden off-screen: put on own line below address bar * Windows: inline mkdir in every rule, remove dir target that confused make * Windows: move all target to top so it's the default rule * Fix pool server not starting: always start when operator selected, re-sync dialog state on open * Write debug.log to data directory (AppData/Roaming/Bitflash on Windows) * Participant miner: use wallet address as username so payouts go to wallet * Add .gitattributes to lock LF line endings, prevent CRLF drift * Refactor pool mining to btf-only transport * Persist pool settings and startup wiring * Prune stale peers and expose pool queries * Fix build regressions and add CLI mode/arg parity * Fix rpc miner stats declaration order * Centralize pool runtime extern declarations * Separate operator/participant dashboards and restore peer stats * Add live telemetry strip and clearer per-mode runtime metrics * Reduce mining dashboard clutter and remove manual pool entry * Count only authorized pool miners * Seed initial pool job on startup * Use a real share target for pool work * Switch pool accounting to round-based shares * Fix nostr pool announcer stats call sites * Fix pool stats definition order * Improve pool worker status display * Add mutex include for participant status * Replace ImClamp in dashboard layout * Clarify participant work status * Log participant status transitions * Reduce peer discovery log noise * Add participant status badge * Track participant auth acknowledgements * Log and validate pool job delivery * Stop persisting mining mode/pool settings across restarts LoadWallet() runs after CLI flags are parsed in main_gui.cpp, and was restoring nMineMode/strParticipantPool/strPoolName/strPoolDashboardUrl/ dPoolFeePercent/fGenerateBitcoins from wallet.dat every time, silently overwriting whatever was just set on the command line or in the current Options session -- no error, no log line. This is why pool name/address could show correctly in the UI but stay stale in the logs (UI held the in-memory value just set; logs eventually reflected whatever LoadWallet clobbered it back to), and why mode changed behavior across restarts. Mode/pool config is now decided fresh every launch: CLI flags if given, otherwise the compiled-in default. Nothing is written back to wallet.dat for these settings anymore, so there's nothing left to go stale or fight over load order. * Add explicit Relay mode as the new startup default 4th mining mode: node runs/syncs, never mines, no pool server -- an explicit option instead of an implicit side-effect of 'Solo + never click Start Mining'. Now the compiled-in default (was Solo). - main.h: MINE_RELAY = 0, renumbered other modes (nothing compares nMineMode against raw integers elsewhere, verified). - main.cpp: default nMineMode = MINE_RELAY; BitcoinMiner() early-returns for Relay, mirroring the existing Participant-mode guard. - gui.cpp: added Relay radio button, status label, and telemetry-strip text. Start/Stop Mining button is hidden for Relay (meaningless -- it never mines by definition); OK forces fGenerateBitcoins off if you switch into Relay while previously mining. * Announce pool changes immediately instead of waiting up to 60s ThreadBtfPoolAnnouncer re-read strPoolName/dPoolFeePercent/etc live, but only once per iteration of its 60s sleep loop, so a pool name/fee change in Options could take up to a minute to reach other nodes. - nostr.h/.cpp: add gAnnounceNow flag; the announcer's sleep loop now wakes early and publishes immediately when it's set, then clears it. - gui.cpp: Options OK handler sets gAnnounceNow when operator pool settings actually changed (name/dashboard/fee/mode), so a saved change is announced right away instead of on the next tick. * Give each pool miner a distinct extranonce2 so jobs no longer overlap mining.notify previously broadcast one identical 80-byte header (baked from a single server-side extraNonce) to every connected miner, so any two miners on the same job searched the exact same nNonce space instead of disjoint ranges. Each Miner connection is now assigned a unique extranonce2 on connect. BuildMinerBlock() takes the shared job template and appends that miner's extranonce2 to the coinbase scriptSig, recomputing the merkle root, so every miner gets its own header variant of the same job. mining.submit validates and, on a full block, assembles the block using that same miner-specific variant (via m->extranonce2), not the shared template. No client-side protocol change needed: main.cpp's participant miner already just takes whatever header bytes mining.notify hands it and submits (jobId, nonce) back, so it works unmodified against per-miner headers. Still simplified vs standard Stratum (no coinb1/coinb2/merkle-branch wire split, no mining.extranonce.subscribe reply payload) since this protocol was already a custom simplification pre-existing this fix. Syntax-checked with g++ -fsyntax-only (full link needs secp256k1/ RandomX/GLFW not present in this sandbox). * Fix debug.log never being written on the real Windows build printf-to-debug.log routing was gated on: #if defined(_WINDOWS) || !defined(_WIN32) _WINDOWS is only ever defined by the legacy, unused MSVC makefile.vc. The actual Windows build (makefile.mingw) never defines it, and _WIN32 IS defined there (mingw builtin), so on real Windows this condition was always false || false = false. printf() fell through to plain libc printf (stdout only), so debug.log was never created, and output was only visible if the process happened to be run attached to a console. OutputDebugStringF() was already platform-safe internally (always writes debug.log; only echoes to console when not on Windows), so the outer condition was pure dead weight. Made the routing unconditional. * Reduce base UI font size one more step (16px -> 14px) * Remove Start/Stop Mining button; mining state follows selected mode The button let a user configure a pool then click a separate toggle, creating states where the button's label/action didn't match what the selected mode actually needed. OK now starts/stops the miner thread itself based on nMineMode: Relay clears fGenerateBitcoins, the other three modes set it and spawn ThreadBitcoinMiner if it isn't already running (guarded by vfThreadRunning[3]). * Fix participant miner stuck waiting for notify after buffered multi-line recv Root cause of the operator/participant pairing successfully but no work ever flowing: PoolParticipantMiner()'s receive loop only pulled one line out of the socket per select() wakeup. The server sends the authorize reply, mining.set_difficulty, and mining.notify back-to-back on the same connection, and these often land in a single TCP segment — one recv() inside StratumRecvLine() buffers all three lines into 'buf', but only the first was extracted and processed. The remaining lines (frequently mining.notify itself) sat in 'buf' indefinitely, because select() only reports readability of the OS socket, not whether our own buffer still holds unprocessed complete lines — and the server had nothing further to send once the initial burst was over, so select() never fired again. Fix: drain any complete line already sitting in 'buf' first; only fall back to select()+recv() when 'buf' has no complete line left. * Fix mining.submit rejecting every share due to wrong param-count check Server required params.size() >= 4 for mining.submit, but the client only ever sends 3: [username, jobId, nonceHex] (indices 0-2, matching what the handler actually reads: p[1]=jobId, p[2]=nonceHex). Every submission was bounced with 'bad params' before its nonce was ever checked against the job, producing an endless share-sent/share-rejected loop with no other visible cause. Likely a leftover from the standard 5-field Stratum mining.submit shape, which this simplified 3-field protocol never matched. Threshold corrected to size() >= 3. * Fix mining.submit rejecting legitimate shares that weren't also winning blocks Pool share difficulty is intentionally ~256x easier than full network difficulty (MakeShareTarget() shifts the block target left 8 bits), so miners are expected to submit many shares per actual block found. But the handler replied to the miner based on ProcessBlock()/CheckBlock() success — validation against the much harder network target — rather than on whether the share met pool difficulty. Every legitimate share that wasn't also a winning block (the vast majority, by design) failed CheckBlock()'s nBits check and got reported to the miner as rejected. Now: reply(true) as soon as a submission clears pool-share difficulty. Only if it ALSO clears full network difficulty (job.target, not job.shareTarget) does it get submitted as a block — with no second reply sent, since the share was already acknowledged. * Fix dead-peer dial priority: freshness sort was undone by full shuffle ConnectDiscoveredBtfPeers sorted candidates newest-first, then immediately shuffled the whole list, making the freshness sort a no-op — every pass was fully random. Meanwhile g_btfPeerFails was tracked but never used to prioritize, so a peer that had failed 20 times in a row got equal footing with an untried or previously-successful peer; the only effect was backoff, capped at 15 minutes, so dead descriptors cycled back into the dial pool constantly. - Track successful connections (g_btfPeerEverConnected) and use it, plus fail history, to order candidates in tiers: known-good, then untried, then known-bad (worst offenders last). Freshness order is preserved within each tier instead of being discarded. - Raise the backoff cap for chronic failures (6+ in a row) from 15 minutes to 6 hours, so descriptors that are clearly dead stop consuming dial budget every pass while still getting retried eventually. * Batch-resolve .btf descriptors to stop hammering public relays during dial passes Root cause of 'stuck at 1 peer' despite good peer discovery: each parallel dial thread in ConnectDiscoveredBtfPeers called ConnectNodeBtf, which itself walked all configured relays (relay.damus.io, nos.lol, relay.nostr.band, relay.snort.social) to resolve that one peer's descriptor. With up to BTF_DIALS_PER_PASS (12) threads dialing at once, a single pass could fire up to 12 * nNostrRelays near-simultaneous fresh connections at the same handful of public relays -- easily enough to trip rate limits or get handshakes refused (exactly what the logs showed: 'handshake refused by relay.damus.io', repeated connect failures to relay.nostr.band / relay.snort.social). Peers that were genuinely reachable looked dead simply because their descriptor couldn't be fetched under that load, and then got penalized as known-bad by the dial-priority tiering from the previous fix. - Add BtfResolveMany: resolves every still-unresolved candidate's descriptor in a single Nostr REQ per relay (multiple authors in one filter), instead of one relay connection per candidate. A 12-candidate pass now costs at most a few relay round-trips total instead of dozens. - Add ConnectNodeBtfResolved / ConnectNodeBtfTail (net.cpp): given an already-resolved descriptor, dial straight to the peer's rendezvous node with zero further relay contact. ConnectDiscoveredBtfPeers now batch- resolves all candidates up front, then fans out tunnel-only connect threads in parallel -- no thundering herd against the relays. - Candidates that fail to resolve are recorded as a failure immediately (same backoff/fail-count bookkeeping as before) instead of spawning a thread with nothing to dial. * Stop reconnecting to relays constantly: pool one persistent connection per relay Real root cause of the ongoing 'handshake refused' / 'connect failed' spam and peer count stuck at 0-1: every relay-touching operation (startup self- test, per-pass seeding, batch descriptor resolve, pool announce, pool query) opened its own brand-new CWebSocket every single time it ran. Two independent threads (ThreadNostrSeed and ThreadBtfPoolAnnouncer) each reconnect from scratch on their own ~60s cycle, so a node could fire well over a dozen fresh TCP+TLS+WS handshakes at the same 4 public relays inside any given minute. Public relays -- relay.damus.io especially -- rate-limit new connections per source IP fairly aggressively, so this node was effectively DoS-ing itself: peers were genuinely reachable, but their descriptors couldn't be fetched because the relay had already started refusing this node's own repeated reconnects. - Add a small per-relay connection pool (g_relayPool) and an RAII CRelayLease that reuses a relay's live socket across calls instead of reconnecting every time, only reconnecting when a socket actually drops or was never established. - Route every relay call site through it: the startup self-test, the self-test loop, SeedFromRelay, BtfResolve, BtfResolveMany, BtfPublishPoolAnnouncement, BtfQueryPoolAnnouncement. - Only log 'connected to <relay>' on an actual fresh (re)connect, not on every pass that's just reusing an already-live socket, so the log reflects what's really happening instead of implying constant churn. This cuts fresh relay connections from several per minute down to essentially one per relay for the life of the process (until a relay actually drops the connection), which should make the rate-limit-driven refusals go away and let descriptor resolution -- and therefore dialing -- actually succeed at the rate the peer list implies it should. * Fix wallet crash on rejected send; remove legacy IP-based peer discovery - SendMoney() no longer throws when a committed tx is rejected by AcceptTransaction() (e.g. raced input already spent). It now unwinds the wallet state via RollbackTransactionSpent() and returns false, which the GUI already handles as 'Transaction failed.' - Removed the dead IP-based peer discovery/connect path now that discovery is entirely Nostr/.btf: CAddrDB/addr.dat, mapAddresses, AddAddress, ConnectNode(CAddress), FindNode(CAddress), ConnectSocket (SOCKS4 proxy helper), addrProxy, ThreadOpenConnections/2 class-C dialer and its thread spawn, the addr/getaddr P2P handlers, and the dead vAddrToSend/setAddrKnown fields on CNode. - Deleted irc.cpp/irc.h (already-disabled legacy seed code) and scrubbed references from headers_core.h and all four makefiles. * Raise peer connection target and add dial diversity; fix IPv4-only relay connect - BTF_TARGET_CONN: 8 -> 24. With ~100 known .btf peers, average degree needs only to exceed ln(N)~=4.6 for the network to stay connected with overwhelming probability (Erdos-Renyi); 24 is a healthy margin. - ConnectDiscoveredBtfPeers now splits each pass's dial budget ~70/30 between the existing reliability-tiered order and a random sample from the full fresh peer pool. Pure reliability bias means every node converges on the same 'known good' hub set, which correlates peer sets across the network -- a relay outage then drops the same edges everywhere at once instead of independent ones. The random slice keeps a floor of uncorrelated edges. - CWebSocket::Connect (relay websocket) now resolves with AF_UNSPEC and tries every returned address (IPv6 or IPv4) in turn instead of hard-failing on AF_INET-only resolution, which was one plausible cause of the relay.nostr.band:443 connect failures (CDN-fronted relays increasingly rate-limit/filter the v4 path). * Remove accidentally committed build binary; ignore src/bitflash * Fix pool participants getting stuck after the first job JobWatcherFn only rebuilt/broadcast a new Stratum job when a new block arrived on this node or no job existed yet. Once a job was built after startup, gHaveJob stayed true forever unless *this* node found the block, so with no new block (slow interval, or this node just not seeing one) every connected miner sat hashing the exact same job -- stale timestamp, stale mempool snapshot -- indefinitely. From the miner's side that's indistinguishable from being stuck: it worked at connect (gets the one-time job sent on authorize) and then nothing ever arrives again. Added a 60s periodic refresh so the job (and therefore mining.notify) gets rebroadcast on a timer too, same as a normal stratum pool, not only on new-block/no-job events. * Diversify Nostr discovery relay list Went from 4 relays to 7, and reduced Cloudflare concentration: previously 2 of 4 (damus.io, snort.social) sat behind the same CDN, so a Cloudflare- side issue could take out half the list even though they're nominally independent relays. Kept damus.io (most established) as the one CF-fronted entry and filled the rest with different hosts (nos.lol, nostr.band on Hetzner, nostr21.com, offchain.pub, nostr.mom, primal.net) so peer discovery doesn't have a single shared upstream as a point of failure. 7 relays is within the commonly recommended 5-10 range for redundancy. * Fix data race in RebuildJob: chain-state reads weren't holding cs_main pindexBest, nBestHeight, GetNextWorkRequired() and GetMedianTimePast() were all read without cs_main. A block being accepted concurrently by the P2P thread could interleave with this: pindexPrev captured from the old best block, but nBestHeight already bumped to the new one by the time job.height is computed, or pindexBest reassigned mid-read. That mismatch would make QueuePayouts() schedule a payout for the wrong maturity height for whatever block gets found against that job. Wrapped the whole chain-state snapshot in one CRITICAL_BLOCK(cs_main), consistent with how the rest of the codebase touches this state. * add operator fee * Add categorized, burst-collapsing logging for pool/worker/payout flow debug.log was growing unboundedly because every printf() call wrote unconditionally, so loops that log once per item (discovered peers, connect attempts) produced a near-identical line per address with no cap. Add LogPrint(category, ...): a drop-in printf replacement that tags each call with a subsystem (pool/worker/payout/net/nostr) and collapses repeated calls from the same call site into one line per 3s window plus a '(xN similar in 3s)' summary, so log growth is bounded by elapsed time instead of event count. Wire it through the whole pool -> work -> payout pipeline (rpc.cpp operator side, main.cpp participant/worker side, net.cpp/nostr.cpp peer & relay discovery), and along the way fix several previously *silent* failure points that produced exactly the reported symptom (worker stuck asking for work, nothing logged): - Relay listener registration failing: no log at all, so a pool with every relay down looked identical to a healthy idle pool. - No relays configured: silent infinite 5s retry loop. - Initial job seed failing at pool startup: silent. - JobWatcher: added a stuck-job watchdog that, after 15s with no job available, logs a specific diagnosis (no chain tip yet vs. RebuildJob() failing) instead of retrying forever in silence. - QueuePayouts(): a block found with zero recorded shares queued no payout and logged nothing. - FlushMaturePayouts(): an unparseable payout address was skipped with no log. - Participant miner: the 'waiting for pool notify' stall was only ever shown as a transient GUI status string, never written to debug.log. Now logs on a 15s cadence while stalled, and after 120s proactively drops the tunnel so the existing reconnect-in-10s loop gets a fresh attempt instead of hanging indefinitely. - Participant miner: share rejections were only a transient GUI status string; now logged with the pool's rejection reason. All edited files verified with g++ -fsyntax-only (gnu++14). * Fix two bugs causing worker stuck + log bloat 1. Worker stuck asking for work (main.cpp): The participant miner checked msg["result"].is_boolean() to detect the mining.subscribe acknowledgement (id==1), but the pool sends an array ([[["mining.notify",sid],sid,4]]) as per Stratum spec, not a boolean. is_boolean() always returned false, so gotSubscribeAck was never set true. This didn't directly block authorize (id==2 path is independent), but it did mean the status never advanced through "subscribed", leaving the progress logging misleading. More importantly, the same wrong assumption meant any pool that also gated job dispatch on a prior subscribe confirmation would leave the worker stuck forever with no diagnosis. Fix: accept any non-null result for id==1 (the array is the session/extranonce info; its contents don't matter for our use case). 2. Log bloat from ProcessMessages (main.cpp): ProcessMessages() used a bare printf() which fired unconditionally for every P2P message received -- the bulk of debug.log was this one line repeating thousands of times. Convert to LogPrint("net", ...) so it is gated behind fDebug (off by default) and burst-collapsed by the dedup introduced in the previous commit. * Fix log bloat, em-dashes, dead code, status bar, Connected/Detected peers Log bloat: - Gate all per-message/per-block/per-loop printf in main.cpp, net.h, net.cpp behind LogAcceptsCategory("net") -- only visible with -debug. This includes: received:/sending: hex dumps, got inventory, askfor, getblocks, getdata, received block, AddToWallet, RelayWalletTransactions, ProcessMessage FAILED, mining loop N-transactions line, retarget block, socket recv/send errors. AddToBlockIndex new best and ProcessBlock ACCEPTED intentionally left always-on (one line per block). - PoolParticipantMiner: status -> now LogPrint(worker) not printf. Em-dashes: - Replace all UTF-8 em-dashes (0xE2 0x80 0x94) with ASCII '--' in every source file (rpc.cpp, gui.cpp, main.cpp, main_gui.cpp, net.cpp, nostr.cpp, util.cpp, btfrv.cpp, db.cpp, db.h, main.h, headers.h, headers_core.h, util.h). 40 occurrences across 14 files. Dead code: - Remove unused gJobSeq atomic from rpc.cpp (written, never read). - Fix minerReward: was computed but payout loop used blockReward directly (operator fee was advertised but never deducted). Now payout correctly uses minerReward = blockReward * (1 - feeFrac). Status bar / peers: - Add GetDiscoveredPeerCount() to nostr.cpp/nostr.h (reads g_btfPeers size under cs_btfPeers). - Replace scrollable inline status text with DrawStatusBar(): a separate ImGui overlay window pinned to bottom of screen (NoScrollbar, NoBringToDisplayFront). Labels changed from 'Peers N' to 'Connected peers: N Detected peers: N'. * Rewrite gui.cpp: proper fixed status bar, scrollable content child Layout architecture: - DrawMainWindow() covers the full display width, height minus STATUS_BAR_H (22px). NoScrollbar + NoScrollWithMouse on the outer window so the chrome (menu, address/balance strip, telemetry strip, separators) never scrolls. - A BeginChild("##scroll") fills the remaining height after the fixed chrome, sized to GetContentRegionAvail().y -- which is already the space between the cursor and the bottom of the outer window. All mode-specific content (transaction table, participant pool list, operator workers/payouts) lives inside this child. Content that overflows gets a scrollbar; nothing bleeds past the outer window edge. - DrawStatusBar() is a separate overlay window pinned to the bottom 22px, drawn last so it is always on top. NoBringToDisplayFront is NOT used here -- drawing last is sufficient and avoids interaction issues with dialogs. - Status bar background is fully opaque (not alpha-blended) so it never shows content behind it. Labels and content: - 'Peers N' replaced with 'Connected peers: N Detected peers: N' using GetDiscoveredPeerCount(). - Mining indicator: '* Mode' instead of the 'filled circle' Unicode glyph that renders as boxes on some Linux font configs. - FmtAge used consistently; 'blocks deep' shortened to 'N deep' in tx list. - Options dialog: em-dashes removed from RadioButton labels (ASCII '--'). - Removed usedY dead variable (GetCursorPosY() result was unused). * Fix blocking bugs, dead code, pool/participant flow correctness Bugs fixed: StratumRecvLine blocking (main.cpp): The participant miner's recv loop called recv() with no timeout after select() said the socket was readable. If the server sent a partial line (split across two TCP segments), the second recv() would block indefinitely waiting for the rest -- the classic 'stuck asking for work' hang even though the pool was alive and had sent data. Fix: single non-blocking recv() pass (MSG_DONTWAIT on Linux, FIONREAD+recv on Windows). If no complete line is in the buffer yet, return false; the outer select() loop retries when more data arrives. BroadcastJob holding mutex during send() (rpc.cpp): BroadcastJob() held gMinersMutex across all SendLine() calls. send() can block if a slow miner's TCP receive buffer is full. With the mutex held, MinerThreadFn could not acquire it to remove a disconnecting miner, causing a deadlock-adjacent stall: broadcast blocked on slow miner, disconnect blocked on broadcast, new jobs not delivered. Fix: snapshot {fd, authorised, address, extranonce2} under the mutex, release it, then send to each fd outside the lock. Dead code removed (rpc.cpp): - gRpcUser, gRpcPassword: defined, never read or set by anything. - dHashesPerSec, nHPSTimerStart: leftover Bitcoin 0.1 stubs, unused. - IsInitialBlockDownload(): stub that returned pindexBest==NULL, never called anywhere in this codebase. - struct Share: declared with three fields, never instantiated. - Duplicate comment block before payout section. Other cleanup (main.cpp): - STUCK_NO_JOB_TIMEOUT_SECS moved from inside the loop body to file scope (was 'static const' inside a loop -- correct but confusing). - pblock->print() in solo miner gated behind LogAcceptsCategory("net") -- was unconditionally dumping a full block to stdout on every solve. - ERROR in BitcoinMiner printf converted to LogPrint("net"). * Pool/participant: fix recv blocking, BroadcastJob mutex, listener spawn, escaped em-dash main.cpp -- StratumRecvLine rewrite: The previous version called recv() in a while loop -- if select() said the socket was readable but only a partial line had arrived, the second recv() call would block indefinitely waiting for the rest of the line. This was the root cause of the recurring stuck-worker bug. Rewrite: single non-blocking recv (MSG_DONTWAIT on Linux, FIONREAD+recv on Windows). If no complete newline is in the buffer yet, return false immediately; the outer 50ms select() loop retries when more data arrives. This means the hash loop always stays responsive regardless of network fragmentation. rpc.cpp -- BroadcastJob mutex held across send(): BroadcastJob held gMinersMutex for the entire duration of sending jobs to all connected miners. send() can block if a slow miner's TCP buffer is full. With the mutex held, MinerThreadFn could not acquire it to clean up a disconnecting miner, stalling the whole broadcast. Fix: snapshot {fd, authorised, address, extranonce2} under the mutex, release it, then send to each fd without holding any lock. rpc.cpp -- LaunchThread failure not handled in BtfStratumAcceptOneFn: The replacement listener thread was launched via LaunchThread() which wraps _beginthread() but discarded the return value. If _beginthread fails (thread limit, OOM), the listener count stayed at 1 with no thread behind it -- that relay would get no new listener until the 30s outer loop in BtfStratumAcceptFn fired. Fix: call _beginthread() directly, check the return value, decrement and log on failure. rpc.cpp -- escaped em-dash in log string: BtfStratumAcceptFn had a literal \xe2\x80\x94 in a LogPrint format string that survived the em-dash sweep (it was source-encoded, not a UTF-8 byte in the file). Replaced with '--'. * Rewrite pool server: single event loop, no per-miner threads Replace the old architecture (one thread per connected miner + separate JobWatcher thread + BtfStratumAcceptFn thread with listener count tracking) with a clean two-layer design: Accept layer (one thread per relay, AcceptOneFn): Each relay gets exactly one persistent thread. It loops: calls blocking RvServiceRegister (waits for a miner to knock), then BtfServiceWrap (echan handshake), then pushes the finished plain socket to a small lock-protected queue, then loops immediately to accept the next miner. No listener count tracking. No replacement thread spawning. No races around spawn failure. The relay always has exactly one pending accept. Event loop (PoolEventLoop, runs on the ThreadRPCServer thread): Single thread owns all connected miner sockets. Each tick: 1. Drain the accept queue -- pick up any newly-connected miners. 2. Check for a new block -- rebuild job and broadcast if so. 3. No-job watchdog -- log and retry if job is missing too long. 4. Periodic job refresh -- restamp nTime every 60s. 5. select() over all miner fds with 50ms timeout. 6. For each readable fd: non-blocking RecvLine, drain all complete lines, dispatch each to HandleLine, collect dead fds. 7. Refresh GUI stats snapshot every 2s. Because the event loop is the only writer to gMiners, no mutex is needed on the miner list. The only mutexes remaining are: - gStatsMutex: guards the GUI-visible snapshot (StatsSnapshot, gWorkerStats, gPayoutViews) written by the event loop and read by GUI threads via GetPoolOperatorStats/GetPoolWorkerStats/GetPendingPayouts. - gReadyMutex: guards the accept queue between AcceptOneFn threads and the event loop. Other improvements in this rewrite: - gPendingPayouts is event-loop-only (no mutex needed). - Round share tracking lives in the event loop (roundShareCount map + roundShareTotal counter) -- zeroed on block found, no per-miner stat mutex needed mid-round. - QueuePayouts takes the share snapshot as a parameter instead of reaching into gMinerStats under a separate mutex. - BroadcastJob no longer snapshots miners to avoid a mutex -- it runs directly in the event loop with exclusive access to gMiners. - AcceptOneFn backs off 30s on relay registration failure instead of returning -- one relay going down doesn't kill the accept thread. - No goto. No per-thread dynamic allocation for listener contexts on each accepted connection. * Thorough logging and correctness fixes across the full pool/participant flow Every failure point in the operator->miner->payout chain now logs exactly what broke, with enough context to diagnose without a debugger. Operator side (rpc.cpp): RebuildJob: logs 'no chain tip (pindexBest is null)' on failure instead of silently returning false. HandleLine: - JSON parse errors logged with the raw line (first 80 chars) - subscribe: logs fd and session id - authorize: logs address, worker, and whether the address is valid - submit: logs stale-job case with submitted vs current job id; logs high-hash with actual hash and target values; logs valid shares with nonce and running session count; logs BLOCK CANDIDATE separately from BLOCK ACCEPTED/REJECTED so a ProcessBlock failure is unambiguous - unknown method logged (reveals miner software quirks) - reply() logs send failures with method name QueuePayouts: logs total payout amount, miner count, fee applied, and how many miners were below dust threshold. FlushMaturePayouts: logs 'insufficient funds or wallet locked?' on SendMoney failure instead of just 'FAILED'. BroadcastJob: logs job id and miner count on every broadcast. Event loop: logs when each new miner socket enters the loop; logs disconnect with session and round share counts. No-job watchdog: RebuildJob retried every 5s (not every 50ms tick), eliminating cs_main hammering when there is no chain tip. AcceptLoopFn: re-polls BtfAllRelays every 60s so relays discovered after startup are picked up; logs each new relay thread spawned. AcceptOneFn: logs relay name on start/stop; logs BtfServiceWrap (echan handshake) failure separately from RvServiceRegister failure. RecvLine: disconnected out-param distinguishes 'socket closed' from 'no complete line yet', preventing incorrect disconnection on partial recv. Participant side (main.cpp): StratumRecvLine: same disconnected out-param fix as RecvLine in rpc.cpp. Previously a false return could mean either 'disconnect' or 'no data yet', causing spurious reconnects when a partial line arrived. PoolParticipantMiner rewritten with step-by-step logging: Step 1 resolve: logs specific failure (no descriptor vs bad format) Step 2 tunnel: logs relay and failure reason Step 3 address: warns explicitly if payout address cannot be determined Step 4 subscribe/authorize: logs each send and each response Step 5 RandomX: logs VM mode Step 6 main loop: - malformed mining.notify (wrong param count or short header/target) logged with sizes instead of silently ignored - authorize rejected: logs reason, does not disconnect (some pools reject bad addresses but still send work) - share accepted/rejected: logs share id and rejection reason - unknown server method logged - pool disconnect logged with handshake state at that moment (gotSubscribeAck, gotAuthorizeAck, haveJob) so you know exactly how far the connection got - nonce space exhausted logged (was silent before) - on exit: logs total hashes, shares sent, shares accepted * Fix build error: ImGuiWindowFlags_NoBringToDisplayFront -> NoBringToFrontOnFocus NoBringToDisplayFront does not exist in this version of ImGui (v1.89.x). The correct flag is ImGuiWindowFlags_NoBringToFrontOnFocus (bit 13). Used in two places: ##statusbar and ##main windows. Also remove dead variable usedY (GetCursorPosY() result assigned but never read) and replace the confusing 'ImGuiWindowFlags_NoScrollbar * 0' expression (evaluates to 0 but looks like a mistake) with a plain 0 in the BeginChild call. * Remove duplicate status logging from SetParticipantMiningStatus Every transition in PoolParticipantMiner already has a direct LogPrint with full context (addresses, job ids, nonces, error reasons). The LogPrint inside SetParticipantMiningStatus was firing on top of those, producing redundant 'PoolParticipantMiner: status -> ...' lines after every meaningful log entry. SetParticipantMiningStatus now just updates the GUI string silently. * Implement vardiff: stable share rate instead of fixed difficulty Previously the pool set shareTarget = blockTarget >> 8 for every miner forever. This meant at low network difficulty a fast miner found shares every few nonces (dozens per second), while at high difficulty a slow miner might go hours without one -- both are bad for fair payout accounting and pool stability. Pool (rpc.cpp): Per-miner difficulty that adjusts to target one share every 15 seconds. After every 5 shares, check actual seconds/share vs target. If the ratio is off by more than 50% (VARDIFF_RETARGET_RATIO), recompute: new_difficulty = current_difficulty / (actual_secs_per_share / target) i.e. shares coming too fast -> difficulty goes up; too slow -> down. Only apply if the change exceeds 10% to avoid jitter. Difficulty is bounded to [0.001, 1e12]. Each miner gets their own shareTarget derived from their difficulty via ShareTargetFromDifficulty(), which maps Stratum difficulty to a uint256 target using the Bitcoin difficulty-1 base (0x1d00ffff compact). New difficulty is sent to the miner via mining.set_difficulty. Participant (main.cpp): Apply the received difficulty value from mining.set_difficulty. Previously the handler was a no-op ('acknowledge only'); now it parses the difficulty double and logs the change. The share target used for comparison comes from the pool's mining.notify p[3] field, which the pool updates after each vardiff adjustment -- this is the standard approach and matches how cpuminer, xmrig etc. handle it. With vardiff, share rate is roughly constant regardless of miner speed or network difficulty. Payouts are proportional to shares submitted, so each miner's payout accurately reflects their CPU contribution. * Fix share target mismatch: pool rejected shares it should have accepted Root cause: the pool put job.shareTarget (from blockTarget<<8, a fixed per-job value) into mining.notify p[3], but checked m->shareTarget (from ShareTargetFromDifficulty, the vardiff value) on submit. With difficulty=1.0, ShareTargetFromDifficulty gives a much HARDER target than blockTarget<<8, so shares that the participant thought were valid (passed the easier notify target) were rejected by the pool (failed the harder difficulty-1 target). Fix: MakeNotifyParams now takes the per-miner shareTarget as an explicit parameter. SendJob passes m->shareTarget. Both sides -- the participant reading p[3] and HandleLine checking m->shareTarget on submit -- now use exactly the same value. Single source of truth. Cleanup: - Remove shareTarget field from StratumJob (was only set, never read after the MakeNotifyParams call was fixed). - Remove MakeShareTarget() function (was only used to populate that now-dead field). - Participant set_difficulty log: 'initial' vs 'updated' instead of 'unchanged' (first connect sends 1.0 which matches the default 1.0, so it was misleadingly logged as 'unchanged'). * Fix double broadcast, correct block reward calculation, improve payout log Double broadcast (event loop vs HandleLine): When a pool miner finds a block, HandleLine calls RebuildJob() + BroadcastJob(true) immediately. The event loop then detects nBestHeight changed (step 2) and was calling RebuildJob() + BroadcastJob(true) again -- miners received duplicate job broadcasts. Fix: step 2 now checks gHaveJob before rebuilding. If HandleLine already built and broadcast a job for this height (gHaveJob=true), step 2 just logs 'job already broadcast by submit handler' and skips. If the block came from an external peer (not our miner), gHaveJob is false and step 2 handles it as before. Block reward calculation in QueuePayouts: Was calling CBlock().GetBlockValue(0) on an empty block object. GetBlockValue uses nBestHeight globally, which by the time QueuePayouts runs has already been incremented to the height AFTER the found block. Fix: compute subsidy directly as '50 COIN >> (blockHeight / 210000)' using the actual found height. At current scale this makes no difference (same subsidy for thousands of blocks) but is now correct by construction. Payout log now shows: - Full block subsidy - Miner share after fee - Operator fee amount in BTF (not just percentage) - Number of recipients, maturity height, dust-filtered count Example: '[payout] block 2096: subsidy 50.00 BTF, miners get 49.00 (fee 2.00% = 1.00 to operator), 3 recipients, matures height 2196' * Fix 6 bugs found in full flow re-read Bug 1 -- Double broadcast (re-applied fix that was lost): When HandleLine accepted a block it called RebuildJob()+BroadcastJob(true). The event loop then detected nBestHeight changed and did it again. Miners received two back-to-back mining.notify clean=true, wasting their work. Fix: step 2 of event loop checks gHaveJob before rebuilding. If HandleLine already built a fresh job (gHaveJob=true), step 2 just logs and skips. Bug 3 -- Disconnect log showed global totals, not session totals: gParticipantSharesSent/Accepted accumulate since node start, not since the last connect. Added sessionSharesSent/sessionSharesAccepted local counters that reset each time PoolParticipantMiner() is called. Bug 4 -- Dead function ParticipantShareTargetFromDiff (main.cpp): Defined but never called anywhere. Removed. Bug 5 -- Invalid-address miner shares silently burned: If a miner authorized with an invalid address, their share of the block reward was neither paid out nor logged -- it just vanished. QueuePayouts now validates addresses up front, logs the forfeited amount explicitly ('X BTF forfeited (bad address)'), and excludes those entries so the payout log is accurate. Bug 6 -- SendMoney called from event loop (stalls miner I/O): FlushMaturePayouts called SendMoney which takes cs_main. If the P2P thread held cs_main (processing a block), the event loop would stall for seconds, causing all connected miners to time out waiting for responses. Fix: FlushMaturePayouts now only moves matured entries to gPayoutExecQueue (fast, no locks except a brief mutex). A new PayoutThreadFn thread drains the queue and calls SendMoney independently, so the event loop is never blocked by wallet I/O. Bug 7 -- Dead goto + dead HandleLine return-false path: HandleLine always returns true; the goto next_miner path was never reached. Removed goto and simplified the select drain loop. * Fix share-target scale mismatch and dead pool hashrate reporting - ShareTargetFromDifficulty() based Stratum difficulty 1 on Bitcoin's SHA256 diff-1 constant (0x1d00ffff, ~2^32 hashes/share) instead of this chain's actual PoW floor (bnProofOfWorkLimit = ~uint256(0)>>12, ~2^12 hashes/share). That's a ~2^20 (~1,048,576x) mismatch: at the supposedly-easy difficulty of 1.0, workers were being asked for shares roughly a million times harder than the chain's own easiest target. Vardiff never gets a chance to correct this because it only retargets after real shares come in, and none were coming in. Fixed by basing the diff-1 reference on bnProofOfWorkLimit instead. - Pool hashrate was never computed anywhere despite the data (per-miner difficulty + share timing) being available: ThreadBtfPoolAnnouncer in nostr.cpp hardcoded ann.hashRate = 0.0, PoolWorkerStatView had no hashrate field, and the GUI workers table had no column for it. Added an EWMA hashrate estimate per miner (updated on each accepted share from expected-hashes-at-difficulty / time-since-last-share), threaded it through GetPoolOperatorStats/GetPoolWorkerStats, the pool announcement payload, and the GUI (new Hashrate column + totals in the telemetry line). Verified: full clean build via src/Makefile (secp256k1 + RandomX deps built from source, g++ 13, all four touched files compile and link). * Remove stale wxWidgets-era build files and orphaned assets These predate the ImGui/GLFW migration (83af065) and are dead weight: - src/makefile.linux, build-linux.sh: superseded by src/Makefile + root Makefile (make linux). The old ones reference obj/uibase.o and obj/ui.o, which don't exist -- they never worked post-migration. - src/makefile.vc: MSVC build for the old wx UI (obj\ui.obj, obj\uibase.obj, obj\irc.obj) -- irc.cpp doesn't even exist anymore, and nothing invokes this makefile. Windows builds go through makefile.mingw via the root Makefile's target. - src/ui.rc, src/uiproject.fbp: wxFormBuilder project/resource files for the old wx UI. The current Windows resource file is bitflash.rc. - src/rc/{addressbook,send}*.bmp, check.ico, bitcoin_bc_original.ico: icons used only by the old wx UI. bitcoin.ico (used by bitflash.rc) is kept. Verified nothing includes uibase.h/ui.h/irc.h anywhere, and did a full clean rebuild afterward (secp256k1 + RandomX from source, src/Makefile) to confirm removal doesn't break the real build. * Mine with RandomX fast (2GB dataset) mode instead of light mode forever RandomXInitDataset() was fully implemented and ready to switch mining into fast mode, but nothing ever called it -- not in PoolParticipantMiner() (pool worker), not in the solo BitcoinMiner() loop. RandomXCreateMinerVM() falls back to light mode whenever the dataset isn't built, so every miner, participant or solo, has always been hashing in light/cache-only mode. Light mode exists for cheap single-hash verification (which is why the pool's own share verification correctly stays on it) -- it recomputes dataset items on the fly for every hash, which is dramatically slower than fast mode's direct dataset lookups. Combined with the share-target scale bug fixed in e87a905, this compounds into exactly the symptom reported: a participant sitting there hashing for many minutes per share instead of the vardiff-targeted ~15s, even after the target fix landed. Fix: build the ~2GB dataset once (multi-threaded, sized to hardware_concurrency) before mining starts, in both the participant and solo paths, so RandomXCreateMinerVM() actually gets to use fast mode. Verified: full clean rebuild via src/Makefile. * Add vardiff stall watchdog: force difficulty down on zero shares, not just share count ShareTargetFromDifficulty already fixed the diff-1 scale mismatch (chain floor vs Bitcoin's SHA256 diff-1), so difficulty 1 correctly means ~4096 expected hashes on this chain, not ~2^32. That part was already correct. But the normal vardiff retarget in HandleLine only runs after VARDIFF_SHARES_PER_CHECK (5) shares arrive. A miner that never finds even one share -- e.g. stuck in RandomX light/cache mode instead of the fast 2GB dataset, or just slower hardware than the target assumes -- never reaches that check, so it can sit at its initial/current difficulty indefinitely with vardiff having no samples to act on. Add a time-based fallback in PoolEventLoop: if a miner's vardiff window has been open for VARDIFF_STALL_SECS (90s, 6x the 15s target) with zero shares, force difficulty down by VARDIFF_STALL_CUT (4x) regardless of share count, and re-notify via mining.set_difficulty. Once a miner is already at VARDIFF_MIN, log it plainly as a hashrate/connectivity issue instead of a difficulty issue, so it's not confused with the same-looking but different problem this was actually fixed for before. * Fix PrintException rethrow killing the whole node on any transient exception The uploaded participant log shows the real bug behind the mining stalls: the node process itself was dying and restarting from scratch every minute or two ('UNKNOWN EXCEPTION ... in ThreadMessageHandler()' / 'ThreadSocketHandler()'), wiping the RandomX dataset/cache and losing all progress toward a share -- not a difficulty problem. Every background thread (ThreadMessageHandler, ThreadSocketHandler, ThreadBtfConnect, the Nostr helpers) wraps its real work in a 'try { Foo2() } catch(...) { log, sleep 5s, loop again }' self-healing retry pattern specifically so one bad exception doesn't take the whole node down. But PrintException(), called from inside every one of those catch blocks, ended with 'if (!fShutdown) throw;' -- re-throwing the just- caught exception during ordinary operation. Nothing above the retry loop catches it, so it escapes the thread and std::terminate()s the entire process on the very first transient error (a flaky relay connect, a malformed message, whatever). The comment's intent (suppress noise while already shutting down) was inverted from what the surrounding retry loops actually need. Removed the rethrow. Threads now log the exception and let their own retry loop handle it, as designed. * Push a fresh job immediately after any difficulty change, not just on next broadcast mining.set_difficulty alone doesn't change what the worker actually hashes against -- the participant only reads its share target from mining.notify's params[3] (see main.cpp's mining.notify handler); the set_difficulty message just updates a locally-logged currentDifficulty value. So both the normal vardiff retarget (in HandleLine, on 5 shares) and the new stall watchdog were updating m->shareTarget and telling the worker about the new difficulty, but the worker kept hashing against its old target until the next natural job broadcast -- a new block, or the 60s trickle refresh. That could delay any difficulty correction by up to a minute for no reason. Call SendJob(m, false) right after each set_difficulty send so the updated shareTarget reaches the worker in the very next tick instead of waiting on the next unrelated broadcast. * Build RandomX dataset before stratum handshake, not after Worker was sending mining.subscribe/authorize, then blocking for the duration of the synchronous ~2GB RandomX dataset build, and only then reading the socket. The pool's replies (subscribe ack, authorize ack, set_difficulty, first job) sat unread in the OS receive buffer for that entire window -- nothing was lost, but with the build taking anywhere from seconds to a couple minutes depending on core count, the worker looked and logged as permanently stuck on 'waiting for pool response' when it just wasn't listening yet. Move the dataset build ahead of the subscribe/authorize sends so the socket is actively being read the moment the pool replies. Also add missing RandomXDestroyMinerVM cleanup on the two early-return paths that now happen after VM creation. * Reset round shares on externally-found blocks, not just our own Round shares were only cleared in HandleLine() after our own miner's block got accepted. When the chain height advanced because someone else found the block, the main loop rebuilt the job but left roundShareCount/roundShareTotal/Miner::roundShares untouched, so they kept accumulating across rounds instead of resetting. * Show pool hashrate in participant view; show immature coinbase value with maturity countdown * Persist pending payouts to disk -- survive operator restarts * Fix log escapes, stall timeout 90->45s, save-before-exec ordering, Immature tx status * Sort transactions by nTimeReceived not chain median time -- new txs always on top * Sort txs by chain depth not nTimeReceived -- survives resync, unconfirmed always first * Fix orphan block false-positive payout; meaningful tx status instead of raw depth * Show Orphaned status in red for orphaned coinbases; distinguish from genuinely unconfirmed --------- Co-authored-by: Vic-Nas <nasci.victorio@gmail.com> Co-authored-by: Bitflash Pool Dev <pool@bitflash> Co-authored-by: Victorio Nascimento <155357371+Vic-Nas@users.noreply.github.com> Co-authored-by: Claude <claude@anthropic.com>
author: Bitflash <btf01@proton.me> 2026-07-28 12:55:04 -0300
committer: GitHub <noreply@github.com> 2026-07-28 12:55:04 -0300
commit: 663784eae9b04ec71e3e1eebf445910e5a8add42 (patch)
tree: 1482b0778a11c1b46cfbd476a5d91e12ef31204b /src/rpc.cpp
parent: 1d0314c0d220231afc56193ba66b70234fa24092 (diff)
1 files changed, 1074 insertions, 470 deletions
diff --git a/src/rpc.cpp b/src/rpc.cpp
index 99d182e..1b529e8 100644
--- a/src/rpc.cpp
+++ b/src/rpc.cpp
@@ -1,14 +1,19 @@
 // Copyright (c) 2009 Satoshi Nakamoto / Copyright (c) 2026 Bitflash developers
 // Distributed under the MIT/X11 software license.
 //
-// Bitflash pool server — .btf-only pool listener.
+// Bitflash pool server -- .btf Stratum pool, operator side.
-// Miners connect through rendezvous tunnels; no raw IP:port endpoints remain.
-// Pending payouts are held until maturity and shown in the GUI.
 //
-// Compiles on both Windows (mingw) and Linux unchanged.
+// Architecture:
-// Launched from ui.cpp (GUI) and headless.cpp (node) via ThreadRPCServer().
+//   PoolEventLoop  -- single thread, owns all miner fds, all job/share/payout
+//                     state. No locks needed on any of that data.
+//   AcceptOneFn    -- one thread per relay. Blocks on RvServiceRegister +
+//                     BtfServiceWrap, pushes finished socket to gReadyQueue.
+//   AcceptLoopFn   -- spawns AcceptOneFn threads, re-polls relay list every
+//                     60s so dynamically discovered relays get picked up.
+//
+// GUI-visible state is snapshotted under gStatsMutex every 2s.
+// Accept queue handoff uses gReadyMutex (held for microseconds).
-// nlohmann must be included before headers.h because util.h redefines snprintf
 #pragma push_macro("snprintf")
 #undef snprintf
 #include <nlohmann/json.hpp>
@@ -20,8 +25,6 @@
 #endif
 #include "btftunnel.h"
-// POSIX socket headers — already provided by compat.h on Windows,
-// and by the OS directly on Linux.
 #ifndef _WIN32
 #include <sys/socket.h>
 #include <sys/select.h>
@@ -33,14 +36,15 @@
 #include <atomic>
 #include <mutex>
 #include <map>
+#include <set>
 #include <deque>
+#include <vector>
+#include <algorithm>
 #include <sstream>
 #include <iomanip>
-#include <ctime>
 using json = nlohmann::json;
-// Cross-platform socket close / send flags
 #ifdef _WIN32
 #define sock_close(s)  closesocket(s)
 #define SEND_FLAGS     0
@@ -49,660 +53,1260 @@ using json = nlohmann::json;
 #define SEND_FLAGS     MSG_NOSIGNAL
 #endif
-// Cross-platform thread launch: wraps _beginthread (compat.h maps it to
-// pthread_create+detach on Linux, native _beginthread on Windows).
-// fn must be void(*)(void*).
-static void LaunchThread(void (*fn)(void*), void* arg)
-{
-    _beginthread(fn, 0, arg);
-}
-// ---------------------------------------------------------------------------
-// Config — set by headless.cpp / ui.cpp before threads launch
-// ---------------------------------------------------------------------------
-std::string gRpcUser;
-std::string gRpcPassword;
-// Pool server running flag — set false to stop server cleanly (all loops check it)
 volatile bool gPoolRunning = false;
 // ---------------------------------------------------------------------------
-// Stubs for symbols absent from Bitflash 0.1.0
-// ---------------------------------------------------------------------------
-double dHashesPerSec  = 0.0;
-int64  nHPSTimerStart = 0;
-static bool IsInitialBlockDownload()
-{
-    return (pindexBest == NULL || nBestHeight < 1);
-}
-// ---------------------------------------------------------------------------
 // Hex helpers
 // ---------------------------------------------------------------------------
 static std::string ToHex(const void* p, size_t n)
 {
    const unsigned char* b = (const unsigned char*)p;
-    std::string s; s.reserve(n*2);
+    std::string s; s.reserve(n * 2);
    static const char* H = "0123456789abcdef";
-    for (size_t i = 0; i < n; i++) { s += H[b[i]>>4]; s += H[b[i]&0xf]; }
+    for (size_t i = 0; i < n; i++) { s += H[b[i] >> 4]; s += H[b[i] & 0xf]; }
    return s;
 }
 static std::vector<unsigned char> FromHex(const std::string& s)
 {
    std::vector<unsigned char> v;
-    for (size_t i = 0; i+1 < s.size(); i += 2) {
+    for (size_t i = 0; i + 1 < s.size(); i += 2) {
-        auto h=[](char c)->int{
+        auto h = [](char c) -> int {
-            if(c>='0'&&c<='9') return c-'0';
+            if (c >= '0' && c <= '9') return c - '0';
-            if(c>='a'&&c<='f') return c-'a'+10;
+            if (c >= 'a' && c <= 'f') return c - 'a' + 10;
-            if(c>='A'&&c<='F') return c-'A'+10;
+            if (c >= 'A' && c <= 'F') return c - 'A' + 10;
            return 0;
        };
-        v.push_back((unsigned char)((h(s[i])<<4)|h(s[i+1])));
+        v.push_back((unsigned char)((h(s[i]) << 4) | h(s[i + 1])));
    }
    return v;
 }
 // ---------------------------------------------------------------------------
-// PPLNS share tracking
+// Job -- written and read exclusively by the event loop thread
-// ---------------------------------------------------------------------------
-struct Share {
-    std::string minerAddress;
-    int64       timestamp;
-    uint64      difficulty;
-};
-struct MinerStats {
-    std::string address;
-    std::string worker;
-    uint64 totalShares = 0;
-    uint64 roundShares = 0;
-    int64  lastSeen    = 0;
-};
-static std::mutex                        gMinerStatsMutex;
-static std::map<std::string, MinerStats> gMinerStats;
-struct FoundBlock {
-    int    height;
-    int64  timestamp;
-    std::string minerAddress;
-    uint256 hash;
-};
-static std::mutex             gBlocksMutex;
-static std::deque<FoundBlock> gFoundBlocks;
-struct Miner;
-static std::mutex          gMinersMutex;
-static std::vector<Miner*> gMiners;
-static std::string MinerKey(const std::string& address, const std::string& worker)
-{
-    return address + "\n" + worker;
-}
-void GetPoolWorkerStats(std::vector<PoolWorkerStatView>& out)
-{
-    out.clear();
-    int64 now = GetTime();
-    std::lock_guard<std::mutex> lk(gMinerStatsMutex);
-    for (std::map<std::string, MinerStats>::const_iterator it = gMinerStats.begin(); it != gMinerStats.end(); ++it)
-    {
-        const MinerStats& ms = it->second;
-        if (ms.lastSeen <= 0)
-            continue;
-        if (now - ms.lastSeen > 15 * 60)
-            continue;
-        PoolWorkerStatView view;
-        view.address = ms.address;
-        view.worker = ms.worker;
-        view.totalShares = ms.totalShares;
-        view.roundShares = ms.roundShares;
-        view.lastSeen = ms.lastSeen;
-        out.push_back(view);
-    }
-    std::sort(out.begin(), out.end(), [](const PoolWorkerStatView& a, const PoolWorkerStatView& b) {
-        if (a.roundShares != b.roundShares) return a.roundShares > b.roundShares;
-        if (a.totalShares != b.totalShares) return a.totalShares > b.totalShares;
-        return a.lastSeen > b.lastSeen;
-    });
-}
-// ---------------------------------------------------------------------------
-// Current mining job
 // ---------------------------------------------------------------------------
 struct StratumJob {
    std::string jobId;
    CBlock      block;
-    uint256     target;
+    uint256     target;  // full block target; share targets are per-miner via vardiff
-    uint256     shareTarget;
    int         height;
 };
+static StratumJob gCurrentJob;
+static bool       gHaveJob = false;
+// Compute a share target from a Stratum difficulty value.
+// Stratum difficulty 1 must correspond to THIS chain's easiest allowed target
+// (bnProofOfWorkLimit = ~uint256(0) >> 12, compact 0x1f0fffff), not Bitcoin's
+// SHA256 diff-1 target (0x1d00ffff). Those differ by about 2^20 (~1e6x):
+// Bitcoin's diff-1 needs ~2^32 hashes/share on average, while this chain's PoW
+// floor needs only ~2^12. Using the Bitcoin constant made every miner's
+// "difficulty 1" about a million times harder than the chain's own floor, so a
+// worker could hash for minutes without ever finding a share -- and vardiff
+// never gets the samples it needs to correct course, because no share ever
+// comes in for it to measure. Base off the actual chain limit instead so
+// difficulty 1 is genuinely easy and vardiff has real data to retarget from.
+// Higher difficulty = smaller (harder) target.
+static uint256 ShareTargetFromDifficulty(double difficulty)
+{
+    if (difficulty <= 0.0) difficulty = 1.0;
+    static const uint256 diff1 = CBigNum(bnProofOfWorkLimit).getuint256();
+    // shareTarget = diff1 / difficulty
+    CBigNum bn; bn.setuint256(diff1);
+    // Multiply by 2^16 to keep precision, divide, shift back
+    bn <<= 16;
+    bn /= (uint64)(difficulty * 65536.0);
+    uint256 t = bn.getuint256();
+    // Cap at all-ones (maximum, easiest possible)
+    if (t < diff1 && difficulty < 1.0) t = ~uint256(0);
+    return t;
+}
-static std::mutex    gJobMutex;
+// Expected number of hashes to find one share at a given Stratum difficulty,
-static StratumJob    gCurrentJob;
+// on this chain's scale (difficulty 1 == bnProofOfWorkLimit, which needs on
-static bool          gHaveJob = false;
+// average 2^12 = 4096 hashes). Used to turn "shares per second" into H/s.
-static std::atomic<uint32_t> gJobSeq{0};
+static const double SHARE_HASHES_AT_DIFF_1 = 4096.0;
+static double ExpectedHashesForDifficulty(double difficulty)
-static uint256 MakeShareTarget(const uint256& blockTarget)
 {
-    uint256 shareTarget = blockTarget;
+    if (difficulty <= 0.0) difficulty = 1.0;
-    shareTarget <<= 8;
+    return difficulty * SHARE_HASHES_AT_DIFF_1;
-    if (shareTarget < blockTarget)
-        shareTarget = ~uint256(0);
-    return shareTarget;
 }
+// Rebuild the current job from the best chain tip.
+// Must be called from the event loop thread (or startup, before the loop).
+// Returns true on success. Logs the specific failure reason on false.
 static bool RebuildJob()
 {
-    if (!pindexBest) return false;
+    CRITICAL_BLOCK(cs_main)
+    {
+        if (!pindexBest) {
+            LogPrint("pool", "RebuildJob: no chain tip (pindexBest is null)\n");
+            return false;
+        }
-    CBlockIndex* pindexPrev = pindexBest;
+        CBlockIndex* pindexPrev = pindexBest;
-    unsigned int nBits = GetNextWorkRequired(pindexPrev);
+        unsigned int nBits = GetNextWorkRequired(pindexPrev);
-    CKey key;
+        CKey key; key.MakeNewKey();
-    key.MakeNewKey();
+        static std::atomic<uint32_t> sExtra{0};
-    static std::atomic<uint32_t> sExtra{0};
+        uint32_t extraNonce = ++sExtra;
-    uint32_t extraNonce = ++sExtra;
-    CTransaction txNew;
+        CTransaction txNew;
-    txNew.vin.resize(1);
+        txNew.vin.resize(1);
-    txNew.vin[0].prevout.SetNull();
+        txNew.vin[0].prevout.SetNull();
-    txNew.vin[0].scriptSig << nBits << (CBigNum)extraNonce;
+        txNew.vin[0].scriptSig << nBits << (CBigNum)extraNonce;
-    txNew.vout.resize(1);
+        txNew.vout.resize(1);
-    // Always pay coinbase to a fresh wallet key. DoPayouts() distributes
+        txNew.vout[0].scriptPubKey << key.GetPubKey() << OP_CHECKSIG;
-    // shares to miners via SendMoney() after the block is accepted.
-    txNew.vout[0].scriptPubKey << key.GetPubKey() << OP_CHECKSIG;
-    CBlock block;
+        CBlock block;
-    block.vtx.push_back(txNew);
+        block.vtx.push_back(txNew);
-    {
-        CTxDB txdb("r");
-        CRITICAL_BLOCK(cs_mapTransactions)
        {
-            map<uint256,CTxIndex> pool;
+            CTxDB txdb("r");
-            unsigned int sz = 0;
+            CRITICAL_BLOCK(cs_mapTransactions)
-            for (auto& kv : mapTransactions) {
+            {
-                CTransaction& tx = kv.second;
+                map<uint256, CTxIndex> pool;
-                if (tx.IsCoinBase() || !tx.IsFinal()) continue;
+                unsigned int sz = 0;
-                int64 nFees = 0;
+                for (auto& kv : mapTransactions) {
-                int64 nMinFee = tx.GetMinFee(block.vtx.size() < 100);
+                    CTransaction& tx = kv.second;
-                map<uint256,CTxIndex> tmp(pool);
+                    if (tx.IsCoinBase() || !tx.IsFinal()) continue;
-                if (!tx.ConnectInputs(txdb, tmp, CDiskTxPos(1,1,1), 0, nFees, false, true, nMinFee)) continue;
+                    int64 nFees = 0;
-                pool = tmp;
+                    map<uint256, CTxIndex> tmp(pool);
-                block.vtx.push_back(tx);
+                    if (!tx.ConnectInputs(txdb, tmp, CDiskTxPos(1,1,1), 0, nFees,
-                sz += ::GetSerializeSize(tx, SER_NETWORK);
+                                          false, true, tx.GetMinFee(block.vtx.size() < 100)))
-                if (sz > MAX_SIZE/2) break;
+                        continue;
+                    pool = tmp;
+                    block.vtx.push_back(tx);
+                    sz += ::GetSerializeSize(tx, SER_NETWORK);
+                    if (sz > MAX_SIZE / 2) break;
+                }
            }
        }
+        block.vtx[0].vout[0].nValue = block.GetBlockValue(0);
+        block.hashPrevBlock  = pindexPrev->GetBlockHash();
+        block.hashMerkleRoot = block.BuildMerkleTree();
+        block.nTime = max((unsigned int)(pindexPrev->GetMedianTimePast() + 1),
+                          (unsigned int)GetAdjustedTime());
+        block.nBits  = nBits;
+        block.nNonce = 1;
+        AddKey(key);
+        StratumJob job;
+        job.jobId       = ToHex(&extraNonce, 4);
+        job.block       = block;
+        job.target      = CBigNum().SetCompact(nBits).getuint256();
+        job.height      = nBestHeight + 1;
+        gCurrentJob = job;
+        gHaveJob    = true;
+        return true;
    }
-    block.vtx[0].vout[0].nValue = block.GetBlockValue(0);
+    return false;
-    block.hashPrevBlock  = pindexPrev->GetBlockHash();
-    block.hashMerkleRoot = block.BuildMerkleTree();
-    block.nTime = max((unsigned int)(pindexPrev->GetMedianTimePast()+1),
-                      (unsigned int)GetAdjustedTime());
-    block.nBits  = nBits;
-    block.nNonce = 1;
-    AddKey(key);
-    StratumJob job;
-    job.jobId  = ToHex(&extraNonce, 4);
-    job.block  = block;
-    job.target = CBigNum().SetCompact(nBits).getuint256();
-    job.shareTarget = MakeShareTarget(job.target);
-    job.height = nBestHeight + 1;
-    std::lock_guard<std::mutex> lk(gJobMutex);
-    gCurrentJob = job;
-    gHaveJob    = true;
-    ++gJobSeq;
-    return true;
 }
 // ---------------------------------------------------------------------------
-// PPLNS payout
+// Payouts -- event loop thread only
-// ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
-// Deferred payouts — coinbase outputs require COINBASE_MATURITY (100) blocks
-// before they can be spent. We store the share snapshot when a block is found
-// and execute the actual SendMoney() calls once the coinbase matures.
 // ---------------------------------------------------------------------------
 struct PendingPayout {
-    int matureAtHeight;                   // pay out when nBestHeight >= this
+    int                          matureAtHeight;
-    std::map<std::string, int64> amounts; // addr -> BTF amount
+    std::map<std::string, int64> amounts; // address -> satoshis
 };
+static std::vector<PendingPayout> gPendingPayouts;
-static std::mutex                   gPayoutMutex;
+static std::string PayoutFilePath()
-static std::vector<PendingPayout>   gPendingPayouts;
+{
+    return GetAppDir() + "/pending_payouts.json";
+}
-void GetPendingPayouts(std::vector<PendingPayoutView>& out)
+static void SavePendingPayouts()
 {
-    out.clear();
+    nlohmann::json arr = nlohmann::json::array();
-    std::lock_guard<std::mutex> lk(gPayoutMutex);
+    for (const auto& pp : gPendingPayouts) {
-    for (const PendingPayout& p : gPendingPayouts)
+        nlohmann::json obj;
-    {
+        obj["matureAtHeight"] = pp.matureAtHeight;
-        PendingPayoutView view;
+        nlohmann::json amounts = nlohmann::json::object();
-        view.matureAtHeight = p.matureAtHeight;
+        for (const auto& kv : pp.amounts)
-        view.recipients = (int)p.amounts.size();
+            amounts[kv.first] = kv.second;
-        view.totalAmount = 0;
+        obj["amounts"] = amounts;
-        for (const std::map<std::string, int64>::value_type& kv : p.amounts)
+        arr.push_back(obj);
-            view.totalAmount += kv.second;
+    }
-        out.push_back(view);
+    std::string path = PayoutFilePath();
+    FILE* f = fopen(path.c_str(), "w");
+    if (f) {
+        std::string s = arr.dump(2);
+        fwrite(s.c_str(), 1, s.size(), f);
+        fclose(f);
+    } else {
+        LogPrint("payout", "[payout] WARNING: could not write %s\n", path.c_str());
    }
 }
-// Called when a block is found: snapshot shares, schedule payout for maturity.
+static void LoadPendingPayouts()
-static void QueuePayouts(int blockHeight)
 {
-    if (nMineMode != MINE_OPERATOR) return;
+    std::string path = PayoutFilePath();
+    FILE* f = fopen(path.c_str(), "r");
-    std::map<std::string, uint64> shareCount;
+    if (!f) return; // no file yet -- first run, nothing to load
-    uint64 total = 0;
+    fseek(f, 0, SEEK_END);
-    {
+    long sz = ftell(f);
-        std::lock_guard<std::mutex> lk(gMinerStatsMutex);
+    fseek(f, 0, SEEK_SET);
-        for (std::map<std::string, MinerStats>::iterator it = gMinerStats.begin(); it != gMinerStats.end(); ++it)
+    std::string s(sz, '\0');
-        {
+    fread(&s[0], 1, sz, f);
-            MinerStats& ms = it->second;
+    fclose(f);
-            if (ms.roundShares == 0)
+    try {
-                continue;
+        nlohmann::json arr = nlohmann::json::parse(s);
-            if (ms.address.empty())
+        for (const auto& obj : arr) {
-                continue;
+            PendingPayout pp;
-            shareCount[ms.address] += ms.roundShares;
+            pp.matureAtHeight = obj["matureAtHeight"].get<int>();
-            total += ms.roundShares;
+            for (auto it = obj["amounts"].begin(); it != obj["amounts"].end(); ++it)
-            ms.roundShares = 0;
+                pp.amounts[it.key()] = it.value().get<int64>();
+            gPendingPayouts.push_back(pp);
        }
+        LogPrint("payout", "[payout] loaded %zu pending payout(s) from disk\n",
+                 gPendingPayouts.size());
+    } catch (const std::exception& e) {
+        LogPrint("payout", "[payout] WARNING: failed to parse %s: %s\n",
+                 path.c_str(), e.what());
+    }
+}
+// Payouts ready to execute are moved here under gPayoutExecMutex.
+// A dedicated thread drains this list so SendMoney (which takes cs_main)
+// never runs on the event loop thread and can't stall miner I/O.
+static std::vector<PendingPayout> gPayoutExecQueue;
+static std::mutex                 gPayoutExecMutex;
+static std::atomic<bool>          gPayoutThreadRunning{false};
+static void QueuePayouts(int blockHeight,
+                         const std::map<std::string, uint64>& shareCount,
+                         uint64 total)
+{
+    if (total == 0) {
+        LogPrint("payout", "[payout] block %d: zero shares recorded -- nothing to pay out\n",
+                 blockHeight);
+        return;
    }
-    if (total == 0) return;
-    int64 blockReward = CBlock().GetBlockValue(0);
+    double feeFrac = dPoolFeePercent / 100.0;
+    if (feeFrac < 0.0) feeFrac = 0.0;
+    if (feeFrac > 1.0) feeFrac = 1.0;
+    // Compute the block subsidy at the height that was just found.
+    // We do not include tx fees in miner payout -- those stay in the operator
+    // wallet as part of the coinbase, which is the operator's cut on top of feeFrac.
+    int64 nSubsidy = 50 * COIN;
+    nSubsidy >>= (blockHeight / 210000); // halving schedule
+    int64 minerReward = (int64)((double)nSubsidy * (1.0 - feeFrac));
    PendingPayout pp;
    pp.matureAtHeight = blockHeight + COINBASE_MATURITY;
+    int skipped = 0;
+    int64 burned = 0; // amount owed to miners with bad/empty addresses
    for (auto& kv : shareCount) {
-        int64 amount = (int64)(((double)kv.second / (double)total) * (double)blockReward);
+        int64 amount = (int64)(((double)kv.second / (double)total) * (double)minerReward);
-        if (amount >= CENT)
+        if (amount < CENT) {
-            pp.amounts[kv.first] = amount;
+            skipped++;
+            continue;
+        }
+        uint160 addrCheck;
+        if (kv.first.empty() || !AddressToHash160(kv.first, addrCheck)) {
+            // Address was invalid at authorize time (warned then). Their share
+            // of the reward cannot be paid -- log the amount so it's visible.
+            burned += amount;
+            LogPrint("payout", "[payout] WARNING: %s owed to miner with invalid"
+                     " address '%s' -- cannot pay out, amount forfeited\n",
+                     FormatMoney(amount).c_str(), kv.first.c_str());
+            continue;
+        }
+        pp.amounts[kv.first] = amount;
    }
-    { std::lock_guard<std::mutex> lk(gPayoutMutex); gPendingPayouts.push_back(pp); }
+    gPendingPayouts.push_back(pp);
+    SavePendingPayouts();
-    printf("Pool: block %d payout queued for height %d (%zu miners)\n",
-           blockHeight, pp.matureAtHeight, pp.amounts.size());
+    int64 operatorCut = nSubsidy - minerReward;
+    LogPrint("payout",
+             "[payout] block %d: subsidy %s BTF, miners get %s"
+             " (fee %.2f%% = %s to operator),"
+             " %zu recipients, matures height %d,"
+             " %d below dust%s\n",
+             blockHeight,
+             FormatMoney(nSubsidy).c_str(),
+             FormatMoney(minerReward).c_str(),
+             dPoolFeePercent,
+             FormatMoney(operatorCut).c_str(),
+             pp.amounts.size(), pp.matureAtHeight, skipped,
+             burned > 0 ? (", " + FormatMoney(burned) + " forfeited (bad address)").c_str()
+                        : "");
 }
-// Called from JobWatcher every new block: execute any matured payouts.
+// Called from event loop: move matured entries to the exec queue (fast).
+// Save BEFORE moving to exec queue: if we crash between the save and SendMoney,
+// LoadPendingPayouts re-queues them from the exec-queue section of the file.
 static void FlushMaturePayouts()
 {
-    if (nMineMode != MINE_OPERATOR) return;
+    std::vector<PendingPayout> ready;
-    std::lock_guard<std::mutex> lk(gPayoutMutex);
    for (auto it = gPendingPayouts.begin(); it != gPendingPayouts.end(); ) {
        if (nBestHeight < it->matureAtHeight) { ++it; continue; }
+        LogPrint("payout", "[payout] block height %d matured -- queuing %zu payments\n",
-        printf("Pool: executing payout for block matured at height %d\n", it->matureAtHeight);
+                 it->matureAtHeight, it->amounts.size());
-        for (auto& kv : it->amounts) {
+        ready.push_back(*it);   // copy first; erase after save
-            uint160 hash160;
+        ++it;
-            if (!AddressToHash160(kv.first, hash160)) continue;
+    }
-            CScript scriptPubKey;
+    if (!ready.empty()) {
-            scriptPubKey << OP_DUP << OP_HASH160 << hash160 << OP_EQUALVERIFY << OP_CHECKSIG;
+        // Erase from pending then save before handing off to exec thread,
-            CWalletTx wtx;
+        // so the file never contains an entry that is already being sent.
-            wtx.mapValue["comment"] = strprintf("Pool payout height %d", it->matureAtHeight);
+        for (auto it = gPendingPayouts.begin(); it != gPendingPayouts.end(); ) {
-            if (SendMoney(scriptPubKey, kv.second, wtx))
+            if (nBestHeight >= it->matureAtHeight)
-                printf("Pool: paid %s to %s\n", FormatMoney(kv.second).c_str(), kv.first.c_str());
+                it = gPendingPayouts.erase(it);
            else
-                printf("Pool: payout FAILED for %s (will not retry)\n", kv.first.c_str());
+                ++it;
+        }
+        SavePendingPayouts();
+        std::lock_guard<std::mutex> lk(gPayoutExecMutex);
+        for (auto& pp : ready)
+            gPayoutExecQueue.push_back(std::move(pp));
+    }
+}
+// Payout execution thread: drains gPayoutExecQueue, calls SendMoney.
+// Runs independently of the event loop so slow wallet operations
+// (SendMoney takes cs_main) never stall miner I/O.
+static void PayoutThreadFn(void*)
+{
+    gPayoutThreadRunning = true;
+    LogPrint("payout", "[payout] payout thread started\n");
+    while (!fShutdown && gPoolRunning) {
+        std::vector<PendingPayout> batch;
+        {
+            std::lock_guard<std::mutex> lk(gPayoutExecMutex);
+            batch.swap(gPayoutExecQueue);
+        }
+        for (auto& pp : batch) {
+            LogPrint("payout", "[payout] executing payments for block matured at %d"
+                     " (%zu miners)\n", pp.matureAtHeight, pp.amounts.size());
+            for (auto& kv : pp.amounts) {
+                uint160 h160;
+                if (!AddressToHash160(kv.first, h160)) {
+                    // Should not happen -- bad addresses are filtered in QueuePayouts
+                    LogPrint("payout", "[payout] SKIPPED bad address '%s'\n",
+                             kv.first.c_str());
+                    continue;
+                }
+                CScript sc;
+                sc << OP_DUP << OP_HASH160 << h160 << OP_EQUALVERIFY << OP_CHECKSIG;
+                CWalletTx wtx;
+                wtx.mapValue["comment"] = strprintf("Pool payout height %d",
+                                                     pp.matureAtHeight);
+                if (SendMoney(sc, kv.second, wtx))
+                    LogPrint("payout", "[payout] paid %s to %s\n",
+                             FormatMoney(kv.second).c_str(), kv.first.c_str());
+                else
+                    LogPrint("payout", "[payout] FAILED to pay %s to %s"
+                             " (insufficient funds or wallet locked?)\n",
+                             FormatMoney(kv.second).c_str(), kv.first.c_str());
+            }
        }
-        it = gPendingPayouts.erase(it);
+        Sleep(500); // check for new work every 500ms
    }
+    gPayoutThreadRunning = false;
+    LogPrint("payout", "[payout] payout thread stopped\n");
 }
 // ---------------------------------------------------------------------------
-// Stratum protocol
+// GUI stats snapshot -- event loop writes, GUI threads read
 // ---------------------------------------------------------------------------
-static json MakeNotifyParams(const StratumJob& job, bool clean)
+struct StatsSnapshot {
+    int    authorizedMiners = 0;
+    int    blocksFound      = 0;
+    uint64 roundShares      = 0;
+    double totalHashRate    = 0.0;
+};
+static StatsSnapshot                   gStats;
+static std::vector<PoolWorkerStatView> gWorkerStats;
+static std::vector<PendingPayoutView>  gPayoutViews;
+static std::mutex                      gStatsMutex;
+void GetPoolOperatorStats(int& authorizedMiners, int& blocksFound, uint64& roundShares, double& totalHashRate)
 {
-    CBlock& b = const_cast<CBlock&>(job.block);
+    std::lock_guard<std::mutex> lk(gStatsMutex);
-    unsigned char hdr[80];
+    authorizedMiners = gStats.authorizedMiners;
-    memcpy(hdr,    &b.nVersion,       4);
+    blocksFound      = gStats.blocksFound;
-    memcpy(hdr+4,  &b.hashPrevBlock,  32);
+    roundShares      = gStats.roundShares;
-    memcpy(hdr+36, &b.hashMerkleRoot, 32);
+    totalHashRate    = gStats.totalHashRate;
-    memcpy(hdr+68, &b.nTime,          4);
+}
-    memcpy(hdr+72, &b.nBits,          4);
-    memcpy(hdr+76, &b.nNonce,         4);
+void GetPoolWorkerStats(std::vector<PoolWorkerStatView>& out)
-    unsigned char shareTgt[32]; memcpy(shareTgt, &job.shareTarget, 32);
+{
-    return json::array({job.jobId, ToHex(hdr,80), b.hashPrevBlock.GetHex(), ToHex(shareTgt,32), clean});
+    std::lock_guard<std::mutex> lk(gStatsMutex);
+    out = gWorkerStats;
+}
+void GetPendingPayouts(std::vector<PendingPayoutView>& out)
+{
+    std::lock_guard<std::mutex> lk(gStatsMutex);
+    out = gPayoutViews;
 }
+// ---------------------------------------------------------------------------
+// Miner state -- event loop thread only
+// ---------------------------------------------------------------------------
+static std::atomic<uint32_t> gNextExtranonce2{1};
+// Vardiff target: aim for one share every VARDIFF_TARGET_SECS seconds per miner.
+// After VARDIFF_SHARES_PER_CHECK shares, recalculate and adjust if rate is off
+// by more than 50%. Shares are the stable unit; difficulty floats to match.
+static const int64  VARDIFF_TARGET_SECS       = 15;  // one share every 15s
+static const uint64 VARDIFF_SHARES_PER_CHECK  = 5;   // re-evaluate every 5 shares
+static const double VARDIFF_RETARGET_RATIO    = 1.5; // adjust if >50% off target
+static const double VARDIFF_MIN               = 0.001;
+static const double VARDIFF_MAX               = 1e12;
+// If a miner has gone this long since its vardiff window opened with ZERO
+// shares, the normal vardiff retarget (which only fires after
+// VARDIFF_SHARES_PER_CHECK shares) can never trigger -- it has no samples to
+// act on. This is the residual gap the ShareTargetFromDifficulty fix above
+// doesn't cover: even with a correctly-easy diff-1 target, a miner stuck in
+// RandomX light mode (or otherwise much slower than expected) can go
+// indefinitely without a single share, and difficulty would never drop to
+// meet it. Force a difficulty cut on a timeout instead of waiting for shares
+// that will never come.
+static const int64  VARDIFF_STALL_SECS        = 45;  // 3x share target -- reacts faster without false-triggering on normal variance
+static const double VARDIFF_STALL_CUT         = 4.0; // divide difficulty by this much
 struct Miner {
-    SOCKET      fd;
+    btf_socket_t fd;
-    bool        authorised;
+    bool         authorised    = false;
-    std::string address;
+    std::string  address;
-    std::string worker;
+    std::string  worker;
-    std::string readBuf;
+    std::string  readBuf;
-    int64       connectTime;
+    int64        connectTime;
-    uint64      sessionShares;
+    uint64       sessionShares  = 0;
-    Miner(SOCKET f) : fd(f), authorised(false), connectTime(GetTime()), sessionShares(0) {}
+    uint64       roundShares    = 0;
+    uint64       totalShares    = 0;
+    int64        lastSeen       = 0;
+    uint32_t     extranonce2;
+    // Vardiff state
+    double       difficulty     = 1.0;   // current share difficulty sent to this miner
+    uint256      shareTarget;            // derived from difficulty; what we check against
+    int64        vardiffWindowStart = 0; // when the current vardiff window opened
+    uint64       vardiffShares  = 0;     // shares found in current window
+    // Hashrate estimate -- EWMA of (expected hashes per share at current
+    // difficulty) / (seconds since the previous share). We had all the data
+    // to compute this (difficulty + share timing) but never actually did,
+    // so pool/GUI hashrate always showed as zero/missing.
+    int64        lastShareTime  = 0;     // GetTime() of the previous accepted share
+    double       hashRate       = 0.0;   // smoothed H/s estimate
+    explicit Miner(btf_socket_t f)
+        : fd(f), connectTime(GetTime()),
+          extranonce2(gNextExtranonce2.fetch_add(1)) {}
 };
-void GetPoolOperatorStats(int& authorizedMiners, int& blocksFound, uint64& roundShares)
+static std::vector<Miner*> gMiners;
+struct FoundBlock { int height; int64 ts; std::string addr; };
+static std::deque<FoundBlock> gFoundBlocks;
+// ---------------------------------------------------------------------------
+// Accept queue -- accept threads push; event loop pops at top of each tick
+// ---------------------------------------------------------------------------
+static std::vector<btf_socket_t> gReadyQueue;
+static std::mutex                gReadyMutex;
+static void PushReady(btf_socket_t s)
 {
-    authorizedMiners = 0;
+    std::lock_guard<std::mutex> lk(gReadyMutex);
-    blocksFound = 0;
+    gReadyQueue.push_back(s);
-    roundShares = 0;
+}
-    {
-        std::lock_guard<std::mutex> lk(gMinersMutex);
+// ---------------------------------------------------------------------------
-        for (Miner* m : gMiners)
+// I/O helpers -- event loop thread only
-            if (m->authorised)
+// ---------------------------------------------------------------------------
-                authorizedMiners++;
+// Blocking send of a complete JSON line. Called only from the event loop so
+// no other thread is writing to the same fd concurrently.
+static bool SendLine(btf_socket_t fd, const json& j)
+{
+    std::string s = j.dump() + "\n";
+    int off = 0, total = (int)s.size();
+    while (off < total) {
+        int r = send(fd, s.c_str() + off, total - off, SEND_FLAGS);
+        if (r <= 0) return false;
+        off += r;
    }
-    {
+    return true;
-        std::lock_guard<std::mutex> lk(gBlocksMutex);
+}
-        blocksFound = (int)gFoundBlocks.size();
+// Non-blocking recv: pull whatever bytes are available now into buf, then
+// return one complete line if one is ready. Three outcomes:
+//   true  -- line is filled; buf may still contain more lines
+//   false, errno EAGAIN/EWOULDBLOCK (or FIONREAD==0) -- no data right now
+//   false, r==0 -- clean disconnect; caller must treat fd as dead
+// Caller distinguishes disconnect from "not yet" by checking whether
+// line.empty() after a false return (line is "" on both paths, so we
+// use a separate out-param for the disconnect signal).
+static bool RecvLine(btf_socket_t fd, std::string& buf,
+                     std::string& line, bool& disconnected)
+{
+    disconnected = false;
+    char tmp[4096];
+#ifdef _WIN32
+    u_long avail = 0;
+    ioctlsocket(fd, FIONREAD, &avail);
+    if (avail > 0) {
+        int r = recv(fd, tmp, (int)std::min((u_long)(sizeof(tmp)-1), avail), 0);
+        if (r > 0)      { tmp[r] = 0; buf += tmp; }
+        else if (r == 0){ disconnected = true; return false; }
+        // r < 0: WSAEWOULDBLOCK -- fall through with what we have
    }
+#else
    {
-        std::lock_guard<std::mutex> lk(gMinerStatsMutex);
+        int r = recv(fd, tmp, sizeof(tmp) - 1, MSG_DONTWAIT);
-        for (std::map<std::string, MinerStats>::const_iterator it = gMinerStats.begin(); it != gMinerStats.end(); ++it)
+        if (r > 0)       { tmp[r] = 0; buf += tmp; }
-            roundShares += it->second.roundShares;
+        else if (r == 0) { disconnected = true; return false; }
+        // r < 0: EAGAIN/EWOULDBLOCK -- fall through with what we have
    }
+#endif
+    size_t pos = buf.find('\n');
+    if (pos == std::string::npos) return false; // no complete line yet
+    line = buf.substr(0, pos);
+    if (!line.empty() && line.back() == '\r') line.pop_back();
+    buf = buf.substr(pos + 1);
+    return true;
 }
-static bool SendLine(Miner* m, const json& j)
+// ---------------------------------------------------------------------------
+// Job helpers
+// ---------------------------------------------------------------------------
+static CBlock BuildMinerBlock(const StratumJob& job, uint32_t extranonce2)
 {
-    std::string s = j.dump() + "\n";
+    CBlock blk = job.block;
-    int off = 0;
+    blk.vtx[0].vin[0].scriptSig << (CBigNum)extranonce2;
-    while (off < (int)s.size()) {
+    blk.hashMerkleRoot = blk.BuildMerkleTree();
-        int n = send(m->fd, s.c_str() + off, (int)s.size() - off, SEND_FLAGS);
+    return blk;
-        if (n <= 0)
+}
-            return false;
-        off += n;
+// shareTarget is per-miner (set by vardiff) and passed explicitly so the
-    }
+// value in p[3] of mining.notify always matches what HandleLine checks on submit.
-    return true;
+// This is the single source of truth for share difficulty.
+static json MakeNotifyParams(const StratumJob& job, const CBlock& b,
+                              const uint256& shareTarget, bool clean)
+{
+    unsigned char hdr[80];
+    memcpy(hdr,    &b.nVersion,       4);
+    memcpy(hdr+4,  &b.hashPrevBlock,  32);
+    memcpy(hdr+36, &b.hashMerkleRoot, 32);
+    memcpy(hdr+68, &b.nTime,          4);
+    memcpy(hdr+72, &b.nBits,          4);
+    memcpy(hdr+76, &b.nNonce,         4);
+    unsigned char tgt[32]; memcpy(tgt, &shareTarget, 32);
+    return json::array({job.jobId, ToHex(hdr, 80),
+                        b.hashPrevBlock.GetHex(), ToHex(tgt, 32), clean});
+}
+static void SendJob(Miner* m, bool clean)
+{
+    if (!gHaveJob) return;
+    CBlock mb = BuildMinerBlock(gCurrentJob, m->extranonce2);
+    // Use this miner's own shareTarget (set by vardiff) in the notify params.
+    // The participant miner reads p[3] as its share target, and HandleLine
+    // checks m->shareTarget on submit -- both sides now use the same value.
+    json n = {{"id",nullptr},{"method","mining.notify"},
+              {"params", MakeNotifyParams(gCurrentJob, mb, m->shareTarget, clean)}};
+    if (!SendLine(m->fd, n))
+        LogPrint("worker", "[pool->worker] job send FAILED for %s -- miner will be dropped\n",
+                 m->address.empty() ? "(not yet authorized)" : m->address.c_str());
 }
 static void BroadcastJob(bool clean)
 {
-    StratumJob job;
+    if (!gHaveJob) return;
-    { std::lock_guard<std::mutex> lk(gJobMutex); if(!gHaveJob) return; job=gCurrentJob; }
+    int sent = 0;
-    json n = {{"id",nullptr},{"method","mining.notify"},{"params",MakeNotifyParams(job,clean)}};
+    for (Miner* m : gMiners) {
-    std::lock_guard<std::mutex> lk(gMinersMutex);
+        if (!m->authorised) continue;
-    for (Miner* m : gMiners)
+        SendJob(m, clean);
-        if (m->authorised && !SendLine(m, n))
+        sent++;
-            printf("Stratum: failed to broadcast job to %s\n", m->address.c_str());
+    }
+    LogPrint("pool", "[pool] job %s broadcast to %d miner(s)\n",
+             gCurrentJob.jobId.c_str(), sent);
 }
-static void HandleLine(Miner* m, const std::string& line)
+// ---------------------------------------------------------------------------
+// Stratum message handler -- called for each complete line from a miner
+// Returns false if the miner should be disconnected immediately.
+// ---------------------------------------------------------------------------
+static bool HandleLine(Miner* m, const std::string& rawLine,
+                       std::map<std::string, uint64>& roundShareCount,
+                       uint64& roundShareTotal,
+                       int& blocksFoundThisSession)
 {
    json req;
-    try { req = json::parse(line); } catch(...){ return; }
+    try { req = json::parse(rawLine); }
+    catch (...) {
+        LogPrint("worker", "[worker] JSON parse error from %s: %.80s\n",
+                 m->address.empty() ? "(unauth)" : m->address.c_str(),
+                 rawLine.c_str());
+        return true; // don't disconnect on bad JSON, just ignore the line
+    }
-    json id = req.value("id", json(nullptr));
+    json        id     = req.value("id", json(nullptr));
-    std::string method = req.value("method","");
+    std::string method = req.value("method", "");
-    auto reply = [&](json result, json error=nullptr){
+    // Reply helper: always sends result+error pair as Stratum requires
-        if (!SendLine(m, json{{"id",id},{"result",result},{"error",error}}))
+    auto reply = [&](json result, std::string error = "") {
-            printf("Stratum: failed to reply to miner %s\n", m->address.c_str());
+        json err = error.empty() ? json(nullptr) : json(error);
+        if (!SendLine(m->fd, json{{"id",id},{"result",result},{"error",err}}))
+            LogPrint("worker", "[pool->worker] reply send FAILED for %s (method=%s)\n",
+                     m->address.empty() ? "(unauth)" : m->address.c_str(),
+                     method.c_str());
    };
+    // ------------------------------------------------------------------
    if (method == "mining.subscribe") {
        std::string sid = ToHex(&m->fd, 4);
-        printf("Stratum: miner subscribed %s\n", sid.c_str());
+        LogPrint("worker", "[worker->pool] subscribe from fd=%d sid=%s\n",
+                 (int)m->fd, sid.c_str());
        reply(json::array({json::array({json::array({"mining.notify",sid})}),sid,4}));
-        return;
+        return true;
    }
+    // ------------------------------------------------------------------
    if (method == "mining.authorize") {
        auto& p = req["params"];
-        m->address = (p.size()>0 && p[0].is_string()) ? p[0].get<std::string>() : "";
+        m->address = (p.size() > 0 && p[0].is_string()) ? p[0].get<std::string>() : "";
-        m->worker  = (p.size()>1 && p[1].is_string()) ? p[1].get<std::string>() : "worker";
+        m->worker  = (p.size() > 1 && p[1].is_string()) ? p[1].get<std::string>() : "worker";
-        m->authorised = true;
+        m->lastSeen = GetTime();
-        printf("Stratum: miner authorized address=%s worker=%s\n", m->address.c_str(), m->worker.c_str());
-        reply(true);
-        uint160 h; bool valid = AddressToHash160(m->address, h);
+        // Validate address before authorising
-        if (!valid) printf("Stratum: miner %s invalid address '%s' — shares won't pay out\n",
+        uint160 h160; bool validAddr = AddressToHash160(m->address, h160);
-                           m->worker.c_str(), m->address.c_str());
-        { std::lock_guard<std::mutex> lk(gMinerStatsMutex);
+        m->authorised = true; // authorise regardless -- shares just won't pay out
-          auto& ms = gMinerStats[m->address];
+        LogPrint("worker", "[worker->pool] authorize address=%s worker=%s addr_valid=%s\n",
-          ms.lastSeen = GetTime(); ms.worker = m->worker; }
+                 m->address.c_str(), m->worker.c_str(), validAddr ? "yes" : "NO");
-        if (!SendLine(m, json{{"id",nullptr},{"method","mining.set_difficulty"},{"params",json::array({1})}}))
+        if (!validAddr)
-            printf("Stratum: failed to send difficulty to %s\n", m->address.c_str());
+            LogPrint("worker", "[pool] WARNING: address '%s' is invalid -- "
+                     "miner will hash but shares cannot be paid out\n",
+                     m->address.c_str());
-        StratumJob job; bool have;
+        reply(true);
-        { std::lock_guard<std::mutex> lk(gJobMutex); have=gHaveJob; if(have) job=gCurrentJob; }
-        if (have) {
+        // Initialize vardiff state and send initial difficulty
-            printf("Stratum: sending job %s to %s\n", job.jobId.c_str(), m->address.c_str());
+        m->difficulty       = 1.0;
-            if (!SendLine(m, json{{"id",nullptr},{"method","mining.notify"},{"params",MakeNotifyParams(job,true)}}))
+        m->shareTarget      = ShareTargetFromDifficulty(m->difficulty);
-                printf("Stratum: failed to send job %s to %s\n", job.jobId.c_str(), m->address.c_str());
+        m->vardiffWindowStart = GetTime();
+        m->vardiffShares    = 0;
+        LogPrint("worker", "[pool->worker] initial difficulty=%.4f for %s\n",
+                 m->difficulty, m->address.c_str());
+        if (!SendLine(m->fd, json{{"id",nullptr},{"method","mining.set_difficulty"},
+                                  {"params",json::array({m->difficulty})}}))
+            LogPrint("worker", "[pool->worker] set_difficulty send FAILED for %s\n",
+                     m->address.c_str());
+        if (gHaveJob) {
+            LogPrint("worker", "[pool->worker] sending job %s to %s\n",
+                     gCurrentJob.jobId.c_str(), m->address.c_str());
+            SendJob(m, true);
        } else {
-            printf("Stratum: no job available for %s\n", m->address.c_str());
+            LogPrint("worker", "[pool->worker] no job available yet for %s"
+                     " -- will be sent one as soon as the pool builds it\n",
+                     m->address.c_str());
        }
-        return;
+        return true;
    }
-    if (method == "mining.extranonce.subscribe") { reply(true); return; }
+    // ------------------------------------------------------------------
+    if (method == "mining.extranonce.subscribe") { reply(true); return true; }
+    if (method == "mining.get_transactions")     { reply(json::array()); return true; }
+    // ------------------------------------------------------------------
    if (method == "mining.submit") {
-        if (!m->authorised) { reply(false,"not authorised"); return; }
+        if (!m->authorised) {
+            LogPrint("worker", "[worker->pool] submit from unauthorized miner (fd=%d)\n",
+                     (int)m->fd);
+            reply(false, "not authorised");
+            return true;
+        }
        auto& p = req["params"];
-        if (p.size() < 4) { reply(false,"bad params"); return; }
+        if (p.size() < 3) {
+            LogPrint("worker", "[worker->pool] submit bad params from %s (size=%zu)\n",
+                     m->address.c_str(), p.size());
+            reply(false, "bad params");
+            return true;
+        }
-        std::string jobId    = p[1].get<std::string>();
+        std::string submitJobId = p[1].get<std::string>();
-        std::string nonceHex = p[2].get<std::string>();
+        std::string nonceHex    = p[2].get<std::string>();
-        StratumJob job;
+        if (!gHaveJob) {
-        { std::lock_guard<std::mutex> lk(gJobMutex);
+            LogPrint("worker", "[worker->pool] submit from %s but pool has no current job\n",
-          if (!gHaveJob || gCurrentJob.jobId != jobId) { reply(false,"stale job"); return; }
+                     m->address.c_str());
-          job = gCurrentJob; }
+            reply(false, "stale job");
+            return true;
+        }
+        if (gCurrentJob.jobId != submitJobId) {
+            LogPrint("worker", "[worker->pool] submit stale job from %s"
+                     " (submitted=%s current=%s)\n",
+                     m->address.c_str(), submitJobId.c_str(), gCurrentJob.jobId.c_str());
+            reply(false, "stale job");
+            return true;
+        }
        auto nb = FromHex(nonceHex);
-        if (nb.size()<4) { reply(false,"bad nonce"); return; }
+        if (nb.size() < 4) {
+            LogPrint("worker", "[worker->pool] submit bad nonce from %s: '%s'\n",
+                     m->address.c_str(), nonceHex.c_str());
+            reply(false, "bad nonce");
+            return true;
+        }
        unsigned int nNonce; memcpy(&nNonce, nb.data(), 4);
-        CBlock& b = job.block;
+        // Rebuild this miner's exact block (unique merkle via extranonce2)
+        CBlock b = BuildMinerBlock(gCurrentJob, m->extranonce2);
        b.nNonce = nNonce;
        unsigned char hdr[80];
-        memcpy(hdr,    &b.nVersion,      4);
+        memcpy(hdr,    &b.nVersion,       4);
-        memcpy(hdr+4,  &b.hashPrevBlock, 32);
+        memcpy(hdr+4,  &b.hashPrevBlock,  32);
-        memcpy(hdr+36, &b.hashMerkleRoot,32);
+        memcpy(hdr+36, &b.hashMerkleRoot, 32);
-        memcpy(hdr+68, &b.nTime,         4);
+        memcpy(hdr+68, &b.nTime,          4);
-        memcpy(hdr+72, &b.nBits,         4);
+        memcpy(hdr+72, &b.nBits,          4);
-        memcpy(hdr+76, &b.nNonce,        4);
+        memcpy(hdr+76, &b.nNonce,         4);
        uint256 powHash = RandomXPoWHash(hdr, 80);
-                // Record share in the current round.
+        // Check against this miner's personal share target (set by vardiff)
-                std::string key = MinerKey(m->address, m->worker);
+        if (powHash > m->shareTarget) {
-                { std::lock_guard<std::mutex> lk(gMinerStatsMutex);
+            LogPrint("worker", "[worker->pool] high-hash from %s"
-                    MinerStats& ms = gMinerStats[key];
+                     " nonce=%u (difficulty=%.4f)\n",
-                    ms.address = m->address;
+                     m->address.c_str(), nNonce, m->difficulty);
-                    ms.worker = m->worker;
+            reply(false, "high-hash");
-                    ms.roundShares++;
+            return true;
-                    ms.totalShares++;
+        }
-                    ms.lastSeen = GetTime(); }
+        // Valid share -- record it
        m->sessionShares++;
+        m->roundShares++;
+        m->totalShares++;
+        m->vardiffShares++;
+        int64 shareTime = GetTime();
+        m->lastSeen = shareTime;
+        roundShareCount[m->address]++;
+        roundShareTotal++;
+        // Update hashrate estimate: expected hashes for this share divided by
+        // the time since the last one, smoothed with an EWMA so a single fast
+        // or slow share doesn't make the number jump around.
+        if (m->lastShareTime > 0) {
+            int64 dt = shareTime - m->lastShareTime;
+            if (dt <= 0) dt = 1;
+            double inst = ExpectedHashesForDifficulty(m->difficulty) / (double)dt;
+            const double alpha = 0.25;
+            m->hashRate = (m->hashRate <= 0.0) ? inst
+                                                : alpha * inst + (1.0 - alpha) * m->hashRate;
+        }
+        m->lastShareTime = shareTime;
-        if (powHash > job.shareTarget) { reply(true); return; }  // valid share, not a full block
+        LogPrint("worker", "[worker->pool] valid share from %s"
+                 " nonce=%u job=%s difficulty=%.4f (session: %llu)\n",
+                 m->address.c_str(), nNonce,
+                 gCurrentJob.jobId.c_str(), m->difficulty,
+                 (unsigned long long)m->sessionShares);
+        reply(true);
+        // Vardiff: after every VARDIFF_SHARES_PER_CHECK shares, check rate
+        if (m->vardiffShares >= VARDIFF_SHARES_PER_CHECK) {
+            int64 elapsed = GetTime() - m->vardiffWindowStart;
+            if (elapsed <= 0) elapsed = 1;
+            double actualSecsPerShare = (double)elapsed / (double)m->vardiffShares;
+            double ratio = actualSecsPerShare / (double)VARDIFF_TARGET_SECS;
+            // ratio < 1 means shares arriving faster than target (too easy)
+            // ratio > 1 means shares arriving slower than target (too hard)
+            if (ratio < (1.0 / VARDIFF_RETARGET_RATIO) ||
+                ratio > VARDIFF_RETARGET_RATIO) {
+                // New difficulty scales inversely with actual share rate
+                double newDiff = m->difficulty / ratio;
+                if (newDiff < VARDIFF_MIN) newDiff = VARDIFF_MIN;
+                if (newDiff > VARDIFF_MAX) newDiff = VARDIFF_MAX;
+                // Only apply if the change is meaningful (>10%)
+                if (newDiff / m->difficulty > 1.1 || m->difficulty / newDiff > 1.1) {
+                    m->difficulty    = newDiff;
+                    m->shareTarget   = ShareTargetFromDifficulty(m->difficulty);
+                    LogPrint("worker", "[pool] vardiff: %s new difficulty=%.4f"
+                             " (%.1fs/share actual vs %ds target)\n",
+                             m->address.c_str(), m->difficulty,
+                             actualSecsPerShare, (int)VARDIFF_TARGET_SECS);
+                    SendLine(m->fd, json{{"id",nullptr},
+                                        {"method","mining.set_difficulty"},
+                                        {"params",json::array({m->difficulty})}});
+                    // set_difficulty alone doesn't change what the worker
+                    // actually hashes against -- it only reads its share
+                    // target from mining.notify params[3]. Without this, the
+                    // new difficulty wouldn't take effect until the next
+                    // natural job broadcast (new block, or the 60s trickle
+                    // refresh), so push a fresh notify for this miner now.
+                    SendJob(m, false);
+                }
+            }
+            // Reset window
+            m->vardiffWindowStart = GetTime();
+            m->vardiffShares      = 0;
+        }
+        if (powHash > gCurrentJob.target) return true; // valid share, not a block
+        // Full difficulty met -- submit block to the chain
+        LogPrint("pool", "[pool] BLOCK CANDIDATE from %s height=%d nNonce=%u -- submitting\n",
+                 m->address.c_str(), gCurrentJob.height, nNonce);
-        // Full block
        CBlock* pblock = new CBlock(b);
        bool accepted = false;
        CRITICAL_BLOCK(cs_main)
        {
+            int heightBefore = nBestHeight;
            if (ProcessBlock(NULL, pblock)) {
-                accepted = true;
+                // ProcessBlock returns true for orphans too -- verify the chain
-                printf("Pool: BLOCK FOUND by %s height=%d nNonce=%u\n",
+                // actually advanced. If nBestHeight didn't increase, the block
-                       m->address.c_str(), job.height, nNonce);
+                // was shelved as an orphan (pool was behind the chain tip) and
-                FoundBlock fb{job.height, GetTime(), m->address, pblock->GetHash()};
+                // no coinbase was added to the wallet. Do not pay out.
-                { std::lock_guard<std::mutex> lk(gBlocksMutex);
+                if (nBestHeight > heightBefore) {
-                  gFoundBlocks.push_front(fb);
+                    accepted = true;
-                  if (gFoundBlocks.size()>50) gFoundBlocks.pop_back(); }
+                    LogPrint("pool", "[pool] BLOCK ACCEPTED height=%d by %s\n",
-                { std::lock_guard<std::mutex> lk(gJobMutex); gHaveJob=false; }
+                             gCurrentJob.height, m->address.c_str());
+                    gFoundBlocks.push_front({gCurrentJob.height, GetTime(), m->address});
+                    if (gFoundBlocks.size() > 50) gFoundBlocks.pop_back();
+                    blocksFoundThisSession++;
+                    gHaveJob = false; // invalidate job immediately
+                } else {
+                    LogPrint("pool", "[pool] BLOCK ORPHANED height=%d by %s"
+                             " -- pool was behind chain tip, no payout\n",
+                             gCurrentJob.height, m->address.c_str());
+                    gHaveJob = false; // job is stale regardless
+                }
            } else {
+                LogPrint("pool", "[pool] BLOCK REJECTED height=%d (ProcessBlock returned false)\n",
+                         gCurrentJob.height);
                delete pblock;
            }
        }
-        reply(accepted);
-        if (accepted) { QueuePayouts(job.height); RebuildJob(); BroadcastJob(true); }
+        if (accepted) {
-        return;
+            // Snapshot height before RebuildJob() (which increments it)
+            int foundHeight = gCurrentJob.height;
+            QueuePayouts(foundHeight, roundShareCount, roundShareTotal);
+            // Reset round shares
+            roundShareCount.clear();
+            roundShareTotal = 0;
+            for (Miner* mi : gMiners) mi->roundShares = 0;
+            // Build and broadcast new job immediately
+            if (RebuildJob()) {
+                LogPrint("pool", "[pool] new job %s built after block %d\n",
+                         gCurrentJob.jobId.c_str(), foundHeight);
+                BroadcastJob(true);
+            } else {
+                LogPrint("pool", "[pool] WARNING: RebuildJob() failed after block %d"
+                         " -- miners will wait\n", foundHeight);
+            }
+        }
+        return true;
    }
-    if (method == "mining.get_transactions") { reply(json::array()); return; }
+    // Unknown method -- log it (can reveal miner software quirks)
+    LogPrint("worker", "[worker->pool] unknown method '%s' from %s\n",
+             method.c_str(),
+             m->address.empty() ? "(unauth)" : m->address.c_str());
    reply(nullptr, "unknown method");
+    return true;
 }
-static void MinerThreadFn(void* arg)
+// ---------------------------------------------------------------------------
+// Stats refresh -- called every 2s from event loop
+// ---------------------------------------------------------------------------
+static void RefreshStats(int blocksFoundThisSession, uint64 roundShareTotal)
 {
-    Miner* m = (Miner*)arg;
+    std::lock_guard<std::mutex> lk(gStatsMutex);
-    while (!fShutdown && gPoolRunning) {
-        fd_set fds; FD_ZERO(&fds); FD_SET(m->fd, &fds);
+    gStats.authorizedMiners = 0;
-        struct timeval tv={1,0};
+    gStats.blocksFound      = blocksFoundThisSession;
-        if (select((int)m->fd+1, &fds, NULL, NULL, &tv) <= 0) continue;
+    gStats.roundShares      = roundShareTotal;
-        char buf[4096]; 
+    gStats.totalHashRate    = 0.0;
-        int n = recv(m->fd, buf, sizeof(buf)-1, 0);
+    for (Miner* m : gMiners)
-        if (n <= 0) break;
+        if (m->authorised) gStats.authorizedMiners++;
-        buf[n]=0; m->readBuf += buf;
-        size_t pos;
+    gWorkerStats.clear();
-        while ((pos = m->readBuf.find('\n')) != std::string::npos) {
+    for (Miner* m : gMiners) {
-            std::string line = m->readBuf.substr(0, pos);
+        if (!m->authorised || m->lastSeen <= 0) continue;
-            m->readBuf = m->readBuf.substr(pos+1);
+        PoolWorkerStatView v;
-            if (!line.empty() && line.back()=='\r') line.pop_back();
+        v.address     = m->address;
-            if (!line.empty()) HandleLine(m, line);
+        v.worker      = m->worker;
-        }
+        v.roundShares = m->roundShares;
+        v.totalShares = m->totalShares;
+        v.lastSeen    = m->lastSeen;
+        v.hashRate    = m->hashRate;
+        gWorkerStats.push_back(v);
+        gStats.totalHashRate += m->hashRate;
+    }
+    std::sort(gWorkerStats.begin(), gWorkerStats.end(),
+        [](const PoolWorkerStatView& a, const PoolWorkerStatView& b) {
+            return a.roundShares != b.roundShares ? a.roundShares > b.roundShares
+                                                  : a.lastSeen > b.lastSeen;
+        });
+    // gPendingPayouts is event-loop-only data (no lock needed here since
+    // RefreshStats is always called from the event loop thread).
+    gPayoutViews.clear();
+    for (const PendingPayout& pp : gPendingPayouts) {
+        PendingPayoutView pv;
+        pv.matureAtHeight = pp.matureAtHeight;
+        pv.recipients     = (int)pp.amounts.size();
+        pv.totalAmount    = 0;
+        for (auto& kv : pp.amounts) pv.totalAmount += kv.second;
+        gPayoutViews.push_back(pv);
    }
-    sock_close(m->fd);
-    printf("Stratum: miner %s disconnected (%llu shares)\n",
-           m->worker.empty()?"unknown":m->worker.c_str(),
-           (unsigned long long)m->sessionShares);
-    { std::lock_guard<std::mutex> lk(gMinersMutex);
-      auto it = std::find(gMiners.begin(), gMiners.end(), m);
-      if (it != gMiners.end()) gMiners.erase(it); }
-    delete m;
 }
-static void JobWatcherFn(void*)
+// ---------------------------------------------------------------------------
+// Event loop
+// ---------------------------------------------------------------------------
+static void PoolEventLoop()
 {
-    int lastHeight = -1;
+    int   lastHeight            = -1;
+    int64 lastRefresh           = GetTime();
+    int64 lastStatsRefresh      = 0;
+    int   blocksFoundThisSession = 0;
+    int64 noJobSince            = 0;   // 0 = have a job
+    bool  warnedNoJob           = false;
+    int64 lastNoJobRetry        = 0;   // throttle RebuildJob calls when no tip
+    std::map<std::string, uint64> roundShareCount;
+    uint64 roundShareTotal = 0;
+    static const int64 JOB_REFRESH_SECS  = 60;  // re-stamp nTime periodically
+    static const int64 NO_JOB_WARN_SECS  = 15;  // warn after this long with no job
+    static const int64 NO_JOB_RETRY_SECS = 5;   // how often to retry RebuildJob
    while (!fShutdown && gPoolRunning) {
-        Sleep(500);
-        bool newBlock = false;
+        // 1. Drain accept queue
-        CRITICAL_BLOCK(cs_main)
+        {
-        { if (nBestHeight != lastHeight && pindexBest) { lastHeight = nBestHeight; newBlock = true; } }
+            std::lock_guard<std::mutex> lk(gReadyMutex);
-        if (newBlock) {
+            for (btf_socket_t fd : gReadyQueue) {
-            FlushMaturePayouts();
+                gMiners.push_back(new Miner(fd));
-            if (RebuildJob()) { printf("Stratum: new job height=%d\n", lastHeight+1); BroadcastJob(true); }
+                LogPrint("worker", "[pool] miner fd=%d entered event loop"
-        } else if (!gHaveJob) {
+                         " -- awaiting subscribe/authorize\n", (int)fd);
+            }
+            gReadyQueue.clear();
+        }
+        // 2. Detect new block.
+        // When our own miner found the block, HandleLine already called
+        // RebuildJob() + BroadcastJob(true) and set gHaveJob=true.
+        // We still flush mature payouts and update bookkeeping, but skip
+        // rebuilding if a fresh job already exists for this height.
+        {
+            bool newBlock = false;
+            CRITICAL_BLOCK(cs_main)
+            {
+                if (pindexBest && nBestHeight != lastHeight) {
+                    lastHeight = nBestHeight;
+                    newBlock   = true;
+                }
+            }
+            if (newBlock) {
+                FlushMaturePayouts();
+                if (!gHaveJob) {
+                    // External block (not found by our miners), or HandleLine's
+                    // RebuildJob failed. Either way this round is over with no
+                    // payout from us, so clear round shares before starting the
+                    // next one -- otherwise they'd keep accumulating across
+                    // rounds that our own miners didn't win.
+                    roundShareCount.clear();
+                    roundShareTotal = 0;
+                    for (Miner* mi : gMiners) mi->roundShares = 0;
+                    // Build and broadcast now.
+                    if (RebuildJob()) {
+                        LogPrint("pool", "[pool] new block height=%d -- job %s ready,"
+                                 " %zu miner(s) connected\n",
+                                 lastHeight, gCurrentJob.jobId.c_str(), gMiners.size());
+                        BroadcastJob(true);
+                    } else {
+                        LogPrint("pool", "[pool] new block height=%d but RebuildJob() failed"
+                                 " -- miners will wait\n", lastHeight);
+                    }
+                } else {
+                    // HandleLine already built and broadcast for this height.
+                    LogPrint("pool", "[pool] new block height=%d -- job already"
+                             " broadcast by submit handler\n", lastHeight);
+                }
+                lastRefresh  = GetTime();
+                noJobSince   = 0;
+                warnedNoJob  = false;
+            }
+        }
+        // 3. No-job watchdog (throttled: only retry every NO_JOB_RETRY_SECS)
+        if (!gHaveJob) {
+            int64 now = GetTime();
+            if (noJobSince == 0) noJobSince = now;
+            if (now - lastNoJobRetry >= NO_JOB_RETRY_SECS) {
+                lastNoJobRetry = now;
+                if (RebuildJob()) {
+                    LogPrint("pool", "[pool] job built after %llds without one\n",
+                             (long long)(now - noJobSince));
+                    BroadcastJob(false);
+                    noJobSince  = 0;
+                    warnedNoJob = false;
+                    lastRefresh = now;
+                } else if (!warnedNoJob && now - noJobSince >= NO_JOB_WARN_SECS) {
+                    LogPrint("pool", "[pool] STUCK: no job for %llds -- %s."
+                             " Miners are waiting. Will keep retrying every %llds.\n",
+                             (long long)(now - noJobSince),
+                             pindexBest ? "RebuildJob() keeps failing (check above for why)"
+                                        : "no chain tip yet (node still syncing)",
+                             (long long)NO_JOB_RETRY_SECS);
+                    warnedNoJob = true;
+                }
+            }
+        } else if (GetTime() - lastRefresh >= JOB_REFRESH_SECS) {
+            // Periodic nTime refresh -- stale timestamps cause valid hashes to be rejected
            if (RebuildJob()) BroadcastJob(false);
+            lastRefresh = GetTime();
+        }
+        // 3.5. Vardiff stall watchdog -- runs independently of share count.
+        // The normal vardiff check in HandleLine only fires once
+        // VARDIFF_SHARES_PER_CHECK shares have arrived; a miner that never
+        // finds a single share never reaches that check, so it can be stuck
+        // at its initial (or last) difficulty forever. Catch that here.
+        for (Miner* m : gMiners) {
+            if (!m->authorised || m->vardiffShares != 0 || m->vardiffWindowStart <= 0)
+                continue;
+            int64 stalled = GetTime() - m->vardiffWindowStart;
+            if (stalled < VARDIFF_STALL_SECS) continue;
+            double newDiff = m->difficulty / VARDIFF_STALL_CUT;
+            if (newDiff < VARDIFF_MIN) newDiff = VARDIFF_MIN;
+            if (newDiff < m->difficulty) {
+                m->difficulty         = newDiff;
+                m->shareTarget        = ShareTargetFromDifficulty(m->difficulty);
+                m->vardiffWindowStart = GetTime();
+                LogPrint("worker", "[pool] vardiff STALL: %s sent zero shares in"
+                         " %llds -- forcing difficulty down to %.6f (no share data"
+                         " to retarget from normally)\n",
+                         m->address.c_str(), (long long)stalled, m->difficulty);
+                SendLine(m->fd, json{{"id",nullptr},
+                                    {"method","mining.set_difficulty"},
+                                    {"params",json::array({m->difficulty})}});
+                // Same reasoning as the normal vardiff retarget above: the
+                // worker only reads its share target from mining.notify, so
+                // push a fresh job now instead of waiting on the next
+                // natural broadcast.
+                SendJob(m, false);
+            } else {
+                // Already at the difficulty floor -- this miner's problem isn't
+                // difficulty, it's something else (slow hashing, bad connection,
+                // stuck RandomX light mode, etc). Log once per stall window so
+                // it's visible without spamming.
+                LogPrint("worker", "[pool] vardiff STALL: %s still at zero shares"
+                         " after %llds at floor difficulty %.6f -- likely a"
+                         " hashrate/connectivity problem, not a difficulty problem\n",
+                         m->address.c_str(), (long long)stalled, m->difficulty);
+                m->vardiffWindowStart = GetTime(); // avoid re-logging every tick
+            }
+        }
+        // 4. Select over miner sockets
+        if (!gMiners.empty()) {
+            fd_set fds; FD_ZERO(&fds);
+            int maxfd = 0;
+            for (Miner* m : gMiners) {
+                FD_SET(m->fd, &fds);
+                if ((int)m->fd > maxfd) maxfd = (int)m->fd;
+            }
+            struct timeval tv = {0, 50000}; // 50ms
+            if (select(maxfd + 1, &fds, NULL, NULL, &tv) > 0) {
+                std::vector<Miner*> dead;
+                for (Miner* m : gMiners) {
+                    if (!FD_ISSET(m->fd, &fds)) continue;
+                    std::string line;
+                    bool disc = false;
+                    // Drain all complete lines buffered for this miner.
+                    // HandleLine always returns true; disc signals clean disconnect.
+                    while (RecvLine(m->fd, m->readBuf, line, disc))
+                        HandleLine(m, line, roundShareCount,
+                                   roundShareTotal, blocksFoundThisSession);
+                    if (disc) dead.push_back(m);
+                }
+                for (Miner* m : dead) {
+                    LogPrint("worker", "[pool] miner %s disconnected"
+                             " (session shares: %llu, round shares: %llu)\n",
+                             m->worker.empty() ? "(never authorized)" : m->worker.c_str(),
+                             (unsigned long long)m->sessionShares,
+                             (unsigned long long)m->roundShares);
+                    sock_close(m->fd);
+                    gMiners.erase(std::find(gMiners.begin(), gMiners.end(), m));
+                    delete m;
+                }
+            }
+        } else {
+            Sleep(50);
+        }
+        // 5. Refresh GUI stats every 2s
+        if (GetTime() - lastStatsRefresh >= 2) {
+            RefreshStats(blocksFoundThisSession, roundShareTotal);
+            lastStatsRefresh = GetTime();
        }
    }
+    for (Miner* m : gMiners) { sock_close(m->fd); delete m; }
+    gMiners.clear();
 }
 // ---------------------------------------------------------------------------
-// Main Stratum accept loop — entry point called from ui.cpp and headless.cpp
+// Accept threads
-// ---------------------------------------------------------------------------
-// .btf Stratum listener — miners connect via rendezvous relay using the
-// node's .btf address instead of a raw IP:port. Same Stratum protocol,
-// same MinerThreadFn handler, works through CGNAT with no port forwarding.
-//
-// Keeps one listener registered per relay at all times. When a miner
-// connects, a replacement listener is spawned immediately so the next
-// miner doesn't have to wait.
 // ---------------------------------------------------------------------------
+struct AcceptCtx { unsigned char pk[32]; unsigned char sk[32]; std::string relay; };
-struct BtfAcceptCtx { unsigned char pk[32]; unsigned char sk[32]; string relay; };
+// One persistent thread per relay. Loops: register -> wrap -> push -> repeat.
+static void AcceptOneFn(void* arg)
-// Track active listener count per relay to avoid pile-up when relay is slow
-static std::map<string,int> gBtfListenerCount;
-static std::mutex            gBtfListenerMutex;
-static void BtfStratumAcceptOneFn(void* arg)
 {
-    BtfAcceptCtx* ctx = (BtfAcceptCtx*)arg;
+    AcceptCtx* ctx = (AcceptCtx*)arg;
    unsigned char pk[32], sk[32];
    memcpy(pk, ctx->pk, 32); memcpy(sk, ctx->sk, 32);
-    string relay = ctx->relay;
+    std::string relay = ctx->relay;
    delete ctx;
-    auto decrement = [&]() {
-        std::lock_guard<std::mutex> lk(gBtfListenerMutex);
-        gBtfListenerCount[relay]--;
-    };
    size_t colon = relay.rfind(':');
-    if (colon == string::npos) { decrement(); return; }
+    if (colon == std::string::npos) {
-    string strHost = relay.substr(0, colon);
+        LogPrint("pool", "[pool] AcceptOneFn: bad relay address '%s'\n", relay.c_str());
-    int nPort = atoi(relay.substr(colon+1).c_str());
+        return;
-    btf::RvSocket rv = btf::RvServiceRegister(strHost.c_str(), (unsigned short)nPort, pk);
-    if (fShutdown || !gPoolRunning) { if (rv != btf::RV_INVALID) btf::RvClose(rv); decrement(); return; }
-    if (rv == btf::RV_INVALID) { decrement(); return; }
-    // Paired: spawn replacement (count transfers to new thread)
-    if (!fShutdown && gPoolRunning) {
-        BtfAcceptCtx* next = new BtfAcceptCtx();
-        memcpy(next->pk, pk, 32); memcpy(next->sk, sk, 32);
-        next->relay = relay;
-        LaunchThread(BtfStratumAcceptOneFn, next);
-    } else {
-        decrement();
    }
+    std::string host = relay.substr(0, colon);
+    int         port = atoi(relay.substr(colon + 1).c_str());
+    LogPrint("pool", "[pool] accept thread started for relay %s\n", relay.c_str());
+    while (!fShutdown && gPoolRunning) {
+        // Blocks until a miner connects to us at this relay
+        btf::RvSocket rv = btf::RvServiceRegister(host.c_str(), (unsigned short)port, pk);
-    btf_socket_t hSocket = btf::BtfServiceWrap(rv, sk);
+        if (fShutdown || !gPoolRunning) {
-    if (hSocket == INVALID_SOCKET) return;
+            if (rv != btf::RV_INVALID) btf::RvClose(rv);
+            break;
+        }
+        if (rv == btf::RV_INVALID) {
+            LogPrint("pool", "[pool] relay %s: RvServiceRegister failed"
+                     " -- backing off 30s before retry\n", relay.c_str());
+            for (int i = 0; i < 30 && !fShutdown && gPoolRunning; i++) Sleep(1000);
+            continue;
+        }
-    printf("Stratum/.btf: miner connected via %s\n", relay.c_str());
+        // Echan handshake -- blocking but fast (local + relay round-trip)
-    Miner* m = new Miner(hSocket);
+        btf_socket_t fd = btf::BtfServiceWrap(rv, sk);
-    { std::lock_guard<std::mutex> lk(gMinersMutex); gMiners.push_back(m); }
+        if (fd == INVALID_SOCKET) {
-    LaunchThread(MinerThreadFn, m);
+            LogPrint("pool", "[pool] relay %s: BtfServiceWrap failed (echan handshake)"
+                     " -- miner dropped, will accept next\n", relay.c_str());
+            continue;
+        }
+        LogPrint("worker", "[pool] miner arrived via relay %s -- pushing to event loop\n",
+                 relay.c_str());
+        PushReady(fd);
+        // Loop immediately: register again so the next miner can connect
+    }
+    LogPrint("pool", "[pool] accept thread stopped for relay %s\n", relay.c_str());
 }
-static void BtfStratumAcceptFn(void*)
+// Spawns one AcceptOneFn per relay. Re-polls relay list every 60s to pick up
+// newly discovered relays. Uses a set to avoid spawning duplicate threads.
+static void AcceptLoopFn(void*)
 {
-    printf("Stratum/.btf: starting \xe2\x80\x94 miners can connect via %s\n",
+    LogPrint("pool", "[pool] AcceptLoopFn started -- miners can connect via %s\n",
-           BtfLocalAddress().c_str());
+             BtfLocalAddress().c_str());
+    // Wait for our identity to be ready
    unsigned char pk[32], sk[32];
+    int waitSecs = 0;
    while (!BtfGetIdentity(pk, sk)) {
        if (fShutdown || !gPoolRunning) return;
+        if (waitSecs == 0)
+            LogPrint("pool", "[pool] waiting for .btf identity...\n");
+        waitSecs++;
        Sleep(2000);
    }
+    LogPrint("pool", "[pool] .btf identity ready after %ds\n", waitSecs * 2);
+    std::set<std::string> spawned; // relays we've already started a thread for
    while (!fShutdown && gPoolRunning) {
        vector<string> relays = BtfAllRelays();
-        if (relays.empty()) { Sleep(5000); continue; }
+        if (relays.empty()) {
+            LogPrint("pool", "[pool] no relays available -- miners cannot connect yet\n");
-        // Spawn one listener per relay, only if none already active
+        } else {
-        for (const string& relay : relays) {
+            for (const string& relay : relays) {
-            std::lock_guard<std::mutex> lk(gBtfListenerMutex);
+                if (spawned.count(relay)) continue; // already running
-            if (gBtfListenerCount[relay] == 0) {
+                AcceptCtx* ctx = new AcceptCtx();
-                gBtfListenerCount[relay]++;
-                BtfAcceptCtx* ctx = new BtfAcceptCtx();
                memcpy(ctx->pk, pk, 32); memcpy(ctx->sk, sk, 32);
                ctx->relay = relay;
-                LaunchThread(BtfStratumAcceptOneFn, ctx);
+                uintptr_t tid = _beginthread(AcceptOneFn, 0, ctx);
+                if (tid == (uintptr_t)-1) {
+                    delete ctx;
+                    LogPrint("pool", "[pool] failed to spawn accept thread for %s\n",
+                             relay.c_str());
+                } else {
+                    spawned.insert(relay);
+                    LogPrint("pool", "[pool] accept thread spawned for relay %s"
+                             " (%zu total)\n", relay.c_str(), spawned.size());
+                }
            }
        }
-        for (int i = 0; i < 30 && !fShutdown && gPoolRunning; i++) Sleep(1000);
+        // Re-poll every 60s -- newly discovered relays get picked up
+        for (int i = 0; i < 60 && !fShutdown && gPoolRunning; i++) Sleep(1000);
    }
 }
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
 void ThreadRPCServer(void*)
 {
    gPoolRunning = true;
-    printf("Bitflash pool server starting\n");
-    printf("  Stratum .btf:       %s  (no port forwarding needed)\n",
-           BtfLocalAddress().c_str());
-    printf("  Mode:               operator\n");
-    if (RebuildJob())
+    LogPrint("pool", "[pool] ============================================\n");
-        printf("Stratum: initial job seeded height=%d\n", nBestHeight + 1);
+    LogPrint("pool", "[pool] Pool server starting\n");
+    LogPrint("pool", "[pool] .btf address: %s\n", BtfLocalAddress().c_str());
+    LogPrint("pool", "[pool] fee: %.2f%%\n", dPoolFeePercent);
+    if (RebuildJob()) {
+        LogPrint("pool", "[pool] initial job %s seeded at height %d\n",
+                 gCurrentJob.jobId.c_str(), nBestHeight + 1);
+    } else {
+        LogPrint("pool", "[pool] no chain tip yet -- job will build on first block\n");
+    }
+    LoadPendingPayouts();
+    _beginthread(AcceptLoopFn, 0, NULL);
+    _beginthread(ThreadBtfPoolAnnouncer, 0, NULL);
+    _beginthread(PayoutThreadFn, 0, NULL);
-    LaunchThread(JobWatcherFn, NULL);
+    PoolEventLoop(); // blocks until gPoolRunning = false or fShutdown
-    LaunchThread(BtfStratumAcceptFn, NULL);
-    LaunchThread(ThreadBtfPoolAnnouncer, NULL);
-    while (!fShutdown && gPoolRunning)
+    LogPrint("pool", "[pool] pool server stopped\n");
-        Sleep(1000);
+    LogPrint("pool", "[pool] ============================================\n");
-    printf("Pool server stopped\n");
+    gPoolRunning = false;
 }
author	Bitflash <btf01@proton.me>	2026-07-28 12:55:04 -0300
committer	GitHub <noreply@github.com>	2026-07-28 12:55:04 -0300
commit	663784eae9b04ec71e3e1eebf445910e5a8add42 (patch)
tree	1482b0778a11c1b46cfbd476a5d91e12ef31204b /src/rpc.cpp
parent	1d0314c0d220231afc56193ba66b70234fa24092 (diff)