Show blocks won, rewards, lost races and the node log on the dashboard

The dashboard now reads the chain over IPC for blocks mined by the payout address and keeps them, with the last block read, in an owner-only dashboard-index.json in the node folder, so a restart only reads new blocks. When the hash it kept for a height no longer matches the node's chain, it drops the entries from there and reads again. Each block's reward is the payout address's balance change across that block.

New endpoints behind the dashboard key: /api/rewards (blocks won, today's and total count and earnings, payout balance, and the count of block lost lines from the node log with a plain explanation) and /api/log (the last 200 lines of node.log, newest first, with plain meanings for common lines). The log is only read from inside the node folder; a node.log linking elsewhere is refused.

Author: ghostcoin-org

README.md

@@ -32,7 +32,12 @@ The page refreshes every 5 seconds without reloading. Each panel says "Node not
 - **Mining:** mining or paused; cores used (`<node-dir>/miner-threads`, else every core) of the computer's cores; the node's hash rate when it reports one; the payout address with a copy button; and estimates of your share of the network and the time to your next block.
 - **Network:** height; average block time over the last 100 blocks; difficulty; an estimated network hash rate (difficulty ÷ the target block time); and the last 20 blocks, with your own in violet.
 
-The estimates use a target block time of 15 seconds. Each panel reads one endpoint, behind the dashboard key: `/api/node`, `/api/mining` and `/api/network`.
+- **Rewards:** the blocks your payout address won (number, time and reward), how many you won and what they earned today (this computer's time) and in total, and the payout address balance. A block's reward is the payout address's balance change across that block, read from the node; when the node no longer keeps the balances of an old block its reward shows as unknown and is left out of the sums. The panel also counts the node log's "block lost" lines: each one is a lost race, where your node found a block but another node's block at the same height was accepted first. That is normal and earns nothing.
+- **Node log:** the last 200 lines of `<node-dir>/node.log`, newest first, with a plain meaning beside common lines (mined potential block, block lost, imported new chain segment, looking for peers). The log is only read, and only from inside the node folder: a `node.log` that links elsewhere is refused.
+
+The dashboard finds your blocks by reading the chain over IPC and keeps what it found in `<node-dir>/dashboard-index.json` (owner-only), with the last block it read, so after a restart it only reads new blocks. On a long chain the first reading is spread over several refreshes. When the chain is reorganised it drops the blocks the new chain replaced and reads again from there; when the payout address changes it starts over.
+
+The estimates use a target block time of 15 seconds. Each panel reads one endpoint, behind the dashboard key: `/api/node`, `/api/mining`, `/api/network`, `/api/rewards` and `/api/log`.
 
 ### Access
 

internal/server/rewards_test.go

@@ -0,0 +1,112 @@
+package server
+
+import (
+	"encoding/json"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/ghostcoin-core/ghost-node-dashboard/internal/ipc/ipctest"
+	"github.com/ghostcoin-core/ghost-node-dashboard/internal/status"
+)
+
+func TestRewardsAndLogNeedKey(t *testing.T) {
+	h := panelHandler(t, nil, panelOpts{})
+	for _, target := range []string{"/api/rewards", "/api/log"} {
+		rec := do(h, http.MethodGet, target, goodHost, nil)
+		if rec.Code != http.StatusUnauthorized {
+			t.Errorf("%s without cookie: status %d, want 401", target, rec.Code)
+		}
+		rec = do(h, http.MethodGet, target, "evil.example:8580", withSession)
+		if rec.Code != http.StatusForbidden {
+			t.Errorf("%s on another host: status %d, want 403", target, rec.Code)
+		}
+	}
+}
+
+func TestRewardsPanelEndpoint(t *testing.T) {
+	// Blocks 0 to 4; the node won block 2, which paid 3 coins.
+	const coin = "de0b6b3a7640000"
+	_, node := startFake(t, map[string]ipctest.Handler{
+		"web3_clientVersion": ipctest.Value("Ghost/test"),
+		"eth_coinbase":       ipctest.Value(ownAddress),
+		"eth_blockNumber":    ipctest.Value("0x4"),
+		"eth_getBlockByNumber": func(params json.RawMessage) (any, *ipctest.Error) {
+			var args []any
+			_ = json.Unmarshal(params, &args)
+			tag, _ := args[0].(string)
+			n, _ := strconv.ParseUint(strings.TrimPrefix(tag, "0x"), 16, 64)
+			if n > 4 {
+				return nil, nil
+			}
+			miner := otherAddress
+			if n == 2 {
+				miner = ownAddress
+			}
+			return map[string]string{
+				"number":     tag,
+				"hash":       "0xh" + tag,
+				"parentHash": "0xh0x" + strconv.FormatUint(n-1, 16),
+				"timestamp":  "0x" + strconv.FormatUint(1_700_000_000+n, 16),
+				"miner":      miner,
+			}, nil
+		},
+		"eth_getBalance": func(params json.RawMessage) (any, *ipctest.Error) {
+			var args []string
+			_ = json.Unmarshal(params, &args)
+			if args[1] == "0x1" {
+				return "0x" + coin, nil
+			}
+			// 4 coins from block 2 on: 1 before plus the 3 it paid.
+			return "0x3782dace9d900000", nil
+		},
+	})
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "node.log"), []byte("INFO 😱 block lost number=3\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	got := getPanel(t, panelHandler(t, node, panelOpts{nodeDir: dir}), "/api/rewards")
+	expect(t, got, map[string]any{
+		"running":       true,
+		"payoutAddress": ownAddress,
+		"wonTotal":      1,
+		"lostRaces":     1,
+		"indexing":      nil,
+	})
+	blocks, _ := got["blocks"].([]any)
+	if len(blocks) != 1 {
+		t.Fatalf("blocks %v, want block 2", got["blocks"])
+	}
+	b := blocks[0].(map[string]any)
+	if reward, _ := b["reward"].(map[string]any); b["number"] != 2.0 || reward["coins"] != "3" {
+		t.Errorf("block won %v, want block 2 paying 3 coins", b)
+	}
+	if bal, _ := got["balance"].(map[string]any); bal["coins"] != "4" {
+		t.Errorf("balance %v, want 4 coins", got["balance"])
+	}
+	if _, err := os.Stat(status.IndexPath(dir)); err != nil {
+		t.Errorf("index not written: %v", err)
+	}
+}
+
+func TestLogPanelEndpoint(t *testing.T) {
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "node.log"), []byte("one\nINFO Looking for peers peercount=0\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	got := getPanel(t, panelHandler(t, nil, panelOpts{nodeDir: dir}), "/api/log")
+	if got["available"] != true {
+		t.Fatalf("log panel %v", got)
+	}
+	lines, _ := got["lines"].([]any)
+	if len(lines) != 2 {
+		t.Fatalf("lines %v", got["lines"])
+	}
+	first := lines[0].(map[string]any)
+	if first["text"] != "INFO Looking for peers peercount=0" || first["meaning"] == nil {
+		t.Errorf("newest line %v, want the peers line with its meaning", first)
+	}
+}

internal/server/server.go

@@ -52,6 +52,8 @@ type handler struct {
 	node    status.Caller
 	nodeEnv status.NodeEnv
 	mining  status.MiningEnv
+	rewards *status.Rewards
+	nodeDir string
 	mux     *http.ServeMux
 }
 
@@ -68,8 +70,10 @@ func New(cfg Config) http.Handler {
 			AutoUpdate: cfg.AutoUpdate,
 			Now:        cfg.Now,
 		},
-		mining: status.MiningEnv{NodeDir: cfg.NodeDir, LogicalCores: cfg.LogicalCores},
-		mux:    http.NewServeMux(),
+		mining:  status.MiningEnv{NodeDir: cfg.NodeDir, LogicalCores: cfg.LogicalCores},
+		rewards: status.NewRewards(status.RewardsEnv{NodeDir: cfg.NodeDir, Now: cfg.Now}),
+		nodeDir: cfg.NodeDir,
+		mux:     http.NewServeMux(),
 	}
 	if h.nodeEnv.AutoUpdate == nil {
 		h.nodeEnv.AutoUpdate = status.AutoUpdateInstalled
@@ -96,6 +100,8 @@ func New(cfg Config) http.Handler {
 	h.mux.HandleFunc("GET /api/node", h.nodePanel)
 	h.mux.HandleFunc("GET /api/mining", h.miningPanel)
 	h.mux.HandleFunc("GET /api/network", h.networkPanel)
+	h.mux.HandleFunc("GET /api/rewards", h.rewardsPanel)
+	h.mux.HandleFunc("GET /api/log", h.logPanel)
 	return h
 }
 
@@ -204,6 +210,16 @@ func (h *handler) networkPanel(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, status.FetchNetwork(ctx, h.node))
 }
 
+func (h *handler) rewardsPanel(w http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), StatusTimeout)
+	defer cancel()
+	writeJSON(w, h.rewards.Fetch(ctx, h.node))
+}
+
+func (h *handler) logPanel(w http.ResponseWriter, r *http.Request) {
+	writeJSON(w, status.ReadLog(h.nodeDir))
+}
+
 func writeJSON(w http.ResponseWriter, v any) {
 	w.Header().Set("Content-Type", "application/json")
 	_ = json.NewEncoder(w).Encode(v)