@VisibleForTesting
  public void runTransaction(
      final ProtocolContext protocolContext,
      final BlockHeader blockHeader,
      final int transactionLocation,
      final Transaction transaction,
      final Address miningBeneficiary,
      final BlockHashLookup blockHashLookup,
      final Wei blobGasPrice) {
    final BlockHeader chainHeadHeader = protocolContext.getBlockchain().getChainHeadHeader();
    if (chainHeadHeader.getHash().equals(blockHeader.getParentHash())) {
      try (BonsaiWorldState ws =
          (BonsaiWorldState)
              protocolContext
                  .getWorldStateArchive()
                  .getWorldState(
                      WorldStateQueryParams.withBlockHeaderAndNoUpdateNodeHead(chainHeadHeader))
                  .orElse(null)) {
        if (ws != null) {
          ws.disableCacheMerkleTrieLoader();
          final ParallelizedTransactionContext.Builder contextBuilder =
              new ParallelizedTransactionContext.Builder();
          final PathBasedWorldStateUpdateAccumulator<?> roundWorldStateUpdater =
              (PathBasedWorldStateUpdateAccumulator<?>) ws.updater();
          final TransactionProcessingResult result =
              transactionProcessor.processTransaction(
                  roundWorldStateUpdater,
                  blockHeader,
                  transaction.detachedCopy(),
                  miningBeneficiary,
                  new OperationTracer() {
                    @Override
                    public void traceBeforeRewardTransaction(
                        final WorldView worldView,
                        final org.hyperledger.besu.datatypes.Transaction tx,
                        final Wei miningReward) {
                      /*
                       * This part checks if the mining beneficiary's account was accessed before increasing its balance for rewards.
                       * Indeed, if the transaction has interacted with the address to read or modify it,
                       * it means that the value is necessary for the proper execution of the transaction and will therefore be considered in collision detection.
                       * If this is not the case, we can ignore this address during conflict detection.
                       */
                      if (transactionCollisionDetector
                          .getAddressesTouchedByTransaction(
                              transaction, Optional.of(roundWorldStateUpdater))
                          .contains(miningBeneficiary)) {
                        contextBuilder.isMiningBeneficiaryTouchedPreRewardByTransaction(true);
                      }
                      contextBuilder.miningBeneficiaryReward(miningReward);
                    }
                  },
                  blockHashLookup,
                  TransactionValidationParams.processingBlock(),
                  blobGasPrice);

          // commit the accumulator in order to apply all the modifications
          ws.getAccumulator().commit();

          contextBuilder
              .transactionAccumulator(ws.getAccumulator())
              .transactionProcessingResult(result);

          final ParallelizedTransactionContext parallelizedTransactionContext =
              contextBuilder.build();
          if (!parallelizedTransactionContext.isMiningBeneficiaryTouchedPreRewardByTransaction()) {
            /*
             * If the address of the mining beneficiary has been touched only for adding rewards,
             * we remove it from the accumulator to avoid a false positive collision.
             * The balance will be increased during the sequential processing.
             */
            roundWorldStateUpdater.getAccountsToUpdate().remove(miningBeneficiary);
          }
          parallelizedTransactionContextByLocation.put(
              transactionLocation, parallelizedTransactionContext);
        }
      } catch (Exception ex) {
        // no op as failing to get worldstate
      }
    }
  }
Initiates the parallel and optimistic execution of transactions within a block by creating a
copy of the world state for each transaction. This method processes transactions in a
non-blocking manner. Transactions are executed against their respective copies of the world
state, ensuring that the original world state passed as a parameter remains unmodified during
this process.

@param protocolContext the current context of the protocol
@param blockHeader Header of the current block containing the transactions.
@param transactions List of transactions to be processed.
@param miningBeneficiary Address of the beneficiary to receive mining rewards.
@param blockHashLookup Function for block hash lookup.
@param blobGasPrice Gas price for blob transactions.
@param executor The executor to use for asynchronous execution.
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/parallelization/ParallelizedConcurrentTransactionProcessor.java