Merge dashboard-refinements: Sharechain Transparency Explorer (v0.12.0)

Major dashboard milestone — defragmenter-style sharechain visualization,
interactive PPLNS treemaps with LTC+DOGE payouts, animated hover effects,
block solution banners (Legendary/Epic), V36 upgrade pressure for miners,
modern share detail pages, per-miner hashrate/version/coinbase tooltips.

Author: frstrtr

CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.12.0] - 2026-04-07
+
+### Milestone
+- **Sharechain Transparency Explorer** — Windows Defragmenter-style canvas visualization of the full sharechain window (8640 mainnet / 400 testnet shares) with interactive PPLNS treemaps, animated hover effects, and V36 upgrade pressure for miners.
+
+### Added
+- **Defrag sharechain viewer** — canvas grid where each share is a colored cell. Colors: blue (this node), green (verified), gray (unverified), yellow (orphan), red (dead), purple (pool fee), teal (V36 signaling). Gold/cyan/orange borders for LTC/DOGE/twin block solutions.
+- **PPLNS Distribution treemap** — interactive squarified treemap on dashboard and share detail pages. Shows per-miner LTC % and DOGE % with clickable addresses (Blockchair). V35-only miners shown desaturated with "NO DOGE" labels and red borders.
+- **Animated hover effects** — share cells enlarge 2.5x with white glow and spring animation. PPLNS treemap cells scale with brightness boost. Chain structure cells (Best Share, Verified Heads, Tails) as colored squares with tooltips.
+- **Rich share tooltips** — hash, absolute + relative height, miner address, hashrate, difficulty, age, version + desired version, coinbase tag, stale status, V36 signaling tags, LTC/DOGE block solution badges.
+- **Block solution banners** — share detail page shows prominent banners for block solutions: gold (LTC), cyan (DOGE), orange pulsing (LEGENDARY twin). Blockchair links, confirmations, block reward.
+- **Modern share.html** — complete redesign matching dashboard dark theme. Card layout with navigation, share data, local data, block header, generation TX, V36 metadata, full PPLNS treemap with DOGE payouts and version tags.
+- **`/sharechain/window` enhanced** — compact JSON keys, human-readable miner addresses, `is_block_solution` flag, `desired_version`, coinbase ASCII tag (longest 10+ char run with letters), DOGE discovered blocks.
+- **`/web/share/<hash>` endpoint** — full share lookup via `set_share_lookup_fn` callback. Returns p2pool-compatible JSON with block solution detection, DOGE block info, LTC confirmations.
+- **V36? column in Current Payouts** — green checkmark (V36), teal arrow (signaling), red X (V35 only, no DOGE).
+- **Time axis** — left-side hour labels on defrag grid showing share age per row.
+- **WoW quality colors** — Best Share: Epic purple glow. Twin blocks: Legendary orange pulse.
+
+### Changed
+- "My Shares" / "Mine" renamed to "This Node" throughout.
+- Share explorer section renamed to "Sharechain Transparency Explorer".
+- Donation field removed from tooltips (always 0 in V36+).
+
 ## [0.9.5] - 2026-03-27
 
 ### Milestone

README.md

@@ -12,6 +12,8 @@ Original forum thread: <https://bitcointalk.org/index.php?topic=18313>
 > **First daemonless DOGE block:** (2026-03-27) — DOGE block accepted on testnet4alpha via embedded SPV P2P, no dogecoind RPC needed
 >
 > **First V36 Twin Block:** LTC [#3085349](https://blockchair.com/litecoin/block/3085349) + DOGE [#6154761](https://blockchair.com/dogecoin/block/6154761) (2026-04-05) — simultaneous LTC+DOGE block found by v36-signalling nodes running p2pool v36 producing V35 shares with `desired_version=36`; detected and displayed by c2pool's embedded block scanner
+>
+> **Sharechain Transparency Explorer** (2026-04-07) — defragmenter-style sharechain visualization with interactive PPLNS treemaps, animated hover effects, per-miner LTC+DOGE payout breakdown, V36 upgrade pressure for V35 miners
 
 ---
 

config/c2pool_mainnet.yaml

@@ -12,6 +12,7 @@ port: 9326                     # P2P p2pool sharechain port (LTC mainnet default
 stratum_port: 9327             # Stratum mining port
 web_port: 8080                 # Web dashboard / JSON-RPC API port
 http_host: "0.0.0.0"          # HTTP bind address
+external_ip: "voidbind.com"   # Public IP/domain for stratum URL display
 
 # ─── Operating Mode ────────────────────────────────────────────────────────
 # integrated: true             # Full P2P pool (DEFAULT)

src/c2pool/c2pool_refactored.cpp

@@ -281,6 +281,28 @@ class CoinBroadcaster
         return static_cast<int>(m_peers.size());
     }
 
