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>

1 files changed, 424 insertions, 277 deletions

diff --git a/src/gui.cpp b/src/gui.cpp
index 2210296..a1a0698 100644
--- a/src/gui.cpp
+++ b/src/gui.cpp
@@ -1,4 +1,4 @@
-// Bitflash GUI — ImGui + GLFW + OpenGL3
+// Bitflash GUI -- ImGui + GLFW + OpenGL3
 // Same source on Linux and Windows. No platform ifdefs.
 
 #include "imgui/imgui.h"
@@ -25,6 +25,7 @@ extern std::string   strParticipantPool;
 extern CAddress      addrLocalHost;
 
 void   MainFrameRepaint();
+int    GetDiscoveredPeerCount();
 string DateTimeStr(int64 nTime);
 bool   SendMoney(CScript scriptPubKey, int64 nValue, CWalletTx& wtxNew);
 int64  GetBalance();
@@ -34,15 +35,20 @@ void   ThreadBitcoinMiner(void*);
 void   ThreadRPCServer(void*);
 
 // ---------------------------------------------------------------------------
-// State
+// Layout constants
+// ---------------------------------------------------------------------------
+static const float STATUS_BAR_H = 22.0f;
+
+// ---------------------------------------------------------------------------
+// GUI state
 // ---------------------------------------------------------------------------
 static std::string g_myAddress;
-static int64       g_balance     = 0;
+static int64       g_balance           = 0;
 static int64       g_lastWalletRefresh = 0;
-static bool        g_showSend    = false;
-static bool        g_showOptions = false;
-static bool        g_showAbout   = false;
-static bool        g_needRefresh = true;
+static bool        g_showSend          = false;
+static bool        g_showOptions       = false;
+static bool        g_showAbout         = false;
+static bool        g_needRefresh       = true;
 
 static char        g_sendAddr[128]        = {};
 static char        g_sendAmount[32]       = {};
@@ -73,36 +79,34 @@ static std::string FmtMoney(int64 n)
 static std::string FmtAge(int64 createdAt)
 {
     int64 age = GetTime() - createdAt;
-    if (age < 0)
-        age = 0;
-    if (age < 60)
-        return strprintf("%llds", (long long)age);
-    if (age < 3600)
-        return strprintf("%lldm", (long long)(age / 60));
-    return strprintf("%lldh", (long long)(age / 3600));
+    if (age < 0)  age = 0;
+    if (age < 60)   return strprintf("%llds",  (long long)age);
+    if (age < 3600) return strprintf("%lldm",  (long long)(age / 60));
+    return              strprintf("%lldh",  (long long)(age / 3600));
 }
 
-static ImVec4 ParticipantStatusColor(const std::string& status)
+static ImVec4 StatusColor(const std::string& s)
 {
-    if (status.find("failed") != std::string::npos ||
-        status.find("rejected") != std::string::npos ||
-        status.find("stopped") != std::string::npos)
-        return ImVec4(1.0f, 0.38f, 0.38f, 1.0f);
-    if (status.find("hashing") != std::string::npos ||
-        status.find("accepted") != std::string::npos ||
-        status.find("connected") != std::string::npos)
-        return ImVec4(0.35f, 1.0f, 0.45f, 1.0f);
-    if (status.find("asking") != std::string::npos ||
-        status.find("authoriz") != std::string::npos ||
-        status.find("subscrib") != std::string::npos)
-        return ImVec4(1.0f, 0.75f, 0.25f, 1.0f);
-    return ImVec4(0.55f, 0.80f, 1.0f, 1.0f);
+    if (s.find("failed")   != std::string::npos ||
+        s.find("rejected") != std::string::npos ||
+        s.find("stopped")  != std::string::npos)
+        return ImVec4(1.0f, 0.38f, 0.38f, 1.0f);   // red
+    if (s.find("hashing")  != std::string::npos ||
+        s.find("accepted") != std::string::npos ||
+        s.find("connected")!= std::string::npos)
+        return ImVec4(0.35f, 1.0f, 0.45f, 1.0f);   // green
+    if (s.find("asking")   != std::string::npos ||
+        s.find("authoriz") != std::string::npos ||
+        s.find("subscrib") != std::string::npos)
+        return ImVec4(1.0f, 0.75f, 0.25f, 1.0f);   // amber
+    return ImVec4(0.55f, 0.80f, 1.0f, 1.0f);        // blue-grey
 }
 
 static std::string PoolLabel(const BtfPoolAnnouncement& ann)
 {
     std::ostringstream o;
-    o << ann.poolName << " - " << std::fixed << std::setprecision(2) << ann.feePercent << "%";
+    o << ann.poolName << " - "
+      << std::fixed << std::setprecision(2) << ann.feePercent << "%";
     if (ann.connectedMiners > 0)
         o << " - " << ann.connectedMiners << " miners";
     return o.str();
@@ -118,19 +122,47 @@ static void RefreshWallet()
     g_txRows.clear();
     TRY_CRITICAL_BLOCK(cs_mapWallet)
     {
-        std::vector<std::pair<int64,uint256>> vs;
-        for (auto& kv : mapWallet) vs.push_back({kv.second.GetTxTime(), kv.first});
-        std::sort(vs.rbegin(), vs.rend());
+        // Sort: unconfirmed first (depth 0), then by depth ascending (least
+        // deep = most recent). We can't use nTimeReceived because a node
+        // resync re-stamps all txs with the same time. Depth is always correct.
+        std::vector<std::pair<int,uint256>> vs;
+        for (auto& kv : mapWallet)
+            vs.push_back({kv.second.GetDepthInMainChain(), kv.second.GetHash()});
+        std::sort(vs.begin(), vs.end(),
+            [](const std::pair<int,uint256>& a, const std::pair<int,uint256>& b) {
+                return a.first < b.first; // 0 (unconfirmed) first, then shallowest
+            });
         for (auto& sv : vs) {
             auto mi = mapWallet.find(sv.second);
             if (mi == mapWallet.end()) continue;
             CWalletTx& wtx = mi->second;
-            int64 net = wtx.GetCredit() - wtx.GetDebit();
-            int depth = wtx.GetDepthInMainChain();
+            int   depth    = wtx.GetDepthInMainChain();
+            int   toMature = wtx.IsCoinBase() ? wtx.GetBlocksToMaturity() : 0;
+            // An orphaned coinbase has hashBlock set but depth=0 (block not in main chain).
+            // A genuinely unconfirmed tx has hashBlock==0.
+            bool isOrphaned = wtx.IsCoinBase() && wtx.hashBlock != 0 && depth == 0;
+            int64 net;
             std::string desc;
-            if (wtx.IsCoinBase())        desc = depth<1 ? "Generated (unconfirmed)" : "Generated";
-            else if (wtx.GetDebit() > 0) desc = "Sent";
-            else                          desc = "Received";
+            if (wtx.IsCoinBase()) {
+                if (isOrphaned) {
+                    net  = 0;
+                    desc = "Generated (orphaned -- block not in main chain)";
+                } else if (toMature > 0) {
+                    net  = wtx.GetValueOut();
+                    char buf[64];
+                    snprintf(buf, sizeof(buf), "Generated (matures in %d blocks)", toMature);
+                    desc = buf;
+                } else {
+                    net  = wtx.GetCredit() - wtx.GetDebit();
+                    desc = depth < 1 ? "Generated (unconfirmed)" : "Generated";
+                }
+            } else if (wtx.GetDebit() > 0) {
+                net  = wtx.GetCredit() - wtx.GetDebit();
+                desc = "Sent";
+            } else {
+                net  = wtx.GetCredit() - wtx.GetDebit();
+                desc = "Received";
+            }
             g_txRows.push_back({DateTimeStr(wtx.GetTxTime()), desc, net, depth});
         }
     }
@@ -149,18 +181,103 @@ string DateTimeStr(int64 nTime)
 }
 
 // ---------------------------------------------------------------------------
