Fix 3 critical consensus bugs: Scrypt diff, canonical coinbase, DOGE P2P port

1. DUMB_SCRYPT_DIFF (65536) missing from mining.set_difficulty.
   Scrypt miners received raw difficulty (0.005) instead of scaled (327).
   Miners showed Diff=0, submitted everything, 80% rejection, 0 real shares.

2. Canonical merged coinbase strings must match p2pool for consensus:
   scriptSig: "/c2pool/" -> "/P2Pool/"
   OP_RETURN: "c2pool merged mining" -> "P2Pool merged mining"
   Mismatch caused 426 merkle_root failures per session on every peer share.

3. DOGE testnet P2P port: 44556 (RPC) -> 44557 (P2P).
   CoinBroadcaster connected to RPC port, got non-P2P data, disconnected
   with "prefix doesn't match" on every attempt.

Also: multiaddress PPLNS tests, embedded fallback wiring, FUTURE.md updates.

Author: frstrtr

docs/FUTURE.md

@@ -257,6 +257,131 @@ commitment chain is already established on the blockchain.
 
 ---
 
+## Multi-Parent Chain Architecture (LTC + DGB Simultaneous Operation)
+
+### Overview
+
+c2pool can serve both Litecoin and DigiByte Scrypt as parent chains simultaneously.
+Each parent chain runs its own independent P2Pool sharechain network with separate
+ports and validation rules.
+
+### Deployment Models
+
+#### Model A: Two Processes (recommended for first release)
+
+Two independent c2pool instances, each handling one parent chain. Zero code changes
+required — works today.
+
+```
+# Instance 1: LTC parent + DOGE/PEP/BELLS merged mining
+c2pool --integrated --net litecoin \
+  --p2pool-port 9326 --worker-port 9327 --web-port 8080 \
+  --coind-address 127.0.0.1 --coind-rpc-port 9332 --coind-p2p-port 9333 \
+  --merged DOGE:98:127.0.0.1:22555:user:pass \
+  --merged PEP:63:127.0.0.1:33874:user:pass
+
+# Instance 2: DGB parent + DOGE/PEP/BELLS merged mining
+c2pool --integrated --net digibyte \
+  --p2pool-port 5024 --worker-port 5025 --web-port 8081 \
+  --coind-address 127.0.0.1 --coind-rpc-port 14024 --coind-p2p-port 12024 \
+  --merged DOGE:98:127.0.0.1:22555:user:pass \
+  --merged PEP:63:127.0.0.1:33874:user:pass
+```
+
+Miners connect to port 9327 for LTC mining, port 5025 for DGB mining.
+
+**Port allocation:**
+
+| Service | LTC Instance | DGB Instance |
+|---------|-------------|-------------|
+| P2Pool P2P | 9326 | 5024 |
+| Stratum (miners) | 9327 | 5025 |
+| Web dashboard | 8080 | 8081 |
+
+**Pros:** Simple, crash-isolated, independent restarts, no code changes.
+**Cons:** Duplicate memory for shared state, separate dashboards, merged mining
+daemons contacted independently from each instance.
+
+#### Model B: Single Process, Multiple Networks (future optimization)
+
+One c2pool process hosting both parent chain networks. Shares a single `io_context`,
+`MergedMiningManager`, and web dashboard.
+
+```
+c2pool --integrated \
+  --net litecoin --worker-port 9327 --p2pool-port 9326 \
+  --net digibyte --worker-port 5025 --p2pool-port 5024 \
+  --merged DOGE:98:127.0.0.1:22555:user:pass \
+  --web-port 8080
+```
+
+**Architecture changes required:**
+
+1. **CLI parser** — allow multiple `--net` flags, each followed by its own
+   `--worker-port` and `--p2pool-port`. Current parser stores a single
+   `blockchain` variable; needs a vector of network configs.
+
+2. **EnhancedNode instantiation** — create one `EnhancedNode` per parent chain,
+   each with its own `StratumServer`, `ShareChain`, and `P2PNode`. Currently
+   `c2pool_refactored.cpp` creates exactly one.
+
+3. **Shared MergedMiningManager** — both parent chains submit aux work to the
+   same merged mining daemon. When either LTC or DGB finds a share meeting an
+   aux chain's target, it submits the merged block. DOGE blocks get found from
+   both LTC and DGB Scrypt work simultaneously, increasing aux chain hit rate.
+
+4. **Unified web dashboard** — single HTTP server on one port, with per-network
+   API prefix (`/api/ltc/stats`, `/api/dgb/stats`) and a combined overview page.
+
+5. **Shared io_context** — both networks run on the same Boost.ASIO thread pool,
+   reducing thread overhead.
+
+**Pros:** Single dashboard, shared merged mining state (DOGE contacted once, not
+twice), lower memory footprint, simpler operations.
+**Cons:** More complex startup/shutdown, single process crash affects both chains.
+
+### Merged Mining Overlap
+
+Both LTC and DGB are Scrypt chains that can merge-mine the same aux coins.
+When running both parent chains simultaneously, the merged mining situation:
+
+| Aux Coin | Merged via LTC | Merged via DGB | Notes |
+|----------|---------------|---------------|-------|
+| DOGE (chain_id=98) | Yes | Yes | Both parents submit DOGE blocks independently |
+| PEP (chain_id=63) | Yes | Yes | |
+| BELLS (chain_id=16) | Yes | Yes | |
+| LKY (chain_id=8211) | Yes | Yes | |
+| JKC (chain_id=8224) | Yes | Yes | |
+| SHIC (chain_id=74) | Yes | Yes | |
+| DINGO (chain_id=98) | Conflicts with DOGE | Conflicts with DOGE | Same chain_id, pick one |
+
+**Important:** Running both parents effectively doubles the hashrate attacking
+aux chain targets, since both LTC and DGB share submissions are evaluated against
+each aux chain's difficulty. This is especially valuable for low-difficulty aux
+chains where even DGB's smaller hashrate regularly finds blocks.
+
+### DGB Node Embedding Decision
+
+**Not planned.** DGB does NOT need embedded SPV because:
+
+- DGB is a parent chain, not an aux chain — miners need full `digibyte-core` for
+  `getblocktemplate` anyway
+- DOGE embedding was justified by DOGE being 73% of combined LTC+DOGE revenue
+  and requiring a 50GB+ blockchain sync
+- DGB miners are dedicated DGB miners who already run the full node
+- Embedding effort (header sync, fork handling, difficulty validation) is the same
+  as DOGE but benefits 100x fewer users
+
+### Implementation Phases
+
+| Phase | Scope | Effort |
+|-------|-------|--------|
+| **Now** | Model A (two processes) | Zero — works today |
+| **Next** | Unified web dashboard proxy | Small — nginx/traefik reverse proxy config |
+| **Later** | Model B (single process) | Medium — CLI parser + multi-EnhancedNode |
+
+---
+
 ## Stratum Protocol Enhancements (from p2pool-merged-v36)
 
 ### `mining.ping` — Not Started

