Fix system-TX inclusion (heartbeat/activation) + decouple identity from region

Producer sites classified system TXs via drifted inline lists instead of the
canonical Transaction::is_system_tx(). NodeActivation/Heartbeat/NodeReactivation
were treated as user TXs and dropped by the user-only ParallelExecutor, so they
never reached a block: heartbeats were never tallied (no liveness -> no emission)
and super-node activation never applied (the pre-activation sync gate stayed
closed). Route all three producer sites (node.rs 18167/18249/19096) through
is_system_tx().

- generate_super_node_pseudonym no longer embeds QNET_REGION: the sync gate
  recomputes the id per-peer, so a region mismatch made one wallet resolve to two
  different ids and the gate never opened.
- Drop geo-IP region auto-detection at boot; region is now an inert constant with
  no consensus/topology/port role (ports come from QNET_P2P_PORT/DOCKER_ENV).
- Activation client logs on_chain_inclusion=pending instead of a false
  "registered successfully" (it only confirms broadcast).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: AIQnetLab

development/qnet-integration/src/activation_validation.rs

@@ -888,7 +888,9 @@ impl BlockchainActivationRegistry {
 
         // NOTE: DHT propagation removed - activation syncs through blockchain and ReputationSync
 
-        println!("✅ Activation registered on blockchain successfully");
+        // Local record only — the NodeActivation TX is broadcast separately and its
+        // on-chain inclusion is NOT confirmed here (verify via node/status before trusting).
+        println!("[INFO][ACTIVATION] activation_recorded_local on_chain_inclusion=pending");
         Ok(())
     }
 

development/qnet-integration/src/bin/qnet-node.rs

