Light/reward UX + explorer fixes; light-eligibility restart resilience

Explorer: split LightNodeEligibilityBitmap/ping out of the "Heartbeat"
category into "Light Eligibility"; render tx_type_data on the TX detail
page (epoch/genesis_id/eligible_count); count active light over the last
3 sealed epochs to de-flicker a single intermittent mobile node.

Node RPC status (display-only): pace needs_attention/is_reward_eligible to
elapsed subwindows so a healthy super is not flagged mid-epoch; light flag
from online+recency; drop the fabricated pool breakdown.

Node: persist per-epoch light attestations (zero-padded key, O(1) prune;
rebuilt at boot) so a genesis restart mid-epoch keeps its shard's
eligibility for the boundary bitmap TX — no silent light reward loss.
Distinct skip log when no eligible light (no TX emitted).

App: remove the dead 404 legacy reward path (getNodeRewards / /api/rewards/*)
that would gate light claims at 0 if re-wired; working claim path untouched.

Deferred (need coordinated/fresh-genesis deploy, reward-determinism):
mid-epoch light roster eligibility + ping/reward shard unification.

187 lib tests pass; explorer tsc clean.

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

Author: AIQnetLab

applications/qnet-explorer/frontend/lib/db.ts

@@ -156,7 +156,8 @@ const DISPLAY_TYPE_TO_DB: Record<string, string[]> = {
   'Transfer': ['Transfer', 'BatchTransfers'],
   'Reward': ['RewardDistribution', 'BatchRewardClaims', 'SystemReward', 'SystemRewards', 'SystemEmission', 'Emission', 'Reward'],
   'Swap': ['Swap'],
-  'Heartbeat': ['Heartbeat', 'HeartbeatCommitment', 'PingCommitmentWithSampling', 'LightNodeEligibilityBitmap', 'BitmapCommitment', 'PingAttestation'],
+  'Heartbeat': ['Heartbeat', 'HeartbeatCommitment'],
+  'Light Eligibility': ['LightNodeEligibilityBitmap', 'BitmapCommitment', 'PingAttestation', 'PingCommitmentWithSampling'],
   'Registration': ['NodeRegistration', 'Registration'],
   'Activation': ['NodeActivation', 'BatchNodeActivations'],
   'Contract': ['ContractDeploy', 'ContractCall'],

applications/qnet-explorer/frontend/src/app/api/activity/route.ts

@@ -93,7 +93,7 @@ export async function GET(request: NextRequest) {
     const typesParam = searchParams.get('types');
     let displayTypes: string[] | undefined = undefined;
     if (typesParam) {
-      displayTypes = typesParam.split(',').filter(t => /^[a-zA-Z]+$/.test(t.trim())).map(t => t.trim());
+      displayTypes = typesParam.split(',').map(t => t.trim()).filter(t => /^[a-zA-Z ]+$/.test(t));
       if (displayTypes.length === 0) displayTypes = undefined;
     }
 

applications/qnet-explorer/frontend/src/app/api/blocks/[hash]/route.ts

@@ -30,10 +30,11 @@ function getTransactionType(txType: unknown, fromAddress?: string): string {
       'NodeActivation': 'Activation',
       'RewardDistribution': 'Reward',
       'CreateAccount': 'System',
-      'PingAttestation': 'Heartbeat',
-      'PingCommitmentWithSampling': 'Heartbeat',
+      'PingAttestation': 'Light Eligibility',
+      'PingCommitmentWithSampling': 'Light Eligibility',
       'HeartbeatCommitment': 'Heartbeat',
-      'LightNodeEligibilityBitmap': 'Heartbeat',
+      'LightNodeEligibilityBitmap': 'Light Eligibility',
+      'BitmapCommitment': 'Light Eligibility',
       'Swap': 'Swap',
       'ContractDeploy': 'Contract',
       'ContractCall': 'Contract',

applications/qnet-explorer/frontend/src/app/api/network/stats/route.ts

@@ -60,12 +60,18 @@ export async function GET() {
           AND t.block >= ep.pe * 14400 AND t.block < ep.pe * 14400 + 14400
       `),
 
-      // Active LIGHT nodes = sealed eligible_count summed over the per-genesis bitmaps of the previous epoch.
+      // Active LIGHT nodes = MAX over the last 3 sealed epochs of (per-epoch SUM of eligible_count across genesis shards).
+      // Per-epoch SUM across shards = that epoch's light total (each light is in exactly one shard); MAX de-flickers a light
+      // that missed only the most-recent epoch's ping window.
       pool.query(`${prevEpochCte}
-        SELECT COALESCE(SUM((t.tx_type_data->>'eligible_count')::bigint), 0) AS active_light
-        FROM transactions t, ep
-        WHERE t.tx_type = 'LightNodeEligibilityBitmap'
-          AND t.block >= ep.pe * 14400 AND t.block < ep.pe * 14400 + 14400
+        SELECT COALESCE(MAX(epoch_light), 0) AS active_light FROM (
+          SELECT FLOOR(t.block / 14400)::bigint AS epoch,
+                 SUM((t.tx_type_data->>'eligible_count')::bigint) AS epoch_light
+          FROM transactions t, ep
+          WHERE t.tx_type = 'LightNodeEligibilityBitmap'
+            AND t.block >= GREATEST(ep.pe - 2, 0) * 14400 AND t.block < (ep.pe + 1) * 14400
+          GROUP BY FLOOR(t.block / 14400)
+        ) per_epoch
       `)
     ]);
 

applications/qnet-explorer/frontend/src/app/api/tx/[hash]/route.ts

@@ -36,6 +36,17 @@ function getNodeRpcUrl(): string {
 
 const NODE_RPC_URL = getNodeRpcUrl();
 
+// Normalize type-specific public data (JSONB object or JSON string) → object|null; null if empty.
+function parseTxTypeData(raw: unknown): Record<string, unknown> | null {
+  if (!raw) return null;
+  let obj: unknown = raw;
+  if (typeof raw === 'string') {
+    try { obj = JSON.parse(raw); } catch { return null; }
+  }
+  if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) return null;
+  return Object.keys(obj).length > 0 ? (obj as Record<string, unknown>) : null;
+}
+
 // Fetch TX from Node RPC (fallback if not in DB)
 async function fetchTransaction(hash: string): Promise<Record<string, unknown> | null> {
   try {
@@ -259,6 +270,7 @@ export async function GET(
           dilithium_signature: dbTx.dilithium_signature,
           dilithium_public_key: dbTx.dilithium_public_key,
           data: dbTx.data,
+          tx_type_data: parseTxTypeData(dbTx.tx_type_data),
         },
       }, {
         headers: {
@@ -370,6 +382,7 @@ export async function GET(
         dilithium_signature: tx.dilithium_signature as string | undefined,
         dilithium_public_key: tx.dilithium_public_key as string | undefined,
         data: tx.data as string | undefined,
+        tx_type_data: parseTxTypeData(tx.tx_type_data),
       },
     }, {
       headers: {

applications/qnet-explorer/frontend/src/app/explorer/ExplorerClient.tsx

@@ -93,7 +93,7 @@ const ActivityRow = memo(function ActivityRow({ item }: { item: ActivityItem })
 });
 
 const ITEMS_PER_PAGE = 50;
-const TX_TYPES = ['Transfer', 'Reward', 'Swap', 'Heartbeat', 'Registration', 'Activation', 'Contract', 'System'];
+const TX_TYPES = ['Transfer', 'Reward', 'Swap', 'Heartbeat', 'Light Eligibility', 'Registration', 'Activation', 'Contract', 'System'];
 
 export default function ExplorerClient({ initialData, initialHeight, initialTotal }: ExplorerClientProps) {
   // ========== STATE: initialized from SSR data — table renders INSTANTLY ==========

applications/qnet-explorer/frontend/src/app/explorer/tx/[hash]/page.tsx

@@ -27,6 +27,7 @@ interface TransactionData {
   is_quantum_signed?: boolean;
   dilithium_signature?: string;
   dilithium_public_key?: string;
+  tx_type_data?: Record<string, unknown> | null;
 }
 
 // Truncate
@@ -53,6 +54,17 @@ const formatTime = (ts: number | string | undefined): string => {
   return `${dd}.${mm}.${yyyy}, ${hh}:${min}:${ss}`;
 };
 
+// snake_case/genesis_id → "Genesis Id" for the data card labels
+const humanizeKey = (key: string): string =>
+  key.replace(/[_-]+/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+
+// Render any tx_type_data value as a string (objects/arrays → JSON)
+const formatDataValue = (val: unknown): string => {
+  if (val === null || val === undefined) return 'N/A';
+  if (typeof val === 'object') return JSON.stringify(val);
+  return String(val);
+};
+
 // Copy button
 const CopyBtn = ({ text }: { text: string }) => {
   const [copied, setCopied] = useState(false);
@@ -218,6 +230,21 @@ export default function TransactionPage() {
           </div>
         </div>
       </div>
+
+      {/* Type-specific public data (bitmap epoch/eligible_count, reward pool, etc.) */}
+      {tx.tx_type_data && Object.keys(tx.tx_type_data).length > 0 && (
+        <div className="block-card">
+          <h2 className="card-title">Transaction Data</h2>
+          <div className="details-grid">
+            {Object.entries(tx.tx_type_data).map(([key, value]) => (
+              <div className="detail-row" key={key}>
+                <span className="detail-label">{humanizeKey(key)}</span>
+                <span className="detail-value">{formatDataValue(value)}</span>
+              </div>
+            ))}
+          </div>
+        </div>
+      )}
     </div>
   );
 }