src/c2pool/c2pool_refactored.cpp

@@ -41,6 +41,16 @@
 #include <c2pool/storage/sharechain_storage.hpp>
 #include <c2pool/storage/found_block_store.hpp>
 #include <c2pool/payout/payout_manager.hpp>
+#include <execinfo.h>  // for backtrace()
+
+static void segfault_handler(int sig) {
+    void* frames[64];
+    int n = backtrace(frames, 64);
+    fprintf(stderr, "\n=== SEGFAULT (signal %d) ===\n", sig);
+    backtrace_symbols_fd(frames, n, STDERR_FILENO);
+    fprintf(stderr, "=== END SEGFAULT ===\n");
+    _exit(128 + sig);
+}
 
 // Integrated merged mining
 #include <c2pool/merged/merged_mining.hpp>
@@ -267,6 +277,7 @@ int main(int argc, char* argv[]) {
     // Install signal handlers
     std::signal(SIGINT, signal_handler);
     std::signal(SIGTERM, signal_handler);
+    std::signal(SIGSEGV, segfault_handler);
 
     // Initialize logging
     core::log::Logger::init();
@@ -379,7 +390,7 @@ int main(int argc, char* argv[]) {
     // Well-known P2P ports for coin daemons (same machine as RPC by default)
     auto get_coin_p2p_port = [](const std::string& symbol, bool testnet) -> int {
         if (symbol == "LTC"   || symbol == "ltc")   return testnet ? 19335 : 9333;
-        if (symbol == "DOGE"  || symbol == "doge")  return testnet ? 44556 : 22556;
+        if (symbol == "DOGE"  || symbol == "doge")  return testnet ? 44557 : 22556;
         if (symbol == "BTC"   || symbol == "btc")   return testnet ? 18333 : 8333;
         if (symbol == "DGB"   || symbol == "dgb")   return testnet ? 12026 : 12024;
         if (symbol == "PEP"   || symbol == "pep")   return testnet ? 44874 : 33874;
@@ -1137,16 +1148,18 @@ int main(int argc, char* argv[]) {
                      << " payout_window=" << payout_window_seconds << "s"
                      << " save_interval=" << storage_save_interval << "s";
 
+            // io_context needed for block verification timers in all modes
+            web_server.get_mining_interface()->set_io_context(&ioc);
+
             // Wire live coin-daemon RPC so getblocktemplate/submitblock use real data
             if (!embedded_ltc) {
                 web_server.set_coin_rpc(node_rpc.get(), &coin_node);
             } else if (embedded_broadcaster && embedded_chain) {
                 // Wire embedded node + header-sync callback (now that web_server is alive)
                 web_server.set_embedded_node(embedded_node.get());
 
-                // Wire block verification: check header chain for found blocks
+                // Wire block verification for embedded mode
                 auto* mi = web_server.get_mining_interface();
-                mi->set_io_context(&ioc);
 
                 // --- Layer +2: Persistent found block storage ---
                 // Uses a dedicated LevelDB in the network data dir.
@@ -1796,8 +1809,11 @@ int main(int argc, char* argv[]) {
 
             // Wire the ref_hash computation hook for per-connection coinbase generation.
             // This computes the p2pool ref_hash from share fields + tracker state.
+            // Also stores the computed share target so mining.notify and share
+            // creation use the share difficulty (not block difficulty).
+            auto* mi_for_share_bits = web_server.get_mining_interface();
             web_server.get_mining_interface()->set_ref_hash_fn(
-                [&p2p_node, &whale_detector](
+                [&p2p_node, &whale_detector, mi_for_share_bits](
                     const uint256& frozen_prev_share,
                     const std::vector<unsigned char>& coinbase_scriptSig,
                     const std::vector<unsigned char>& payout_script,
@@ -1824,6 +1840,17 @@ int main(int argc, char* argv[]) {
                     params.bits = share_bits;
                     params.timestamp = timestamp;
 
+                    // Store share target for mining.notify and share creation
+                    mi_for_share_bits->m_share_bits.store(share_bits);
+                    mi_for_share_bits->m_share_max_bits.store(share_max_bits);
+                    {
+                        auto st = chain::bits_to_target(share_bits);
+                        double sd = chain::target_to_difficulty(st);
+                        LOG_INFO << "[ShareTarget] share_bits=" << std::hex << share_bits
+                                 << " max_bits=" << share_max_bits << std::dec
+                                 << " share_diff=" << sd;
+                    }
+
                     // Extract pubkey_hash and type from payout_script
                     if (payout_script.size() == 25 &&
                         payout_script[0] == 0x76 && payout_script[1] == 0xa9 &&
@@ -2272,12 +2299,21 @@ int main(int argc, char* argv[]) {
                     auto payouts_map = p2p_node->tracker().get_merged_expected_payouts(
                         best, block_target, coinbase_value, chain_id, donation_script);
 
+                    LOG_INFO << "[MM-payout] chain_id=" << chain_id
+                             << " coinbase_value=" << coinbase_value
+                             << " payouts_map_size=" << payouts_map.size()
+                             << " chain_height=" << p2p_node->tracker().chain.get_height(best)
+                             << " block_target=" << block_target.GetHex().substr(0,16);
+
                     // Convert map → sorted vector for coinbase construction
                     std::vector<std::pair<std::vector<unsigned char>, uint64_t>> result;
                     result.reserve(payouts_map.size());
                     for (auto& [script, amount] : payouts_map) {
                         if (amount >= 1.0)
                             result.emplace_back(script, static_cast<uint64_t>(amount));
+                        else
+                            LOG_WARNING << "[MM-payout] Skipping script (len=" << script.size()
+                                        << ") with amount=" << amount;
                     }
                     // Sort by script for deterministic coinbase ordering
                     std::sort(result.begin(), result.end());