+// Status bar -- separate fullscreen-width overlay pinned to bottom edge.
+// Drawn last so it always sits on top of everything else.
+// ---------------------------------------------------------------------------
+static void DrawStatusBar()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    ImGui::SetNextWindowPos(ImVec2(0.0f, io.DisplaySize.y - STATUS_BAR_H));
+    ImGui::SetNextWindowSize(ImVec2(io.DisplaySize.x, STATUS_BAR_H));
+    ImGui::SetNextWindowBgAlpha(1.0f);
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding,  ImVec2(10.0f, 3.0f));
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
+    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.13f, 0.13f, 0.13f, 1.0f));
+    ImGui::Begin("##statusbar", nullptr,
+        ImGuiWindowFlags_NoTitleBar       |
+        ImGuiWindowFlags_NoResize         |
+        ImGuiWindowFlags_NoMove           |
+        ImGuiWindowFlags_NoScrollbar      |
+        ImGuiWindowFlags_NoScrollWithMouse|
+        ImGuiWindowFlags_NoSavedSettings  |
+        ImGuiWindowFlags_NoBringToFrontOnFocus);
+    ImGui::PopStyleVar(3);
+    ImGui::PopStyleColor();
+
+    int connected  = (int)vNodes.size();
+    int discovered = GetDiscoveredPeerCount();
+
+    if (nMineMode == MINE_PARTICIPANT) {
+        uint64 sent = 0, accepted = 0;
+        double hashRate = 0.0;
+        std::string st = GetParticipantMiningStatus();
+        GetParticipantMiningStats(sent, accepted, hashRate);
+        if (sent > 0 || accepted > 0 || hashRate > 0.0)
+            ImGui::TextDisabled(
+                "Connected peers: %d  Detected peers: %d  Height: %d"
+                "  Shares: %llu sent / %llu accepted  %.2f H/s",
+                connected, discovered, nBestHeight,
+                (unsigned long long)sent, (unsigned long long)accepted, hashRate);
+        else if (!st.empty())
+            ImGui::TextDisabled(
+                "Connected peers: %d  Detected peers: %d  Height: %d  %s",
+                connected, discovered, nBestHeight, st.c_str());
+        else
+            ImGui::TextDisabled(
+                "Connected peers: %d  Detected peers: %d  Height: %d",
+                connected, discovered, nBestHeight);
+    } else if (nMineMode == MINE_OPERATOR) {
+        int miners = 0, blocksFound = 0;
+        uint64 roundShares = 0;
+        double totalHashRate = 0.0;
+        GetPoolOperatorStats(miners, blocksFound, roundShares, totalHashRate);
+        ImGui::TextDisabled(
+            "Connected peers: %d  Detected peers: %d  Height: %d"
+            "  Miners: %d  Round shares: %llu  Blocks found: %d  %.2f H/s",
+            connected, discovered, nBestHeight,
+            miners, (unsigned long long)roundShares, blocksFound, totalHashRate);
+    } else {
+        ImGui::TextDisabled(
+            "Connected peers: %d  Detected peers: %d  Height: %d",
+            connected, discovered, nBestHeight);
+    }
+
+    ImGui::End();
+}
+
+// ---------------------------------------------------------------------------
 // Main window
+//
+// Layout:
+//   [menu bar]                  -- ImGui built-in menu
+//   [header strip]              -- address, balance, send button, mine status
+//   [separator]
+//   [telemetry strip]           -- mode-specific live stats (never scrolls)
+//   [separator]
+//   [scrollable content child]  -- transactions + mode panels
+//
+// The scrollable child ends at the top of the status bar so content never
+// hides behind it. The child is explicitly sized to fill the remaining space.
 // ---------------------------------------------------------------------------
 static void DrawMainWindow()
 {
     ImGuiIO& io = ImGui::GetIO();
-    ImGui::SetNextWindowPos(ImVec2(0,0));
-    ImGui::SetNextWindowSize(io.DisplaySize);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(12,12));
+
+    // Full display height minus the status bar at the bottom.
+    const float winH = io.DisplaySize.y - STATUS_BAR_H;
+
+    ImGui::SetNextWindowPos(ImVec2(0.0f, 0.0f));
+    ImGui::SetNextWindowSize(ImVec2(io.DisplaySize.x, winH));
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(12.0f, 12.0f));
     ImGui::Begin("##main", nullptr,
-        ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
-        ImGuiWindowFlags_NoMove | ImGuiWindowFlags_MenuBar |
-        ImGuiWindowFlags_NoFocusOnAppearing);
+        ImGuiWindowFlags_NoTitleBar        |
+        ImGuiWindowFlags_NoResize          |
+        ImGuiWindowFlags_NoMove            |
+        ImGuiWindowFlags_NoScrollbar       |
+        ImGuiWindowFlags_NoScrollWithMouse |
+        ImGuiWindowFlags_MenuBar           |
+        ImGuiWindowFlags_NoBringToFrontOnFocus);
     ImGui::SetWindowFontScale(0.92f);
     ImGui::PopStyleVar();
 
@@ -170,179 +287,209 @@ static void DrawMainWindow()
             if (ImGui::MenuItem("Exit")) glfwSetWindowShouldClose(glfwGetCurrentContext(), true);
             ImGui::EndMenu();
         }
-        if (ImGui::MenuItem("Options"))  g_showOptions = true;
-        if (ImGui::MenuItem("About"))    g_showAbout   = true;
+        if (ImGui::MenuItem("Options")) g_showOptions = true;
+        if (ImGui::MenuItem("About"))   g_showAbout   = true;
         ImGui::EndMenuBar();
     }
 
-    // ---- Address bar ----
+    // ---- Header strip (never scrolls) ----
     ImGui::Spacing();
     ImGui::TextDisabled("Address:");
     ImGui::SameLine();
-    ImGui::SetNextItemWidth(-80);
-    ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(0.14f,0.14f,0.14f,1));
+    ImGui::SetNextItemWidth(-80.0f);
+    ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(0.14f, 0.14f, 0.14f, 1.0f));
     ImGui::InputText("##addr", (char*)g_myAddress.c_str(), g_myAddress.size()+1,
                      ImGuiInputTextFlags_ReadOnly);
     ImGui::PopStyleColor();
     ImGui::SameLine();
     if (ImGui::Button("Copy##a")) ImGui::SetClipboardText(g_myAddress.c_str());
 
-    // ---- Balance on its own line ----
     ImGui::TextDisabled("Balance:");
     ImGui::SameLine();
-    ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.35f,1.0f,0.35f,1.0f));
+    ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.35f, 1.0f, 0.35f, 1.0f));
     ImGui::Text("%s BTF", FmtMoney(g_balance).c_str());
     ImGui::PopStyleColor();
 
-    // ---- Toolbar ----
     ImGui::Spacing();
-    ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.15f,0.40f,0.15f,1));
-    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.20f,0.55f,0.20f,1));
+    ImGui::PushStyleColor(ImGuiCol_Button,        ImVec4(0.15f, 0.40f, 0.15f, 1.0f));
+    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.20f, 0.55f, 0.20f, 1.0f));
     if (ImGui::Button("  Send Coins  ")) g_showSend = true;
     ImGui::PopStyleColor(2);
 
