Various TransactionType small optimizations

Signed-off-by: Fabio Di Fabio <[email protected]>

Author: fab-10

datatypes/src/main/java/org/hyperledger/besu/datatypes/TransactionType.java

@@ -14,14 +14,14 @@
  */
 package org.hyperledger.besu.datatypes;
 
-import java.util.Arrays;
 import java.util.EnumSet;
+import java.util.Optional;
 import java.util.Set;
 
 /** The enum Transaction type. */
 public enum TransactionType {
   /** The Frontier. */
-  FRONTIER(0xf8 /* this is serialized as 0x0 in TransactionCompleteResult */),
+  FRONTIER(0xf8, 0x00),
   /** Access list transaction type. */
   ACCESS_LIST(0x01),
   /** Eip1559 transaction type. */
@@ -32,15 +32,65 @@ public enum TransactionType {
   DELEGATE_CODE(0x04);
 
   private static final Set<TransactionType> ACCESS_LIST_SUPPORTED_TRANSACTION_TYPES =
-      Set.of(ACCESS_LIST, EIP1559, BLOB, DELEGATE_CODE);
+      EnumSet.of(ACCESS_LIST, EIP1559, BLOB, DELEGATE_CODE);
 
-  private static final EnumSet<TransactionType> LEGACY_FEE_MARKET_TRANSACTION_TYPES =
-      EnumSet.of(TransactionType.FRONTIER, TransactionType.ACCESS_LIST);
+  private static final Set<TransactionType> LEGACY_FEE_MARKET_TRANSACTION_TYPES =
+      EnumSet.of(FRONTIER, ACCESS_LIST);
 
-  private final int typeValue;
+  // The theoretical boundaries of the first byte of the RLP of a Frontier transaction.
+  // In practice Frontier transactions almost always start with 0xf8 or 0xf9.
+  private static final byte MIN_LEGACY_TX_OPAQUE_BYTE = (byte) 0xc0;
+  private static final byte MAX_LEGACY_TX_OPAQUE_BYTE = (byte) 0xfe;
+
+  // This array helps to translate the first opaque byte of an RLP encoded transaction
+  // to its type.
+  // Note that Frontier type occupies more slots, since there are different first byte values,
+  // that represent such type.
+  // Holes in the array represents invalid first byte values, for which there is not (yet)
+  // a defined transaction type
+  private static final TransactionType[] transactionTypeByOpaqueByte =
+      new TransactionType[Byte.toUnsignedInt(MAX_LEGACY_TX_OPAQUE_BYTE) + 1];
+
+  private static final TransactionType[] transactionTypeByEthSerializedType =
+      new TransactionType[values().length];
+
+  static {
+    EnumSet.allOf(TransactionType.class).stream()
+        .forEach(
+            tt -> {
+              tt.requireChainId = tt != FRONTIER;
+              tt.supportAccessList = ACCESS_LIST_SUPPORTED_TRANSACTION_TYPES.contains(tt);
+              tt.supportBaseFeeMarket = !LEGACY_FEE_MARKET_TRANSACTION_TYPES.contains(tt);
+              tt.supportBlob = tt == BLOB;
+              tt.supportDelegatedCode = tt == DELEGATE_CODE;
+              if (tt == FRONTIER) {
+                for (int i = Byte.toUnsignedInt(MIN_LEGACY_TX_OPAQUE_BYTE);
+                    i < Byte.toUnsignedInt(MAX_LEGACY_TX_OPAQUE_BYTE);
+                    i++) {
+                  transactionTypeByOpaqueByte[i] = FRONTIER;
+                }
+              } else {
+                transactionTypeByOpaqueByte[tt.getSerializedType()] = tt;
+              }
+              transactionTypeByEthSerializedType[tt.getEthSerializedType()] = tt;
+            });
+  }
+
+  private final byte typeValue;
+  private final byte serializedType;
+  boolean requireChainId;
+  boolean supportAccessList;
+  boolean supportBaseFeeMarket;
+  boolean supportBlob;
+  boolean supportDelegatedCode;
+
+  TransactionType(final int typeValue, final int serializedType) {
+    this.typeValue = (byte) typeValue;
+    this.serializedType = (byte) serializedType;
+  }
 
   TransactionType(final int typeValue) {
-    this.typeValue = typeValue;
+    this(typeValue, typeValue);
   }
 
   /**
@@ -49,7 +99,7 @@ public enum TransactionType {
    * @return the serialized type
    */
   public byte getSerializedType() {
-    return (byte) this.typeValue;
+    return typeValue;
   }
 
   /**
@@ -60,30 +110,35 @@ public byte getSerializedType() {
    * @return the serialized type
    */
   public byte getEthSerializedType() {
-    return (this == FRONTIER ? 0x00 : this.getSerializedType());
+    return serializedType;
   }
 
   /**
-   * Convert TransactionType from int serialized type value.
+   * Convert from opaque byte to type value.
    *
-   * @param serializedTypeValue the serialized type value
+   * @param opaqueByte the opaque byte from serialized bytes
    * @return the transaction type
    */
-  public static TransactionType of(final int serializedTypeValue) {
-    return Arrays.stream(
-            new TransactionType[] {
-              TransactionType.FRONTIER,
-              TransactionType.ACCESS_LIST,
-              TransactionType.EIP1559,
-              TransactionType.BLOB,
-              TransactionType.DELEGATE_CODE
-            })
-        .filter(transactionType -> transactionType.typeValue == serializedTypeValue)
-        .findFirst()
-        .orElseThrow(
-            () ->
-                new IllegalArgumentException(
-                    String.format("Unsupported transaction type %x", serializedTypeValue)));
+  public static Optional<TransactionType> fromOpaque(final byte opaqueByte) {
+    try {
+      return Optional.ofNullable(transactionTypeByOpaqueByte[Byte.toUnsignedInt(opaqueByte)]);
+    } catch (final ArrayIndexOutOfBoundsException e) {
+      return Optional.empty();
+    }
+  }
+
+  /**
+   * Convert from ETH serialized byte to type value.
+   *
+   * @param ethSerializedType the opaque byte from serialized bytes
+   * @return the transaction type
+   */
+  public static Optional<TransactionType> fromEthSerializedType(final byte ethSerializedType) {
+    try {
+      return Optional.ofNullable(transactionTypeByEthSerializedType[ethSerializedType]);
+    } catch (final ArrayIndexOutOfBoundsException e) {
+      return Optional.empty();
+    }
   }
 
   /**
@@ -92,7 +147,7 @@ public static TransactionType of(final int serializedTypeValue) {
    * @return the boolean
    */
   public boolean supportsAccessList() {
-    return ACCESS_LIST_SUPPORTED_TRANSACTION_TYPES.contains(this);
+    return supportAccessList;
   }
 
   /**
@@ -101,7 +156,7 @@ public boolean supportsAccessList() {
    * @return the boolean
    */
   public boolean supports1559FeeMarket() {
-    return !LEGACY_FEE_MARKET_TRANSACTION_TYPES.contains(this);
+    return supportBaseFeeMarket;
   }
 
   /**
@@ -110,7 +165,7 @@ public boolean supports1559FeeMarket() {
    * @return the boolean
    */
   public boolean requiresChainId() {
-    return !this.equals(FRONTIER);
+    return requireChainId;
   }
 
   /**
@@ -119,7 +174,7 @@ public boolean requiresChainId() {
    * @return the boolean
    */
   public boolean supportsBlob() {
-    return this.equals(BLOB);
+    return supportBlob;
   }
 
   /**
@@ -128,15 +183,6 @@ public boolean supportsBlob() {
    * @return the boolean
    */
   public boolean supportsDelegateCode() {
-    return this.equals(DELEGATE_CODE);
-  }
-
-  /**
-   * Does transaction type require code.
-   *
-   * @return the boolean
-   */
-  public boolean requiresCodeDelegation() {
-    return this.equals(DELEGATE_CODE);
+    return supportDelegatedCode;
   }
 }

ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/jsonrpc/SimpleTestTransactionBuilder.java

@@ -14,6 +14,7 @@
  */
 package org.hyperledger.besu.ethereum.api.jsonrpc;
 
+import static org.hyperledger.besu.datatypes.TransactionType.FRONTIER;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -70,7 +71,9 @@ public static Transaction transaction(
     when(transaction.getR()).thenReturn(bigInteger(r));
     when(transaction.getS()).thenReturn(bigInteger(s));
     when(transaction.getTo()).thenReturn(Optional.ofNullable(address(toAddress)));
-    when(transaction.getType()).thenReturn(TransactionType.of(Integer.decode(type)));
+    when(transaction.getType())
+        .thenReturn(
+            TransactionType.fromOpaque(Bytes.fromHexString(type, 1).get(0)).orElse(FRONTIER));
     when(transaction.getSender()).thenReturn(address(fromAddress));
     when(transaction.getPayload()).thenReturn(Bytes.fromHexString(input));
     when(transaction.getValue()).thenReturn(wei(value));

ethereum/core/src/jmh/java/org/hyperledger/besu/ethereum/core/TransactionTypeBenchmark.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright contributors to Besu.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package org.hyperledger.besu.ethereum.core;
+
+import org.hyperledger.besu.datatypes.TransactionType;
+
+import java.util.concurrent.TimeUnit;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
+
+@State(Scope.Thread)
+@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS)
+@OutputTimeUnit(value = TimeUnit.NANOSECONDS)
+@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
+@BenchmarkMode(Mode.AverageTime)
+public class TransactionTypeBenchmark {
+
+  @Setup()
+  public void setUp() {}
+
+  @Benchmark
+  public void ofSerializedType(final Blackhole blackhole) {
+    blackhole.consume(TransactionType.fromOpaque((byte) 0xf8));
+    blackhole.consume(TransactionType.fromOpaque((byte) 0x01));
+    blackhole.consume(TransactionType.fromOpaque((byte) 0x02));
+    blackhole.consume(TransactionType.fromOpaque((byte) 0x03));
+    blackhole.consume(TransactionType.fromOpaque((byte) 0x04));
+  }
+}

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/Transaction.java

@@ -246,7 +246,7 @@ private Transaction(
             maxFeePerBlobGas.isPresent(), "Must specify max fee per blob gas for blob transaction");
       }
 
-      if (transactionType.requiresCodeDelegation()) {
+      if (transactionType.supportsDelegateCode()) {
         checkArgument(
             maybeCodeDelegationList.isPresent(),
             "Must specify code delegation authorizations for code delegation transaction");

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/FrontierTransactionDecoder.java

@@ -28,21 +28,26 @@
 import org.hyperledger.besu.datatypes.TransactionType;
 import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.ethereum.core.Transaction;
+import org.hyperledger.besu.ethereum.rlp.RLP;
 import org.hyperledger.besu.ethereum.rlp.RLPInput;
 
 import java.math.BigInteger;
 import java.util.Optional;
 import java.util.function.Supplier;
 
 import com.google.common.base.Suppliers;
+import org.apache.tuweni.bytes.Bytes;
 
 public class FrontierTransactionDecoder {
   // Supplier for the signature algorithm
   private static final Supplier<SignatureAlgorithm> SIGNATURE_ALGORITHM =
       Suppliers.memoize(SignatureAlgorithmFactory::getInstance);
 
-  public static Transaction decode(final RLPInput input) {
-    RLPInput transactionRlp = input.readAsRlp();
+  public static Transaction decode(final Bytes input) {
+    return decode(RLP.input(input));
+  }
+
+  public static Transaction decode(final RLPInput transactionRlp) {
     int size = transactionRlp.currentSize();
     transactionRlp.enterList();
     final Transaction.Builder builder =
@@ -51,7 +56,7 @@ public static Transaction decode(final RLPInput input) {
             .nonce(transactionRlp.readLongScalar())
             .gasPrice(Wei.of(transactionRlp.readUInt256Scalar()))
             .gasLimit(transactionRlp.readLongScalar())
-            .to(transactionRlp.readBytes(v -> v.size() == 0 ? null : Address.wrap(v)))
+            .to(transactionRlp.readBytes(v -> v.isEmpty() ? null : Address.wrap(v)))
             .value(Wei.of(transactionRlp.readUInt256Scalar()))
             .payload(transactionRlp.readBytes())
             .rawRlp(transactionRlp.raw())