Fix a bunch of bugs

galt-tr · galt-tr · commit fdc65b5aaf54 · 2025-10-07T20:39:32.000-04:00
diff --git a/Dockerfile b/Dockerfile
@@ -7,7 +7,7 @@ COPY frontend-react/ ./
 RUN npm run build
 
 # Build the manager binary
-FROM golang:1.24.5 AS builder
+FROM golang:1.25.1 AS builder
 ARG TARGETOS
 ARG TARGETARCH
 
diff --git a/config.yaml b/config.yaml
@@ -24,8 +24,6 @@ database:
 networks:
   - "mainnet"
   - "testnet"
-  - "regtest"
-  - "stn"
   - "teratestnet"
   - "tstn"
 
diff --git a/frontend-react/src/components/Dashboard.tsx b/frontend-react/src/components/Dashboard.tsx
@@ -55,11 +55,8 @@ export const Dashboard: React.FC = () => {
       
       // Check if message matches current filters
       const messageNetwork = message.Topic.split('/')[3]?.split('-')[0];
-      console.log(messageNetwork)
       const messageType = message.Topic.split('-')[1];
-      console.log(messageType)
-      
-      
+
       const matchesNetwork = selectedNetwork === 'all' || messageNetwork === selectedNetwork;
       const matchesType = selectedMessageType === 'all' || messageType === selectedMessageType;
       
@@ -178,13 +175,8 @@ export const Dashboard: React.FC = () => {
     switch (messageType) {
       case 'block':
         return <BlockCard key={item.ID || index} block={item as Block} isNew={isNew} />;
-      // Temporarily disabling miningon message type
-      // case 'miningon':
-      //   return <MiningCard key={item.ID || index} mining={item as MiningOn} isNew={isNew} />;
       case 'subtree':
         return <SubtreeCard key={item.ID || index} subtree={item as Subtree} isNew={isNew} />;
-      case 'handshake':
-        return <HandshakeCard key={item.ID || index} handshake={item as Handshake} isNew={isNew} />;
       case 'rejected_tx':
         return <RejectedTxCard key={item.ID || index} rejectedTx={item as RejectedTx} isNew={isNew} />;
       case 'node_status':
diff --git a/frontend-react/src/components/MessageTypeFilter.tsx b/frontend-react/src/components/MessageTypeFilter.tsx
@@ -29,11 +29,6 @@ const typeInfo: Record<MessageType | 'all', { label: string; icon: string; descr
     icon: '🌳', 
     description: 'Transaction batch announcements' 
   },
-  handshake: { 
-    label: 'Handshakes', 
-    icon: '🤝', 
-    description: 'Peer connection handshakes' 
-  },
   rejected_tx: {
     label: 'Rejected TX',
     icon: '❌',
diff --git a/frontend-react/src/components/Networks.tsx b/frontend-react/src/components/Networks.tsx
@@ -1,4 +1,5 @@
 import React, { useState, useEffect, useCallback, useMemo } from 'react';
+import { useSearchParams } from 'react-router-dom';
 import { Network, NodeStatus, Message } from '../types/Message';
 import { ApiService } from '../services/api';
 import { nodeStatusStore, NodeStatusWithScore } from '../services/nodeStatusStore';
@@ -7,8 +8,27 @@ import { useWebSocket } from '../hooks/useWebSocket';
 import { PeerNameEditor } from './PeerNameEditor';
 import { PeerNamesService } from '../services/peerNames';
 
+const NETWORK_STORAGE_KEY = 'teranode-selected-network';
+
 const Networks: React.FC = () => {
-  const [selectedNetwork, setSelectedNetwork] = useState<Network>('mainnet');
+  const [searchParams, setSearchParams] = useSearchParams();
+
+  // Get network from URL query param, then localStorage, then default to mainnet
+  const getInitialNetwork = (): Network => {
+    const urlNetwork = searchParams.get('network');
+    if (urlNetwork && ['mainnet', 'testnet', 'teratestnet', 'tstn'].includes(urlNetwork)) {
+      return urlNetwork as Network;
+    }
+
+    const storedNetwork = localStorage.getItem(NETWORK_STORAGE_KEY);
+    if (storedNetwork && ['mainnet', 'testnet', 'teratestnet', 'tstn'].includes(storedNetwork)) {
+      return storedNetwork as Network;
+    }
+
+    return 'mainnet';
+  };
+
+  const [selectedNetwork, setSelectedNetwork] = useState<Network>(getInitialNetwork());
   const [nodeStatuses, setNodeStatuses] = useState<NodeStatusWithScore[]>([]);
   const [isLoading, setIsLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
@@ -17,6 +37,25 @@ const Networks: React.FC = () => {
   const [sortDirection, setSortDirection] = useState<'asc' | 'desc'>('desc');
   const [recentlyUpdated, setRecentlyUpdated] = useState<Set<string>>(new Set());
 
+  // Handle network change
+  const handleNetworkChange = useCallback((network: Network) => {
+    setSelectedNetwork(network);
+    // Update URL query parameter
+    setSearchParams({ network });
+    // Store in localStorage
+    localStorage.setItem(NETWORK_STORAGE_KEY, network);
+  }, [setSearchParams]);
+
+  // Sync with URL changes (browser back/forward)
+  useEffect(() => {
+    const urlNetwork = searchParams.get('network');
+    if (urlNetwork && ['mainnet', 'testnet', 'teratestnet', 'tstn'].includes(urlNetwork)) {
+      const network = urlNetwork as Network;
+      setSelectedNetwork(network);
+      localStorage.setItem(NETWORK_STORAGE_KEY, network);
+    }
+  }, [searchParams]);
+
   // WebSocket message handler
   const handleWebSocketMessage = useCallback((message: Message) => {
     // Check if it's a node_status message
@@ -258,7 +297,7 @@ const Networks: React.FC = () => {
             <div className="flex items-center gap-4">
               <select
                 value={selectedNetwork}
-                onChange={(e) => setSelectedNetwork(e.target.value as Network)}
+                onChange={(e) => handleNetworkChange(e.target.value as Network)}
                 className="px-4 py-2 bg-white border border-gray-300 rounded-lg shadow-sm focus:outline-none focus:ring-2 focus:ring-blue-500"
               >
                 <option value="mainnet">Mainnet</option>
diff --git a/frontend-react/src/components/PeerDetail.tsx b/frontend-react/src/components/PeerDetail.tsx
@@ -124,8 +124,9 @@ const PeerDetail: React.FC = () => {
       block: '📦',
       // miningon: '⛏️', // Temporarily disabled
       subtree: '🌳',
-      handshake: '🤝',
+      // handshake: '🤝', // Deprecated
       rejected_tx: '❌',
+      node_status: '🖥️',
       bestblock: '🏆'
     };
     return icons[type] || '📄';
@@ -324,46 +325,75 @@ const PeerDetail: React.FC = () => {
           </div>
         </div>
 
-        {/* Recent Handshakes */}
-        {peerDetail.handshakes.length > 0 && (
+        {/* Recent Node Status Updates */}
+        {peerDetail.nodeStatuses && peerDetail.nodeStatuses.length > 0 && (
           <div className="bg-white/80 backdrop-blur-xl rounded-2xl shadow-xl border border-white/50 p-6 sm:p-8 mb-8">
             <div className="flex items-center gap-3 mb-6">
               <div className="w-10 h-10 bg-gradient-to-br from-blue-500 to-cyan-600 rounded-xl flex items-center justify-center">
-                <span className="text-2xl">🤝</span>
+                <span className="text-2xl">🖥️</span>
               </div>
-              <h2 className="text-xl font-semibold text-gray-900">Recent Handshakes</h2>
+              <h2 className="text-xl font-semibold text-gray-900">Recent Node Status</h2>
             </div>
-            
+
             <div className="overflow-hidden rounded-xl border border-gray-200">
               <div className="overflow-x-auto">
                 <table className="min-w-full divide-y divide-gray-200">
                   <thead className="bg-gradient-to-r from-gray-50 to-gray-100">
                     <tr>
-                      <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Type</th>
-                      <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">User Agent</th>
+                      <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">FSM State</th>
+                      <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Client / Version</th>
                       <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Best Height</th>
+                      <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Uptime</th>
                       <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Time</th>
                     </tr>
                   </thead>
                   <tbody className="bg-white divide-y divide-gray-200">
-                    {peerDetail.handshakes.map((handshake, idx) => (
-                      <tr key={idx} className="hover:bg-gray-50 transition-colors duration-150">
-                        <td className="px-6 py-4 whitespace-nowrap">
-                          <span className="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-blue-100 text-blue-800">
-                            {handshake.Type}
-                          </span>
-                        </td>
-                        <td className="px-6 py-4 text-sm text-gray-600 max-w-xs truncate" title={handshake.UserAgent}>
-                          {handshake.UserAgent}
-                        </td>
-                        <td className="px-6 py-4 whitespace-nowrap text-sm font-medium text-gray-900">
-                          {handshake.BestHeight.toLocaleString()}
-                        </td>
-                        <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-500">
-                          {formatTime(handshake.ReceivedAt)}
-                        </td>
-                      </tr>
-                    ))}
+                    {peerDetail.nodeStatuses.map((status, idx) => {
+                      const getFSMStateColor = (state: string) => {
+                        switch(state?.toUpperCase()) {
+                          case 'RUNNING': return 'bg-green-100 text-green-800';
+                          case 'CATCHINGBLOCKS': return 'bg-orange-100 text-orange-800';
+                          case 'LEGACYSYNC': return 'bg-yellow-100 text-yellow-800';
+                          case 'IDLE': return 'bg-gray-100 text-gray-800';
+                          default: return 'bg-blue-100 text-blue-800';
+                        }
+                      };
+
+                      const formatUptime = (seconds: number) => {
+                        if (!seconds || seconds <= 0) return 'N/A';
+                        const days = Math.floor(seconds / 86400);
+                        const hours = Math.floor((seconds % 86400) / 3600);
+                        const minutes = Math.floor((seconds % 3600) / 60);
+                        if (days > 0) return `${days}d ${hours}h`;
+                        if (hours > 0) return `${hours}h ${minutes}m`;
+                        return `${minutes}m`;
+                      };
+
+                      return (
+                        <tr key={idx} className="hover:bg-gray-50 transition-colors duration-150">
+                          <td className="px-6 py-4 whitespace-nowrap">
+                            <span className={`inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium ${getFSMStateColor(status.FSMState)}`}>
+                              {status.FSMState || 'UNKNOWN'}
+                            </span>
+                          </td>
+                          <td className="px-6 py-4 text-sm text-gray-600">
+                            <div>
+                              <div className="font-medium">{status.ClientName || 'Unknown'}</div>
+                              <div className="text-xs text-gray-500">{status.Version || 'N/A'}</div>
+                            </div>
+                          </td>
+                          <td className="px-6 py-4 whitespace-nowrap text-sm font-medium text-gray-900">
+                            {status.BestHeight?.toLocaleString() || 'N/A'}
+                          </td>
+                          <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-600">
+                            {formatUptime(status.Uptime)}
+                          </td>
+                          <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-500">
+                            {formatTime(status.ReceivedAt)}
+                          </td>
+                        </tr>
+                      );
+                    })}
                   </tbody>
                 </table>
               </div>
diff --git a/frontend-react/src/components/Peers.tsx b/frontend-react/src/components/Peers.tsx
@@ -78,6 +78,7 @@ const Peers: React.FC = () => {
       case 'subtree': return '🌳';
       case 'handshake': return '🤝';
       case 'rejected_tx': return '❌';
+      case 'node_status': return '🖥️';
       case 'bestblock': return '🏆';
       default: return '📦';
     }
diff --git a/frontend-react/src/components/Stats.tsx b/frontend-react/src/components/Stats.tsx
@@ -67,6 +67,7 @@ const Stats: React.FC = () => {
       case 'subtree': return '🌳';
       case 'handshake': return '🤝';
       case 'rejected_tx': return '❌';
+      case 'node_status': return '🖥️';
       case 'bestblock': return '🏆';
       default: return '📦';
     }
diff --git a/frontend-react/src/services/api.ts b/frontend-react/src/services/api.ts
@@ -278,8 +278,6 @@ export class ApiService {
         //   return await this.getMiningMessages(filters);
         case 'subtree':
           return await this.getSubtrees(filters);
-        case 'handshake':
-          return await this.getHandshakes(filters);
         case 'rejected_tx':
           return await this.getRejectedTransactions(filters);
         case 'node_status':
diff --git a/frontend-react/src/types/Message.ts b/frontend-react/src/types/Message.ts
@@ -82,6 +82,7 @@ export interface PeerDetail {
   networks: string[];
   messageTypes: Record<string, number>;
   handshakes: Handshake[];
+  nodeStatuses: NodeStatus[];
   recentBlocks: Block[];
   recentMining: MiningOn[];
   timeStats: {
@@ -213,7 +214,7 @@ export interface NodeStatus {
 
 // Temporarily removing 'miningon' from visible message types
 // export type MessageType = 'block' | 'miningon' | 'subtree' | 'handshake' | 'rejected_tx' | 'node_status';
-export type MessageType = 'block' | 'subtree' | 'handshake' | 'rejected_tx' | 'node_status';
+export type MessageType = 'block' | 'subtree' | 'rejected_tx' | 'node_status';
 export type Network = 'mainnet' | 'testnet' | 'regtest' | 'stn' | 'teratestnet' | 'tstn';
 
 export interface DashboardFilters {
diff --git a/pkg/http/server.go b/pkg/http/server.go
diff --git a/pkg/parser/message_parser.go b/pkg/parser/message_parser.go
diff --git a/pkg/service/stats_service.go b/pkg/service/stats_service.go

Original file line number	Diff line number	Diff line change
`@@ -78,6 +78,7 @@ const Peers: React.FC = () => {`
`78`	`78`	`case 'subtree': return '🌳';`
`79`	`79`	`case 'handshake': return '🤝';`
`80`	`80`	`case 'rejected_tx': return '❌';`
	`81`	`+ case 'node_status': return '🖥️';`
`81`	`82`	`case 'bestblock': return '🏆';`
`82`	`83`	`default: return '📦';`
`83`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -67,6 +67,7 @@ const Stats: React.FC = () => {`
`67`	`67`	`case 'subtree': return '🌳';`
`68`	`68`	`case 'handshake': return '🤝';`
`69`	`69`	`case 'rejected_tx': return '❌';`
	`70`	`+ case 'node_status': return '🖥️';`
`70`	`71`	`case 'bestblock': return '🏆';`
`71`	`72`	`default: return '📦';`
`72`	`73`	`}`