-    // Mining status indicator
-    ImGui::SameLine(0, 20);
+    ImGui::SameLine(0.0f, 20.0f);
     if (fGenerateBitcoins) {
-        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f,0.6f,0.0f,1.0f));
-        const char* modeLabel = nMineMode==MINE_OPERATOR ? "Mining (operator)" :
-                                nMineMode==MINE_PARTICIPANT ? "Mining (pool)" : "Mining";
-        ImGui::Text("⬤ %s", modeLabel);
+        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.6f, 0.0f, 1.0f));
+        const char* modeLabel =
+            nMineMode == MINE_OPERATOR   ? "Mining (operator)"  :
+            nMineMode == MINE_PARTICIPANT ? "Mining (pool)"       :
+            nMineMode == MINE_RELAY       ? "Relay"               : "Mining";
+        ImGui::Text("* %s", modeLabel);
         ImGui::PopStyleColor();
         if (nMineMode == MINE_PARTICIPANT) {
-            std::string mineStatus = GetParticipantMiningStatus();
-            if (!mineStatus.empty()) {
-                ImGui::SameLine(0, 12);
-                ImGui::PushStyleColor(ImGuiCol_Text, ParticipantStatusColor(mineStatus));
-                ImGui::Text("[%s]", mineStatus.c_str());
+            std::string st = GetParticipantMiningStatus();
+            if (!st.empty()) {
+                ImGui::SameLine(0.0f, 12.0f);
+                ImGui::PushStyleColor(ImGuiCol_Text, StatusColor(st));
+                ImGui::Text("[%s]", st.c_str());
                 ImGui::PopStyleColor();
             }
         }
     } else {
-        ImGui::TextDisabled("○ Not mining");
+        ImGui::TextDisabled("Not mining");
     }
 
     ImGui::Spacing();
     ImGui::Separator();
-    ImGui::Spacing();
 
-    // ---- Live telemetry strip ----
+    // ---- Telemetry strip (never scrolls) ----
     {
-        const char* modeName = nMineMode==MINE_OPERATOR ? "Operator" :
-                               nMineMode==MINE_PARTICIPANT ? "Participant" : "Solo";
-        int64 age = g_lastWalletRefresh > 0 ? (GetTime() - g_lastWalletRefresh) : -1;
-        if (age < 0) age = 0;
+        ImGui::Spacing();
+        const char* modeName =
+            nMineMode == MINE_OPERATOR    ? "Operator"    :
+            nMineMode == MINE_PARTICIPANT  ? "Participant" :
+            nMineMode == MINE_RELAY        ? "Relay"       : "Solo";
+        int64 age = g_lastWalletRefresh > 0 ? GetTime() - g_lastWalletRefresh : 0;
 
         ImGui::Text("Mode: %s", modeName);
-        ImGui::SameLine(0, 16);
-        ImGui::Text("Wallet refresh: %llds ago", (long long)age);
+        ImGui::SameLine(0.0f, 16.0f);
+        ImGui::TextDisabled("Wallet refreshed %llds ago", (long long)age);
 
         if (nMineMode == MINE_PARTICIPANT) {
             uint64 sent = 0, accepted = 0;
             double hashRate = 0.0;
-            std::string mineStatus = GetParticipantMiningStatus();
+            std::string st = GetParticipantMiningStatus();
             GetParticipantMiningStats(sent, accepted, hashRate);
             if (sent > 0 || accepted > 0 || hashRate > 0.0) {
-                double acceptPct = sent ? (100.0 * (double)accepted / (double)sent) : 0.0;
-                ImGui::TextDisabled("Your mining: sent %llu, accepted %llu (%.1f%%), %.2f H/s",
-                                    (unsigned long long)sent,
-                                    (unsigned long long)accepted,
-                                    acceptPct,
-                                    hashRate);
-            } else if (!mineStatus.empty()) {
-                ImGui::TextDisabled("Your mining: %s", mineStatus.c_str());
+                double pct = sent ? (100.0 * (double)accepted / (double)sent) : 0.0;
+                ImGui::TextDisabled(
+                    "Sent %llu shares, accepted %llu (%.1f%%),  %.2f H/s",
+                    (unsigned long long)sent, (unsigned long long)accepted, pct, hashRate);
+            } else if (!st.empty()) {
+                ImGui::TextDisabled("Status: %s", st.c_str());
             } else {
-                ImGui::TextDisabled("Your mining: asking pool for work");
+                ImGui::TextDisabled("Waiting for pool work...");
             }
         } else if (nMineMode == MINE_OPERATOR) {
             int miners = 0, blocksFound = 0;
             uint64 roundShares = 0;
-            GetPoolOperatorStats(miners, blocksFound, roundShares);
+            double totalHashRate = 0.0;
+            GetPoolOperatorStats(miners, blocksFound, roundShares, totalHashRate);
             if (miners > 0 || blocksFound > 0 || roundShares > 0)
-                ImGui::TextDisabled("Pool runtime: %d authorized miners, %llu round shares, %d blocks found", miners, (unsigned long long)roundShares, blocksFound);
+                ImGui::TextDisabled(
+                    "Authorized miners: %d  Round shares: %llu  Blocks found: %d  %.2f H/s",
+                    miners, (unsigned long long)roundShares, blocksFound, totalHashRate);
             else
-                ImGui::TextDisabled("Pool runtime: waiting for miners");
+                ImGui::TextDisabled("Pool server running, waiting for miners");
+        } else if (nMineMode == MINE_RELAY) {
+            ImGui::TextDisabled("Relay mode: syncing, not mining");
         } else {
-            ImGui::TextDisabled("Solo runtime: local wallet mining telemetry");
+            ImGui::TextDisabled("Solo mining");
         }
         ImGui::Spacing();
         ImGui::Separator();
         ImGui::Spacing();
     }
 
+    // ---- Scrollable content child ----
+    // Fills all remaining height in the window (cursor Y to bottom of window).
+    // Content that overflows scrolls; nothing leaks past the window edge.
+    // Size the scrollable child to fill exactly the remaining window height.
+    // GetContentRegionAvail() already accounts for padding/borders.
+    const float availH = ImGui::GetContentRegionAvail().y;
+    ImGui::BeginChild("##scroll", ImVec2(0.0f, availH), false, 0);
+
     // ---- Transaction list ----
