Add a page which proves the best share PoW

.gitignore

@@ -43,3 +43,5 @@ logs/
 # Environment
 .env
 .env.local
+giteaNew
+giteaNew.pub

README.md

@@ -32,7 +32,7 @@ CKPool is a high-performance stratum server, but it has no web interface and lim
 
 ### Patches Applied to CKPool
 
-Seven patches are applied to upstream commit `cfb0f83` (which itself includes the workbase_id fix, extended ESP32/NerdMiner timeouts, configurable `dropidle`, and vardiff improvements):
+Eight patches are applied to upstream commit `cfb0f83` (which itself includes the workbase_id fix, extended ESP32/NerdMiner timeouts, configurable `dropidle`, and vardiff improvements):
 
 | Patch | Purpose |
 |-------|---------|
@@ -43,6 +43,7 @@ Seven patches are applied to upstream commit `cfb0f83` (which itself includes th
 | `0005` | Log ZMQ-to-notify latency for block-update performance monitoring |
 | `0006` | Expose raw reject count in pool stats |
 | `0007` | Replace hardcoded "ckpool" branding in the coinbase scriptSig with "kamado" (same 6 bytes, consensus-safe) |
+| `0008` | Log full PoW reproduction data (raw 80-byte header, coinbase, merkle branches) when a share sets a new best difficulty |
 
 ### Middleware API
 
@@ -77,6 +78,7 @@ The Svelte 5 dashboard connects via WebSocket for real-time push updates (no pol
 - **User/worker detail pages** — Deep dive into individual miner stats, cumulative work, and luck
 - **Block history** — Found blocks with height, hash, reward, solving worker, chain name, orphan status
 - **Best share leaderboard** — "This round" and "all-time" tracking with per-worker breakdown and glowing difficulty range indicators
+- **PoW inspector** — Graphical breakdown of the block header behind the best share (version, prev block, merkle root, time, bits, nonce), the raw 80-byte header hex, and the coinbase + merkle branches that reproduce the merkle root — with one-click in-browser verification that replays the real SHA-256 compression rounds as an animation, ending at the share's block hash — self-contained implementation, no external services, works over plain-HTTP LAN
 - **Transaction accelerator** — Boost transactions via `prioritisetransaction` with marginal fee displacement analysis showing the revenue impact of each boost
 - **Block-found animation** — Celebratory toast on solve events
 - **Health banners** — Live status indicators for CKPool, bitcoind, ZMQ, and submit-gap diagnostics

api/internal/logmon/tailer.go

@@ -15,6 +15,7 @@ package logmon
 import (
 	"bufio"
 	"context"
+	"encoding/json"
 	"errors"
 	"io"
 	"log/slog"
@@ -67,6 +68,31 @@ type ShareEvent struct {
 	Hash     string  // block header hash (hex, accepted shares only)
 	Rejected bool
 	Reason   string // rejection reason (e.g. "Stale", "Duplicate"); empty for accepted
+	// Pow is set instead of the fields above when the line was a
+	// "Best share PoW data" record (ckpool patch 0008). It travels on
+	// the same channel as accepted/rejected events so ordering with
+	// the matching "Accepted client" line is preserved.
+	Pow *PowData
+}
+
+// PowData is the proof-of-work reproduction record ckpool logs (patch
+// 0008) when a share sets a new process-wide best difficulty: the raw
+// 80-byte block header exactly as it was double-SHA256'd, the assembled
+// coinbase transaction, and the merkle branch hashes linking that
+// coinbase to the merkle root committed in the header. Field names
+// mirror the JSON emitted by the patch.
+type PowData struct {
+	SDiff          float64  `json:"sdiff"`
+	NetDiff        float64  `json:"netdiff"`
+	Height         int64    `json:"height"`
+	Hash           string   `json:"hash"`     // display-order (big-endian) block header hash
+	Header         string   `json:"header"`   // 160 hex chars, hashing byte order
+	Coinbase       string   `json:"coinbase"` // full serialized coinbase tx, hex
+	CB1Len         int      `json:"cb1len"`   // bytes preceding extranonce1 in the coinbase
+	MerkleBranches []string `json:"merklebranches"`
+	Enonce1        string   `json:"enonce1"`
+	Nonce2         string   `json:"nonce2"`
+	Workername     string   `json:"workername"`
 }
 
 // Tailer follows a log file, surviving rotation/truncation, and emits
@@ -136,6 +162,40 @@ var (
 	rejectedInvalRE = regexp.MustCompile(`Rejected client \S+ invalid share (.+)`)
 )
 
+// powDataMarker precedes the JSON payload of a PoW reproduction line
+// from our patch 0008, logged just before the matching "Accepted client"
+// line when a share sets a new process-wide best:
+//
+//	"Best share PoW data {"sdiff":...,"header":"...",...}"
+const powDataMarker = "Best share PoW data "
+
+// parsePowLine extracts the PoW record from a log line carrying
+// powDataMarker. It decodes exactly one JSON value starting at the first
+// '{' after the marker and deliberately ignores everything after it —
+// production logs have carried trailing bytes after the closing brace,
+// which silently defeated an end-of-line-anchored regex. Returns
+// (nil, nil) when the marker is absent, and a non-nil error for a
+// present-but-undecodable record.
+func parsePowLine(line string) (*PowData, error) {
+	i := strings.Index(line, powDataMarker)
+	if i < 0 {
+		return nil, nil
+	}
+	rest := line[i+len(powDataMarker):]
+	j := strings.IndexByte(rest, '{')
+	if j < 0 {
+		return nil, errors.New("no JSON object after PoW data marker")
+	}
+	var pd PowData
+	if err := json.NewDecoder(strings.NewReader(rest[j:])).Decode(&pd); err != nil {
+		return nil, err
+	}
+	if pd.Header == "" || pd.Hash == "" {
+		return nil, errors.New("PoW record missing header or hash")
+	}
+	return &pd, nil
+}
+
 // Run blocks until ctx is cancelled. It opens the file, seeks to either
 // the saved cursor (if LoadCursor returns one and the inode still
 // matches) or the end on first-ever run, and reads new lines as they
@@ -284,6 +344,22 @@ func (t *Tailer) Run(ctx context.Context) {
 }
 
 func (t *Tailer) handleLine(line string) {
+	// PoW reproduction data (patch 0008). Must ship on the Shares
+	// channel so it stays ordered before its "Accepted client" line.
+	if strings.Contains(line, powDataMarker) {
+		pd, err := parsePowLine(line)
+		if err != nil {
+			t.Log.Warn("logmon: unparseable PoW data line", "err", err)
+			return
+		}
+		if pd != nil {
+			select {
+			case t.Shares <- ShareEvent{SeenAt: time.Now(), Pow: pd}:
+			default:
+			}
+		}
+		return
+	}
 	// Accepted share: extract share difficulty and block header hash.
 	if m := acceptedShareRE.FindStringSubmatch(line); m != nil {
 		if d, err := strconv.ParseFloat(m[1], 64); err == nil {
@@ -384,29 +460,116 @@ func FindBestShareHash(path string) (float64, string) {
 
 	var bestDiff float64
 	var bestHash string
-	scanner := bufio.NewScanner(f)
+	_ = scanLines(f, func(line string) {
-	scanner.Buffer(make([]byte, 0, 64*1024), 256*1024)
-	for scanner.Scan() {
-		line := scanner.Text()
 		if !strings.Contains(line, "Accepted client") {
-			continue
+			return
 		}
 		m := acceptedShareRE.FindStringSubmatch(line)
 		if m == nil {
-			continue
+			return
 		}
 		d, err := strconv.ParseFloat(m[1], 64)
 		if err != nil {
-			continue
+			return
 		}
 		if d >= bestDiff {
 			bestDiff = d
 			bestHash = m[2]
 		}
-	}
+	})
 	return bestDiff, bestHash
 }
 
+// scanLines invokes fn for every line of r. Unlike bufio.Scanner, a line
+// of any length can never abort the scan: an oversized line is passed to
+// fn truncated to the buffer size and its remainder is discarded. A
+// months-old production log with one pathological line must not silently
+// stop a backfill scan partway through — that failure mode is invisible
+// and permanent.
+func scanLines(f *os.File, fn func(line string)) error {
+	r := bufio.NewReaderSize(f, 256*1024)
+	skipping := false
+	for {
+		chunk, isPrefix, err := r.ReadLine()
+		if len(chunk) > 0 && !skipping {
+			fn(string(chunk))
+		}
+		skipping = isPrefix
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				return nil
+			}
+			return err
+		}
+	}
+}
+
+// logStampRE extracts the "[YYYY-MM-DD HH:MM:SS.mmm]" prefix ckpool
+// puts on every log line (local time of the ckpool process).
+var logStampRE = regexp.MustCompile(`^\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})`)
+
+// FindBestPowData scans the log for the highest-difficulty "Best share
+// PoW data" record (patch 0008) whose share was subsequently confirmed
+// by an "Accepted client" line with the same hash. Used as a one-time
+// backfill when kamado-api holds no persisted record but the log
+// already contains some (fresh database, or PoW events dropped under
+// load) — without it the PoW inspector would sit empty until a share
+// beat ckpool's in-process best, which after a long uptime can take
+// arbitrarily long. The returned time is parsed from the log line's
+// timestamp; zero when unparseable. Returns a nil record if no confirmed
+// record exists; err reports open/read failures and the returned counts
+// say how many PoW lines were seen and how many failed to parse, so the
+// caller can log a diagnosable outcome instead of a silent nil.
+func FindBestPowData(path string) (best *PowData, bestAt time.Time, seen, unparseable int, err error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, time.Time{}, 0, 0, err
+	}
+	defer f.Close()
+
+	// Records awaiting their "Accepted client" confirmation, keyed by
+	// hash. Bounded the same way as the aggregator's live pairing.
+	type parked struct {
+		pow *PowData
+		at  time.Time
+	}
+	pending := make(map[string]parked)
+	err = scanLines(f, func(line string) {
+		if strings.Contains(line, powDataMarker) {
+			seen++
+			pd, perr := parsePowLine(line)
+			if perr != nil || pd == nil {
+				unparseable++
+				return
+			}
+			var at time.Time
+			if sm := logStampRE.FindStringSubmatch(line); sm != nil {
+				at, _ = time.ParseInLocation("2006-01-02 15:04:05", sm[1], time.Local)
+			}
+			if len(pending) >= 16 {
+				pending = make(map[string]parked)
+			}
+			pending[pd.Hash] = parked{pow: pd, at: at}
+			return
+		}
+		if !strings.Contains(line, "Accepted client") {
+			return
+		}
+		m := acceptedShareRE.FindStringSubmatch(line)
+		if m == nil {
+			return
+		}
+		if p, ok := pending[m[2]]; ok {
+			delete(pending, m[2])
+			if best == nil || p.pow.SDiff > best.SDiff {
+				best = p.pow
+				bestAt = p.at
+			}
+		}
+	})
+	return best, bestAt, seen, unparseable, err
+}
+
 // sleep returns false if ctx was cancelled during the wait.
 func sleep(ctx context.Context, d time.Duration) bool {
 	select {

api/internal/logmon/tailer_test.go

@@ -5,6 +5,8 @@ import (
 	"io"
 	"log/slog"
 	"os"
+	"strconv"
+	"strings"
 	"sync"
 	"testing"
 	"time"
@@ -118,6 +120,158 @@ func TestHandleLine_Unrelated(t *testing.T) {
 	}
 }
 
+func TestHandleLine_PowData(t *testing.T) {
+	tl := New("/unused", discardLog())
+	line := `[2026-08-31 10:11:12.123] Best share PoW data {"sdiff":123456789.5,"netdiff":136597951737045.0,"height":911111,` +
+		`"hash":"0000000000abcdef0000000000000000000000000000000000000000deadbeef",` +
+		`"header":"20000000" + "aa",` + "\n"
+	// Malformed JSON must not emit an event.
+	tl.handleLine(line)
+	select {
+	case ev := <-tl.Shares:
+		t.Errorf("unexpected ShareEvent from malformed PoW line: %+v", ev)
+	default:
+	}
+
+	good := `[2026-08-31 10:11:12.123] Best share PoW data {"sdiff":123456789.5,"netdiff":136597951737045.0,"height":911111,` +
+		`"hash":"0000000000abcdef0000000000000000000000000000000000000000deadbeef",` +
+		`"header":"0000002006226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f00000000000000000000000000000000000000000000000000000000000000006859a06817e0377c00000000",` +
+		`"coinbase":"01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff00ffffffff0100f2052a01000000160014000000000000000000000000000000000000000000000000",` +
+		`"cb1len":41,"merklebranches":["ab"],"enonce1":"a1b2c3d4","nonce2":"0011223344556677","workername":"bc1qexample.axe"}` + "\n"
+	tl.handleLine(good)
+	select {
+	case ev := <-tl.Shares:
+		if ev.Pow == nil {
+			t.Fatalf("ShareEvent.Pow = nil, want parsed PoW data (event %+v)", ev)
+		}
+		if ev.Pow.SDiff != 123456789.5 {
+			t.Errorf("SDiff = %v, want 123456789.5", ev.Pow.SDiff)
+		}
+		if ev.Pow.Height != 911111 {
+			t.Errorf("Height = %d, want 911111", ev.Pow.Height)
+		}
+		if len(ev.Pow.Header) != 160 {
+			t.Errorf("Header length = %d, want 160", len(ev.Pow.Header))
+		}
+		if ev.Pow.CB1Len != 41 {
+			t.Errorf("CB1Len = %d, want 41", ev.Pow.CB1Len)
+		}
+		if len(ev.Pow.MerkleBranches) != 1 || ev.Pow.MerkleBranches[0] != "ab" {
+			t.Errorf("MerkleBranches = %v, want [ab]", ev.Pow.MerkleBranches)
+		}
+		if ev.Pow.Workername != "bc1qexample.axe" {
+			t.Errorf("Workername = %q", ev.Pow.Workername)
+		}
+	default:
+		t.Fatal("no ShareEvent emitted for PoW data line")
+	}
+}
+
+func powLine(hash string, sdiff float64) string {
+	return `[2026-08-30 09:15:42.123] Best share PoW data {"sdiff":` +
+		strconv.FormatFloat(sdiff, 'f', -1, 64) +
+		`,"netdiff":1.3e14,"height":911111,"hash":"` + hash +
+		`","header":"00000020aabb","coinbase":"0100","cb1len":41,` +
+		`"merklebranches":[],"enonce1":"a1b2c3d4","nonce2":"0011223344556677","workername":"bc1q.axe"}` + "\n"
+}
+
+func acceptedLine(hash string, sdiff float64) string {
+	return `[2026-08-30 09:15:42.124] Accepted client 7 share diff ` +
+		strconv.FormatFloat(sdiff, 'f', -1, 64) + `/42/1.0K: ` + hash + "\n"
+}
+
+// FindBestPowData must return the highest-diff record that was
+// confirmed accepted, skip unconfirmed ones, and recover the log
+// line's timestamp.
+func TestFindBestPowData(t *testing.T) {
+	path := tempLog(t)
+	appendLines(t, path,
+		powLine("aaaa", 100),
+		acceptedLine("aaaa", 100),
+		// Never confirmed (e.g. rejected below vardiff): must be ignored
+		// even though it carries the highest diff.
+		powLine("bbbb", 99999),
+		powLine("cccc", 500),
+		acceptedLine("cccc", 500),
+	)
+
+	pow, at, seen, unparseable, err := FindBestPowData(path)
+	if err != nil {
+		t.Fatalf("scan error: %v", err)
+	}
+	if pow == nil {
+		t.Fatal("FindBestPowData returned nil, want the confirmed 500-diff record")
+	}
+	if pow.Hash != "cccc" || pow.SDiff != 500 {
+		t.Errorf("got hash %s sdiff %v, want cccc/500", pow.Hash, pow.SDiff)
+	}
+	if seen != 3 || unparseable != 0 {
+		t.Errorf("seen=%d unparseable=%d, want 3/0", seen, unparseable)
+	}
+	want := time.Date(2026, 8, 30, 9, 15, 42, 0, time.Local)
+	if !at.Equal(want) {
+		t.Errorf("timestamp = %v, want %v", at, want)
+	}
+}
+
+// Production ckpool logs have carried bytes after the JSON's closing
+// brace (observed in the field: an end-of-line-anchored regex matched 0
+// of 54 real PoW lines while synthetic lines passed). The parser must
+// decode the JSON value and ignore ANY trailing bytes — NULs, \r,
+// or an interleaved second message on the same line.
+func TestHandleLine_PowDataTrailingGarbage(t *testing.T) {
+	suffixes := []string{
+		"\x00\x00\n",  // NUL padding
+		"\r\n",        // CR before LF
+		" [2026-08-31 18:00:01.125] Accepted client 3 share diff 1.0/1/1: aa\n", // interleaved write
+	}
+	for _, suffix := range suffixes {
+		tl := New("/unused", discardLog())
+		tl.handleLine(strings.TrimRight(powLine("cafe", 777), "\n") + suffix)
+		select {
+		case ev := <-tl.Shares:
+			if ev.Pow == nil || ev.Pow.Hash != "cafe" || ev.Pow.SDiff != 777 {
+				t.Errorf("suffix %q: got %+v, want cafe/777 PoW event", suffix, ev.Pow)
+			}
+		default:
+			t.Errorf("suffix %q: no PoW event emitted", suffix)
+		}
+	}
+}
+
+// A pathologically long line earlier in the log must not abort the scan
+// before it reaches the PoW records — bufio.Scanner did exactly that,
+// silently, which left the backfill permanently empty on real logs.
+func TestFindBestPowData_SurvivesOversizedLine(t *testing.T) {
+	path := tempLog(t)
+	appendLines(t, path,
+		"junk "+strings.Repeat("x", 600*1024)+"\n", // > any fixed buffer
+		powLine("abab", 250),
+		acceptedLine("abab", 250),
+	)
+	pow, _, seen, _, err := FindBestPowData(path)
+	if err != nil {
+		t.Fatalf("scan error: %v", err)
+	}
+	if pow == nil || pow.Hash != "abab" || seen != 1 {
+		t.Fatalf("pow=%+v seen=%d, want abab record found past the oversized line", pow, seen)
+	}
+}
+
+func TestFindBestPowData_Empty(t *testing.T) {
+	path := tempLog(t)
+	appendLines(t, path,
+		"Stratifier started\n",
+		acceptedLine("dddd", 10), // accepted share without PoW data (pre-patch line)
+	)
+	if pow, _, _, _, err := FindBestPowData(path); pow != nil || err != nil {
+		t.Errorf("got %+v err=%v, want nil/nil for log without confirmed PoW records", pow, err)
+	}
+	if pow, _, _, _, err := FindBestPowData(path + ".missing"); pow != nil || err == nil {
+		t.Errorf("got %+v err=%v, want nil record and an error for missing file", pow, err)
+	}
+}
+
 // ---- Tailer.Run integration tests (filesystem + goroutines) ----
 
 func tempLog(t *testing.T) string {

api/internal/state/aggregator.go

@@ -25,6 +25,15 @@ type HashratePoint struct {
 	V float64 `json:"v"` // H/s
 }
 
+// BestSharePow wraps the PoW reproduction record ckpool logs for a new
+// best share (patch 0008) with the time we ingested it. Persisted as
+// JSON in the kv store so the header of the best share survives
+// restarts.
+type BestSharePow struct {
+	logmon.PowData
+	SeenAt time.Time `json:"seen_at"`
+}
+
 // StratumServer describes one entry in ckpool's serverurl[] array. ckpool
 // tags every client with the index of the bind it arrived on, but the index
 // alone doesn't say what that bind *is* — that depends on how the deployment
@@ -64,6 +73,12 @@ type Snapshot struct {
 	BestShareHash string `json:"best_share_hash,omitempty"`
 	// Network difficulty at the time the best share was found.
 	BestShareNetDiff float64 `json:"best_share_net_diff,omitempty"`
+	// Full PoW reproduction data (raw block header, coinbase, merkle
+	// branches) for the best share seen since ckpool patch 0008 was
+	// deployed. May describe a lower-diff share than BestDiff when the
+	// all-time best predates the patch — the UI compares hashes and
+	// shows a disclaimer in that case.
+	BestSharePow *BestSharePow `json:"best_share_pow,omitempty"`
 	// Last best-diff value acknowledged by the user via the UI.
 	// The frontend shows a "new best" glow when best_diff > this.
 	AckedBestDiff float64 `json:"acked_best_diff"`
@@ -177,6 +192,7 @@ const (
 	kvBestDiff         = "best_diff"
 	kvBestShareHash    = "best_share_hash"
 	kvBestShareNetDiff = "best_share_net_diff"
+	kvBestSharePow     = "best_share_pow"
 
 	kvAllTimeAccepted = "alltime_accepted"
 	kvAllTimeRejected = "alltime_rejected"
@@ -329,6 +345,19 @@ type Aggregator struct {
 	bestShareHash    string
 	bestShareNetDiff float64 // network difficulty when best share was found
 
+	// PoW reproduction data for the best share seen since ckpool patch
+	// 0008 went live. Tracked as its own high-water mark (by SDiff)
+	// because the all-time best share may predate the patch and have no
+	// reconstructible header. Never mutated after assignment, so the
+	// pointer is safe to hand out in snapshots.
+	bestPow *BestSharePow
+	// PoW data lines arrive on the share channel just before their
+	// matching "Accepted client" line. Park them here keyed by header
+	// hash until the accepted event confirms the share, so data from a
+	// share that ends up rejected (e.g. below the client's vardiff
+	// right after a ckpool restart) is never persisted.
+	pendingPow map[string]*logmon.PowData
+
 	// Last best-diff value acknowledged by the user in the UI.
 	ackedBestDiff float64
 
@@ -352,6 +381,7 @@ func New(ck *ckpool.Client, rpc *bitcoind.RPC, interval time.Duration, log *slog
 		Log:                  log,
 		sessionRejectReasons: make(map[string]int64),
 		alltimeRejectReasons: make(map[string]int64),
+		pendingPow:           make(map[string]*logmon.PowData),
 		ready:                make(chan struct{}),
 		notifierDone:         make(chan struct{}, 1),
 	}
@@ -572,6 +602,7 @@ func (a *Aggregator) refresh(ctx context.Context) {
 	next.BestDiff = a.bestDiff
 	next.BestShareHash = a.bestShareHash
 	next.BestShareNetDiff = a.bestShareNetDiff
+	next.BestSharePow = a.bestPow
 	next.AckedBestDiff = a.ackedBestDiff
 	now := time.Now()
 
@@ -821,6 +852,17 @@ func (a *Aggregator) IngestShareEvents(ctx context.Context, events <-chan logmon
 				return
 			}
 			a.mu.Lock()
+			if ev.Pow != nil {
+				// PoW reproduction line (patch 0008). Park it until the
+				// matching "Accepted client" event arrives; a bounded
+				// reset guards against unmatched entries piling up.
+				if len(a.pendingPow) >= 16 {
+					a.pendingPow = make(map[string]*logmon.PowData)
+				}
+				a.pendingPow[ev.Pow.Hash] = ev.Pow
+				a.mu.Unlock()
+				continue
+			}
 			if ev.Rejected {
 				reason := ev.Reason
 				if reason == "" {
@@ -836,6 +878,25 @@ func (a *Aggregator) IngestShareEvents(ctx context.Context, events <-chan logmon
 				a.alltimeDiffCount++
 				a.sessionDiffSum += ev.Diff
 				a.alltimeDiffSum += ev.Diff
+				// Promote parked PoW data once its share is confirmed
+				// accepted and beats the best PoW record we hold. This
+				// high-water mark is separate from bestDiff: the
+				// all-time best share may predate ckpool patch 0008,
+				// in which case this tracks the best share since the
+				// patch went live and the UI discloses the difference.
+				if pow, ok := a.pendingPow[ev.Hash]; ok {
+					delete(a.pendingPow, ev.Hash)
+					if a.bestPow == nil || pow.SDiff > a.bestPow.SDiff {
+						a.bestPow = &BestSharePow{PowData: *pow, SeenAt: time.Now()}
+						if a.Store != nil {
+							if data, err := json.Marshal(a.bestPow); err == nil {
+								_ = a.Store.SetKV(kvBestSharePow, string(data))
+							}
+						}
+						a.Log.Info("best share PoW data captured",
+							"sdiff", pow.SDiff, "height", pow.Height, "hash", pow.Hash)
+					}
+				}
 				// Track hash of the best share from log parsing.
 				if ev.Hash != "" && ev.Diff > a.bestDiff {
 					a.bestDiff = ev.Diff
@@ -971,6 +1032,16 @@ func (a *Aggregator) loadPersistedState() {
 			a.mu.Unlock()
 		}
 	}
+	if v, err := a.Store.GetKV(kvBestSharePow); err == nil && v != "" {
+		var pow BestSharePow
+		if uerr := json.Unmarshal([]byte(v), &pow); uerr == nil && pow.Header != "" {
+			a.mu.Lock()
+			a.bestPow = &pow
+			a.mu.Unlock()
+		} else if uerr != nil {
+			a.Log.Warn("best_share_pow load failed", "err", uerr)
+		}
+	}
 
 	// One-time backfill: if we have no hash (pre-upgrade), scan the
 	// ckpool log for the highest-difficulty accepted share and use its hash.
@@ -998,6 +1069,41 @@ func (a *Aggregator) loadPersistedState() {
 		}
 	}
 
+	// One-time backfill: if we hold no PoW record but the log already
+	// contains confirmed "Best share PoW data" lines (fresh database, or
+	// events dropped under load), adopt the best of them. Without this
+	// the PoW inspector would wait for a share beating ckpool's
+	// in-process best, which after a long ckpool uptime can take
+	// arbitrarily long.
+	a.mu.RLock()
+	needsPowBackfill := a.bestPow == nil && a.LogFilePath != ""
+	a.mu.RUnlock()
+	if needsPowBackfill {
+		pow, at, seen, unparseable, err := logmon.FindBestPowData(a.LogFilePath)
+		switch {
+		case err != nil:
+			a.Log.Warn("best share PoW backfill: log scan failed", "err", err)
+		case pow == nil:
+			// Deliberately loud: "no record" is indistinguishable from a
+			// broken pipeline without the counts.
+			a.Log.Info("best share PoW backfill: no confirmed record adopted",
+				"pow_lines_seen", seen, "unparseable", unparseable)
+		default:
+			if at.IsZero() {
+				at = time.Now()
+			}
+			best := &BestSharePow{PowData: *pow, SeenAt: at}
+			a.mu.Lock()
+			a.bestPow = best
+			a.mu.Unlock()
+			if data, jerr := json.Marshal(best); jerr == nil {
+				_ = a.Store.SetKV(kvBestSharePow, string(data))
+			}
+			a.Log.Info("backfilled best share PoW data from log",
+				"sdiff", pow.SDiff, "hash", pow.Hash, "pow_lines_seen", seen)
+		}
+	}
+
 	// Restore acknowledged best diff.
 	if v, err := a.Store.GetKV(kvAckedBestDiff); err == nil && v != "" {
 		if f, perr := strconv.ParseFloat(v, 64); perr == nil {

api/internal/state/pow_e2e_test.go

@@ -0,0 +1,121 @@
+package state
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/kamadopool/kamado-api/internal/logmon"
+)
+
+// The two lines below are the verbatim output of ckpool patch 0008's
+// jansson code (replicated against ckpool's in-tree jansson 2.14 with
+// identical calls and JSON_COMPACT), using Bitcoin block 125552's real
+// header and hash. If ckpool's encoding and this pipeline ever drift,
+// this test is the tripwire.
+const (
+	ckpoolPowLine = `[2026-08-31 18:00:01.123] Best share PoW data {"sdiff":62953.415063916997,"netdiff":136597951737045.02,"height":911234,"hash":"00000000000000001e8d6829a8a21adc5d38d0a473b144b6765798e61f98bd1d","header":"0100000081cd02ab7e569e8bcd9317e2fe99f2de44d49ab2b8851ba4a308000000000000e320b6c2fffc8d750423db8b1eb942ae710e951ed797f7affc8892b0f1fc122bc7f5d74df2b9441a42a14695","coinbase":"01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff2703e2e60d04858ee468086b616d61646f2f04a1b2c3d40011223344556677ffffffff0100f2052a010000001600140123456789abcdef0123456789abcdef0123456700000000","cb1len":41,"merklebranches":["fff2525b8931402dd09222c50775608f75787bd2b87e56995a7bdd30f79702c4","6359f0868171b1d194cbee1af2f16ea598ae8fad666d9b012c8ed2b79a236ec4"],"enonce1":"a1b2c3d4","nonce2":"0011223344556677","workername":"bc1qexample.axe1"}` + "\n"
+	ckpoolAcceptLine = `[2026-08-31 18:00:01.124] Accepted client 271 share diff 62953.4/512/1.02K: 00000000000000001e8d6829a8a21adc5d38d0a473b144b6765798e61f98bd1d` + "\n"
+)
+
+// End to end: real ckpool log bytes -> real Tailer.Run -> aggregator
+// ingest -> snapshot JSON. Exercises the exact production path.
+func TestPowEndToEnd_LogToSnapshot(t *testing.T) {
+	f, err := os.CreateTemp("", "ckpool_e2e*.log")
+	if err != nil {
+		t.Fatal(err)
+	}
+	f.Close()
+	t.Cleanup(func() { _ = os.Remove(f.Name()) })
+
+	tl := logmon.New(f.Name(), discardLog())
+	tl.PollWait = 10 * time.Millisecond
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	go tl.Run(ctx)
+
+	a := New(nil, nil, time.Minute, discardLog())
+	go a.IngestShareEvents(ctx, tl.Shares)
+
+	// Give the tailer a moment to open the (empty) file and seek to the
+	// end, then append what ckpool would write.
+	time.Sleep(50 * time.Millisecond)
+	lf, err := os.OpenFile(f.Name(), os.O_APPEND|os.O_WRONLY, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := lf.WriteString(ckpoolPowLine + ckpoolAcceptLine); err != nil {
+		t.Fatal(err)
+	}
+	lf.Close()
+
+	deadline := time.Now().Add(5 * time.Second)
+	for {
+		a.mu.RLock()
+		pow := a.bestPow
+		a.mu.RUnlock()
+		if pow != nil {
+			if pow.Hash != "00000000000000001e8d6829a8a21adc5d38d0a473b144b6765798e61f98bd1d" {
+				t.Fatalf("hash = %s", pow.Hash)
+			}
+			if pow.SDiff != 62953.415063916997 || pow.NetDiff != 136597951737045.02 {
+				t.Fatalf("sdiff/netdiff = %v/%v", pow.SDiff, pow.NetDiff)
+			}
+			if len(pow.Header) != 160 || len(pow.MerkleBranches) != 2 {
+				t.Fatalf("header len %d, branches %d", len(pow.Header), len(pow.MerkleBranches))
+			}
+			break
+		}
+		if time.Now().After(deadline) {
+			t.Fatal("bestPow never populated from the tailed log")
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+
+	// The snapshot must expose it under best_share_pow with the flattened
+	// PowData fields — this is the contract the UI reads.
+	snap := Snapshot{BestSharePow: func() *BestSharePow {
+		a.mu.RLock()
+		defer a.mu.RUnlock()
+		return a.bestPow
+	}()}
+	data, err := json.Marshal(snap)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var out map[string]any
+	if err := json.Unmarshal(data, &out); err != nil {
+		t.Fatal(err)
+	}
+	powJSON, ok := out["best_share_pow"].(map[string]any)
+	if !ok {
+		t.Fatalf("snapshot JSON missing best_share_pow: %s", data)
+	}
+	for _, key := range []string{"sdiff", "netdiff", "height", "hash", "header", "coinbase", "cb1len", "merklebranches", "enonce1", "nonce2", "workername", "seen_at"} {
+		if _, ok := powJSON[key]; !ok {
+			t.Errorf("best_share_pow JSON missing %q", key)
+		}
+	}
+}
+
+// The startup backfill must recover the same record from an existing
+// log file (the path taken when live events were missed).
+func TestPowEndToEnd_Backfill(t *testing.T) {
+	path := tempLogFile(t, ckpoolPowLine, ckpoolAcceptLine)
+	pow, at, _, _, err := logmon.FindBestPowData(path)
+	if err != nil {
+		t.Fatalf("scan error: %v", err)
+	}
+	if pow == nil {
+		t.Fatal("FindBestPowData found nothing in verbatim ckpool output")
+	}
+	if pow.SDiff != 62953.415063916997 || len(pow.MerkleBranches) != 2 {
+		t.Fatalf("got %+v", pow)
+	}
+	want := time.Date(2026, 8, 31, 18, 0, 1, 0, time.Local)
+	if !at.Equal(want) {
+		t.Errorf("timestamp = %v, want %v", at, want)
+	}
+}

api/internal/state/pow_test.go

@@ -0,0 +1,207 @@
+package state
+
+import (
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/kamadopool/kamado-api/internal/logmon"
+)
+
+// ingest runs IngestShareEvents over the given events and waits for the
+// goroutine to drain them.
+func ingest(t *testing.T, a *Aggregator, events ...logmon.ShareEvent) {
+	t.Helper()
+	ch := make(chan logmon.ShareEvent, len(events))
+	for _, ev := range events {
+		ch <- ev
+	}
+	close(ch)
+	done := make(chan struct{})
+	go func() {
+		a.IngestShareEvents(context.Background(), ch)
+		close(done)
+	}()
+	select {
+	case <-done:
+	case <-time.After(5 * time.Second):
+		t.Fatal("IngestShareEvents did not drain")
+	}
+}
+
+func powFixture(hash string, sdiff float64) *logmon.PowData {
+	return &logmon.PowData{
+		SDiff:          sdiff,
+		NetDiff:        1.36e14,
+		Height:         911111,
+		Hash:           hash,
+		Header:         "00000020" + "aa" + "bb", // content is opaque to the aggregator
+		Coinbase:       "0100",
+		CB1Len:         41,
+		MerkleBranches: []string{"cd"},
+		Enonce1:        "a1b2c3d4",
+		Nonce2:         "0011223344556677",
+		Workername:     "bc1qexample.axe",
+	}
+}
+
+// A PoW data line followed by its matching accepted share must promote
+// the parked record to bestPow and persist it.
+func TestPowPairing_AcceptedPromotes(t *testing.T) {
+	s := openTempStore(t)
+	a := New(nil, nil, time.Minute, discardLog())
+	a.Store = s
+
+	const hash = "0000000000abcdef0000000000000000000000000000000000000000deadbeef"
+	ingest(t, a,
+		logmon.ShareEvent{SeenAt: time.Now(), Pow: powFixture(hash, 5000)},
+		logmon.ShareEvent{SeenAt: time.Now(), Diff: 5000, Hash: hash},
+	)
+
+	a.mu.RLock()
+	pow := a.bestPow
+	a.mu.RUnlock()
+	if pow == nil {
+		t.Fatal("bestPow not set after accepted share matched PoW data")
+	}
+	if pow.Hash != hash || pow.SDiff != 5000 {
+		t.Errorf("bestPow = %+v, want hash %s sdiff 5000", pow.PowData, hash)
+	}
+
+	// Reload from the store to verify persistence round-trips.
+	b := New(nil, nil, time.Minute, discardLog())
+	b.Store = s
+	b.loadPersistedState()
+	b.mu.RLock()
+	reloaded := b.bestPow
+	b.mu.RUnlock()
+	if reloaded == nil || reloaded.Hash != hash || reloaded.CB1Len != 41 {
+		t.Fatalf("persisted bestPow did not reload, got %+v", reloaded)
+	}
+}
+
+// PoW data for a share that is never confirmed accepted (e.g. rejected
+// below vardiff right after a ckpool restart) must not become bestPow.
+func TestPowPairing_UnmatchedIsNotPromoted(t *testing.T) {
+	a := New(nil, nil, time.Minute, discardLog())
+
+	ingest(t, a,
+		logmon.ShareEvent{SeenAt: time.Now(), Pow: powFixture("aa11", 9000)},
+		logmon.ShareEvent{SeenAt: time.Now(), Rejected: true, Reason: "Above target"},
+	)
+
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if a.bestPow != nil {
+		t.Errorf("bestPow = %+v, want nil for unconfirmed PoW data", a.bestPow)
+	}
+	if _, ok := a.pendingPow["aa11"]; !ok {
+		t.Error("pending PoW entry missing; expected it parked until matched or evicted")
+	}
+}
+
+// The all-time best share may hugely outrank anything recent (found
+// before header capture existed). The PoW record must still populate
+// from the first confirmed share — it tracks "best since the feature
+// went live", never waiting for the all-time best to be beaten — while
+// leaving the all-time bestDiff/bestShareHash untouched.
+func TestPowPairing_BelowAllTimeBestStillPopulates(t *testing.T) {
+	a := New(nil, nil, time.Minute, discardLog())
+	a.mu.Lock()
+	a.bestDiff = 4.2e11 // legacy all-time best, no PoW data recorded for it
+	a.bestShareHash = "legacyhash"
+	a.mu.Unlock()
+
+	ingest(t, a,
+		logmon.ShareEvent{SeenAt: time.Now(), Pow: powFixture("smallhash", 1234)},
+		logmon.ShareEvent{SeenAt: time.Now(), Diff: 1234, Hash: "smallhash"},
+	)
+
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if a.bestPow == nil || a.bestPow.Hash != "smallhash" {
+		t.Fatalf("bestPow = %+v, want the 1234-diff record despite the 4.2e11 all-time best", a.bestPow)
+	}
+	if a.bestDiff != 4.2e11 || a.bestShareHash != "legacyhash" {
+		t.Errorf("all-time best mutated: diff %v hash %q", a.bestDiff, a.bestShareHash)
+	}
+}
+
+// With no persisted PoW record, loadPersistedState must adopt the best
+// confirmed record already present in the ckpool log, so the inspector
+// never waits for ckpool's long-lived in-process best to be beaten.
+func TestPowBackfill_FromLog(t *testing.T) {
+	logPath := tempLogFile(t,
+		`[2026-08-30 09:15:42.123] Best share PoW data {"sdiff":777,"netdiff":1.3e14,"height":911111,"hash":"eeee","header":"00000020aabb","coinbase":"0100","cb1len":41,"merklebranches":[],"enonce1":"a1","nonce2":"b2","workername":"w"}`+"\n",
+		`[2026-08-30 09:15:42.124] Accepted client 7 share diff 777/42/1.0K: eeee`+"\n",
+	)
+	s := openTempStore(t)
+	a := New(nil, nil, time.Minute, discardLog())
+	a.Store = s
+	a.LogFilePath = logPath
+	a.loadPersistedState()
+
+	a.mu.RLock()
+	pow := a.bestPow
+	a.mu.RUnlock()
+	if pow == nil || pow.Hash != "eeee" || pow.SDiff != 777 {
+		t.Fatalf("bestPow = %+v, want backfilled eeee/777", pow)
+	}
+	if pow.SeenAt.IsZero() {
+		t.Error("SeenAt is zero, want the log line timestamp")
+	}
+
+	// A persisted record must suppress the backfill on the next load,
+	// even when the log holds a lower-diff record.
+	b := New(nil, nil, time.Minute, discardLog())
+	b.Store = s
+	b.LogFilePath = tempLogFile(t,
+		`[2026-08-31 10:00:00.000] Best share PoW data {"sdiff":5,"netdiff":1.3e14,"height":911112,"hash":"ffff","header":"00000020ccdd","coinbase":"0100","cb1len":41,"merklebranches":[],"enonce1":"a1","nonce2":"b2","workername":"w"}`+"\n",
+		`[2026-08-31 10:00:00.001] Accepted client 7 share diff 5/42/1.0K: ffff`+"\n",
+	)
+	b.loadPersistedState()
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+	if b.bestPow == nil || b.bestPow.Hash != "eeee" {
+		t.Fatalf("bestPow = %+v, want the persisted eeee record kept", b.bestPow)
+	}
+}
+
+func tempLogFile(t *testing.T, lines ...string) string {
+	t.Helper()
+	f, err := os.CreateTemp("", "ckpool_pow*.log")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, l := range lines {
+		if _, werr := f.WriteString(l); werr != nil {
+			t.Fatal(werr)
+		}
+	}
+	f.Close()
+	t.Cleanup(func() { _ = os.Remove(f.Name()) })
+	return f.Name()
+}
+
+// A lower-diff PoW record (ckpool restarts reset its in-process best,
+// so it re-logs on the first share of each run) must not replace a
+// higher one already held.
+func TestPowPairing_LowerDiffDoesNotReplace(t *testing.T) {
+	a := New(nil, nil, time.Minute, discardLog())
+
+	ingest(t, a,
+		logmon.ShareEvent{SeenAt: time.Now(), Pow: powFixture("high", 9000)},
+		logmon.ShareEvent{SeenAt: time.Now(), Diff: 9000, Hash: "high"},
+		// ckpool restarted: first share of the new process is its
+		// in-process best and gets logged again at a lower diff.
+		logmon.ShareEvent{SeenAt: time.Now(), Pow: powFixture("low", 42)},
+		logmon.ShareEvent{SeenAt: time.Now(), Diff: 42, Hash: "low"},
+	)
+
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if a.bestPow == nil || a.bestPow.Hash != "high" {
+		t.Fatalf("bestPow = %+v, want the 9000-diff record kept", a.bestPow)
+	}
+}

ckpool/patches/0008-log-best-share-pow-data.patch

@@ -0,0 +1,90 @@
+diff --git a/src/stratifier.c b/src/stratifier.c
+index 7940d4fa..a856b3eb 100644
+--- a/src/stratifier.c
++++ b/src/stratifier.c
+@@ -5865,6 +5865,65 @@ out_nouserwb:
+ 	return wb->coinb2bin;
+ }
+ 
++/* Kamado (patches/0008): highest share diff for which PoW reproduction
++ * data has been logged in this process run. Deliberately unlocked — a
++ * race between share-processing threads can at worst emit a duplicate
++ * or out-of-order log line, which kamado-api deduplicates by diff. */
++static double best_pow_diff;
++
++/* Kamado (patches/0008): log everything needed to independently
++ * reproduce and verify the proof of work of a best share — the
++ * serialized 80-byte block header exactly as it was hashed, plus the
++ * assembled coinbase transaction and merkle branch hashes that
++ * reproduce the merkle root committed in that header. kamado-api
++ * parses this line from the log to power the dashboard PoW inspector.
++ * Needs to be entered with workbase readcount held. */
++static void log_best_pow_data(const stratum_instance_t *client, const workbase_t *wb,
++			      const char *nonce2, const char *coinbase, const int cblen,
++			      const uchar *swap, const uchar *hash, const double sdiff)
++{
++	char header_hex[164], hexhash[68];
++	json_t *val, *branches;
++	uchar sharehash[32];
++	char *cb_hex, *s;
++	int i;
++
++	__bin2hex(header_hex, swap, 80);
++	bswap_256(sharehash, hash);
++	__bin2hex(hexhash, sharehash, 32);
++	cb_hex = bin2hex(coinbase, cblen);
++	if (unlikely(!cb_hex))
++		return;
++	branches = json_array();
++	for (i = 0; i < wb->merkles; i++)
++		json_array_append_new(branches, json_string(&wb->merklehash[i][0]));
++	val = json_object();
++	json_set_double(val, "sdiff", sdiff);
++	json_set_double(val, "netdiff", wb->network_diff);
++	json_set_int(val, "height", wb->height);
++	json_set_string(val, "hash", hexhash);
++	json_set_string(val, "header", header_hex);
++	json_set_string(val, "coinbase", cb_hex);
++	json_set_int(val, "cb1len", wb->coinb1len);
++	json_object_set_new(val, "merklebranches", branches);
++	json_set_string(val, "enonce1", client->enonce1);
++	json_set_string(val, "nonce2", nonce2);
++	json_set_string(val, "workername", client->workername ? client->workername : "");
++	s = json_dumps(val, JSON_COMPACT);
++	json_decref(val);
++	free(cb_hex);
++	if (likely(s)) {
++		/* Call logmsg directly rather than LOGNOTICE: the LOGMSG
++		 * macro splits messages into DEFLOGBUFSIZ (512-byte) chunks,
++		 * each written as a separate timestamped log line — and its
++		 * length arithmetic drops everything past ~3 chunks. This
++		 * record is ~2.5KB of JSON that kamado-api must read back as
++		 * one intact line. logmsg itself is unbounded. */
++		logmsg(LOG_NOTICE, "Best share PoW data %s", s);
++		free(s);
++	}
++}
++
+ /* Needs to be entered with workbase readcount and client holding a ref count. */
+ static double submission_diff(sdata_t *sdata, const stratum_instance_t *client, const workbase_t *wb,
+ 			      const char *nonce2, const uint32_t ntime32, uint32_t version_mask,
+@@ -5937,6 +5996,19 @@ static double submission_diff(sdata_t *sdata, const stratum_instance_t *client,
+ 	/* Calculate the diff of the share here */
+ 	ret = diff_from_target(hash);
+ 
++	/* Kamado (patches/0008): if this is the highest-diff share this
++	 * process has seen, log full PoW reproduction data for the
++	 * dashboard's best-share header inspector. Skip shares that will
++	 * be rejected: stale ones, and those outside the ntime roll
++	 * window (mirrors the check in parse_submit). Duplicates cannot
++	 * trigger this — an identical share has an equal, not greater,
++	 * diff. */
++	if (unlikely(ret > best_pow_diff && !stale &&
++		     ntime32 >= wb->ntime32 && ntime32 <= wb->ntime32 + 7000)) {
++		best_pow_diff = ret;
++		log_best_pow_data(client, wb, nonce2, coinbase, cblen, swap, hash, ret);
++	}
++
+ 	/* Test we haven't solved a block regardless of share status */
+ 	test_blocksolve(client, wb, swap, hash, ret, coinbase, cblen, nonce2, nonce, ntime32, version_mask, stale);
+ 

ui/src/App.svelte

@@ -14,6 +14,7 @@
   import AcceleratorPage from "./lib/AcceleratorPage.svelte";
   import StatsPage from "./lib/StatsPage.svelte";
   import BestSharePage from "./lib/BestSharePage.svelte";
+  import SharePowPage from "./lib/SharePowPage.svelte";
   import SharesBar from "./lib/SharesBar.svelte";
   import BlockFoundAnimation from "./lib/BlockFoundAnimation.svelte";
   import QRCode from "qrcode";
@@ -64,6 +65,12 @@
         <BestSharePage />
       </div>
     {/key}
+  {:else if selection.page === "bestshare-pow"}
+    {#key 'bestshare-pow'}
+      <div class="page-enter">
+        <SharePowPage />
+      </div>
+    {/key}
   {:else if selection.worker}
     {#key selection.worker}
       <div class="page-enter">

ui/src/lib/BestSharePage.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import { clearSelection } from "../stores/selection.svelte";
+  import { clearSelection, selectBestSharePow } from "../stores/selection.svelte";
   import { snap } from "../stores/snapshot.svelte";
   import { formatDifficulty } from "../format";
 
@@ -179,6 +179,19 @@
     <button type="button" class="back" onclick={clearSelection}>
       &larr; Back to dashboard
     </button>
+    <button
+      type="button"
+      class="pow-btn"
+      onclick={selectBestSharePow}
+      title="Show the block header and raw data that reproduce this share's proof of work"
+    >
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" width="14" height="14">
+        <path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"/>
+        <polyline points="3.27 6.96 12 12.01 20.73 6.96"/>
+        <line x1="12" y1="22.08" x2="12" y2="12"/>
+      </svg>
+      Show PoW
+    </button>
   </nav>
 
   <header class="head">
@@ -350,6 +363,10 @@
   }
   .crumbs {
     margin-bottom: 0.25rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 0.75rem;
   }
   .back {
     font: inherit;
@@ -365,6 +382,23 @@
     border-color: var(--accent);
     background: var(--bg-hover);
   }
+  .pow-btn {
+    font: inherit;
+    display: inline-flex;
+    align-items: center;
+    gap: 0.45em;
+    color: var(--accent);
+    background: transparent;
+    border: 1px solid var(--accent-dim);
+    border-radius: 6px;
+    padding: 0.4em 0.85em;
+    cursor: pointer;
+  }
+  .pow-btn:hover {
+    border-color: var(--accent);
+    background: var(--bg-hover);
+    text-shadow: 0 0 8px rgba(255, 122, 58, 0.4);
+  }
 
   /* Difficulty view toggle */
   .toggle-bar {

ui/src/stores/selection.svelte.ts

@@ -14,6 +14,7 @@ const WORKER_PREFIX = "#/worker/";
 const ACCELERATOR_HASH = "#/accelerator";
 const STATS_HASH = "#/stats";
 const BESTSHARE_HASH = "#/bestshare";
+const BESTSHARE_POW_HASH = "#/bestshare/pow";
 
 type Selection = { user: string | null; worker: string | null; page: string | null };
 
@@ -28,6 +29,9 @@ function readHash(): Selection {
   if (h === STATS_HASH) {
     return { user: null, worker: null, page: "stats" };
   }
+  if (h === BESTSHARE_POW_HASH) {
+    return { user: null, worker: null, page: "bestshare-pow" };
+  }
   if (h === BESTSHARE_HASH) {
     return { user: null, worker: null, page: "bestshare" };
   }
@@ -73,6 +77,10 @@ export function selectBestShare(): void {
   window.location.hash = BESTSHARE_HASH;
 }
 
+export function selectBestSharePow(): void {
+  window.location.hash = BESTSHARE_POW_HASH;
+}
+
 export function clearSelection(): void {
   window.location.hash = "";
 }

ui/src/types.ts

@@ -113,6 +113,26 @@ export type HashratePoint = {
   v: number; // H/s
 };
 
+// PoW reproduction data for the best share seen since ckpool patch 0008
+// went live (logged by ckpool, ingested from the log by kamado-api).
+// `header` is the raw 80-byte block header in hashing byte order —
+// double-SHA256 it and reverse the digest to get `hash`. `coinbase` plus
+// `merklebranches` reproduce the merkle root committed in the header.
+export type BestSharePow = {
+  sdiff: number;
+  netdiff: number;
+  height: number;
+  hash: string; // display-order (big-endian) block header hash
+  header: string; // 160 hex chars
+  coinbase: string; // full serialized coinbase tx, hex
+  cb1len: number; // bytes preceding extranonce1 within the coinbase
+  merklebranches: string[] | null;
+  enonce1: string;
+  nonce2: string;
+  workername: string;
+  seen_at: string; // RFC 3339, when kamado-api ingested the record
+};
+
 // One entry per ckpool serverurl[] bind, declared by the deployment via
 // the STRATUM_SERVERS env. `kind` is the stable tag the UI switches on;
 // `label` is free text shown on hover.
@@ -137,6 +157,11 @@ export type Snapshot = {
   best_diff: number;
   best_share_hash?: string;
   best_share_net_diff?: number;
+  // Full header/coinbase/merkle-branch record for the best share seen
+  // since ckpool patch 0008 was deployed. May describe a lower-diff
+  // share than best_diff when the all-time best predates the patch —
+  // compare hashes and disclose.
+  best_share_pow?: BestSharePow;
   acked_best_diff: number;
   cumulative_shares: number;
   next_block_reward_btc: number;