Private sharechain identity: --chain-id, --chain-prefix, --no-persist

Add chain identity to THE metadata for private sharechain support:
  metadata[8-11] = chain_id (0 = public p2pool network)
  metadata[12-15] = chain_prefix (P2P magic, 0 = default for coin)

New CLI flags:
  --chain-id ID        Private chain identifier (hex, e.g. DEADBEEF)
  --chain-prefix PFX   P2P magic prefix (4 hex bytes)
  --no-persist         Create genesis share immediately (for new chains)

Chain identity is embedded in every found block's THE metadata,
allowing blockchain scanners to distinguish between:
  - Public p2pool network (chain_id=0)
  - Private mining pools (chain_id=nonzero)
  - Multiple private chains (different chain_ids)

TheCheckpoint now stores chain_id_val and chain_prefix_val alongside
sharechain state for checkpoint attribution.

TheMetadata layout updated:
  [0]     version
  [1-4]   sharechain_height
  [5-6]   miner_count
  [7]     hashrate_class
  [8-11]  chain_id (NEW)
  [12-15] chain_prefix (NEW, was pool_aps)
  [16-17] share_period
  [18-19] verified_length

Author: frstrtr

src/c2pool/c2pool_refactored.cpp

@@ -220,6 +220,14 @@ void print_help() {
     std::cout << "                            Max 20 chars with merged mining, 64 without\n";
     std::cout << "                            Default: /c2pool/ (c2pool always identified by donation address)\n\n";
 
+    std::cout << "PRIVATE SHARECHAIN:\n";
+    std::cout << "  --chain-id ID             Private chain identifier (hex, e.g. DEADBEEF)\n";
+    std::cout << "                            Default: 0 (public p2pool network)\n";
+    std::cout << "  --chain-prefix PREFIX     P2P magic prefix (4 hex bytes, e.g. C2C2C2C2)\n";
+    std::cout << "                            Default: standard p2pool prefix for the coin\n";
+    std::cout << "  --no-persist              Create genesis share immediately (don't wait for peers)\n";
+    std::cout << "                            Required when starting a new private chain\n\n";
+
     std::cout << "V36 SHARE MESSAGE BLOB (CLI operator control):\n";
     std::cout << "  --message-blob-hex HEX    Encrypted authority-signed message_data blob\n";
     std::cout << "                            to embed in locally created V36 shares\n\n";
@@ -378,6 +386,11 @@ int main(int argc, char* argv[]) {
     // Coinbase scriptSig customization
     std::string coinbase_text;  // --coinbase-text (replaces /c2pool/ tag)
 
+    // Private sharechain
+    uint32_t chain_id = 0;          // 0 = public p2pool network
+    uint32_t chain_prefix = 0;      // 0 = use default p2pool prefix
+    bool no_persist = false;        // create genesis share immediately
+
     // Track which options were explicitly set via CLI so that --config file
     // values only fill in gaps (CLI always wins).
     std::set<std::string> cli_explicit;
@@ -635,6 +648,18 @@ int main(int argc, char* argv[]) {
             coinbase_text = argv[++i];
             cli_explicit.insert("coinbase_text");
         }
+        else if (arg == "--chain-id" && i + 1 < argc) {
+            chain_id = static_cast<uint32_t>(std::stoul(argv[++i], nullptr, 16));
+            cli_explicit.insert("chain_id");
+        }
+        else if (arg == "--chain-prefix" && i + 1 < argc) {
+            chain_prefix = static_cast<uint32_t>(std::stoul(argv[++i], nullptr, 16));
+            cli_explicit.insert("chain_prefix");
+        }
+        else if (arg == "--no-persist") {
+            no_persist = true;
+            cli_explicit.insert("no_persist");
+        }
         // Legacy support for old --port option
         else if (arg == "--port" && i + 1 < argc) {
             p2p_port = std::stoi(argv[++i]);
@@ -1249,7 +1274,7 @@ int main(int argc, char* argv[]) {
                             return arr;
                         },
                         [](const uint256&, uint32_t) -> bool { return true; },
-                        [the_store, mi](const std::string& chain, uint64_t height,
+                        [the_store, mi, chain_id, chain_prefix](const std::string& chain, uint64_t height,
                                         const std::string& hash, uint64_t ts) {
                             c2pool::storage::TheCheckpoint cp;
                             cp.chain = chain; cp.block_height = height;
@@ -1259,6 +1284,8 @@ int main(int argc, char* argv[]) {
                             cp.sharechain_height = work.sharechain_height;
                             cp.miner_count = work.miner_count;
                             cp.hashrate_class = c2pool::TheMetadata::encode_hashrate(work.pool_hashrate);
+                            cp.chain_id_val = chain_id;
+                            cp.chain_prefix_val = chain_prefix;
                             the_store->store(cp);
                             LOG_INFO << "[THE] Checkpoint: " << chain << " height=" << height
                                      << " miners=" << cp.miner_count

src/c2pool/storage/the_checkpoint.hpp

@@ -41,6 +41,8 @@ struct TheCheckpoint {
     std::string block_hash;             // blockchain block hash
     uint64_t    timestamp{0};           // when found
     uint8_t     status{0};              // 0=pending, 1=verified, 2=mismatch
+    uint32_t    chain_id_val{0};        // 0 = public network, nonzero = private chain
+    uint32_t    chain_prefix_val{0};    // P2P magic prefix (0 = default)
 
     std::vector<uint8_t> serialize() const {
         std::vector<uint8_t> out;

src/core/coinbase_builder.hpp

@@ -62,15 +62,20 @@ static constexpr size_t MAX_OPERATOR_TEXT_MM = 20;
 // Maximum operator text without merged mining
 static constexpr size_t MAX_OPERATOR_TEXT_SOLO = 64;
 
+// Public p2pool network chain_id (default — no private chain)
+static constexpr uint32_t PUBLIC_CHAIN_ID = 0;
+static constexpr uint32_t PUBLIC_CHAIN_PREFIX = 0;
+
 /// THE metadata — compact pool state for on-chain commitment
 struct TheMetadata {
     uint8_t  version = C2POOL_PROTOCOL_VERSION;
     uint32_t sharechain_height = 0;    // share chain height at block-find
     uint16_t miner_count = 0;          // unique miners in PPLNS window
     uint8_t  hashrate_class = 0;       // log2(pool_hashrate_in_h_per_s)
+    uint32_t chain_id = PUBLIC_CHAIN_ID;       // 0 = public network, nonzero = private chain
+    uint32_t chain_prefix = PUBLIC_CHAIN_PREFIX; // P2P magic prefix (0 = default)
     uint16_t share_period = 0;         // current share period (seconds)
     uint16_t verified_length = 0;      // verified chain length
-    uint32_t pool_aps_compressed = 0;  // compressed pool attempts/s
     uint32_t reserved = 0;            // future: THE temporal layer flags
 
     /// Pack into bytes (up to max_bytes, truncated from end)
@@ -93,10 +98,10 @@ struct TheMetadata {
         push32(sharechain_height);   // [1-4]
         push16(miner_count);         // [5-6]
         push8(hashrate_class);       // [7]
-        push16(share_period);        // [8-9]
-        push16(verified_length);     // [10-11]
-        push32(pool_aps_compressed); // [12-15]
-        push32(reserved);            // [16-19]
+        push32(chain_id);            // [8-11]  0 = public network
+        push32(chain_prefix);        // [12-15] P2P magic prefix
+        push16(share_period);        // [16-17]
+        push16(verified_length);     // [18-19]
         return out;
     }
 
@@ -107,10 +112,10 @@ struct TheMetadata {
         if (len >= 5) m.sharechain_height = data[1] | (data[2]<<8) | (data[3]<<16) | (data[4]<<24);
         if (len >= 7) m.miner_count = data[5] | (data[6]<<8);
         if (len >= 8) m.hashrate_class = data[7];
-        if (len >= 10) m.share_period = data[8] | (data[9]<<8);
-        if (len >= 12) m.verified_length = data[10] | (data[11]<<8);
-        if (len >= 16) m.pool_aps_compressed = data[12] | (data[13]<<8) | (data[14]<<16) | (data[15]<<24);
-        if (len >= 20) m.reserved = data[16] | (data[17]<<8) | (data[18]<<16) | (data[19]<<24);
+        if (len >= 12) m.chain_id = data[8] | (data[9]<<8) | (data[10]<<16) | (data[11]<<24);
+        if (len >= 16) m.chain_prefix = data[12] | (data[13]<<8) | (data[14]<<16) | (data[15]<<24);
+        if (len >= 18) m.share_period = data[16] | (data[17]<<8);
+        if (len >= 20) m.verified_length = data[18] | (data[19]<<8);
         return m;
     }