kuny0707 · Oct 15, 2026 · Oct 13, 2026 · Oct 13, 2026 · Oct 13, 2026 · Oct 15, 2026
diff --git a/framework/src/main/java/org/tron/core/config/args/DynamicArgs.java b/framework/src/main/java/org/tron/core/config/args/DynamicArgs.java
@@ -73,8 +73,12 @@ private void updateActiveNodes(NodeConfig nodeConfig) {
         Args.filterInetSocketAddress(nodeConfig.getActive(), true);
     parameter.setActiveNodes(newActiveNodes);
     List<InetSocketAddress> activeNodes = TronNetService.getP2pConfig().getActiveNodes();
-    activeNodes.clear();
-    activeNodes.addAll(newActiveNodes);
+    activeNodes.removeIf(node -> !newActiveNodes.contains(node));
+    newActiveNodes.forEach(node -> {
+      if (!activeNodes.contains(node)) {
+        activeNodes.add(node);
+      }
+    });
     logger.debug("p2p active nodes : {}",
         TronNetService.getP2pConfig().getActiveNodes().toString());
   }

diff --git a/framework/src/main/java/org/tron/core/net/peer/PeerConnection.java b/framework/src/main/java/org/tron/core/net/peer/PeerConnection.java
@@ -334,17 +334,4 @@ public synchronized boolean checkAndPutAdvInvRequest(Item key, Long value) {
     return true;
   }
 
-  @Override
-  public boolean equals(Object o) {
-    if (!(o instanceof PeerConnection)) {
-      return false;
-    }
-    return this.channel.equals(((PeerConnection) o).getChannel());
-  }
-
-  @Override
-  public int hashCode() {
-    return this.channel.hashCode();
-  }
-
 }
diff --git a/framework/src/main/java/org/tron/core/net/peer/PeerManager.java b/framework/src/main/java/org/tron/core/net/peer/PeerManager.java
@@ -84,13 +84,16 @@ public static synchronized PeerConnection remove(Channel channel) {
     return peerConnection;
   }
 