+    /// Return per-peer info JSON array (daemon-style getpeerinfo).
+    nlohmann::json get_peer_info() const
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        nlohmann::json arr = nlohmann::json::array();
+        for (const auto& [key, peer] : m_peers) {
+            arr.push_back({
+                {"addr", key},
+                {"version", peer->node_p2p.peer_version()},
+                {"subver", peer->node_p2p.peer_subver()},
+                {"services", peer->node_p2p.peer_services()},
+                {"startingheight", peer->node_p2p.peer_start_height()},
+                {"conntime", peer->node_p2p.peer_uptime_sec()},
+                {"inbound", false},  // broadcaster only makes outbound connections
+                {"connected", peer->node_p2p.peer_version() > 0}
+            });
+        }
+        return arr;
+    }
+
+    const std::string& symbol() const { return m_symbol; }
+
     /// Request a full block (MSG_MWEB_BLOCK) from all peers via getdata.
     /// Used after a chain reorg to re-fetch MWEB state for the new tip.
     void request_full_block(const uint256& block_hash)
@@ -299,6 +321,24 @@ class CoinBroadcaster
         }
     }
 
+    /// Request a block via plain MSG_BLOCK (0x02) from all peers.
+    /// Works for any block in the chain regardless of MWEB/witness support.
+    void request_block_plain(const uint256& block_hash)
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        int sent = 0;
+        for (auto& [key, peer] : m_peers) {
+            try {
+                peer->node_p2p.request_block(block_hash);
+                ++sent;
+            } catch (...) {}
+        }
+        if (sent > 0) {
+            LOG_INFO << "[" << m_symbol << "] Block (MSG_BLOCK) requested from "
+                     << sent << " peer(s): " << block_hash.GetHex().substr(0, 16) << "...";
+        }
+    }
+
     /// Send getheaders to all connected peers using the supplied block locator.
     /// Used by the embedded node to request initial header sync after seeding genesis.
     void request_headers(const std::vector<uint256>& locator, const uint256& stop_hash)
@@ -321,7 +361,6 @@ class CoinBroadcaster
                  << (locator.empty() ? "" : " tip=" + locator.front().GetHex().substr(0, 16) + "...");
     }
 
-    const std::string& symbol() const { return m_symbol; }
     CoinPeerManager& peer_manager() { return m_peer_manager; }
 
 private:

src/c2pool/merged/coin_broadcaster.hpp

@@ -1658,6 +1658,7 @@ void MergedMiningManager::record_discovered_block(
                             std::chrono::system_clock::now().time_since_epoch()).count();
     blk.accepted       = accepted;
     blk.coinbase_value = chain.current_work.coinbase_value;
+    blk.is_local       = true;  // our own submission
 
     m_discovered_blocks.push_back(std::move(blk));
     m_blocks_per_chain[chain.config.chain_id]++;
@@ -1722,6 +1723,20 @@ void MergedMiningManager::add_discovered_block(const DiscoveredMergedBlock& blk)
              << " hash=" << blk.block_hash.substr(0, 16);
 }
 
