hyperledger · matkt · Mar 25, 2025 · Feb 25, 2025 · Feb 28, 2025 · Feb 28, 2025
diff --git a/.gitignore b/.gitignore
@@ -31,3 +31,4 @@ site/
 **/src/*/generated
 jitpack.yml
 /ethereum/eth/src/test/resources/tx.csv.gz
+**/**/.factorypath
diff --git a/...reum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/AbstractBlockProcessor.java b/...reum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/AbstractBlockProcessor.java
@@ -49,6 +49,7 @@
 import java.util.List;
 import java.util.Optional;
 
+import com.google.common.annotations.VisibleForTesting;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -116,6 +117,7 @@ public BlockProcessingResult processBlock(
         new NoPreprocessing());
   }
 
+  @VisibleForTesting
   protected BlockProcessingResult processBlock(
       final ProtocolContext protocolContext,
       final Blockchain blockchain,

diff --git a/...core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionProcessor.java b/...core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionProcessor.java
@@ -627,6 +627,10 @@ public MessageCallProcessor getMessageCallProcessor() {
     return messageCallProcessor;
   }
 
+  public boolean getClearEmptyAccounts() {
+    return clearEmptyAccounts;
+  }
+
   private String printableStackTraceFromThrowable(final RuntimeException re) {
     final StringBuilder builder = new StringBuilder();
 

diff --git a/.../org/hyperledger/besu/ethereum/mainnet/parallelization/MainnetParallelBlockProcessor.java b/.../org/hyperledger/besu/ethereum/mainnet/parallelization/MainnetParallelBlockProcessor.java
@@ -32,7 +32,6 @@
 import org.hyperledger.besu.ethereum.mainnet.ProtocolSpecBuilder;
 import org.hyperledger.besu.ethereum.privacy.storage.PrivateMetadataUpdater;
 import org.hyperledger.besu.ethereum.processing.TransactionProcessingResult;
-import org.hyperledger.besu.ethereum.trie.pathbased.common.provider.PathBasedWorldStateProvider;
 import org.hyperledger.besu.evm.blockhash.BlockHashLookup;
 import org.hyperledger.besu.evm.worldstate.WorldUpdater;
 import org.hyperledger.besu.metrics.BesuMetricCategory;
@@ -41,6 +40,8 @@
 
 import java.util.List;
 import java.util.Optional;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -49,10 +50,12 @@ public class MainnetParallelBlockProcessor extends MainnetBlockProcessor {
 
   private static final Logger LOG = LoggerFactory.getLogger(MainnetParallelBlockProcessor.class);
 
-  private final Optional<MetricsSystem> metricsSystem;
   private final Optional<Counter> confirmedParallelizedTransactionCounter;
   private final Optional<Counter> conflictingButCachedTransactionCounter;
 
+  private static final int NCPU = Runtime.getRuntime().availableProcessors();
+  private static final Executor executor = Executors.newFixedThreadPool(NCPU);
+
   public MainnetParallelBlockProcessor(
       final MainnetTransactionProcessor transactionProcessor,
       final TransactionReceiptFactory transactionReceiptFactory,
@@ -68,24 +71,19 @@ public MainnetParallelBlockProcessor(
         miningBeneficiaryCalculator,
         skipZeroBlockRewards,
         protocolSchedule);
-    this.metricsSystem = Optional.of(metricsSystem);
     this.confirmedParallelizedTransactionCounter =
         Optional.of(
-            this.metricsSystem
-                .get()
-                .createCounter(
-                    BesuMetricCategory.BLOCK_PROCESSING,
-                    "parallelized_transactions_counter",
-                    "Counter for the number of parallelized transactions during block processing"));
+            metricsSystem.createCounter(
+                BesuMetricCategory.BLOCK_PROCESSING,
+                "parallelized_transactions_counter",
+                "Counter for the number of parallelized transactions during block processing"));
 
     this.conflictingButCachedTransactionCounter =
         Optional.of(
-            this.metricsSystem
-                .get()
-                .createCounter(
-                    BesuMetricCategory.BLOCK_PROCESSING,
-                    "conflicted_transactions_counter",
-                    "Counter for the number of conflicted transactions during block processing"));
+            metricsSystem.createCounter(
+                BesuMetricCategory.BLOCK_PROCESSING,
+                "conflicted_transactions_counter",
+                "Counter for the number of conflicted transactions during block processing"));
   }
 
   @Override
@@ -156,7 +154,7 @@ public BlockProcessingResult processBlock(
             ommers,
             maybeWithdrawals,
             privateMetadataUpdater,
-            new ParallelTransactionPreprocessing());
+            new ParallelTransactionPreprocessing(transactionProcessor, executor));
 
     if (blockProcessingResult.isFailed()) {
       // Fallback to non-parallel processing if there is a block processing exception .
@@ -209,35 +207,4 @@ public BlockProcessor apply(
           metricsSystem);
     }
   }
