dash(mint 3/3): run-loop share minting — ShareAccept -> tracker insert + broadcast + PPLNS weights

[frstrtr]

Slice 3/3 of the DASH sharechain-MINT campaign: the run-loop wiring that makes c2pool-dash --run actually MINT legacy v16 shares onto the p2pool-dash sharechain — ShareAccept -> producer rebuild -> tracker insert -> peer broadcast, with best-share election and the PPLNS window bound into the coinbase. Enables PPLNS payouts and is the prerequisite for joining the live p2pool-dash network.

Re-verified gap delta (vs the earlier assessment)

• Slice 2 was NOT on master. share_producer_bind.hpp (+ its 5 KATs) sat unmerged on dash/s8-share-producer-mint-bind with no PR. The two commits are included here (cherry-picked, unchanged) — this PR stacks on them.
• (b) think(): the tracker half already existed — ShareTracker::think() (P1 verify walk / P2 budgeted verify / scoring) is fully implemented on master. What was missing was the NODE-side driver: run_think(), m_best_share_hash publication, the pending-adds drain, and any caller. All added.
• (a) mint seam, (c) broadcast/forward leg, (d) storage construction, (e) PPLNS weights binding — all still missing on master; all built here.
• Two additional blocking gaps found during re-verification, both fixed:
  • the DASH node NEVER SENT its own version message (no connected() override / send_version) — a p2pool-dash peer drops the link on handshake timeout, so reception alone could not hold a session; send_ping was also a stub;
  • nothing set tracker.m_coin_params (X11 pow_func) — reception verify would run with an empty pow function and reject every share.

What was built

Byte-parity architecture (the ban-safety keystone): when the producer seam is bound, the stratum coinbase served to miners IS the producer share gentx (producer::build_gentx), split verbatim around the zeroed nonce64 slot. The mint-time rebuild (build_mint_share, slice 2) re-runs the identical deterministic producer walks (all anchored backward from the frozen prev_share_hash), so the rebuilt share reproduces the solved header bytes exactly — ONE gentx serializer, byte-parity by construction rather than by parallel-implementation parity. Fail-closed gates stack: frozen-job registry miss (ref_hash recovered from the coinb1 tail), the slice-2 X11 identity gate, and a new explicit pow <= committed m_bits target guard so a stratum share-bits race can never mint a share peers would ban over.

• src/impl/dash/mint_runloop.hpp — build_producer_job, FrozenJobRegistry, mint_from_inputs (ban-safety gate), elect_best_share (verified-accumulated-work-first; KAT-able pure function), pplns_weights_for (ORACLE window: grandparent start, data.py:181), fee policy (below).
• src/impl/dash/node.{hpp,cpp} — run_think + election + snapshot publication; broadcast_share/send_shares (message_shares codec + remember_tx/forget_tx tx forwarding); connected()/send_version (+ real ping); SharechainStorage construction + reload + verified-mark/removal persistence + batch share persist; add_local_share; register_template_txs.
• src/impl/dash/stratum/work_source.{hpp,cpp} — ProducerJobFn seam (byte-unchanged fallback path when unbound); MintShareInputs extended with ref_hash / last_txout_nonce / tx_data.
• src/c2pool/main_dash.cpp — full --run wiring: coin-params + storage init, best-share fn, producer-job fn (per-job cache to keep notify bytes stable + the registry within its window), mint fn, PPLNS weights fn, work-refresh on best change, initial + 15 s think tick, shutdown flush.

Fee flags (README design, LTC sharechain-lane port): --give-author (default 0.1%) -> the share's donation u16 (oracle dev-fee channel; PPLNS weights decay by att*(65535-donation); the donation output is ALWAYS emitted by the gentx — --give-author 0 keeps the dust-marker output present). -f/--fee + --node-owner-address -> the consensus-safe probabilistic identity substitution (~fee% of minted shares carry the owner's pubkey_hash; identical coinbases on every peer). --redistribute fee|donate for non-P2PKH miner credentials (donate = donation=65535, the pubkey-hash-keyed DASH form of 100%-to-donation); the LTC weighted pplns|boost redistribution engine is NOT yet ported — those decline fail-closed (the pre-existing behavior), reported as a follow-up. The pre-v36 donation script stays dash::DONATION_SCRIPT (what the live v16 network verifies); the v36 COMBINED-script migration surface (compute_dash_payouts version gate) is untouched — when the crossing slice lands, producer::build_gentx needs the same share-version gate (flagged, not silently wrong: this slice mints v16 only by construction).

STOPPED on (honest gaps, loudly logged — not half-wired)

• Desired-share DOWNLOAD leg (p2pool node.py download loop): think()'s desired set is logged, not requested. Reception can serve peers (handle_get_share), but filling OUR gaps beyond what peers push rides a later slice — required for a cold-start sync against the live network.
• Peer ban list + rejected-share tracking (btc m_ban_list/m_rejected_share_hashes): bad-share peers are logged, not banned.
• pplns/boost redistribute engine — LTC's weighted redistribution not yet ported (declines fail-closed).
• clean_tracker/prune driver on the DASH node (tracker-side machinery exists; the periodic prune caller is a later slice — bounded exposure while chains are short).

KATs (11 new, in the existing allowlisted test_dash_share_hash_link target; 40/40 green)

Full pipeline with REAL X11 nonce searches: ShareAccept mints a share that passes the in-tree verifier and whose hash IS the solved header PoW; message_shares codec round-trip byte-identical + peer-side re-verify to the same hash; tracker insert + get_shares walk; heaviest-verified-head election (+ refusal with peers-but-no-verified-chain); PPLNS oracle-window pin (grandparent start, tip's miner excluded, hand-computed weights); ban-safety decline of an above-target solve (isolated to the target gate via mainnet params); registry fail-closed + FIFO bound; donation u16 mapping; fee-roll/redistribute identity resolution; the combined --fee 1 --give-author 0 split (owner identity + donation 0 + donation output PRESENT); oracle weight decay att*(65535-donation).

Verification

• test_dash_share_hash_link 40/40 (slice-1 + slice-2 + slice-3 KATs); all 17 affected dash test targets rebuilt + green (node, tracker, work_source x4, stratum x4, p2p_node, peer, messages x2, reception wire, auto_ratchet, min_protocol_gate, conformance 56/56).
• c2pool-dash --selftest OK; 20 s --run --testnet smoke: listener + stratum up, think tick live, clean shutdown with persistence flush.
• Fenced to src/impl/dash/ + main_dash.cpp + dash test files; no core/other-coin source edits; dashd-RPC fallback untouched.

Byte-parity confidence vs the oracle

The producer core (slice 1) is hand-traced from frstrtr/p2pool-dash with oracle-pinned KATs; slice 3 adds no second serializer — the mint reuses the producer end-to-end and self-verifies through the in-tree verifier plus the X11 identity + target gates, so a diverging share CANNOT reach the tracker or the wire (it declines instead). What KATs cannot prove is live-oracle ACCEPTANCE semantics (e.g. tx-forwarding expectations of a real peer, timestamp/donation edge tolerances) — the next step is a controlled soak against a p2pool-dash testnet peer (available on request) BEFORE pointing at mainnet: connect, mint on the live tip, and confirm the oracle keeps the session + tracks our share.

Remaining gap to a live p2pool-dash JOIN

1. Controlled-peer soak (above) — the acceptance evidence gate.
2. The desired-share download leg (cold-start sync).
3. Outbound dial machinery exists via bootstrap addrs; addnode/connect reach the addr store and inbound handshakes now complete both ways — verify a sustained outbound session against the controlled peer.
4. Ban list + clean_tracker driver (robustness under long uptime).