Add support for 4byteTracer in debug_trace* methods

CHANGELOG.md

@@ -21,6 +21,7 @@
     - Fast Sync
 
 ### Additions and Improvements
+- Add support for `4byteTracer` in `debug_trace*` methods to collect function selectors from internal calls via PR [#9462][9462]. Thanks to [@JukLee0ira](https://github.com/JukLee0ira).
 - Performance: Optimise EIP-196 AltBn128: EcAdd 33-128% faster, EcMul 8% faster [#9570](https://github.com/hyperledger/besu/pull/9570)
 - Update to Netty 4.2.9.Final [#9587](https://github.com/hyperledger/besu/pull/9587)
 - Update to log4j 2.25.3 [#9600](https://github.com/hyperledger/besu/pull/9600)
@@ -33,6 +34,8 @@
 - Fix promotion to prioritized layer for gas price fee markets [#9635](https://github.com/hyperledger/besu/pull/9635)
 - Fix callTracer to properly capture nested calls and populate revertReason field when transactions revert [#9651](https://github.com/hyperledger/besu/pull/9651)
 
+[PR_9462]: https://github.com/hyperledger/besu/pull/9642
+
 ##  25.12.0
 
 ### Breaking Changes

ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/methods/DebugTraceTransactionStepFactory.java

@@ -17,6 +17,7 @@
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.processor.TransactionTrace;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.results.CallTracerResultConverter;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.results.DebugTraceTransactionResult;
+import org.hyperledger.besu.ethereum.api.jsonrpc.internal.results.FourByteTracerResultConverter;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.results.OpCodeLoggerTracerResult;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.results.tracing.diff.StateDiffTrace;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.results.tracing.diff.StateTraceGenerator;
@@ -83,6 +84,11 @@ public static Function<TransactionTrace, DebugTraceTransactionResult> create(
             return new DebugTraceTransactionResult(
                 transactionTrace, new StateTraceResult(trace, diffMode));
           };
+      case FOUR_BYTE_TRACER ->
+          transactionTrace -> {
+            var result = FourByteTracerResultConverter.convert(transactionTrace);
+            return new DebugTraceTransactionResult(transactionTrace, result);
+          };
     };
   }
 

ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/results/FourByteTracerResult.java

@@ -0,0 +1,74 @@
+/*
+ * 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.api.jsonrpc.internal.results;
+
+import java.util.Collections;
+import java.util.Map;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+
+/**
+ * Represents the result format for Ethereum's 4byteTracer as specified in the Geth documentation.
+ *
+ * <p>The 4byteTracer collects function selectors (the first 4 bytes of call data) from all calls
+ * made during transaction execution, along with the size of the supplied call data. This is useful
+ * for analyzing which contract functions were invoked during a transaction.
+ *
+ * <p>The JSON output is a simple map where keys are in the format
+ * "0x[4-byte-selector]-[calldata-size]" and values are the number of times that combination was
+ * called. For example:
+ *
+ * <pre>{@code
+ * {
+ *   "0x27dc297e-128": 1,
+ *   "0x38cc4831-0": 2,
+ *   "0x524f3889-96": 1
+ * }
+ * }</pre>
+ *
+ * @see <a
+ *     href="https://geth.ethereum.org/docs/developers/evm-tracing/built-in-tracers#4byte-tracer">
+ *     Geth 4byteTracer Documentation</a>
+ */
+public class FourByteTracerResult {
+
+  /**
+   * Map of function selector + call data size to occurrence count. Key format:
+   * "0x[4-byte-selector]-[calldata-size]"
+   */
+  private final Map<String, Integer> selectorCounts;
+
+  /**
+   * Constructs a FourByteTracerResult with the given selector counts.
+   *
+   * @param selectorCounts map of selector-size keys to occurrence counts
+   */
+  public FourByteTracerResult(final Map<String, Integer> selectorCounts) {
+    this.selectorCounts = selectorCounts != null ? selectorCounts : Collections.emptyMap();
+  }
+
+  /**
+   * Gets the map of function selectors and their occurrence counts.
+   *
+   * <p>The {@link JsonValue} annotation causes Jackson to serialize this object directly as the
+   * map, without wrapping it in an object. This matches Geth's output format.
+   *
+   * @return the map of selector-size keys to occurrence counts
+   */
+  @JsonValue
+  public Map<String, Integer> getSelectorCounts() {
+    return selectorCounts;
+  }
+}

ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/results/FourByteTracerResultConverter.java

@@ -0,0 +1,221 @@
+/*
+ * 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.api.jsonrpc.internal.results;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import org.hyperledger.besu.datatypes.Address;
+import org.hyperledger.besu.ethereum.api.jsonrpc.internal.processor.TransactionTrace;
+import org.hyperledger.besu.ethereum.api.jsonrpc.internal.results.calltrace.OpcodeCategory;
+import org.hyperledger.besu.ethereum.core.Transaction;
+import org.hyperledger.besu.evm.tracing.TraceFrame;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.TreeMap;
+
+import org.apache.tuweni.bytes.Bytes;
+
+/**
+ * Converts Ethereum transaction traces into 4byte tracer format.
+ *
+ * <p>This class transforms transaction traces to collect function selectors (the first 4 bytes of
+ * call data) from all internal calls made during transaction execution, along with the size of the
+ * remaining call data (excluding the 4-byte selector). This matches Geth's 4byteTracer output
+ * format.
+ *
+ * <p>The converter processes only CALL-type operations that successfully enter:
+ *
+ * <ul>
+ *   <li>CALL
+ *   <li>CALLCODE
+ *   <li>DELEGATECALL
+ *   <li>STATICCALL
+ * </ul>
+ *
+ * <p>CREATE and CREATE2 operations are excluded, as are calls to precompiled contracts and calls
+ * that fail to enter.
+ *
+ * <p>For each qualifying call operation, it extracts the first 4 bytes of the input data (the
+ * function selector) and combines it with the size of the remaining call data (size - 4) to create
+ * a key in the format "0x[4-byte-selector]-[remaining-size]". The result is a map of these keys to
+ * their occurrence counts.
+ *
+ * @see <a href="https://github.com/ethereum/go-ethereum/blob/master/eth/tracers/native/4byte.go">
+ *     Geth 4byteTracer Implementation</a>
+ */
+public class FourByteTracerResultConverter {
+
+  private static final int FUNCTION_SELECTOR_LENGTH = 4;
+
+  private FourByteTracerResultConverter() {
+    // Utility class - prevent instantiation
+  }
+
+  /**
+   * Converts a transaction trace to a 4byte tracer result.
+   *
+   * @param transactionTrace The transaction trace to convert
+   * @return A 4byte tracer result containing function selector counts
+   * @throws NullPointerException if transactionTrace is null
+   */
+  public static FourByteTracerResult convert(final TransactionTrace transactionTrace) {
+    checkNotNull(
+        transactionTrace, "FourByteTracerResultConverter requires a non-null TransactionTrace");
+
+    // Sort keys alphabetically to match Geth's JSON encoding behavior
+    final Map<String, Integer> selectorCounts = new TreeMap<>();
+
+    processInitialTransaction(transactionTrace, selectorCounts);
+
+    // Process all trace frames for internal calls only (not the initial transaction)
+    if (transactionTrace.getTraceFrames() != null) {
+      processTraceFrames(transactionTrace.getTraceFrames(), selectorCounts);
+    }
+
+    return new FourByteTracerResult(selectorCounts);
+  }
+
+  /**
+   * Processes the initial transaction to extract its function selector.
+   *
+   * <p>This matches Geth's behavior where OnEnter fires for the transaction's entry into the
+   * contract, not just for internal calls.
+   *
+   * @param transactionTrace the transaction trace
+   * @param selectorCounts the map to update with selector counts
+   */
+  private static void processInitialTransaction(
+      final TransactionTrace transactionTrace, final Map<String, Integer> selectorCounts) {
+
+    final Transaction tx = transactionTrace.getTransaction();
+
+    // Skip if this is a contract creation (no function selector)
+    if (tx.isContractCreation()) {
+      return;
+    }
+
+    // Skip if target is not present
+    final Optional<Address> to = tx.getTo();
+    if (to.isEmpty()) {
+      return;
+    }
+
+    // Skip precompiled contracts (addresses 0x01-0x0a typically)
+    // Note: This logic should match how precompiles are detected elsewhere in Besu
+    // For now, simple check for addresses <= 0x0a
+    final Bytes toAddressBytes = to.get().getBytes();
+    if (toAddressBytes.numberOfLeadingZeroBytes() >= 19
+        && toAddressBytes.trimLeadingZeros().size() == 1
+        && toAddressBytes.trimLeadingZeros().get(0) <= 0x0a) {
+      return;
+    }
+
+    final Bytes inputData = tx.getPayload();
+
+    // Only process if we have at least 4 bytes for the function selector
+    if (inputData != null && inputData.size() >= FUNCTION_SELECTOR_LENGTH) {
+      final String key = createKey(inputData);
+      selectorCounts.merge(key, 1, Integer::sum);
+    }
+  }
+
+  /**
+   * Processes all trace frames to extract function selectors from CALL operations.
+   *
+   * <p>This method only processes CALL, CALLCODE, DELEGATECALL, and STATICCALL operations that
+   * successfully enter a new execution scope. CREATE and CREATE2 operations are ignored to match
+   * Geth's behavior.
+   *
+   * @param frames the list of trace frames to process
+   * @param selectorCounts the map to update with selector counts
+   */
+  private static void processTraceFrames(
+      final List<TraceFrame> frames, final Map<String, Integer> selectorCounts) {
+
+    for (int i = 0; i < frames.size(); i++) {
+      final TraceFrame frame = frames.get(i);
+      final String opcode = frame.getOpcode();
+
+      // Only process CALL-type operations (not CREATE/CREATE2)
+      if (OpcodeCategory.isCallOp(opcode)) {
+        final TraceFrame nextTrace = (i < frames.size() - 1) ? frames.get(i + 1) : null;
+        processCall(frame, nextTrace, selectorCounts);
+      }
+    }
+  }
+
+  /**
+   * Processes a single CALL operation to extract its function selector.
+   *
+   * <p>This method:
+   *
+   * <ul>
+   *   <li>Checks if the call actually entered (depth increased in next frame)
+   *   <li>Skips calls to precompiled contracts
+   *   <li>Extracts the input data from the entered call
+   *   <li>Skips calls with less than 4 bytes of input (no function selector)
+   *   <li>Creates a key in the format "0x[selector]-[size-4]" and increments its count
+   * </ul>
+   *
+   * <p>This matches Geth's OnEnter hook behavior which only fires when a call successfully enters a
+   * new execution scope.
+   *
+   * @param frame the current trace frame (the CALL instruction)
+   * @param nextTrace the next trace frame (first frame inside the call, may be null)
+   * @param selectorCounts the map to update with selector counts
+   */
+  private static void processCall(
+      final TraceFrame frame,
+      final TraceFrame nextTrace,
+      final Map<String, Integer> selectorCounts) {
+
+    // Skip precompiled contracts
+    if (frame.isPrecompile()) {
+      return;
+    }
+
+    // Check if call entered (depth increased) - matches Geth's OnEnter behavior
+    final boolean calleeEntered = nextTrace != null && nextTrace.getDepth() > frame.getDepth();
+    if (!calleeEntered) {
+      return;
+    }
+
+    // Get the input data from the entered call (nextTrace has the actual input data)
+    final Bytes inputData = nextTrace.getInputData();
+
+    // Only process if we have at least 4 bytes for the function selector
+    if (inputData != null && inputData.size() >= FUNCTION_SELECTOR_LENGTH) {
+      final String key = createKey(inputData);
+      selectorCounts.merge(key, 1, Integer::sum);
+    }
+  }
+
+  /**
+   * Creates a key in the format "0x[4-byte-selector]-[size-4]" from the input data.
+   *
+   * <p>The size portion represents the length of the input data minus the 4-byte selector, matching
+   * Geth's implementation where the size is calculated as `len(input) - 4`.
+   *
+   * @param inputData the input data containing the function selector
+   * @return the formatted key (e.g., "0x27dc297e-128")
+   */
+  private static String createKey(final Bytes inputData) {
+    final Bytes selector = inputData.slice(0, FUNCTION_SELECTOR_LENGTH);
+    final int remainingSize = inputData.size() - FUNCTION_SELECTOR_LENGTH;
+    return selector.toHexString() + "-" + remainingSize;
+  }
+}

ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/methods/DebugTraceTransactionStepFactoryTest.java

@@ -23,6 +23,7 @@
 import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.processor.TransactionTrace;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.results.DebugTraceTransactionResult;
+import org.hyperledger.besu.ethereum.api.jsonrpc.internal.results.FourByteTracerResult;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.results.OpCodeLoggerTracerResult;
 import org.hyperledger.besu.ethereum.core.Transaction;
 import org.hyperledger.besu.ethereum.debug.TraceOptions;
@@ -94,6 +95,24 @@ void shouldCreateFunctionForOpcodeTracer() {
     assertThat(result.getResult()).isInstanceOf(OpCodeLoggerTracerResult.class);
   }
 
+  @Test
+  @DisplayName("should create function for FOUR_BYTE_TRACER that returns FourByteTracerResult")
+  void shouldCreateFunctionForFourByteTracer() {
+    // Given
+    TracerType tracerType = TracerType.FOUR_BYTE_TRACER;
+    TraceOptions traceOptions = new TraceOptions(tracerType, null, null);
+    Function<TransactionTrace, DebugTraceTransactionResult> function =
+        DebugTraceTransactionStepFactory.create(traceOptions);
+
+    // When
+    DebugTraceTransactionResult result = function.apply(mockTransactionTrace);
+
+    // Then
+    assertThat(result).isNotNull();
+    assertThat(result.getTxHash()).isEqualTo(EXPECTED_HASH);
+    assertThat(result.getResult()).isInstanceOf(FourByteTracerResult.class);
+  }
+
   @ParameterizedTest
   @EnumSource(
       value = TracerType.class,