-
-  class ParallelTransactionPreprocessing implements PreprocessingFunction {
-
-    @Override
-    public Optional<PreprocessingContext> run(
-        final ProtocolContext protocolContext,
-        final PrivateMetadataUpdater privateMetadataUpdater,
-        final BlockHeader blockHeader,
-        final List<Transaction> transactions,
-        final Address miningBeneficiary,
-        final BlockHashLookup blockHashLookup,
-        final Wei blobGasPrice) {
-      if ((protocolContext.getWorldStateArchive() instanceof PathBasedWorldStateProvider)) {
-        ParallelizedConcurrentTransactionProcessor parallelizedConcurrentTransactionProcessor =
-            new ParallelizedConcurrentTransactionProcessor(transactionProcessor);
-        // runAsyncBlock, if activated, facilitates the  non-blocking parallel execution of
-        // transactions in the background through an optimistic strategy.
-        parallelizedConcurrentTransactionProcessor.runAsyncBlock(
-            protocolContext,
-            blockHeader,
-            transactions,
-            miningBeneficiary,
-            blockHashLookup,
-            blobGasPrice,
-            privateMetadataUpdater);
-        return Optional.of(
-            new ParallelizedPreProcessingContext(parallelizedConcurrentTransactionProcessor));
-      }
-      return Optional.empty();
-    }
-  }
 }
