feat(net): optimize disconnectRandom by tracking block receive time per peer

- Add blockRcvTime/blockRcvTimeCmp fields to PeerConnection to track when
  a peer last delivered a valid block
- Set blockRcvTime in BlockMsgHandler after each block is received
- Fix lastInteractiveTime update in InventoryMsgHandler: only update for
  block inventories above current head block num, preventing attackers from
  forging activity via stale block hashes
- Add getRandomDisconnectionPeers() to ResilienceService: narrows the
  disconnect candidate pool to the oldest half by blockRcvTime, so peers
  that recently delivered blocks are protected from random eviction

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: 2 people

framework/src/main/java/org/tron/core/net/messagehandler/BlockMsgHandler.java

@@ -150,6 +150,7 @@ private void processBlock(PeerConnection peer, BlockCapsule block) throws P2pExc
 
     try {
       tronNetDelegate.processBlock(block, false);
+      peer.setBlockRcvTime(System.currentTimeMillis());
       witnessProductBlockService.validWitnessProductTwoBlock(block);
 
       Item item = new Item(blockId, InventoryType.BLOCK);

framework/src/main/java/org/tron/core/net/messagehandler/InventoryMsgHandler.java

@@ -6,6 +6,7 @@
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 import org.tron.common.utils.Sha256Hash;
+import org.tron.core.capsule.BlockCapsule.BlockId;
 import org.tron.core.config.args.Args;
 import org.tron.core.exception.P2pException;
 import org.tron.core.exception.P2pException.TypeEnum;
@@ -44,7 +45,10 @@ public void processMessage(PeerConnection peer, TronMessage msg) throws P2pExcep
       peer.getAdvInvReceive().put(item, System.currentTimeMillis());
       advService.addInv(item);
       if (type.equals(InventoryType.BLOCK) && peer.getAdvInvSpread().getIfPresent(item) == null) {
-        peer.setLastInteractiveTime(System.currentTimeMillis());
+        long headNum = tronNetDelegate.getHeadBlockId().getNum();
+        if (new BlockId(id).getNum() > headNum) {
+          peer.setLastInteractiveTime(System.currentTimeMillis());
+        }
       }
     }
   }

framework/src/main/java/org/tron/core/net/peer/PeerConnection.java