-    float listHeight = io.DisplaySize.y * 0.26f;
-    if (listHeight < 190.0f) listHeight = 190.0f;
-    if (listHeight > 260.0f) listHeight = 260.0f;
+    float txH = io.DisplaySize.y * 0.26f;
+    if (txH < 180.0f) txH = 180.0f;
+    if (txH > 260.0f) txH = 260.0f;
+
     if (ImGui::BeginTable("txlist", 4,
-        ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg |
-        ImGuiTableFlags_ScrollY | ImGuiTableFlags_SizingStretchProp,
-        ImVec2(0, listHeight)))
+        ImGuiTableFlags_Borders     |
+        ImGuiTableFlags_RowBg       |
+        ImGuiTableFlags_ScrollY     |
+        ImGuiTableFlags_SizingStretchProp,
+        ImVec2(0.0f, txH)))
     {
         ImGui::TableSetupScrollFreeze(0, 1);
-        ImGui::TableSetupColumn("Status",      ImGuiTableColumnFlags_WidthFixed, 110);
-        ImGui::TableSetupColumn("Date",        ImGuiTableColumnFlags_WidthFixed, 130);
+        ImGui::TableSetupColumn("Status",      ImGuiTableColumnFlags_WidthFixed,   110.0f);
+        ImGui::TableSetupColumn("Date",        ImGuiTableColumnFlags_WidthFixed,   130.0f);
         ImGui::TableSetupColumn("Description", ImGuiTableColumnFlags_WidthStretch);
-        ImGui::TableSetupColumn("Amount",      ImGuiTableColumnFlags_WidthFixed, 140);
+        ImGui::TableSetupColumn("Amount",      ImGuiTableColumnFlags_WidthFixed,   140.0f);
         ImGui::TableHeadersRow();
 
         for (auto& row : g_txRows) {
             ImGui::TableNextRow();
             ImGui::TableSetColumnIndex(0);
-            if (row.depth < 1)
-                ImGui::TextColored(ImVec4(1,0.6f,0,1), "Unconfirmed");
+            bool isImmatureCoinbase = (row.desc.find("matures in") != std::string::npos);
+            bool isOrphaned         = (row.desc.find("orphaned") != std::string::npos);
+            if (isOrphaned)
+                ImGui::TextColored(ImVec4(1.0f, 0.3f, 0.3f, 1.0f), "Orphaned");
+            else if (row.depth < 1)
+                ImGui::TextColored(ImVec4(1.0f, 0.6f, 0.0f, 1.0f), "Unconfirmed");
+            else if (isImmatureCoinbase)
+                ImGui::TextColored(ImVec4(1.0f, 0.75f, 0.25f, 1.0f), "Immature");
+            else if (row.depth < 6)
+                ImGui::TextColored(ImVec4(1.0f, 0.85f, 0.3f, 1.0f), "%d confirm%s",
+                    row.depth, row.depth == 1 ? "" : "s");
             else
-                ImGui::Text("%d blocks deep", row.depth);
+                ImGui::TextColored(ImVec4(0.5f, 0.9f, 0.5f, 1.0f), "Confirmed");
             ImGui::TableSetColumnIndex(1);
             ImGui::TextDisabled("%s", row.date.c_str());
             ImGui::TableSetColumnIndex(2);
             ImGui::TextUnformatted(row.desc.c_str());
             ImGui::TableSetColumnIndex(3);
             if (row.amount >= 0)
-                ImGui::TextColored(ImVec4(0.35f,1,0.35f,1), "+%s BTF", FmtMoney(row.amount).c_str());
+                ImGui::TextColored(ImVec4(0.35f, 1.0f, 0.35f, 1.0f),
+                    "+%s BTF", FmtMoney(row.amount).c_str());
             else
-                ImGui::TextColored(ImVec4(1,0.4f,0.4f,1),   "%s BTF",  FmtMoney(row.amount).c_str());
+                ImGui::TextColored(ImVec4(1.0f, 0.4f, 0.4f, 1.0f),
+                    "%s BTF",  FmtMoney(row.amount).c_str());
         }
         ImGui::EndTable();
     }
 
