@@ -16,6 +16,7 @@
 package org.tron.common.utils;
 
 import com.google.common.collect.Lists;
+import java.util.Arrays;
 import java.util.List;
 import lombok.Getter;
 import lombok.Setter;
@@ -37,6 +38,10 @@ public class LocalWitnesses {
   @Getter
   private List<String> privateKeys = Lists.newArrayList();
 
+  /**
+   * The ECDSA SR account address. Derived from the local ECDSA witness key and
+   * used by the legacy (secp256k1) block-production / signing path.
+   */
   @Setter
   @Getter
   private byte[] witnessAccountAddress;
@@ -115,6 +120,21 @@ public void initPqWitnessAccountAddress(final byte[] explicitAccountAddress) {
     }
   }
 
+  /**
+   * One account address should authorise its witness permission to only one key
+   * (either ECDSA or PQ). Throws if the same address is configured for both.
+   */
+  public void checkWitnessAddressConflict() {
+    if (witnessAccountAddress != null && pqWitnessAccountAddress != null
+        && Arrays.equals(witnessAccountAddress, pqWitnessAccountAddress)) {
+      throw new TronError(
+          String.format("Witness account address %s is authorised to both an ECDSA and a PQ key; "
+                  + "one account address should authorise witness permission to only one key.",
+              ByteArray.toHexString(witnessAccountAddress)),
+          TronError.ErrCode.WITNESS_INIT);
+    }
+  }
+
   /**
    * Private key of ECKey.
    */
 