-  private static void remove(PeerConnection peerConnection) {
-    peers.remove(peerConnection);
+  private static boolean remove(PeerConnection peerConnection) {
+    if (!peers.removeIf(peer -> peer == peerConnection)) {
+      return false;
+    }
     if (peerConnection.getChannel().isActive()) {
       activePeersCount.decrementAndGet();
     } else {
       passivePeersCount.decrementAndGet();
     }
+    return true;
   }
 
   public static synchronized void sortPeers() {
@@ -103,7 +106,7 @@ public static synchronized void sortPeers() {
 
   public static PeerConnection getPeerConnection(Channel channel) {
     for (PeerConnection peer : new ArrayList<>(peers)) {
-      if (peer.getChannel().equals(channel)) {
+      if (peer.getChannel() == channel) {
         return peer;
       }
     }
@@ -120,19 +123,15 @@ public static List<PeerConnection> getPeers() {
     return peers;
   }
 
-  private static void check() {
+  private static synchronized void check() {
     long now = System.currentTimeMillis();
     for (PeerConnection peer : new ArrayList<>(peers)) {
       long disconnectTime = peer.getChannel().getDisconnectTime();
       if (disconnectTime != 0 && now - disconnectTime > DISCONNECTION_TIME_OUT) {
         logger.warn("Notify disconnect peer {}.", peer.getInetSocketAddress());
-        peers.remove(peer);
-        if (peer.getChannel().isActive()) {
-          activePeersCount.decrementAndGet();
-        } else {
-          passivePeersCount.decrementAndGet();
+        if (remove(peer)) {
+          peer.onDisconnect();
         }
-        peer.onDisconnect();
       }
     }
   }

diff --git a/framework/src/main/java/org/tron/core/net/service/handshake/HandshakeService.java b/framework/src/main/java/org/tron/core/net/service/handshake/HandshakeService.java
@@ -1,6 +1,7 @@
 package org.tron.core.net.service.handshake;
 
 import java.util.Arrays;
+import java.util.Objects;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
@@ -34,16 +35,20 @@ public void startHandshake(PeerConnection peer) {
   }
 
   public void processHelloMessage(PeerConnection peer, HelloMessage msg) {
+    if (peer.isDisconnect()) {
+      return;
+    }
+
     if (peer.getHelloMessageReceive() != null) {
       logger.warn("Peer {} receive dup hello message", peer.getInetSocketAddress());
       peer.disconnect(ReasonCode.BAD_PROTOCOL);
       return;
     }
 
-    TronNetService.getP2pService().updateNodeId(peer.getChannel(), msg.getFrom().getHexId());
-    if (peer.isDisconnect()) {
-      logger.info("Duplicate Peer {}", peer.getInetSocketAddress());
-      peer.disconnect(ReasonCode.DUPLICATE_PEER);
+    if (!Objects.equals(peer.getChannel().getNodeId(), msg.getFrom().getHexId())) {
+      logger.warn("Peer {} sent an application HELLO with a different node ID",
+          peer.getInetSocketAddress());
+      peer.disconnect(ReasonCode.UNEXPECTED_IDENTITY);
       return;
     }
 

diff --git a/framework/src/test/java/org/tron/common/utils/PeerManagerStateResetter.java b/framework/src/test/java/org/tron/common/utils/PeerManagerStateResetter.java
@@ -19,8 +19,8 @@
  * static executor, and tests share one JVM across Spring contexts.
  *
  * <p>The old executor is drained to termination <em>before</em> touching any state: {@code
- * check()} is not synchronized (it snapshots peers, then removes entries and decrements
- * counters), so a task left running would decrement the counters zeroed in step 4 and leave
+ * check()} may still be running while state is reset, so a task left running could decrement
+ * the counters zeroed in step 4 and leave
  * them negative; shutdown alone does not guarantee that, so reset fails if termination cannot
  * be confirmed.
  * Residual peers are disconnected before the raw list is cleared because {@code close()} may
@@ -42,8 +42,7 @@ private PeerManagerStateResetter() {
   public static synchronized void reset() {
     // 1) Drain the old executor first: let running/queued check() tasks die out so they
     // cannot interleave with the list/counter reset below. Gate on isTerminated(), not
-    // isShutdown(): shutdown() still lets a running check() finish asynchronously, and
-    // check() decrements the counters even when its peers.remove() is a no-op. If
+    // isShutdown(): shutdown() still lets a running check() finish asynchronously. If
     // termination cannot be confirmed, fail the setup instead of resetting anyway.
     ScheduledExecutorService executor = getFieldValue("executor");
     if (executor != null && !executor.isTerminated()) {

diff --git a/framework/src/test/java/org/tron/core/config/args/DynamicArgsTest.java b/framework/src/test/java/org/tron/core/config/args/DynamicArgsTest.java
@@ -1,8 +1,15 @@
 package org.tron.core.config.args;
 
 import java.io.File;
+import java.net.InetSocketAddress;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.function.Predicate;
 import org.junit.Assert;
 import org.junit.Test;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
 import org.tron.common.BaseMethodTest;
 import org.tron.common.TestConstants;
 import org.tron.common.parameter.CommonParameter;
@@ -55,4 +62,47 @@ public void start() {
 
     dynamicArgs.close();
   }
+
+  @Test
+  public void retainedActiveNodeStaysVisibleDuringReload() {
+    InetSocketAddress retained = new InetSocketAddress("192.0.2.10", 18888);
+    InetSocketAddress removed = new InetSocketAddress("192.0.2.11", 18888);
+    InetSocketAddress added = new InetSocketAddress("192.0.2.12", 18888);
+    List<InetSocketAddress> activeNodes =
+        new CopyOnWriteArrayList<InetSocketAddress>(Arrays.asList(retained, removed)) {
+          @Override
+          public void clear() {
+            super.clear();
+            Assert.assertTrue("Retained node disappeared during reload", contains(retained));
+          }
+
+          @Override
+          public boolean removeIf(Predicate<? super InetSocketAddress> filter) {
+            boolean changed = super.removeIf(filter);
+            Assert.assertTrue("Retained node disappeared during reload", contains(retained));
+            return changed;
+          }
+
+          @Override
+          public boolean add(InetSocketAddress node) {
+            boolean changed = super.add(node);
+            Assert.assertTrue("Retained node disappeared during reload", contains(retained));
+            return changed;
+          }
+        };
+    P2pConfig p2pConfig = new P2pConfig();
+    p2pConfig.setActiveNodes(activeNodes);
+    NodeConfig nodeConfig = new NodeConfig();
+    nodeConfig.setActive(Arrays.asList("192.0.2.10:18888", "192.0.2.12:18888"));
+    List<InetSocketAddress> previousActiveNodes = Args.getInstance().getActiveNodes();
+
+    try (MockedStatic<TronNetService> netService = Mockito.mockStatic(TronNetService.class)) {
+      netService.when(TronNetService::getP2pConfig).thenReturn(p2pConfig);
+      ReflectUtils.invokeMethod(dynamicArgs, "updateActiveNodes",
+          new Class[] {NodeConfig.class}, nodeConfig);
+      Assert.assertEquals(Arrays.asList(retained, added), activeNodes);
+    } finally {
+      Args.getInstance().setActiveNodes(previousActiveNodes);
+    }
+  }
 }
diff --git a/framework/src/test/java/org/tron/core/net/peer/PeerConnectionTest.java b/framework/src/test/java/org/tron/core/net/peer/PeerConnectionTest.java
@@ -4,8 +4,10 @@
 
 import java.net.InetSocketAddress;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 
 import org.junit.AfterClass;
 import org.junit.Assert;
@@ -264,11 +266,11 @@ public void testEquals() {
 
     Assert.assertTrue(p1.equals(p1));
     Assert.assertTrue(!p1.equals(p2));
-    Assert.assertTrue(p2.equals(p3));
+    Assert.assertTrue(!p2.equals(p3));
   }
 
   @Test
-  public void testHashCode() {
+  public void testMapSeparatesPeerConnections() {
     PeerConnection p1 = new PeerConnection();
     InetSocketAddress inetSocketAddress1 =
         new InetSocketAddress("127.0.0.2", 10001);
@@ -293,8 +295,13 @@ public void testHashCode() {
     ReflectUtils.setFieldValue(c3, "inetAddress", inetSocketAddress3.getAddress());
     p3.setChannel(c3);
 
-    Assert.assertTrue(p1.hashCode() != p2.hashCode());
-    Assert.assertTrue(p2.hashCode() == p3.hashCode());
+    Map<PeerConnection, String> peers = new HashMap<>();
+    peers.put(p1, "first");
+    peers.put(p2, "second");
+    peers.put(p3, "third");
+    Assert.assertEquals(3, peers.size());
+    Assert.assertEquals("second", peers.get(p2));
+    Assert.assertEquals("third", peers.get(p3));
   }
 
   @Test

diff --git a/framework/src/test/java/org/tron/core/net/peer/PeerManagerTest.java b/framework/src/test/java/org/tron/core/net/peer/PeerManagerTest.java
@@ -3,6 +3,7 @@
 import static org.mockito.Mockito.mock;
 
 import java.lang.reflect.Field;
+import java.lang.reflect.Method;
 import java.net.InetSocketAddress;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -119,6 +120,85 @@ public void testGetPeerConnection() throws Exception {
     Assert.assertTrue(p != null);
   }
 
+  @Test
+  public void sameAddressChannelsRemainDistinctInEitherRemovalOrder() {
+    for (boolean removeFirst : new boolean[]{false, true}) {
+      PeerManagerStateResetter.reset();
+      InetSocketAddress address = new InetSocketAddress("127.0.0.2", 10001);
+      Channel first = new Channel();
+      Channel second = new Channel();
+      ReflectUtils.setFieldValue(first, "inetSocketAddress", address);
+      ReflectUtils.setFieldValue(first, "inetAddress", address.getAddress());
+      ReflectUtils.setFieldValue(first, "isActive", true);
+      ReflectUtils.setFieldValue(second, "inetSocketAddress", address);
+      ReflectUtils.setFieldValue(second, "inetAddress", address.getAddress());
+      ReflectUtils.setFieldValue(second, "isActive", false);
+
+      PeerConnection firstPeer = new PeerConnection();
+      PeerConnection secondPeer = new PeerConnection();
+      ApplicationContext ctx = mock(ApplicationContext.class);
+      Mockito.when(ctx.getBean(PeerConnection.class)).thenReturn(firstPeer, secondPeer);
+      Assert.assertSame(firstPeer, PeerManager.add(ctx, first));
+      Assert.assertSame(secondPeer, PeerManager.add(ctx, second));
+      Assert.assertNull(PeerManager.add(ctx, first));
+      Assert.assertSame(firstPeer, PeerManager.getPeerConnection(first));
+      Assert.assertSame(secondPeer, PeerManager.getPeerConnection(second));
+      Assert.assertEquals(2, PeerManager.getPeers().size());
+      Assert.assertEquals(1, PeerManager.getActivePeersCount().get());
+      Assert.assertEquals(1, PeerManager.getPassivePeersCount().get());
+
+      Channel removed = removeFirst ? first : second;
+      Channel survivor = removeFirst ? second : first;
+      PeerConnection survivorPeer = removeFirst ? secondPeer : firstPeer;
+      Assert.assertNotNull(PeerManager.remove(removed));
+      Assert.assertNull(PeerManager.remove(removed));
+      Assert.assertSame(survivorPeer, PeerManager.getPeerConnection(survivor));
+      Assert.assertEquals(1, PeerManager.getPeers().size());
+      Assert.assertEquals(survivor.isActive() ? 1 : 0,
+          PeerManager.getActivePeersCount().get());
+      Assert.assertEquals(survivor.isActive() ? 0 : 1,
+          PeerManager.getPassivePeersCount().get());
+      Assert.assertSame(survivorPeer, PeerManager.remove(survivor));
+      Assert.assertTrue(PeerManager.getPeers().isEmpty());
+      Assert.assertEquals(0, PeerManager.getActivePeersCount().get());
+      Assert.assertEquals(0, PeerManager.getPassivePeersCount().get());
+    }
+  }
+
+  @Test
+  public void timedOutSameAddressPeerDoesNotRemoveItsSurvivor() throws Exception {
+    PeerManagerStateResetter.reset();
+    InetSocketAddress address = new InetSocketAddress("127.0.0.2", 10001);
+    Channel survivor = new Channel();
+    Channel timedOut = new Channel();
+    ReflectUtils.setFieldValue(survivor, "inetSocketAddress", address);
+    ReflectUtils.setFieldValue(survivor, "inetAddress", address.getAddress());
+    ReflectUtils.setFieldValue(survivor, "isActive", true);
+    ReflectUtils.setFieldValue(timedOut, "inetSocketAddress", address);
+    ReflectUtils.setFieldValue(timedOut, "inetAddress", address.getAddress());
+    ReflectUtils.setFieldValue(timedOut, "disconnectTime", System.currentTimeMillis() - 61_000);
+
+    PeerConnection survivorPeer = new PeerConnection();
+    PeerConnection timedOutPeer = Mockito.spy(new PeerConnection());
+    Mockito.doNothing().when(timedOutPeer).onDisconnect();
+    ApplicationContext ctx = mock(ApplicationContext.class);
+    Mockito.when(ctx.getBean(PeerConnection.class)).thenReturn(survivorPeer, timedOutPeer);
+    PeerManager.add(ctx, survivor);
+    PeerManager.add(ctx, timedOut);
+
+    Method check = PeerManager.class.getDeclaredMethod("check");
+    check.setAccessible(true);
+    check.invoke(null);
+
+    Assert.assertSame(survivorPeer, PeerManager.getPeerConnection(survivor));
+    Assert.assertNull(PeerManager.getPeerConnection(timedOut));
+    Assert.assertEquals(1, PeerManager.getPeers().size());
+    Assert.assertEquals(1, PeerManager.getActivePeersCount().get());
+    Assert.assertEquals(0, PeerManager.getPassivePeersCount().get());
+    Mockito.verify(timedOutPeer).onDisconnect();
+    PeerManager.remove(survivor);
+  }
+
   @Test
   public void testGetPeers() throws Exception {
     Field field = PeerManager.class.getDeclaredField("peers");