+    // ---- Mode panels ----
     std::vector<BtfPoolAnnouncement> pools;
     BtfGetPoolAnnouncements(pools);
 
     if (nMineMode == MINE_PARTICIPANT) {
         ImGui::Spacing();
         ImGui::SeparatorText("Participant Mining");
-        ImGui::Text("Selected pool:");
+
+        ImGui::TextDisabled("Selected pool:");
+        ImGui::SameLine();
         if (strParticipantPool.empty())
-            ImGui::TextDisabled("No pool selected yet");
+            ImGui::TextDisabled("none");
         else
             ImGui::TextWrapped("%s", strParticipantPool.c_str());
 
-        const BtfPoolAnnouncement* selected = NULL;
+        const BtfPoolAnnouncement* sel = nullptr;
         for (size_t i = 0; i < pools.size(); i++)
-            if (pools[i].btfAddress == strParticipantPool) { selected = &pools[i]; break; }
-
-        if (selected) {
-            ImGui::Text("Pool name: %s", selected->poolName.c_str());
-            ImGui::Text("Fee: %.2f%%", selected->feePercent);
-            ImGui::Text("Live stats: %d miners, %d blocks", selected->connectedMiners, selected->blocksFound);
-            if (!selected->dashboardUrl.empty())
-                ImGui::TextWrapped("Dashboard: %s", selected->dashboardUrl.c_str());
+            if (pools[i].btfAddress == strParticipantPool) { sel = &pools[i]; break; }
+
+        if (sel) {
+            ImGui::Text("Pool: %s  Fee: %.2f%%  Miners: %d  Blocks: %d  %.2f H/s",
+                sel->poolName.c_str(), sel->feePercent,
+                sel->connectedMiners, sel->blocksFound, sel->hashRate);
+            if (!sel->dashboardUrl.empty())
+                ImGui::TextDisabled("Dashboard: %s", sel->dashboardUrl.c_str());
         } else if (!strParticipantPool.empty()) {
-            ImGui::TextDisabled("No fresh announcement found for this pool yet");
+            ImGui::TextDisabled("No live announcement for this pool yet.");
         }
 
         if (!pools.empty()) {
             ImGui::Spacing();
             ImGui::SeparatorText("Live Pools");
             if (ImGui::BeginTable("livepools", 5,
-                ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingStretchProp))
+                ImGuiTableFlags_Borders |
+                ImGuiTableFlags_RowBg   |
+                ImGuiTableFlags_SizingStretchProp))
             {
-                ImGui::TableSetupColumn("Pool", ImGuiTableColumnFlags_WidthStretch);
-                ImGui::TableSetupColumn("Fee", ImGuiTableColumnFlags_WidthFixed, 70);
-                ImGui::TableSetupColumn("Stats", ImGuiTableColumnFlags_WidthFixed, 160);
+                ImGui::TableSetupColumn("Pool",      ImGuiTableColumnFlags_WidthStretch);
+                ImGui::TableSetupColumn("Fee",       ImGuiTableColumnFlags_WidthFixed,  60.0f);
+                ImGui::TableSetupColumn("Stats",     ImGuiTableColumnFlags_WidthFixed, 150.0f);
                 ImGui::TableSetupColumn("Dashboard", ImGuiTableColumnFlags_WidthStretch);
-                ImGui::TableSetupColumn("Use", ImGuiTableColumnFlags_WidthFixed, 60);
+                ImGui::TableSetupColumn("Use",       ImGuiTableColumnFlags_WidthFixed,  50.0f);
                 ImGui::TableHeadersRow();
                 for (size_t i = 0; i < pools.size(); i++) {
                     const BtfPoolAnnouncement& ann = pools[i];
@@ -353,15 +500,19 @@ static void DrawMainWindow()
                     ImGui::TableSetColumnIndex(1);
                     ImGui::Text("%.2f%%", ann.feePercent);
                     ImGui::TableSetColumnIndex(2);
-                    ImGui::Text("%d miners, %d blocks, %s old", ann.connectedMiners, ann.blocksFound, FmtAge(ann.createdAt).c_str());
+                    ImGui::Text("%d miners  %d blocks  %.2f H/s  %s",
+                        ann.connectedMiners, ann.blocksFound, ann.hashRate,
+                        FmtAge(ann.createdAt).c_str());
                     ImGui::TableSetColumnIndex(3);
                     if (!ann.dashboardUrl.empty())
                         ImGui::TextWrapped("%s", ann.dashboardUrl.c_str());
                     else
                         ImGui::TextDisabled("-");
                     ImGui::TableSetColumnIndex(4);
-                    if (ImGui::SmallButton((std::string("Use##") + ann.btfAddress).c_str())) {
-                        strncpy(g_participantPool, ann.btfAddress.c_str(), sizeof(g_participantPool)-1);
+                    std::string btnId = "Use##" + ann.btfAddress;
+                    if (ImGui::SmallButton(btnId.c_str())) {
+                        strncpy(g_participantPool, ann.btfAddress.c_str(),
+                                sizeof(g_participantPool)-1);
                         strParticipantPool = ann.btfAddress;
                         CWalletDB().WriteSetting("strParticipantPool", strParticipantPool);
                         g_needRefresh = true;
@@ -375,55 +526,60 @@ static void DrawMainWindow()
     if (nMineMode == MINE_OPERATOR) {
         ImGui::Spacing();
         ImGui::SeparatorText("Operator Overview");
-        ImGui::Text("Pool .btf address:");
+
         std::string opAddr = BtfLocalAddress();
+        ImGui::TextDisabled("Pool .btf address:");
+        ImGui::SameLine();
         if (opAddr.empty())
-            ImGui::TextDisabled("Identity not ready yet");
+            ImGui::TextDisabled("identity not ready");
         else
             ImGui::TextWrapped("%s", opAddr.c_str());
 
+        // Pending payouts
         std::vector<PendingPayoutView> owed;
         GetPendingPayouts(owed);
         ImGui::Spacing();
-        ImGui::SeparatorText("Pending Pool Payouts (you owe miners)");
+        ImGui::SeparatorText("Pending Payouts (owed to miners)");
         if (owed.empty()) {
-            ImGui::TextDisabled("No pending pool payouts");
+            ImGui::TextDisabled("No pending payouts");
         } else if (ImGui::BeginTable("owedpayouts", 4,
-                   ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingStretchProp))
+                   ImGuiTableFlags_Borders |
+                   ImGuiTableFlags_RowBg   |
+                   ImGuiTableFlags_SizingStretchProp))
         {
-            ImGui::TableSetupColumn("Matures At", ImGuiTableColumnFlags_WidthFixed, 100);
-            ImGui::TableSetupColumn("Blocks Left", ImGuiTableColumnFlags_WidthFixed, 90);
-            ImGui::TableSetupColumn("Recipients", ImGuiTableColumnFlags_WidthFixed, 90);
-            ImGui::TableSetupColumn("Total", ImGuiTableColumnFlags_WidthStretch);
+            ImGui::TableSetupColumn("Matures At",  ImGuiTableColumnFlags_WidthFixed,  90.0f);
+            ImGui::TableSetupColumn("Blocks left", ImGuiTableColumnFlags_WidthFixed,  80.0f);
+            ImGui::TableSetupColumn("Recipients",  ImGuiTableColumnFlags_WidthFixed,  80.0f);
+            ImGui::TableSetupColumn("Total",       ImGuiTableColumnFlags_WidthStretch);
             ImGui::TableHeadersRow();
             for (const PendingPayoutView& row : owed) {
-                int remaining = std::max(0, row.matureAtHeight - nBestHeight);
+                int left = std::max(0, row.matureAtHeight - nBestHeight);
                 ImGui::TableNextRow();
-                ImGui::TableSetColumnIndex(0);
-                ImGui::Text("%d", row.matureAtHeight);
-                ImGui::TableSetColumnIndex(1);
-                ImGui::Text("%d", remaining);
-                ImGui::TableSetColumnIndex(2);
-                ImGui::Text("%d", row.recipients);
-                ImGui::TableSetColumnIndex(3);
-                ImGui::Text("%s BTF", FmtMoney(row.totalAmount).c_str());
+                ImGui::TableSetColumnIndex(0); ImGui::Text("%d", row.matureAtHeight);
+                ImGui::TableSetColumnIndex(1); ImGui::Text("%d", left);
+                ImGui::TableSetColumnIndex(2); ImGui::Text("%d", row.recipients);
+                ImGui::TableSetColumnIndex(3); ImGui::Text("%s BTF", FmtMoney(row.totalAmount).c_str());
             }
             ImGui::EndTable();
         }
 
+        // Workers
         std::vector<PoolWorkerStatView> workers;
         GetPoolWorkerStats(workers);
         ImGui::Spacing();
         ImGui::SeparatorText("Current Round Workers");
         if (workers.empty()) {
-            ImGui::TextDisabled("No active workers in this round");
-        } else if (ImGui::BeginTable("workers", 4,
-                   ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingStretchProp))
+            ImGui::TextDisabled("No active workers this round");
+        } else if (ImGui::BeginTable("workers", 5,
+                   ImGuiTableFlags_Borders |
+                   ImGuiTableFlags_RowBg   |
+                   ImGuiTableFlags_SizingStretchProp))
         {
-            ImGui::TableSetupColumn("Payout Addr", ImGuiTableColumnFlags_WidthStretch);
-            ImGui::TableSetupColumn("Worker", ImGuiTableColumnFlags_WidthStretch);
-            ImGui::TableSetupColumn("Round Shares", ImGuiTableColumnFlags_WidthFixed, 90);
-            ImGui::TableSetupColumn("Last Seen", ImGuiTableColumnFlags_WidthFixed, 100);
+            ImGui::TableSetupColumn("Payout Address", ImGuiTableColumnFlags_WidthStretch);
+            ImGui::TableSetupColumn("Worker",         ImGuiTableColumnFlags_WidthStretch);
+            ImGui::TableSetupColumn("Hashrate",       ImGuiTableColumnFlags_WidthFixed,  90.0f);
+            ImGui::TableSetupColumn("Round shares",   ImGuiTableColumnFlags_WidthFixed,  90.0f);
+            ImGui::TableSetupColumn("Last seen",      ImGuiTableColumnFlags_WidthFixed,  90.0f);
             ImGui::TableHeadersRow();
             for (const PoolWorkerStatView& row : workers) {
                 ImGui::TableNextRow();
@@ -432,53 +588,19 @@ static void DrawMainWindow()
                 ImGui::TableSetColumnIndex(1);
                 ImGui::TextDisabled("%s", row.worker.empty() ? "worker" : row.worker.c_str());
                 ImGui::TableSetColumnIndex(2);
-                ImGui::Text("%llu", (unsigned long long)row.roundShares);
+                ImGui::Text("%.2f H/s", row.hashRate);
                 ImGui::TableSetColumnIndex(3);
-                ImGui::TextDisabled("%s", FmtAge(row.lastSeen).c_str());
+                ImGui::Text("%llu", (unsigned long long)row.roundShares);
+                ImGui::TableSetColumnIndex(4);
+                ImGui::TextDisabled("%s ago", FmtAge(row.lastSeen).c_str());
             }
             ImGui::EndTable();
         }
     }
 
-    // ---- Status bar ----
-    {
-        ImGui::Spacing();
-        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(4,2));
-
-        int peers = (int)vNodes.size();
-        if (nMineMode == MINE_PARTICIPANT) {
-            uint64 sent = 0, accepted = 0;
-            double hashRate = 0.0;
-            std::string mineStatus = GetParticipantMiningStatus();
-            GetParticipantMiningStats(sent, accepted, hashRate);
-            if (sent > 0 || accepted > 0 || hashRate > 0.0)
-                ImGui::TextDisabled("Peers %d  height %d  shares sent %llu  accepted %llu  hash rate %.2f H/s",
-                                    peers,
-                                    nBestHeight,
-                                    (unsigned long long)sent,
-                                    (unsigned long long)accepted,
-                                    hashRate);
-            else if (!mineStatus.empty())
-                ImGui::TextDisabled("Peers %d  height %d  %s", peers, nBestHeight, mineStatus.c_str());
-            else
-                ImGui::TextDisabled("Peers %d  height %d  asking pool for work", peers, nBestHeight);
-        } else if (nMineMode == MINE_OPERATOR) {
-            int miners = 0, blocksFound = 0;
-            uint64 roundShares = 0;
-            GetPoolOperatorStats(miners, blocksFound, roundShares);
-            if (miners > 0 || blocksFound > 0 || roundShares > 0)
-                ImGui::TextDisabled("Peers %d  height %d  authorized miners %d  round shares %llu  blocks found %d",
-                                    peers, nBestHeight, miners, (unsigned long long)roundShares, blocksFound);
-            else
-                ImGui::TextDisabled("Peers %d  height %d  waiting for miners", peers, nBestHeight);
-        } else {
-            ImGui::TextDisabled("Peers %d  height %d", peers, nBestHeight);
-        }
-        ImGui::PopStyleVar();
-    }
-
+    ImGui::EndChild(); // ##scroll
     ImGui::SetWindowFontScale(1.0f);
-    ImGui::End();
+    ImGui::End(); // ##main
 }
 
 // ---------------------------------------------------------------------------