+void MergedMiningManager::update_block_coinbase(const std::string& block_hash, uint64_t coinbase_value)
+{
+    std::lock_guard<std::recursive_mutex> lock(m_mutex);
+    for (auto& blk : m_discovered_blocks) {
+        if (blk.block_hash == block_hash) {
+            blk.coinbase_value = coinbase_value;
+            LOG_INFO << "[MM:" << blk.symbol << "] Coinbase updated: height=" << blk.height
+                     << " value=" << coinbase_value << " (" << (coinbase_value / 1e8) << " "
+                     << blk.symbol << ")";
+            return;
+        }
+    }
+}
+
 std::vector<MergedMiningManager::ChainInfo> MergedMiningManager::get_chain_infos() const
 {
     std::lock_guard<std::recursive_mutex> lock(m_mutex);

src/c2pool/merged/merged_mining.cpp

@@ -153,6 +153,9 @@ struct DiscoveredMergedBlock
     int64_t     timestamp{0};     // unix epoch seconds
     bool        accepted{true};   // RPC returned success
     uint64_t    coinbase_value{0}; // aux block reward in satoshis
+    bool        is_local{false};  // true = our own submission, false = detected from peer share
+    uint32_t    parent_height{0}; // parent (LTC) block height (absheight)
+    std::string miner;            // miner address who found the block
 };
 
 // ─── Integrated Merged Mining Manager ────────────────────────────────────────
@@ -243,6 +246,8 @@ class MergedMiningManager
     uint64_t get_chain_block_count(uint32_t chain_id) const;
     // Add externally discovered block (e.g. from peer share scan)
     void add_discovered_block(const DiscoveredMergedBlock& blk);
+    // Update coinbase_value on a discovered block (after fetching full block from P2P)
+    void update_block_coinbase(const std::string& block_hash, uint64_t coinbase_value);
 
     // Per-chain config snapshots (for REST)
     struct ChainInfo {

src/c2pool/merged/merged_mining.hpp

@@ -198,5 +198,154 @@ class FoundBlockStore {
     }
 };
 