@@ -88,6 +88,10 @@ public class PeerConnection {
   @Setter
   private volatile long lastInteractiveTime;
 
+  @Setter
+  @Getter
+  private volatile long blockRcvTime;
+
   @Getter
   @Setter
   private volatile TronState tronState = TronState.INIT;

framework/src/main/java/org/tron/core/net/service/effective/ResilienceService.java

@@ -3,8 +3,10 @@
 import static org.tron.common.math.Maths.ceil;
 import static org.tron.common.math.Maths.max;
 
+import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.HashMap;
+import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -44,7 +46,7 @@ public class ResilienceService {
 
   @Autowired
   private ChainBaseManager chainBaseManager;
-
+ 
   public void init() {
     if (Args.getInstance().isOpenFullTcpDisconnect) {
       executor.scheduleWithFixedDelay(() -> {
@@ -86,6 +88,7 @@ private void disconnectRandom() {
         .collect(Collectors.toList());
 
     if (peers.size() >= minBroadcastPeerSize) {
+      peers = getRandomDisconnectionPeers(peers);
       long now = System.currentTimeMillis();
       Map<Object, Integer> weights = new HashMap<>();
       peers.forEach(peer -> {
@@ -121,6 +124,14 @@ private void disconnectRandom() {
   }
 
 
+  private List<PeerConnection> getRandomDisconnectionPeers(List<PeerConnection> peers) {
+    Map<PeerConnection, Long> snapshot = new IdentityHashMap<>(peers.size());
+    peers.forEach(p -> snapshot.put(p, p.getBlockRcvTime()));
+    List<PeerConnection> sorted = new ArrayList<>(peers);
+    sorted.sort(Comparator.comparingLong(snapshot::get));
+    return sorted.subList(0, sorted.size() / 2);
+  }
+
   private void disconnectLan() {
     if (!isLanNode()) {
       return;

framework/src/main/java/org/tron/core/net/service/sync/SyncService.java

@@ -337,6 +337,7 @@ private void processSyncBlock(BlockCapsule block, PeerConnection peerConnection)
     try {
       tronNetDelegate.validSignature(block);
       tronNetDelegate.processBlock(block, true);
+      peerConnection.setBlockRcvTime(System.currentTimeMillis());
       pbftDataSyncHandler.processPBFTCommitData(block);
     } catch (P2pException p2pException) {
       logger.error("Process sync block {} failed, type: {}",

framework/src/test/java/org/tron/core/net/messagehandler/BlockMsgHandlerTest.java

@@ -15,7 +15,6 @@
 import lombok.extern.slf4j.Slf4j;
 import org.junit.Assert;
 import org.junit.Before;
-import org.junit.BeforeClass;
 import org.junit.Test;
 import org.mockito.Mockito;
 import org.tron.common.BaseTest;
@@ -39,20 +38,16 @@
 @Slf4j
 public class BlockMsgHandlerTest extends BaseTest {
 
+  static {
+    Args.setParam(new String[] {"--output-directory", dbPath(), "--debug"},
+        TestConstants.TEST_CONF);
+  }
+
   @Resource
   private BlockMsgHandler handler;
   @Resource
   private PeerConnection peer;
 
-  /**
-   * init context.
-   */
-  @BeforeClass
-  public static void init() {
-    Args.setParam(new String[] {"--output-directory", dbPath(), "--debug"},
-        TestConstants.TEST_CONF);
-  }
-
   @Before
   public void before() throws Exception {
     Channel c1 = new Channel();
@@ -122,6 +117,7 @@ public void testProcessMessage() {
     try {
       blockCapsule = new BlockCapsule(1, Sha256Hash.ZERO_HASH,
           System.currentTimeMillis() + 1000, Sha256Hash.ZERO_HASH.getByteString());
+      blockCapsule.setMerkleRoot();
       msg = new BlockMessage(blockCapsule);
       peer.getAdvInvRequest()
           .put(new Item(msg.getBlockId(), InventoryType.BLOCK), System.currentTimeMillis());
@@ -132,12 +128,12 @@ public void testProcessMessage() {
   }
 
   @Test
-  public void testProcessBlock() {
+  public void testProcessBlock() throws Exception {
     TronNetDelegate tronNetDelegate = Mockito.mock(TronNetDelegate.class);
-
+    Field field = handler.getClass().getDeclaredField("tronNetDelegate");
+    field.setAccessible(true);
+    Object origin = field.get(handler);
     try {
-      Field field = handler.getClass().getDeclaredField("tronNetDelegate");
-      field.setAccessible(true);
       field.set(handler, tronNetDelegate);
 
       BlockCapsule blockCapsule0 = new BlockCapsule(1,
@@ -164,8 +160,74 @@ public void testProcessBlock() {
           .getDeclaredMethod("processBlock", PeerConnection.class, BlockCapsule.class);
       method.setAccessible(true);
       method.invoke(handler, peer, blockCapsule0);
-    } catch (Exception e) {
-      Assert.fail();
+    } finally {
+      field.set(handler, origin);
+    }
+  }
+
+  @Test
+  public void testBlockRcvTimeSetAfterProcessBlockSuccess() throws Exception {
+    TronNetDelegate tronNetDelegate = Mockito.mock(TronNetDelegate.class);
+    Field field = handler.getClass().getDeclaredField("tronNetDelegate");
+    field.setAccessible(true);
+    Object origin = field.get(handler);
+    try {
+      field.set(handler, tronNetDelegate);
+
+      BlockCapsule blockCapsule = new BlockCapsule(1,
+          Sha256Hash.wrap(ByteString.copyFrom(ByteArray.fromHexString(
+              "9938a342238077182498b464ac0292229938a342238077182498b464ac029222"))),
+          1234, ByteString.copyFrom("1234567".getBytes()));
+
+      Mockito.doReturn(true).when(tronNetDelegate).validBlock(any(BlockCapsule.class));
+      Mockito.doReturn(true).when(tronNetDelegate).containBlock(any(BlockId.class));
+      Mockito.doReturn(blockCapsule.getBlockId()).when(tronNetDelegate).getHeadBlockId();
+      Mockito.doNothing().when(tronNetDelegate).processBlock(any(BlockCapsule.class), anyBoolean());
+      Mockito.doReturn(new ArrayList<PeerConnection>()).when(tronNetDelegate).getActivePeer();
+
+      peer.setBlockRcvTime(0L);
+      Method method = handler.getClass()
+          .getDeclaredMethod("processBlock", PeerConnection.class, BlockCapsule.class);
+      method.setAccessible(true);
+
+      long before = System.currentTimeMillis();
+      method.invoke(handler, peer, blockCapsule);
+      long after = System.currentTimeMillis();
+
+      Assert.assertTrue("blockRcvTime should be set after successful processBlock",
+          peer.getBlockRcvTime() >= before && peer.getBlockRcvTime() <= after);
+    } finally {
+      field.set(handler, origin);
+    }
+  }
+
+  @Test
+  public void testBlockRcvTimeNotSetWhenValidationFails() throws Exception {
+    TronNetDelegate tronNetDelegate = Mockito.mock(TronNetDelegate.class);
+    Field field = handler.getClass().getDeclaredField("tronNetDelegate");
+    field.setAccessible(true);
+    Object origin = field.get(handler);
+    try {
+      field.set(handler, tronNetDelegate);
+
+      BlockCapsule blockCapsule = new BlockCapsule(1,
+          Sha256Hash.wrap(ByteString.copyFrom(ByteArray.fromHexString(
+              "9938a342238077182498b464ac0292229938a342238077182498b464ac029222"))),
+          1234, ByteString.copyFrom("1234567".getBytes()));
+
+      // validBlock returns false → processBlock short-circuits before setBlockRcvTime
+      Mockito.doReturn(false).when(tronNetDelegate).validBlock(any(BlockCapsule.class));
+
+      peer.setBlockRcvTime(0L);
+      Method method = handler.getClass()
+          .getDeclaredMethod("processBlock", PeerConnection.class, BlockCapsule.class);
+      method.setAccessible(true);
+      method.invoke(handler, peer, blockCapsule);
+
+      Assert.assertEquals("blockRcvTime must stay 0 when block fails validation",
+          0L, peer.getBlockRcvTime());
+    } finally {
+      field.set(handler, origin);
     }
   }
 }

framework/src/test/java/org/tron/core/net/messagehandler/InventoryMsgHandlerTest.java

@@ -1,5 +1,6 @@
 package org.tron.core.net.messagehandler;
 
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 
 import java.lang.reflect.Field;
@@ -12,20 +13,25 @@
 import org.mockito.Mockito;
 import org.tron.common.TestConstants;
 import org.tron.common.utils.Sha256Hash;
+import org.tron.core.capsule.BlockCapsule.BlockId;
 import org.tron.core.config.args.Args;
 import org.tron.core.exception.P2pException;
 import org.tron.core.net.TronNetDelegate;
 import org.tron.core.net.message.adv.InventoryMessage;
 import org.tron.core.net.peer.PeerConnection;
+import org.tron.core.net.service.adv.AdvService;
 import org.tron.p2p.connection.Channel;
 import org.tron.protos.Protocol.Inventory.InventoryType;
 
 public class InventoryMsgHandlerTest {
 
+  static {
+    Args.setParam(new String[] {}, TestConstants.TEST_CONF);
+  }
+
   @Test
   public void testProcessMessage() throws Exception {
     InventoryMsgHandler handler = new InventoryMsgHandler();
-    Args.setParam(new String[] {}, TestConstants.TEST_CONF);
     Args.logConfig();
 
     InventoryMessage msg = new InventoryMessage(new ArrayList<>(), InventoryType.TRX);
@@ -59,7 +65,6 @@ public void testProcessMessage() throws Exception {
   @Test
   public void testDuplicateHashesRejected() throws Exception {
     InventoryMsgHandler handler = new InventoryMsgHandler();
-    Args.setParam(new String[] {}, TestConstants.TEST_CONF);
 
     Sha256Hash hash = Sha256Hash.wrap(new byte[32]);
     InventoryMessage msg = new InventoryMessage(Arrays.asList(hash, hash), InventoryType.TRX);
@@ -74,6 +79,83 @@ public void testDuplicateHashesRejected() throws Exception {
     }
   }
 
+  @Test
+  public void testLastInteractiveTimeNotUpdatedForSolidifiedBlock() throws Exception {
+    InventoryMsgHandler handler = new InventoryMsgHandler();
+
+    TronNetDelegate tronNetDelegate = mock(TronNetDelegate.class);
+    AdvService advService = mock(AdvService.class);
+    Mockito.when(advService.addInv(any())).thenReturn(true);
+    // block num 100 is at head boundary — should NOT update
+    Mockito.when(tronNetDelegate.getHeadBlockId())
+        .thenReturn(new BlockId(Sha256Hash.ZERO_HASH, 100L));
+
+    Field delegateField = handler.getClass().getDeclaredField("tronNetDelegate");
+    delegateField.setAccessible(true);
+    delegateField.set(handler, tronNetDelegate);
+    Field advField = handler.getClass().getDeclaredField("advService");
+    advField.setAccessible(true);
+    advField.set(handler, advService);
+
+    PeerConnection peer = new PeerConnection();
+    peer.setChannel(getChannel("1.0.0.4", 1001));
+    peer.setNeedSyncFromPeer(false);
+    peer.setNeedSyncFromUs(false);
+    peer.setLastInteractiveTime(0L);
+
+    // Block hash encodes num=100 (at solidified boundary — should NOT update)
+    Sha256Hash blockHash = new BlockId(Sha256Hash.ZERO_HASH, 100L);
+    InventoryMessage msg = new InventoryMessage(Arrays.asList(blockHash), InventoryType.BLOCK);
+    handler.processMessage(peer, msg);
+
+    Assert.assertEquals("lastInteractiveTime should NOT be updated for solidified block",
+        0L, peer.getLastInteractiveTime());
+  }
+
+  @Test
+  public void testLastInteractiveTimeUpdatedForBothPeersWithSameAboveSolidifiedBlock()
+      throws Exception {
+    InventoryMsgHandler handler = new InventoryMsgHandler();
+
+    TronNetDelegate tronNetDelegate = mock(TronNetDelegate.class);
+    AdvService advService = mock(AdvService.class);
+    // First call returns true (peer1), second call returns false (peer2 — already in cache)
+    Mockito.when(advService.addInv(any())).thenReturn(true).thenReturn(false);
+    Mockito.when(tronNetDelegate.getHeadBlockId())
+        .thenReturn(new BlockId(Sha256Hash.ZERO_HASH, 99L));
+
+    Field delegateField = handler.getClass().getDeclaredField("tronNetDelegate");
+    delegateField.setAccessible(true);
+    delegateField.set(handler, tronNetDelegate);
+    Field advField = handler.getClass().getDeclaredField("advService");
+    advField.setAccessible(true);
+    advField.set(handler, advService);
+
+    PeerConnection peer1 = new PeerConnection();
+    peer1.setChannel(getChannel("1.0.0.5", 1002));
+    peer1.setNeedSyncFromPeer(false);
+    peer1.setNeedSyncFromUs(false);
+    peer1.setLastInteractiveTime(0L);
+
+    PeerConnection peer2 = new PeerConnection();
+    peer2.setChannel(getChannel("1.0.0.6", 1003));
+    peer2.setNeedSyncFromPeer(false);
+    peer2.setNeedSyncFromUs(false);
+    peer2.setLastInteractiveTime(0L);
+
+    // block num 100 > solidified 99 — both peers should update
+    Sha256Hash blockHash = new BlockId(Sha256Hash.ZERO_HASH, 100L);
+    InventoryMessage msg = new InventoryMessage(Arrays.asList(blockHash), InventoryType.BLOCK);
+
+    handler.processMessage(peer1, msg);
+    handler.processMessage(peer2, msg);
+
+    Assert.assertTrue("peer1 lastInteractiveTime should be updated",
+        peer1.getLastInteractiveTime() > 0L);
+    Assert.assertTrue("peer2 lastInteractiveTime should be updated even when addInv returns false",
+        peer2.getLastInteractiveTime() > 0L);
+  }
+
   private Channel getChannel(String host, int port) throws Exception {
     Channel channel = new Channel();
     InetSocketAddress inetSocketAddress = new InetSocketAddress(host, port);

framework/src/test/java/org/tron/core/net/messagehandler/MessageHandlerTest.java

@@ -42,6 +42,9 @@ public class MessageHandlerTest {
   @ClassRule
   public static final TemporaryFolder temporaryFolder = new TemporaryFolder();
 
+  static {
+    Args.setParam(new String[] {}, TestConstants.TEST_CONF);
+  }
 
   @BeforeClass
   public static void init() throws Exception {

framework/src/test/java/org/tron/core/net/messagehandler/PbftMsgHandlerTest.java

@@ -43,6 +43,9 @@ public class PbftMsgHandlerTest {
   private PeerConnection peer;
   private static String dbPath = "output-pbft-message-handler-test";
 
+  static {
+    Args.setParam(new String[] {}, TestConstants.TEST_CONF);
+  }
 
   @BeforeClass
   public static void init() {

framework/src/test/java/org/tron/core/net/messagehandler/SyncBlockChainMsgHandlerTest.java

@@ -46,6 +46,10 @@ public static String dbPath() {
     return null;
   }
 
+  static {
+    Args.setParam(new String[] {}, TestConstants.TEST_CONF);
+  }
+
   @BeforeClass
   public static void before() {
     Args.setParam(new String[] {"--output-directory", dbPath()}, TestConstants.TEST_CONF);