@@ -487,42 +609,53 @@ static void DrawMainWindow()
 static void DrawSendDialog()
 {
     if (!g_showSend) return;
-    ImGui::SetNextWindowSize(ImVec2(500, 180), ImGuiCond_Always);
-    ImGui::SetNextWindowPos(ImGui::GetMainViewport()->GetCenter(), ImGuiCond_Always, ImVec2(.5f,.5f));
+    ImGui::SetNextWindowSize(ImVec2(500.0f, 180.0f), ImGuiCond_Always);
+    ImGui::SetNextWindowPos(ImGui::GetMainViewport()->GetCenter(),
+                            ImGuiCond_Always, ImVec2(0.5f, 0.5f));
     if (ImGui::Begin("Send Coins", &g_showSend,
         ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse))
     {
         ImGui::Text("Recipient address:");
-        ImGui::SetNextItemWidth(-1);
+        ImGui::SetNextItemWidth(-1.0f);
         ImGui::InputText("##sa", g_sendAddr, sizeof(g_sendAddr));
 
         ImGui::Text("Amount (BTF):");
-        ImGui::SetNextItemWidth(180);
+        ImGui::SetNextItemWidth(180.0f);
         ImGui::InputText("##sm", g_sendAmount, sizeof(g_sendAmount));
 
         if (!g_sendStatus.empty()) {
             ImGui::Spacing();
-            ImGui::TextColored(ImVec4(1,.4f,.4f,1), "%s", g_sendStatus.c_str());
+            ImGui::TextColored(ImVec4(1.0f, 0.4f, 0.4f, 1.0f),
+                "%s", g_sendStatus.c_str());
         }
 
         ImGui::Spacing(); ImGui::Separator(); ImGui::Spacing();
-        if (ImGui::Button("Send", ImVec2(90,0))) {
+        if (ImGui::Button("Send", ImVec2(90.0f, 0.0f))) {
             uint160 h; int64 nv = 0;
-            if (!AddressToHash160(g_sendAddr, h))          g_sendStatus = "Invalid address.";
-            else if (!ParseMoney(g_sendAmount,nv)||nv<=0)   g_sendStatus = "Invalid amount.";
+            if (!AddressToHash160(g_sendAddr, h))
+                g_sendStatus = "Invalid address.";
+            else if (!ParseMoney(g_sendAmount, nv) || nv <= 0)
+                g_sendStatus = "Invalid amount.";
             else {
-                CScript s; s << OP_DUP << OP_HASH160 << h << OP_EQUALVERIFY << OP_CHECKSIG;
+                CScript sc;
+                sc << OP_DUP << OP_HASH160 << h << OP_EQUALVERIFY << OP_CHECKSIG;
                 CWalletTx wtx;
-                if (SendMoney(s, nv, wtx)) {
-                    g_showSend=false; g_sendStatus="";
-                    memset(g_sendAddr,0,sizeof(g_sendAddr));
-                    memset(g_sendAmount,0,sizeof(g_sendAmount));
+                if (SendMoney(sc, nv, wtx)) {
+                    g_showSend = false;
+                    g_sendStatus = "";
+                    memset(g_sendAddr,   0, sizeof(g_sendAddr));
+                    memset(g_sendAmount, 0, sizeof(g_sendAmount));
                     g_needRefresh = true;
-                } else g_sendStatus = "Transaction failed.";
+                } else {
+                    g_sendStatus = "Transaction failed.";
+                }
             }
         }
         ImGui::SameLine();
-        if (ImGui::Button("Cancel", ImVec2(90,0))) { g_showSend=false; g_sendStatus=""; }
+        if (ImGui::Button("Cancel", ImVec2(90.0f, 0.0f))) {
+            g_showSend = false;
+            g_sendStatus = "";
+        }
     }
     ImGui::End();
 }
@@ -534,7 +667,6 @@ static void DrawOptionsDialog()
 {
     if (!g_showOptions) return;
 
-    // Always sync from current globals when dialog opens
     static bool wasOpen = false;
     if (!wasOpen) {
         g_mineRadio = nMineMode;
@@ -544,42 +676,46 @@ static void DrawOptionsDialog()
         strncpy(g_poolDash, strPoolDashboardUrl.c_str(), sizeof(g_poolDash)-1);
     }
     wasOpen = true;
-    ImGui::SetNextWindowSize(ImVec2(500, 310), ImGuiCond_Always);
-    ImGui::SetNextWindowPos(ImGui::GetMainViewport()->GetCenter(), ImGuiCond_Always, ImVec2(.5f,.5f));
+
+    ImGui::SetNextWindowSize(ImVec2(500.0f, 335.0f), ImGuiCond_Always);
+    ImGui::SetNextWindowPos(ImGui::GetMainViewport()->GetCenter(),
+                            ImGuiCond_Always, ImVec2(0.5f, 0.5f));
     if (ImGui::Begin("Options", &g_showOptions,
         ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse))
     {
         // Transaction fee
         ImGui::SeparatorText("Transaction Fee");
         static char feeStr[32] = {};
-        if (feeStr[0]=='\0') snprintf(feeStr,sizeof(feeStr),"%s",FmtMoney(nTransactionFee).c_str());
-        ImGui::SetNextItemWidth(180);
+        if (feeStr[0] == '\0')
+            snprintf(feeStr, sizeof(feeStr), "%s", FmtMoney(nTransactionFee).c_str());
+        ImGui::SetNextItemWidth(180.0f);
         ImGui::InputText("BTF per transaction##fee", feeStr, sizeof(feeStr));
 
-        // Mining
+        // Mining mode
         ImGui::SeparatorText("Mining Mode");
-        ImGui::RadioButton("Solo  — rewards go to your wallet",       &g_mineRadio, MINE_SOLO);
-        ImGui::RadioButton("Operator  — run a pool for other miners", &g_mineRadio, MINE_OPERATOR);
-        ImGui::RadioButton("Participant  — mine to someone's pool",   &g_mineRadio, MINE_PARTICIPANT);
+        ImGui::RadioButton("Relay -- just run the node, don't mine",  &g_mineRadio, MINE_RELAY);
+        ImGui::RadioButton("Solo -- rewards go to your wallet",        &g_mineRadio, MINE_SOLO);
+        ImGui::RadioButton("Operator -- run a pool for other miners",  &g_mineRadio, MINE_OPERATOR);
+        ImGui::RadioButton("Participant -- mine to someone's pool",    &g_mineRadio, MINE_PARTICIPANT);
 
         if (g_mineRadio == MINE_OPERATOR) {
             ImGui::Spacing();
             ImGui::SeparatorText("Pool Announcement");
             ImGui::Text("Pool name:");
-            ImGui::SetNextItemWidth(-1);
+            ImGui::SetNextItemWidth(-1.0f);
             ImGui::InputText("##poolname", g_poolName, sizeof(g_poolName));
             ImGui::Text("Fee %%:");
-            ImGui::SetNextItemWidth(120);
+            ImGui::SetNextItemWidth(120.0f);
             ImGui::InputText("##poolfee", g_poolFee, sizeof(g_poolFee));
             ImGui::Text("Dashboard URL:");
-            ImGui::SetNextItemWidth(-1);
+            ImGui::SetNextItemWidth(-1.0f);
             ImGui::InputText("##pooldash", g_poolDash, sizeof(g_poolDash));
         }
 
         if (g_mineRadio == MINE_PARTICIPANT) {
             ImGui::Spacing();
             ImGui::SeparatorText("Pool Selection");
-            ImGui::TextDisabled("Pick from live discovered pools. Manual entry is disabled here.");
+            ImGui::TextDisabled("Pick from live discovered pools.");
 
             std::vector<BtfPoolAnnouncement> pools;
             BtfGetPoolAnnouncements(pools);
@@ -591,46 +727,49 @@ static void DrawOptionsDialog()
                         break;
                     }
                 }
-                if (ImGui::BeginCombo("Discovered pools", current.c_str())) {
+                if (ImGui::BeginCombo("Discovered pools##combo", current.c_str())) {
                     for (size_t i = 0; i < pools.size(); i++) {
                         const BtfPoolAnnouncement& ann = pools[i];
-                        std::string label = PoolLabel(ann);
-                        bool selected = ann.btfAddress == g_participantPool;
-                        if (ImGui::Selectable(label.c_str(), selected)) {
-                            strncpy(g_participantPool, ann.btfAddress.c_str(), sizeof(g_participantPool)-1);
-                        }
+                        bool selected = (ann.btfAddress == g_participantPool);
+                        if (ImGui::Selectable(PoolLabel(ann).c_str(), selected))
+                            strncpy(g_participantPool, ann.btfAddress.c_str(),
+                                    sizeof(g_participantPool)-1);
                     }
                     ImGui::EndCombo();
                 }
             } else {
-                ImGui::TextDisabled("No live pools discovered yet");
+                ImGui::TextDisabled("No live pools discovered yet.");
             }
         }
 
-        ImGui::Spacing();
-        const char* genLabel = fGenerateBitcoins ? "Stop Mining" : "Start Mining";
-        if (ImGui::Button(genLabel, ImVec2(130,0))) {
-            fGenerateBitcoins = fGenerateBitcoins ? 0 : 1;
-            if (fGenerateBitcoins) _beginthread(ThreadBitcoinMiner, 0, NULL);
-            CWalletDB().WriteSetting("fGenerateBitcoins", fGenerateBitcoins);
-        }
-
         ImGui::Spacing(); ImGui::Separator(); ImGui::Spacing();
-        if (ImGui::Button("OK", ImVec2(90,0))) {
-            int64 fee=0;
-            if (ParseMoney(feeStr,fee)) { nTransactionFee=fee; CWalletDB().WriteSetting("nTransactionFee",nTransactionFee); }
-
-            bool changed = (g_mineRadio != nMineMode);
-            nMineMode = g_mineRadio;
-            strParticipantPool = g_participantPool;
-            strPoolName = g_poolName[0] ? g_poolName : "Bitflash Pool";
-            strPoolDashboardUrl = g_poolDash;
-            dPoolFeePercent = atof(g_poolFee);
-            CWalletDB().WriteSetting("nMineMode", nMineMode);
-            CWalletDB().WriteSetting("strParticipantPool", strParticipantPool);
-            CWalletDB().WriteSetting("strPoolName", strPoolName);
-            CWalletDB().WriteSetting("strPoolDashboardUrl", strPoolDashboardUrl);
-            CWalletDB().WriteSetting("dPoolFeePercent", dPoolFeePercent);
+        if (ImGui::Button("OK", ImVec2(90.0f, 0.0f))) {
+            int64 fee = 0;
+            if (ParseMoney(feeStr, fee)) {
+                nTransactionFee = fee;
+                CWalletDB().WriteSetting("nTransactionFee", nTransactionFee);
+            }
+
+            bool poolChanged =
+                nMineMode != g_mineRadio ||
+                strPoolName != (g_poolName[0] ? g_poolName : "Bitflash Pool") ||
+                strPoolDashboardUrl != g_poolDash ||
+                dPoolFeePercent != atof(g_poolFee);
+
+            nMineMode            = g_mineRadio;
+            strParticipantPool   = g_participantPool;
+            strPoolName          = g_poolName[0] ? g_poolName : "Bitflash Pool";
+            strPoolDashboardUrl  = g_poolDash;
+            dPoolFeePercent      = atof(g_poolFee);
+
+            if (nMineMode == MINE_OPERATOR && poolChanged) gAnnounceNow = true;
+
+            if (nMineMode == MINE_RELAY) {
+                fGenerateBitcoins = 0;
+            } else {
+                fGenerateBitcoins = 1;
+                if (!vfThreadRunning[3]) _beginthread(ThreadBitcoinMiner, 0, NULL);
+            }
 
             if (nMineMode == MINE_OPERATOR) {
                 if (!gPoolServerRunning) {
@@ -645,7 +784,7 @@ static void DrawOptionsDialog()
             g_showOptions = false;
         }
         ImGui::SameLine();
-        if (ImGui::Button("Cancel", ImVec2(90,0))) g_showOptions = false;
+        if (ImGui::Button("Cancel", ImVec2(90.0f, 0.0f))) g_showOptions = false;
     }
     if (!g_showOptions) wasOpen = false;
     ImGui::End();
@@ -657,18 +796,21 @@ static void DrawOptionsDialog()
 static void DrawAboutDialog()
 {
     if (!g_showAbout) return;
-    ImGui::SetNextWindowSize(ImVec2(380, 170), ImGuiCond_Always);
-    ImGui::SetNextWindowPos(ImGui::GetMainViewport()->GetCenter(), ImGuiCond_Always, ImVec2(.5f,.5f));
+    ImGui::SetNextWindowSize(ImVec2(380.0f, 170.0f), ImGuiCond_Always);
+    ImGui::SetNextWindowPos(ImGui::GetMainViewport()->GetCenter(),
+                            ImGuiCond_Always, ImVec2(0.5f, 0.5f));
     if (ImGui::Begin("About Bitflash", &g_showAbout,
         ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse))
     {
-        ImGui::TextColored(ImVec4(1,.6f,0,1), "Bitflash  BTF  v1.1.0");
+        ImGui::TextColored(ImVec4(1.0f, 0.6f, 0.0f, 1.0f), "Bitflash  BTF  v1.1.0");
         ImGui::Spacing();
-        ImGui::TextWrapped("CPU-only cryptocurrency. RandomX proof of work. Anonymous .btf addressing over Nostr. No premine.");
+        ImGui::TextWrapped(
+            "CPU-only cryptocurrency. RandomX proof of work. "
+            "Anonymous .btf addressing over Nostr. No premine.");
         ImGui::Spacing();
         ImGui::TextDisabled("Based on Bitcoin 0.1.0 (Satoshi Nakamoto, 2009)");
         ImGui::Spacing();
-        if (ImGui::Button("OK", ImVec2(90,0))) g_showAbout = false;
+        if (ImGui::Button("OK", ImVec2(90.0f, 0.0f))) g_showAbout = false;
     }
     ImGui::End();
 }
@@ -705,34 +847,33 @@ int RunGUI(int argc, char* argv[])
     ImGuiIO& io = ImGui::GetIO();
     io.IniFilename = nullptr;
 
-    // Load Roboto at 16px — clean, readable on all platforms
     io.Fonts->AddFontFromMemoryCompressedTTF(
-        RobotoMedium_compressed_data, RobotoMedium_compressed_size, 16.0f);
+        RobotoMedium_compressed_data, RobotoMedium_compressed_size, 14.0f);
 
     ImGui::StyleColorsDark();
-    ImGuiStyle& s = ImGui::GetStyle();
-    s.WindowRounding = s.FrameRounding = s.PopupRounding = 4.0f;
-    s.ItemSpacing    = ImVec2(10, 7);
-    s.FramePadding   = ImVec2(8, 5);
-    s.WindowPadding  = ImVec2(12, 12);
+    ImGuiStyle& st = ImGui::GetStyle();
+    st.WindowRounding = st.FrameRounding = st.PopupRounding = 4.0f;
+    st.ItemSpacing  = ImVec2(10.0f, 7.0f);
+    st.FramePadding = ImVec2(8.0f, 5.0f);
+    st.WindowPadding = ImVec2(12.0f, 12.0f);
     // Orange accent
-    s.Colors[ImGuiCol_TitleBgActive]  = ImVec4(.80f,.45f,.00f,1);
-    s.Colors[ImGuiCol_CheckMark]      = ImVec4(1.0f,.60f,.00f,1);
-    s.Colors[ImGuiCol_SliderGrab]     = ImVec4(.80f,.45f,.00f,1);
-    s.Colors[ImGuiCol_Button]         = ImVec4(.25f,.25f,.25f,1);
-    s.Colors[ImGuiCol_ButtonHovered]  = ImVec4(.80f,.45f,.00f,1);
-    s.Colors[ImGuiCol_ButtonActive]   = ImVec4(.60f,.30f,.00f,1);
-    s.Colors[ImGuiCol_Header]         = ImVec4(.80f,.45f,.00f,.40f);
-    s.Colors[ImGuiCol_HeaderHovered]  = ImVec4(.80f,.45f,.20f,.80f);
-    s.Colors[ImGuiCol_Tab]            = ImVec4(.20f,.20f,.20f,1);
-    s.Colors[ImGuiCol_TabHovered]     = ImVec4(.80f,.45f,.00f,1);
-    s.Colors[ImGuiCol_TabActive]      = ImVec4(.80f,.45f,.00f,1);
-    s.Colors[ImGuiCol_SeparatorHovered]=ImVec4(.80f,.45f,.00f,1);
-    s.Colors[ImGuiCol_FrameBg]        = ImVec4(.14f,.14f,.14f,1);
-    s.Colors[ImGuiCol_FrameBgHovered] = ImVec4(.20f,.20f,.20f,1);
-    s.Colors[ImGuiCol_TableHeaderBg]  = ImVec4(.18f,.18f,.18f,1);
-    s.Colors[ImGuiCol_TableRowBg]     = ImVec4(.11f,.11f,.11f,1);
-    s.Colors[ImGuiCol_TableRowBgAlt]  = ImVec4(.14f,.14f,.14f,1);
+    st.Colors[ImGuiCol_TitleBgActive]   = ImVec4(.80f, .45f, .00f, 1.0f);
+    st.Colors[ImGuiCol_CheckMark]       = ImVec4(1.0f, .60f, .00f, 1.0f);
+    st.Colors[ImGuiCol_SliderGrab]      = ImVec4(.80f, .45f, .00f, 1.0f);
+    st.Colors[ImGuiCol_Button]          = ImVec4(.25f, .25f, .25f, 1.0f);
+    st.Colors[ImGuiCol_ButtonHovered]   = ImVec4(.80f, .45f, .00f, 1.0f);
+    st.Colors[ImGuiCol_ButtonActive]    = ImVec4(.60f, .30f, .00f, 1.0f);
+    st.Colors[ImGuiCol_Header]          = ImVec4(.80f, .45f, .00f, .40f);
+    st.Colors[ImGuiCol_HeaderHovered]   = ImVec4(.80f, .45f, .20f, .80f);
+    st.Colors[ImGuiCol_Tab]             = ImVec4(.20f, .20f, .20f, 1.0f);
+    st.Colors[ImGuiCol_TabHovered]      = ImVec4(.80f, .45f, .00f, 1.0f);
+    st.Colors[ImGuiCol_TabActive]       = ImVec4(.80f, .45f, .00f, 1.0f);
+    st.Colors[ImGuiCol_SeparatorHovered]= ImVec4(.80f, .45f, .00f, 1.0f);
+    st.Colors[ImGuiCol_FrameBg]         = ImVec4(.14f, .14f, .14f, 1.0f);
+    st.Colors[ImGuiCol_FrameBgHovered]  = ImVec4(.20f, .20f, .20f, 1.0f);
+    st.Colors[ImGuiCol_TableHeaderBg]   = ImVec4(.18f, .18f, .18f, 1.0f);
+    st.Colors[ImGuiCol_TableRowBg]      = ImVec4(.11f, .11f, .11f, 1.0f);
+    st.Colors[ImGuiCol_TableRowBgAlt]   = ImVec4(.14f, .14f, .14f, 1.0f);
 
     ImGui_ImplGlfw_InitForOpenGL(window, true);
     ImGui_ImplOpenGL3_Init("#version 330");
@@ -744,22 +885,28 @@ int RunGUI(int argc, char* argv[])
     while (!glfwWindowShouldClose(window) && !fShutdown)
     {
         glfwPollEvents();
-        if (g_needRefresh || (frame % 120 == 0)) { RefreshWallet(); g_needRefresh = false; }
+        if (g_needRefresh || (frame % 120 == 0)) {
+            RefreshWallet();
+            g_needRefresh = false;
+        }
         frame++;
 
         ImGui_ImplOpenGL3_NewFrame();
         ImGui_ImplGlfw_NewFrame();
         ImGui::NewFrame();
 
+        // Draw order matters: status bar last so it is always on top.
         DrawMainWindow();
         DrawSendDialog();
         DrawOptionsDialog();
         DrawAboutDialog();
+        DrawStatusBar();
 
         ImGui::Render();
-        int w, h; glfwGetFramebufferSize(window, &w, &h);
+        int w, h;
+        glfwGetFramebufferSize(window, &w, &h);
         glViewport(0, 0, w, h);
-        glClearColor(.08f,.08f,.08f,1);
+        glClearColor(.08f, .08f, .08f, 1.0f);
         glClear(GL_COLOR_BUFFER_BIT);
         ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
         glfwSwapBuffers(window);