@@ -263,11 +263,8 @@ private boolean validatePQSignature(DynamicPropertiesStore dynamicPropertiesStor
       Verify the PQ scheme is supported and proposal opened
      */
     PQScheme scheme = pqAuthSig.getScheme();
-    if (!PQSchemeRegistry.contains(scheme)) {
-      throw new ValidateSignatureException("pq_auth_sig scheme " + scheme + " is not registered");
-    }
     if (!dynamicPropertiesStore.isPqSchemeAllowed(scheme)) {
-      throw new ValidateSignatureException("pq_auth_sig scheme " + scheme + " is not activated");
+      throw new ValidateSignatureException("pq_auth_sig scheme " + scheme + " is not allowed");
     }
 
     byte[] publicKey = pqAuthSig.getPublicKey().toByteArray();
 
@@ -747,11 +747,8 @@ public static long validatePQSignatureGetWeight(Transaction transaction, Permiss
     long weight = 0L;
     for (PQAuthSig witness : transaction.getPqAuthSigList()) {
       PQScheme scheme = witness.getScheme();
-      if (!PQSchemeRegistry.contains(scheme)) {
-        throw new PermissionException("unsupported pq scheme: " + scheme);
-      }
       if (!dynamicPropertiesStore.isPqSchemeAllowed(scheme)) {
-        throw new PermissionException(scheme + " is not activated");
+        throw new PermissionException(scheme + " is not allowed");
       }
       byte[] pk = witness.getPublicKey().toByteArray();
       byte[] sig = witness.getSignature().toByteArray();
 
@@ -953,6 +953,8 @@ private static void initLocalWitnesses(Config config, CLIParameter cmd) {
       merged.initWitnessAccountAddress(ecdsaWitnesses.getWitnessAccountAddress(),
           PARAMETER.isECKeyCryptoEngine());
       merged.initPqWitnessAccountAddress(pqWitnesses.getPqWitnessAccountAddress());
+      // one account address should authorise witness permission to only one key
+      merged.checkWitnessAddressConflict();
       localWitnesses = merged;
     } else if (ecdsaWitnesses != null) {
       localWitnesses = ecdsaWitnesses;
 
@@ -1821,18 +1821,6 @@ public BlockCapsule generateBlock(Miner miner, long blockTime, long timeout) {
   private void signBlockCapsuleWithPQ(BlockCapsule blockCapsule, Miner miner) {
     Param.Miner.PQMiner pq = miner.getPq();
     PQScheme scheme = pq.getScheme();
-    if (scheme == null || !PQSchemeRegistry.contains(scheme)) {
-      throw new IllegalStateException(
-          "PQ miner " + Hex.toHexString(pq.getWitnessAddress().toByteArray())
-              + " has scheme " + scheme
-              + " which is not registered in PQSchemeRegistry");
-    }
-    if (!chainBaseManager.getDynamicPropertiesStore().isPqSchemeAllowed(scheme)) {
-      throw new IllegalStateException(
-          "PQ miner " + Hex.toHexString(pq.getWitnessAddress().toByteArray())
-              + " has scheme " + scheme
-              + " but it is not allowed by dynamic properties");
-    }
     byte[] pqPrivateKey = pq.getPrivateKey();
     byte[] pqPublicKey = pq.getPublicKey();
     if (pqPrivateKey == null || pqPublicKey == null) {
 
@@ -125,6 +125,10 @@ public void processHelloMessage(PeerConnection peer, HelloMessage msg) {
 
     peer.setHelloMessageReceive(msg);
 
+    // Wall-clock from libp2p channel creation to TRON handshake completion (this hello processed).
+    // Both stamps come from this node's clock, so it is skew-free; not a pure network RTT, but a
+    // useful latency reference — especially when the HelloMessage is large (e.g. carrying a PQ
+    // signature), where transfer time grows with message size.
     long latencyMs = System.currentTimeMillis() - peer.getChannel().getStartTime();
     peer.getChannel().updateAvgLatency(latencyMs);
     // Sample only the SR<->FF handshake path:
 
@@ -74,7 +74,7 @@ public class RelayService {
 
   private final List<InetSocketAddress> fastForwardNodes = parameter.getFastForwardNodes();
 
-  private final int keySize = Args.getLocalWitnesses().getPrivateKeys().size();
+  private final int ecdsaKeySize = Args.getLocalWitnesses().getPrivateKeys().size();
 
   private final int pqKeySize = Args.getLocalWitnesses().getPqKeypairs().size();
 
@@ -97,10 +97,11 @@ public void init() {
     backupManager = ctx.getBean(BackupManager.class);
 
     logger.info(
-        "Fast forward config, isWitness: {}, keySize: {}, pqKeySize: {}, fastForwardNodes: {}",
-        parameter.isWitness(), keySize, pqKeySize, fastForwardNodes.size());
+        "Fast forward config, isWitness: {}, ecdsaKeySize: {}, pqKeySize: {}, fastForwardNodes: {}",
+        parameter.isWitness(), ecdsaKeySize, pqKeySize, fastForwardNodes.size());
 
-    if (!parameter.isWitness() || (keySize == 0 && pqKeySize == 0) || fastForwardNodes.isEmpty()) {
+    if (!parameter.isWitness() || (ecdsaKeySize == 0 && pqKeySize == 0) ||
+        fastForwardNodes.isEmpty()) {
       return;
     }
 
@@ -144,7 +145,7 @@ public void fillHelloMessage(HelloMessage message, Channel channel) {
     // is currently in the active schedule — otherwise the receiver
     // rejects on the "not a schedule witness" check in checkHelloMessage.
     List<ByteString> active = witnessScheduleStore.getActiveWitnesses();
-    boolean useEcdsa = keySize > 0 && ecdsaWitnessAddress != null
+    boolean useEcdsa = ecdsaKeySize > 0 && ecdsaWitnessAddress != null
         && active.contains(ecdsaWitnessAddress);
     ByteString announceAddress = useEcdsa ? ecdsaWitnessAddress : pqWitnessAddress;
     Protocol.HelloMessage.Builder builder = message.getHelloMessage().toBuilder()
@@ -258,13 +259,8 @@ private boolean verifyEcdsaSignature(byte[] digest, ByteString signature,
   private boolean verifyPqAuthSig(byte[] digest, PQAuthSig pqAuthSig,
       ByteString witnessAddr, InetAddress remoteAddress) {
     PQScheme scheme = pqAuthSig.getScheme();
-    if (!PQSchemeRegistry.contains(scheme)) {
-      logger.warn("HelloMessage from {}, pq_auth_sig scheme {} is not registered.", remoteAddress,
-          scheme);
-      return false;
-    }
     if (!manager.getDynamicPropertiesStore().isPqSchemeAllowed(scheme)) {
-      logger.warn("HelloMessage from {}, pq_auth_sig scheme {} is not activated on chain.",
+      logger.warn("HelloMessage from {}, pq_auth_sig scheme {} is not allowed on chain.",
           remoteAddress, scheme);
       return false;
     }
@@ -320,7 +316,7 @@ private long getPeerCountByAddress(ByteString address) {
 
   private boolean isActiveWitness() {
     return parameter.isWitness()
-        && (keySize > 0 || pqKeySize > 0)
+        && (ecdsaKeySize > 0 || pqKeySize > 0)
         && !fastForwardNodes.isEmpty()
         && isAnyLocalWitnessActive()
         && backupManager.getStatus().equals(BackupStatusEnum.MASTER);
 
@@ -135,4 +135,40 @@ public void blankKeyRejected() {
     assertEquals(TronError.ErrCode.WITNESS_INIT, err.getErrCode());
     assertTrue(err.getMessage().contains("PQ private key"));
   }
+
+  @Test
+  public void sameWitnessAddressForEcdsaAndPqRejected() {
+    LocalWitnesses lw = new LocalWitnesses();
+    // Distinct array instances with identical content: must be compared by value
+    // (Arrays.equals), not by reference.
+    lw.setWitnessAccountAddress(new byte[] {0x41, 1, 2, 3});
+    lw.setPqWitnessAccountAddress(new byte[] {0x41, 1, 2, 3});
+    TronError err = assertThrows(TronError.class, lw::checkWitnessAddressConflict);
+    assertEquals(TronError.ErrCode.WITNESS_INIT, err.getErrCode());
+    assertTrue(err.getMessage().contains("only one key"));
+  }
+
+  @Test
+  public void distinctWitnessAddressesAccepted() {
+    LocalWitnesses lw = new LocalWitnesses();
+    lw.setWitnessAccountAddress(new byte[] {0x41, 1, 2, 3});
+    lw.setPqWitnessAccountAddress(new byte[] {0x41, 4, 5, 6});
+    lw.checkWitnessAddressConflict(); // no throw
+  }
+
+  @Test
+  public void onlyOneWitnessAddressSetAccepted() {
+    LocalWitnesses ecdsaOnly = new LocalWitnesses();
+    ecdsaOnly.setWitnessAccountAddress(new byte[] {0x41, 1, 2, 3});
+    ecdsaOnly.checkWitnessAddressConflict(); // pq address null -> no throw
+
+    LocalWitnesses pqOnly = new LocalWitnesses();
+    pqOnly.setPqWitnessAccountAddress(new byte[] {0x41, 1, 2, 3});
+    pqOnly.checkWitnessAddressConflict(); // ecdsa address null -> no throw
+  }
+
+  @Test
+  public void noWitnessAddressSetAccepted() {
+    new LocalWitnesses().checkWitnessAddressConflict(); // both null -> no throw
+  }
 }