+/// Persistent record for a discovered merged block (DOGE etc).
+/// Uses key prefix "mblk:" — never pruned.
+struct MergedBlockRecord {
+    uint32_t    chain_id{0};
+    std::string symbol;
+    int         height{0};
+    std::string block_hash;
+    std::string parent_hash;
+    int64_t     timestamp{0};
+    bool        accepted{true};
+    uint64_t    coinbase_value{0};
+    bool        is_local{false};
+    uint32_t    parent_height{0};
+    std::string miner;
+
+    std::vector<uint8_t> serialize() const
+    {
+        PackStream ps;
+        uint8_t version = 1;
+        ps << version;
+        ps << chain_id;
+        uint8_t sym_len = static_cast<uint8_t>(std::min(symbol.size(), size_t(31)));
+        ps << sym_len;
+        ps.write(std::span<const std::byte>(
+            reinterpret_cast<const std::byte*>(symbol.data()), sym_len));
+        ps << static_cast<uint32_t>(height);
+        uint8_t bh_len = static_cast<uint8_t>(std::min(block_hash.size(), size_t(255)));
+        ps << bh_len;
+        ps.write(std::span<const std::byte>(
+            reinterpret_cast<const std::byte*>(block_hash.data()), bh_len));
+        uint8_t ph_len = static_cast<uint8_t>(std::min(parent_hash.size(), size_t(255)));
+        ps << ph_len;
+        ps.write(std::span<const std::byte>(
+            reinterpret_cast<const std::byte*>(parent_hash.data()), ph_len));
+        ps << static_cast<uint64_t>(timestamp);
+        uint8_t flags = (accepted ? 1 : 0) | (is_local ? 2 : 0);
+        ps << flags;
+        ps << coinbase_value;
+        ps << parent_height;
+        uint8_t mn_len = static_cast<uint8_t>(std::min(miner.size(), size_t(255)));
+        ps << mn_len;
+        if (mn_len > 0)
+            ps.write(std::span<const std::byte>(
+                reinterpret_cast<const std::byte*>(miner.data()), mn_len));
+
+        auto span = ps.get_span();
+        return {reinterpret_cast<const uint8_t*>(span.data()),
+                reinterpret_cast<const uint8_t*>(span.data()) + span.size()};
+    }
+
+    static MergedBlockRecord deserialize(const std::vector<uint8_t>& data)
+    {
+        MergedBlockRecord rec;
+        if (data.size() < 4) return rec;
+        size_t pos = 0;
+        auto read_u8 = [&]() -> uint8_t { return pos < data.size() ? data[pos++] : 0; };
+        auto read_u32 = [&]() -> uint32_t {
+            if (pos + 4 > data.size()) return 0;
+            uint32_t v; std::memcpy(&v, &data[pos], 4); pos += 4; return v;
+        };
+        auto read_u64 = [&]() -> uint64_t {
+            if (pos + 8 > data.size()) return 0;
+            uint64_t v; std::memcpy(&v, &data[pos], 8); pos += 8; return v;
+        };
+        auto read_str = [&](uint8_t len) -> std::string {
+            if (pos + len > data.size()) { pos = data.size(); return ""; }
+            std::string s(reinterpret_cast<const char*>(&data[pos]), len);
+            pos += len; return s;
+        };
+
+        uint8_t version = read_u8();
+        if (version != 1) return rec;
+        rec.chain_id = read_u32();
+        rec.symbol = read_str(read_u8());
+        rec.height = static_cast<int>(read_u32());
+        rec.block_hash = read_str(read_u8());
+        rec.parent_hash = read_str(read_u8());
+        rec.timestamp = static_cast<int64_t>(read_u64());
+        uint8_t flags = read_u8();
+        rec.accepted = (flags & 1) != 0;
+        rec.is_local = (flags & 2) != 0;
+        rec.coinbase_value = read_u64();
+        rec.parent_height = read_u32();
+        rec.miner = read_str(read_u8());
+        return rec;
+    }
+};
+
+/// LevelDB-backed persistent store for discovered merged blocks.
+/// Uses key prefix "mblk:" — shares the same LevelDB as found blocks.
+class MergedBlockStore {
+public:
+    explicit MergedBlockStore(core::LevelDBStore& store) : m_store(store) {}
+
+    bool store(const MergedBlockRecord& rec)
+    {
+        auto key = make_key(rec.chain_id, rec.height, rec.block_hash);
+        return m_store.put(key, rec.serialize());
+    }
+
+    bool update_coinbase(const std::string& block_hash, uint32_t chain_id, uint64_t coinbase_value)
+    {
+        auto keys = m_store.list_keys("mblk:", 1000);
+        for (const auto& key : keys) {
+            std::vector<uint8_t> data;
+            if (!m_store.get(key, data)) continue;
+            auto rec = MergedBlockRecord::deserialize(data);
+            if (rec.block_hash == block_hash && rec.chain_id == chain_id) {
+                rec.coinbase_value = coinbase_value;
+                return m_store.put(key, rec.serialize());
+            }
+        }
+        return false;
+    }
+
+    std::vector<MergedBlockRecord> load_all()
+    {
+        std::vector<MergedBlockRecord> result;
+        auto keys = m_store.list_keys("mblk:", 10000);
+        for (const auto& key : keys) {
+            std::vector<uint8_t> data;
+            if (m_store.get(key, data)) {
+                auto rec = MergedBlockRecord::deserialize(data);
+                if (!rec.block_hash.empty())
+                    result.push_back(std::move(rec));
+            }
+        }
+        std::sort(result.begin(), result.end(),
+            [](const MergedBlockRecord& a, const MergedBlockRecord& b) {
+                return a.timestamp > b.timestamp;
+            });
+        return result;
+    }
+
+    size_t count() { return m_store.list_keys("mblk:", 10000).size(); }
+
+private:
+    core::LevelDBStore& m_store;
+
+    static std::string make_key(uint32_t chain_id, int height, const std::string& block_hash)
+    {
+        std::ostringstream oss;
+        oss << "mblk:" << chain_id << ":"
+            << std::setfill('0') << std::setw(12) << height << ":"
+            << block_hash.substr(0, 16);
+        return oss.str();
+    }
+};
+
 } // namespace storage
 } // namespace c2pool