@@ -1213,44 +1213,10 @@ impl AutoConfig {
     async fn new() -> Result<Self, Box<dyn std::error::Error>> {
         println!("🔧 Auto-configuring QNet node...");
 
-        // PRODUCTION FIX: Allow region override for Genesis nodes to ensure stable P2P ports
-        let region = if let Ok(region_str) = std::env::var("QNET_REGION") {
-            match region_str.to_lowercase().as_str() {
-                "na" | "northamerica" | "north_america" => {
-                    println!("🌍 Using fixed region from QNET_REGION: North America");
-                    Region::NorthAmerica
-                },
-                "eu" | "europe" => {
-                    println!("🌍 Using fixed region from QNET_REGION: Europe");
-                    Region::Europe
-                },
-                "asia" | "ap" | "asia_pacific" => {
-                    println!("🌍 Using fixed region from QNET_REGION: Asia");
-                    Region::Asia
-                },
-                "sa" | "southamerica" | "south_america" => {
-                    println!("🌍 Using fixed region from QNET_REGION: South America");
-                    Region::SouthAmerica
-                },
-                "africa" | "af" => {
-                    println!("🌍 Using fixed region from QNET_REGION: Africa");
-                    Region::Africa
-                },
-                "oceania" | "oc" => {
-                    println!("🌍 Using fixed region from QNET_REGION: Oceania");
-                    Region::Oceania
-                },
-                _ => {
-                    println!("⚠️ Unknown QNET_REGION: {}, auto-detecting...", region_str);
-                    auto_detect_region().await?
-                }
-            }
-        } else {
-            // Auto-detect region if not specified
-            let region = auto_detect_region().await?;
-            println!("🌍 Auto-detected region: {:?}", region);
-            region
-        };
+        // Region is a vestigial cosmetic tag (no consensus/topology/port role) — fixed
+        // default, no QNET_REGION read, no geo-IP detection at boot. P2P ports come from
+        // QNET_P2P_PORT / DOCKER_ENV below, never from region.
+        let region = Region::Europe;
 
         // PRODUCTION FIX: Use fixed P2P port from environment for Docker deployments
         // This ensures Docker port mapping works correctly

development/qnet-integration/src/node.rs

@@ -5923,9 +5923,9 @@ impl BlockchainNode {
 
     /// Create a new blockchain node with default settings (backward compatibility)
     pub async fn new(data_dir: &str, p2p_port: u16, bootstrap_peers: Vec<String>) -> Result<Self, QNetError> {
-        // Production region detection - no defaults allowed
-        let region = Self::auto_detect_region().await
-            .map_err(|e| QNetError::NetworkError(format!("Region detection failed: {}", e)))?;
+        // Region is a vestigial cosmetic tag (no consensus/topology role) — fixed
+        // default, no geo-IP/network detection at boot.
+        let region = Region::Europe;
 
         Self::new_with_config(
             data_dir,
@@ -18161,14 +18161,10 @@ impl BlockchainNode {
                             // v2.87: System TX bypass nonce/balance validation
                             // HeartbeatCommitment/PingCommitment are validator rewards - MUST be included!
                             // v2.89: LightNodeEligibilityBitmap (Genesis bitmap TX)
-                            let is_system_tx = tx.from == "system_emission"
-                                || tx.from == "system_ping_commitment"
-                                || tx.from.starts_with("system_")
-                                || matches!(tx.tx_type, qnet_state::TransactionType::NodeRegistration { .. })
-                                || matches!(tx.tx_type, qnet_state::TransactionType::NodeReactivation { .. })
-                                || matches!(tx.tx_type, qnet_state::TransactionType::HeartbeatCommitment { .. })
-                                || matches!(tx.tx_type, qnet_state::TransactionType::PingCommitmentWithSampling { .. })
-                                || matches!(tx.tx_type, qnet_state::TransactionType::LightNodeEligibilityBitmap { .. });
+                            // Canonical system-TX predicate (single source of truth in qnet-state) +
+                            // system_* sender net. Inline lists here had drifted and silently dropped
+                            // NodeActivation/NodeReactivation from blocks (super-node onboarding stall).
+                            let is_system_tx = tx.is_system_tx() || tx.from.starts_with("system_");
 
                             let (is_valid, reject_reason) = if is_benchmark || is_system_tx {
                                 // Benchmark OR System TX: skip balance/nonce validation
@@ -18246,13 +18242,11 @@ impl BlockchainNode {
                             // v2.68: Separate system TX from user TX
                             // v2.71: NodeRegistration is also system TX (no state execution needed)
                             // v2.87: HeartbeatCommitment/PingCommitment are validator reward TX
-                            let is_system = tx.from == "system_emission"
-                                || tx.from == "system_ping_commitment"
-                                || tx.from.starts_with("system_")
-                                || matches!(tx.tx_type, qnet_state::TransactionType::NodeRegistration { .. })
-                                || matches!(tx.tx_type, qnet_state::TransactionType::HeartbeatCommitment { .. })
-                                || matches!(tx.tx_type, qnet_state::TransactionType::PingCommitmentWithSampling { .. })
-                                || matches!(tx.tx_type, qnet_state::TransactionType::LightNodeEligibilityBitmap { .. });
+                            // Canonical system-TX predicate (single source of truth) → route to
+                            // system_txs so it bypasses the user-only ParallelExecutor, which drops
+                            // anything it doesn't recognise → empty body. The inline list here had
+                            // dropped Heartbeat (no liveness tally) AND NodeActivation (no onboarding).
+                            let is_system = tx.is_system_tx() || tx.from.starts_with("system_");
 
                             // v15.12: state-aware producer dedup (closes the cross-block gap). The
                             // v15.5 filter only deduped WITHIN a block; a commitment already
@@ -19095,18 +19089,12 @@ impl BlockchainNode {
                                         qnet_state::TransactionType::NodeRegistration { .. }
                                     ) && tx.data.as_deref().unwrap_or("").starts_with("client_node_reg:");
 
-                                    let is_system_tx = !is_client_nodereg && (
-                                        tx.from == "system_emission"
-                                        || tx.from == "system_ping_commitment"
-                                        || tx.from.starts_with("system_")
-                                        || matches!(tx.tx_type,
-                                            qnet_state::TransactionType::HeartbeatCommitment { .. } |
-                                            qnet_state::TransactionType::PingCommitmentWithSampling { .. } |
-                                            qnet_state::TransactionType::LightNodeEligibilityBitmap { .. } |
-                                            qnet_state::TransactionType::RewardDistribution { .. } |
-                                            qnet_state::TransactionType::NodeRegistration { .. }
-                                        )
-                                    );
+                                    // Canonical system-TX predicate (single source of truth) + system_*
+                                    // net. Client-signed NodeRegistration stays NON-system so its
+                                    // Ed25519+Dilithium are verified below. The inline list had dropped
+                                    // NodeActivation → activation TX rejected → super-node never onboards.
+                                    let is_system_tx = !is_client_nodereg
+                                        && (tx.is_system_tx() || tx.from.starts_with("system_"));
 
                                     if is_system_tx {
                                         // System TX: only basic validation (no signature/amount check)

development/qnet-integration/src/rpc.rs

@@ -12473,17 +12473,11 @@ pub fn generate_super_node_pseudonym(wallet_address: &str) -> String {
     // independent pseudonyms in the two namespaces.
     let pseudonym_hash = blake3::hash(format!("SUPER_NODE_PRIVACY_{}", wallet_address).as_bytes());
 
-    // PRIVACY: Region hint is a coarse operational tag (eu / us / asia / …).
-    // Default "node" keeps the pseudonym deterministic when QNET_REGION is
-    // unset; operators can override per deployment without affecting the
-    // wallet-derived suffix.
-    let region_hint = std::env::var("QNET_REGION")
-        .unwrap_or_else(|_| "node".to_string())
-        .to_lowercase();
-
-    format!("super_{}_{}",
-            region_hint,
-            &pseudonym_hash.to_hex()[..8])
+    // Identity MUST be region-independent: it is recomputed on every node (the P2P
+    // pre-activation sync gate compares this id), so it cannot depend on a per-node env
+    // var — a region mismatch would make the same wallet resolve to two different ids and
+    // the gate would never open. Fixed "node" segment preserves the historical format.
+    format!("super_node_{}", &pseudonym_hash.to_hex()[..8])
 }
 
 /// Extract peer IP from HTTP headers (PRODUCTION ready)