Cleanup leftovers after the removal of eth/66 (hyperledger#9907)

Signed-off-by: Fabio Di Fabio <fabio.difabio@consensys.net>

Author: fab-10

ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/EthProtocol.java

@@ -29,7 +29,6 @@
 public class EthProtocol implements SubProtocol {
   public static final String NAME = "eth";
   private static final EthProtocol INSTANCE = new EthProtocol();
-  public static final Capability ETH66 = Capability.create(NAME, EthProtocolVersion.V66);
   public static final Capability ETH68 = Capability.create(NAME, EthProtocolVersion.V68);
   public static final Capability ETH69 = Capability.create(NAME, EthProtocolVersion.V69);
   public static final BitSet REQUEST_ID_MESSAGES;
@@ -49,7 +48,7 @@ public class EthProtocol implements SubProtocol {
             EthProtocolMessages.RECEIPTS);
     REQUEST_ID_MESSAGES =
         new BitSet(requestIdMessages.stream().mapToInt(i -> i).max().getAsInt() + 1);
-    requestIdMessages.forEach(requestIdMessage -> REQUEST_ID_MESSAGES.set(requestIdMessage));
+    requestIdMessages.forEach(REQUEST_ID_MESSAGES::set);
   }
 
   // Latest version of the Eth protocol
@@ -67,7 +66,7 @@ public String getName() {
   @Override
   public int messageSpace(final int protocolVersion) {
     return switch (protocolVersion) {
-      case EthProtocolVersion.V66, EthProtocolVersion.V68 -> 17;
+      case EthProtocolVersion.V68 -> 17;
       case EthProtocolVersion.V69 -> 18;
       default -> 0;
     };
@@ -80,40 +79,24 @@ public boolean isValidMessageCode(final int protocolVersion, final int code) {
 
   @Override
   public String messageName(final int protocolVersion, final int code) {
-    switch (code) {
-      case EthProtocolMessages.STATUS:
-        return "Status";
-      case EthProtocolMessages.NEW_BLOCK_HASHES:
-        return "NewBlockHashes";
-      case EthProtocolMessages.TRANSACTIONS:
-        return "Transactions";
-      case EthProtocolMessages.GET_BLOCK_HEADERS:
-        return "GetBlockHeaders";
-      case EthProtocolMessages.BLOCK_HEADERS:
-        return "BlockHeaders";
-      case EthProtocolMessages.GET_BLOCK_BODIES:
-        return "GetBlockBodies";
-      case EthProtocolMessages.BLOCK_BODIES:
-        return "BlockBodies";
-      case EthProtocolMessages.NEW_BLOCK:
-        return "NewBlock";
-      case EthProtocolMessages.NEW_POOLED_TRANSACTION_HASHES:
-        return "NewPooledTransactionHashes";
-      case EthProtocolMessages.GET_POOLED_TRANSACTIONS:
-        return "GetPooledTransactions";
-      case EthProtocolMessages.POOLED_TRANSACTIONS:
-        return "PooledTransactions";
-      case EthProtocolMessages.GET_NODE_DATA:
-        return "GetNodeData";
-      case EthProtocolMessages.NODE_DATA:
-        return "NodeData";
-      case EthProtocolMessages.GET_RECEIPTS:
-        return "GetReceipts";
-      case EthProtocolMessages.RECEIPTS:
-        return "Receipts";
-      default:
-        return INVALID_MESSAGE_NAME;
-    }
+    return switch (code) {
+      case EthProtocolMessages.STATUS -> "Status";
+      case EthProtocolMessages.NEW_BLOCK_HASHES -> "NewBlockHashes";
+      case EthProtocolMessages.TRANSACTIONS -> "Transactions";
+      case EthProtocolMessages.GET_BLOCK_HEADERS -> "GetBlockHeaders";
+      case EthProtocolMessages.BLOCK_HEADERS -> "BlockHeaders";
+      case EthProtocolMessages.GET_BLOCK_BODIES -> "GetBlockBodies";
+      case EthProtocolMessages.BLOCK_BODIES -> "BlockBodies";
+      case EthProtocolMessages.NEW_BLOCK -> "NewBlock";
+      case EthProtocolMessages.NEW_POOLED_TRANSACTION_HASHES -> "NewPooledTransactionHashes";
+      case EthProtocolMessages.GET_POOLED_TRANSACTIONS -> "GetPooledTransactions";
+      case EthProtocolMessages.POOLED_TRANSACTIONS -> "PooledTransactions";
+      case EthProtocolMessages.GET_NODE_DATA -> "GetNodeData";
+      case EthProtocolMessages.NODE_DATA -> "NodeData";
+      case EthProtocolMessages.GET_RECEIPTS -> "GetReceipts";
+      case EthProtocolMessages.RECEIPTS -> "Receipts";
+      default -> INVALID_MESSAGE_NAME;
+    };
   }
 
   public static EthProtocol get() {

ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/EthProtocolVersion.java

@@ -25,29 +25,9 @@
  * (ETH)</a>}
  */
 public class EthProtocolVersion {
-  public static final int V66 = 66;
   public static final int V68 = 68;
   public static final int V69 = 69;
 
-  /** eth/66 */
-  private static final List<Integer> eth66Messages =
-      List.of(
-          EthProtocolMessages.STATUS,
-          EthProtocolMessages.NEW_BLOCK_HASHES,
-          EthProtocolMessages.TRANSACTIONS,
-          EthProtocolMessages.GET_BLOCK_HEADERS,
-          EthProtocolMessages.BLOCK_HEADERS,
-          EthProtocolMessages.GET_BLOCK_BODIES,
-          EthProtocolMessages.BLOCK_BODIES,
-          EthProtocolMessages.NEW_BLOCK,
-          EthProtocolMessages.GET_NODE_DATA,
-          EthProtocolMessages.NODE_DATA,
-          EthProtocolMessages.GET_RECEIPTS,
-          EthProtocolMessages.RECEIPTS,
-          EthProtocolMessages.NEW_POOLED_TRANSACTION_HASHES,
-          EthProtocolMessages.GET_POOLED_TRANSACTIONS,
-          EthProtocolMessages.POOLED_TRANSACTIONS);
-
   /** eth/68 */
   private static final List<Integer> eth68Messages =
       List.of(
@@ -94,15 +74,10 @@ public class EthProtocolVersion {
    * @return a list containing the codes of supported messages
    */
   public static List<Integer> getSupportedMessages(final int protocolVersion) {
-    switch (protocolVersion) {
-      case EthProtocolVersion.V66:
-        return eth66Messages;
-      case EthProtocolVersion.V68:
-        return eth68Messages;
-      case EthProtocolVersion.V69:
-        return eth69Messages;
-      default:
-        return Collections.emptyList();
-    }
+    return switch (protocolVersion) {
+      case EthProtocolVersion.V68 -> eth68Messages;
+      case EthProtocolVersion.V69 -> eth69Messages;
+      default -> Collections.emptyList();
+    };
   }
 }

ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/encoding/TransactionAnnouncementEncoder.java

@@ -14,12 +14,9 @@
  */
 package org.hyperledger.besu.ethereum.eth.encoding;
 
-import static org.hyperledger.besu.ethereum.core.Transaction.toHashList;
-
 import org.hyperledger.besu.datatypes.Hash;
 import org.hyperledger.besu.datatypes.TransactionType;
 import org.hyperledger.besu.ethereum.core.Transaction;
-import org.hyperledger.besu.ethereum.eth.EthProtocolVersion;
 import org.hyperledger.besu.ethereum.p2p.rlpx.wire.Capability;
 import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput;
 
@@ -45,25 +42,7 @@ public interface Encoder {
    * @return the correct encoder
    */
   public static Encoder getEncoder(final Capability capability) {
-    if (capability.getVersion() >= EthProtocolVersion.V68) {
-      return TransactionAnnouncementEncoder::encodeForEth68;
-    } else {
-      return TransactionAnnouncementEncoder::encodeForEth66;
-    }
-  }
-
-  /**
-   * Encode a list of hashes for the NewPooledTransactionHashesMessage using the Eth/66
-   *
-   * <p>format: [hash_0: B_32, hash_1: B_32, ...]
-   *
-   * @param transactions the list to encode
-   * @return the encoded value. The message data will contain only the transaction hashes
-   */
-  private static Bytes encodeForEth66(final List<Transaction> transactions) {
-    final BytesValueRLPOutput out = new BytesValueRLPOutput();
-    out.writeList(toHashList(transactions), (h, w) -> w.writeBytes(h.getBytes()));
-    return out.encoded();
+    return TransactionAnnouncementEncoder::encodeForEth68;
   }
 
   /**

ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/messages/NewPooledTransactionHashesMessageTest.java

@@ -35,7 +35,7 @@ public class NewPooledTransactionHashesMessageTest {
   public void roundTripNewPooledTransactionHashesMessage() {
     final List<Transaction> transactions = List.of(new BlockDataGenerator().transaction());
     final NewPooledTransactionHashesMessage msg =
-        NewPooledTransactionHashesMessage.create(transactions, EthProtocol.ETH66);
+        NewPooledTransactionHashesMessage.create(transactions, EthProtocol.LATEST);
     assertThat(msg.getCode()).isEqualTo(EthProtocolMessages.NEW_POOLED_TRANSACTION_HASHES);
     final List<Hash> pendingHashes = msg.pendingTransactionHashes();
     assertThat(pendingHashes).isEqualTo(toHashList(transactions));
@@ -46,6 +46,6 @@ public void readFromMessageWithWrongCodeThrows() {
     final RawMessage rawMsg = new RawMessage(EthProtocolMessages.BLOCK_HEADERS, Bytes.of(0));
 
     assertThatExceptionOfType(IllegalArgumentException.class)
-        .isThrownBy(() -> NewPooledTransactionHashesMessage.readFrom(rawMsg, EthProtocol.ETH66));
+        .isThrownBy(() -> NewPooledTransactionHashesMessage.readFrom(rawMsg, EthProtocol.LATEST));
   }
 }

ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/transactions/NewPooledTransactionHashesMessageProcessorTest.java

@@ -109,7 +109,7 @@ void shouldAddInitiatedRequestingTransactions() {
 
     messageHandler.processNewPooledTransactionHashesMessage(
         peer1,
-        NewPooledTransactionHashesMessage.create(transactionList, EthProtocol.ETH66),
+        NewPooledTransactionHashesMessage.create(transactionList, EthProtocol.LATEST),
         now(),
         ofMinutes(1));
 
@@ -127,7 +127,7 @@ void shouldNotAddAlreadyPresentTransactions() {
 
     messageHandler.processNewPooledTransactionHashesMessage(
         peer1,
-        NewPooledTransactionHashesMessage.create(transactionList, EthProtocol.ETH66),
+        NewPooledTransactionHashesMessage.create(transactionList, EthProtocol.LATEST),
         now(),
         ofMinutes(1));
 
@@ -142,7 +142,7 @@ void shouldAddInitiatedRequestingTransactionsWhenOutOfSync() {
 
     messageHandler.processNewPooledTransactionHashesMessage(
         peer1,
-        NewPooledTransactionHashesMessage.create(transactionList, EthProtocol.ETH66),
+        NewPooledTransactionHashesMessage.create(transactionList, EthProtocol.LATEST),
         now(),
         ofMinutes(1));
     verify(transactionPool, times(3)).getTransactionByHash(any());
@@ -152,7 +152,7 @@ void shouldAddInitiatedRequestingTransactionsWhenOutOfSync() {
   void shouldNotMarkReceivedExpiredTransactionsAsSeen() {
     messageHandler.processNewPooledTransactionHashesMessage(
         peer1,
-        NewPooledTransactionHashesMessage.create(transactionList, EthProtocol.ETH66),
+        NewPooledTransactionHashesMessage.create(transactionList, EthProtocol.LATEST),
         now().minus(ofMinutes(1)),
         ofMillis(1));
     verifyNoInteractions(transactionTracker);
@@ -167,7 +167,7 @@ void shouldNotMarkReceivedExpiredTransactionsAsSeen() {
   void shouldNotAddReceivedTransactionsToTransactionPoolIfExpired() {
     messageHandler.processNewPooledTransactionHashesMessage(
         peer1,
-        NewPooledTransactionHashesMessage.create(transactionList, EthProtocol.ETH66),
+        NewPooledTransactionHashesMessage.create(transactionList, EthProtocol.LATEST),
         now().minus(ofMinutes(1)),
         ofMillis(1));
     verifyNoInteractions(transactionPool);
@@ -187,7 +187,7 @@ void shouldScheduleGetPooledTransactionsTaskWhenNewTransactionAddedFromPeerForTh
     messageHandler.processNewPooledTransactionHashesMessage(
         peer1,
         NewPooledTransactionHashesMessage.create(
-            List.of(transaction1, transaction2), EthProtocol.ETH66),
+            List.of(transaction1, transaction2), EthProtocol.LATEST),
         now(),
         ofMinutes(1));
 
@@ -202,14 +202,14 @@ void shouldNotScheduleGetPooledTransactionsTaskTwice() {
     messageHandler.processNewPooledTransactionHashesMessage(
         peer1,
         NewPooledTransactionHashesMessage.create(
-            Collections.singletonList(transaction1), EthProtocol.ETH66),
+            Collections.singletonList(transaction1), EthProtocol.LATEST),
         now(),
         ofMinutes(1));
 
     messageHandler.processNewPooledTransactionHashesMessage(
         peer1,
         NewPooledTransactionHashesMessage.create(
-            Collections.singletonList(transaction2), EthProtocol.ETH66),
+            Collections.singletonList(transaction2), EthProtocol.LATEST),
         now(),
         ofMinutes(1));
 
@@ -218,32 +218,6 @@ void shouldNotScheduleGetPooledTransactionsTaskTwice() {
             any(FetcherCreatorTask.class), any(Duration.class), any(Duration.class));
   }
 
-  @Test
-  void shouldCreateAndDecodeForEth66() {
-
-    final List<TransactionAnnouncement> expectedAnnouncementList =
-        transactionList.stream().map(TransactionAnnouncement::new).toList();
-
-    final NewPooledTransactionHashesMessage message =
-        NewPooledTransactionHashesMessage.create(transactionList, EthProtocol.ETH66);
-
-    // for eth/66 the message should not contain size or type
-    message
-        .pendingTransactions()
-        .forEach(
-            t -> {
-              assertThat(t.getSize()).isEmpty();
-              assertThat(t.getType()).isEmpty();
-            });
-
-    // assert all transaction hashes are the same as announcement message
-    assertThat(message.pendingTransactionHashes())
-        .containsExactlyElementsOf(
-            expectedAnnouncementList.stream()
-                .map(TransactionAnnouncement::getHash)
-                .collect(Collectors.toList()));
-  }
-
   @Test
   void shouldCreateAndDecodeForEth68() {
     final List<TransactionAnnouncement> expectedTransactions =
@@ -256,24 +230,6 @@ void shouldCreateAndDecodeForEth68() {
     assertThat(announcementList).containsExactlyElementsOf(expectedTransactions);
   }
 
-  @Test
-  void shouldThrowRLPExceptionIfIncorrectVersion() {
-
-    // message for Eth/68 with 66 data should throw RLPException
-    final NewPooledTransactionHashesMessage message66 =
-        new NewPooledTransactionHashesMessage(
-            getEncoder(EthProtocol.ETH68).encode(transactionList), EthProtocol.ETH66);
-    // assert RLPException
-    assertThatThrownBy(message66::pendingTransactions).isInstanceOf(RLPException.class);
-
-    // message for Eth/66 with 68 data should throw RLPException
-    final NewPooledTransactionHashesMessage message68 =
-        new NewPooledTransactionHashesMessage(
-            getEncoder(EthProtocol.ETH68).encode(transactionList), EthProtocol.ETH66);
-    // assert RLPException
-    assertThatThrownBy(message68::pendingTransactions).isInstanceOf(RLPException.class);
-  }
-
   @Test
   void shouldEncodeTransactionsCorrectly_Eth68() {
 
@@ -383,25 +339,6 @@ void shouldDecodeBytesCorrectly_PreviousImplementations_Eth68() {
     assertThat(eip1559.getSize()).hasValue(3L);
   }
 
-  @Test
-  void shouldEncodeAndDecodeTransactionAnnouncement_Eth66() {
-    final Transaction t1 = generator.transaction(TransactionType.FRONTIER);
-    final Transaction t2 = generator.transaction(TransactionType.ACCESS_LIST);
-    final Transaction t3 = generator.transaction(TransactionType.EIP1559);
-    final List<Transaction> list = List.of(t1, t2, t3);
-    final Bytes bytes = getEncoder(EthProtocol.ETH66).encode(list);
-
-    final List<TransactionAnnouncement> announcementList =
-        getDecoder(EthProtocol.ETH66).decode(RLP.input(bytes));
-
-    for (int i = 0; i < announcementList.size(); i++) {
-      final TransactionAnnouncement announcement = announcementList.get(i);
-      assertThat(announcement.getHash()).isEqualTo(list.get(i).getHash());
-      assertThat(announcement.getType()).isEmpty();
-      assertThat(announcement.getType()).isEmpty();
-    }
-  }
-
   @Test
   void shouldEncodeAndDecodeTransactionAnnouncement_Eth68() {
     final Transaction t1 = generator.transaction(TransactionType.FRONTIER);

ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/transactions/NewPooledTransactionHashesMessageSenderTest.java

@@ -143,7 +143,7 @@ private MessageData transactionsMessageContaining(final Transaction... transacti
 
   private Set<Hash> getTransactionsFromMessage(final MessageData message) {
     final NewPooledTransactionHashesMessage transactionsMessage =
-        NewPooledTransactionHashesMessage.readFrom(message, EthProtocol.ETH66);
+        NewPooledTransactionHashesMessage.readFrom(message, EthProtocol.LATEST);
     return newHashSet(transactionsMessage.pendingTransactionHashes());
   }
 }