applications/qnet-explorer/frontend/src/app/globals.css

@@ -2441,6 +2441,11 @@ a[href*="play.google.com"] img {
   color: #ff80b0;
 }
 
+.type-badge.type-light-eligibility {
+  background: rgba(120,200,255,0.15);
+  color: #80c0ff;
+}
+
 .type-badge.type-contract {
   background: rgba(240,130,130,0.15);
   color: #f09090;

applications/qnet-explorer/frontend/src/lib/tx-mapping.ts

@@ -34,14 +34,16 @@ export function mapTxType(type: string | object | undefined, fromAddress?: strin
     emission: 'Reward',
     reward: 'Reward',
 
-    // Heartbeat (all node activity attestations)
+    // Heartbeat (super-node liveness attestation)
     heartbeatcommitment: 'Heartbeat',
-    pingcommitmentwithsampling: 'Heartbeat',
-    lightnodeeligibilitybitmap: 'Heartbeat',
-    bitmapcommitment: 'Heartbeat',
-    pingattestation: 'Heartbeat',
     heartbeat: 'Heartbeat',
 
+    // Light eligibility (ping/bitmap attestations)
+    lightnodeeligibilitybitmap: 'Light Eligibility',
+    bitmapcommitment: 'Light Eligibility',
+    pingattestation: 'Light Eligibility',
+    pingcommitmentwithsampling: 'Light Eligibility',
+
     // Smart Contracts
     contractdeploy: 'Contract',
     contractcall: 'Contract',

applications/qnet-mobile/src/components/WalletManager.js

@@ -5365,126 +5365,6 @@ export class WalletManager {
     }
   }
 
-  // Get validator node metrics from blockchain
-  // v3.35: Added retry logic with different nodes for reliability
-  async getNodeRewards(nodeType, activationCode, walletAddress, maxRetries = 3) {
-    let lastError = null;
-    const triedNodes = new Set();
-    
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-      try {
-        // v3.35: Get random node, avoid retrying same node
-        let apiUrl = this.getRandomBootstrapNode();
-        let retryCount = 0;
-        while (triedNodes.has(apiUrl) && retryCount < 5) {
-          apiUrl = this.getRandomBootstrapNode();
-          retryCount++;
-        }
-        triedNodes.add(apiUrl);
-        
-        // Get rewards periods from blockchain
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), 8000);
-        
-        const periodsResponse = await fetch(`${apiUrl}/api/rewards/periods`, {
-          method: 'GET',
-          headers: { 'Content-Type': 'application/json' },
-          signal: controller.signal
-        });
-        
-        clearTimeout(timeoutId);
-        
-        if (!periodsResponse.ok) {
-          throw new Error(`HTTP ${periodsResponse.status}`);
-        }
-        
-        const periods = await periodsResponse.json();
-        const currentPeriod = periods?.periods?.[0];
-        
-        // Get reward proof for current period
-        const proofController = new AbortController();
-        const proofTimeoutId = setTimeout(() => proofController.abort(), 8000);
-        
-        const proofResponse = await fetch(`${apiUrl}/api/rewards/proof?address=${walletAddress}&period_id=${currentPeriod?.id || 'current'}`, {
-          method: 'GET',
-          headers: { 'Content-Type': 'application/json' },
-          signal: proofController.signal
-        });
-        
-        clearTimeout(proofTimeoutId);
-        
-        let rewardData = {};
-        if (proofResponse.ok) {
-          rewardData = await proofResponse.json();
-        }
-        
-        // Get node ping status from storage
-        const lastPingTime = await AsyncStorage.getItem(`node_last_ping_${walletAddress}`);
-        const lastPing = lastPingTime ? parseInt(lastPingTime) : null;
-        const fourHoursAgo = Date.now() - (4 * 60 * 60 * 1000);
-        const isActive = lastPing && lastPing > fourHoursAgo;
-        
-        // Daily rates by node type
-        // Light nodes are NOT real nodes - just mobile app users
-        const dailyRates = {
-          super: 500,  // Only Super/Genesis nodes earn rewards
-        };
-        
-        // Get stored rewards data
-        const storedRewardsStr = await AsyncStorage.getItem('qnet_node_rewards');
-        let storedRewards = {};
-        if (storedRewardsStr) {
-          try {
-            storedRewards = JSON.parse(storedRewardsStr);
-          } catch (e) {
-            // Error parsing stored rewards
-          }
-        }
-        
-        // Calculate validator activity metrics
-        const dailyRate = dailyRates[nodeType] || 10;
-        const totalEarned = rewardData?.total_earned || storedRewards.totalEarned || 0;
-        const totalClaimed = rewardData?.total_claimed || storedRewards.totalClaimed || 0;
-        const unclaimed = rewardData?.unclaimed || (totalEarned - totalClaimed);
-        
-        // Return validator metrics (rewards are managed automatically by blockchain protocol)
-        return {
-          dailyRate,
-          totalEarned,  // Total on-chain validations
-          totalClaimed, // Confirmed validations
-          unclaimed,    // Pending validations
-          lastPing,
-          isActive,
-          nextClaim: storedRewards.lastClaim 
-            ? storedRewards.lastClaim + (24 * 60 * 60 * 1000)
-            : null,
-          merkleProof: rewardData?.merkle_proof || [],
-          periodId: currentPeriod?.id || null
-        };
-      } catch (error) {
-        lastError = error;
-        // v3.35: Wait before retry (exponential backoff)
-        if (attempt < maxRetries - 1) {
-          await new Promise(r => setTimeout(r, (attempt + 1) * 500));
-        }
-      }
-    }
-    
-    // All retries failed - return default metrics
-    console.warn(`[REWARDS] Failed after ${maxRetries} retries:`, lastError?.message);
-    return {
-      dailyRate: 10,
-      totalEarned: 0,
-      totalClaimed: 0,
-      unclaimed: 0,
-      lastPing: null,
-      isActive: false,
-      nextClaim: null,
-      merkleProof: [],
-      periodId: null
-    };
-  }
-  
   // Query any node to verify that walletAddress has an active registration on-chain.
   // Returns { verified: true, node_id, node_type } or { verified: false }.
   async checkOnChainActivation(walletAddress) {