diff --git a/...g/hyperledger/besu/ethereum/mainnet/parallelization/ParallelTransactionPreprocessing.java b/...g/hyperledger/besu/ethereum/mainnet/parallelization/ParallelTransactionPreprocessing.java
@@ -0,0 +1,73 @@
+/*
+ * 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.mainnet.parallelization;
+
+import org.hyperledger.besu.datatypes.Address;
+import org.hyperledger.besu.datatypes.Wei;
+import org.hyperledger.besu.ethereum.ProtocolContext;
+import org.hyperledger.besu.ethereum.core.BlockHeader;
+import org.hyperledger.besu.ethereum.core.Transaction;
+import org.hyperledger.besu.ethereum.mainnet.AbstractBlockProcessor.PreprocessingContext;
+import org.hyperledger.besu.ethereum.mainnet.AbstractBlockProcessor.PreprocessingFunction;
+import org.hyperledger.besu.ethereum.mainnet.MainnetTransactionProcessor;
+import org.hyperledger.besu.ethereum.mainnet.parallelization.MainnetParallelBlockProcessor.ParallelizedPreProcessingContext;
+import org.hyperledger.besu.ethereum.privacy.storage.PrivateMetadataUpdater;
+import org.hyperledger.besu.ethereum.trie.pathbased.common.provider.PathBasedWorldStateProvider;
+import org.hyperledger.besu.evm.blockhash.BlockHashLookup;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.Executor;
+
+public class ParallelTransactionPreprocessing implements PreprocessingFunction {
+
+  private final MainnetTransactionProcessor transactionProcessor;
+  private final Executor executor;
+
+  public ParallelTransactionPreprocessing(
+      final MainnetTransactionProcessor transactionProcessor, final Executor executor) {
+    this.transactionProcessor = transactionProcessor;
+    this.executor = executor;
+  }
+
+  @Override
+  public Optional<PreprocessingContext> run(
+      final ProtocolContext protocolContext,
+      final PrivateMetadataUpdater privateMetadataUpdater,
+      final BlockHeader blockHeader,
+      final List<Transaction> transactions,
+      final Address miningBeneficiary,
+      final BlockHashLookup blockHashLookup,
+      final Wei blobGasPrice) {
+    if ((protocolContext.getWorldStateArchive() instanceof PathBasedWorldStateProvider)) {
+      ParallelizedConcurrentTransactionProcessor parallelizedConcurrentTransactionProcessor =
+          new ParallelizedConcurrentTransactionProcessor(transactionProcessor);
+      // runAsyncBlock, if activated, facilitates the non-blocking parallel execution
+      // of transactions in the background through an optimistic strategy.
+      parallelizedConcurrentTransactionProcessor.runAsyncBlock(
+          protocolContext,
+          blockHeader,
+          transactions,
+          miningBeneficiary,
+          blockHashLookup,
+          blobGasPrice,
+          privateMetadataUpdater,
+          executor);
+      return Optional.of(
+          new ParallelizedPreProcessingContext(parallelizedConcurrentTransactionProcessor));
+    }
+    return Optional.empty();
+  }
+}
diff --git a/...ger/besu/ethereum/mainnet/parallelization/ParallelizedConcurrentTransactionProcessor.java b/...ger/besu/ethereum/mainnet/parallelization/ParallelizedConcurrentTransactionProcessor.java
@@ -39,7 +39,6 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executor;
-import java.util.concurrent.Executors;
 
 import com.google.common.annotations.VisibleForTesting;
 
@@ -52,9 +51,6 @@
 @SuppressWarnings({"unchecked", "rawtypes"})
 public class ParallelizedConcurrentTransactionProcessor {
 
-  private static final int NCPU = Runtime.getRuntime().availableProcessors();
-  private static final Executor executor = Executors.newFixedThreadPool(NCPU);
-
   private final MainnetTransactionProcessor transactionProcessor;
 
   private final TransactionCollisionDetector transactionCollisionDetector;
@@ -98,6 +94,7 @@ public ParallelizedConcurrentTransactionProcessor(
    * @param blockHashLookup Function for block hash lookup.
    * @param blobGasPrice Gas price for blob transactions.
    * @param privateMetadataUpdater Updater for private transaction metadata.
+   * @param executor The executor to use for asynchronous execution.
    */
   public void runAsyncBlock(
       final ProtocolContext protocolContext,
@@ -106,7 +103,8 @@ public void runAsyncBlock(
       final Address miningBeneficiary,
       final BlockHashLookup blockHashLookup,
       final Wei blobGasPrice,
-      final PrivateMetadataUpdater privateMetadataUpdater) {
+      final PrivateMetadataUpdater privateMetadataUpdater,
+      final Executor executor) {
 
     completableFuturesForBackgroundTransactions = new CompletableFuture[transactions.size()];
     for (int i = 0; i < transactions.size(); i++) {
@@ -261,9 +259,10 @@ public Optional<TransactionProcessingResult> applyParallelizedTransactionResult(
           transactionCollisionDetector.hasCollision(
               transaction, miningBeneficiary, parallelizedTransactionContext, blockAccumulator);
       if (transactionProcessingResult.isSuccessful() && !hasCollision) {
-        blockAccumulator
-            .getOrCreate(miningBeneficiary)
-            .incrementBalance(parallelizedTransactionContext.miningBeneficiaryReward());
+        Wei reward = parallelizedTransactionContext.miningBeneficiaryReward();
+        if (!reward.isZero() || !transactionProcessor.getClearEmptyAccounts()) {
+          blockAccumulator.getOrCreate(miningBeneficiary).incrementBalance(reward);
+        }
 
         blockAccumulator.importStateChangesFromSource(transactionAccumulator);