private BlockSimulationResult processBlockStateCall(
      final BlockHeader baseBlockHeader,
      final BlockStateCall blockStateCall,
      final MutableWorldState ws,
      final boolean shouldValidate,
      final boolean isTraceTransfers,
      final Supplier<SECPSignature> signatureSupplier,
      final Map<Long, Hash> blockHashCache,
      final long simulationCumulativeGasUsed) {

    BlockOverrides blockOverrides = blockStateCall.getBlockOverrides();
    ProtocolSpec protocolSpec =
        protocolSchedule.getForNextBlockHeader(
            baseBlockHeader, blockOverrides.getTimestamp().orElseThrow());

    BlockHeader overridenBaseBlockHeader =
        overrideBlockHeader(baseBlockHeader, protocolSpec, blockOverrides, shouldValidate);

    blockStateCall
        .getStateOverrideMap()
        .ifPresent(stateOverrideMap -> applyStateOverrides(stateOverrideMap, ws));

    // Create the transaction processor with precompile address overrides
    MainnetTransactionProcessor transactionProcessor =
        new SimulationTransactionProcessorFactory(protocolSchedule)
            .getTransactionProcessor(
                overridenBaseBlockHeader, blockStateCall.getStateOverrideMap());

    BlockHashLookup blockHashLookup =
        createBlockHashLookup(
            blockOverrides, protocolSpec, overridenBaseBlockHeader, blockHashCache);

    final BlockProcessingContext blockProcessingContext =
        new BlockProcessingContext(
            overridenBaseBlockHeader,
            ws,
            protocolSpec,
            blockHashLookup,
            OperationTracer.NO_TRACING);
    protocolSpec.getBlockHashProcessor().process(blockProcessingContext);

    BlockStateCallSimulationResult blockStateCallSimulationResult =
        processTransactions(
            overridenBaseBlockHeader,
            blockStateCall,
            ws,
            protocolSpec,
            shouldValidate,
            isTraceTransfers,
            transactionProcessor,
            blockHashLookup,
            signatureSupplier,
            simulationCumulativeGasUsed);

    // EIP-7685: process EL requests
    final Optional<RequestProcessorCoordinator> requestProcessor =
        protocolSpec.getRequestProcessorCoordinator();
    Optional<List<Request>> maybeRequests = Optional.empty();
    if (requestProcessor.isPresent()) {
      RequestProcessingContext requestProcessingContext =
          new RequestProcessingContext(
              blockProcessingContext, blockStateCallSimulationResult.getReceipts());
      maybeRequests = Optional.of(requestProcessor.get().process(requestProcessingContext));
    }

    return createFinalBlock(
        overridenBaseBlockHeader,
        blockStateCallSimulationResult,
        blockOverrides,
        ws,
        maybeRequests);
  }
Processes a single BlockStateCall, simulating the block execution.

@param baseBlockHeader The block header for the simulation.
@param blockStateCall The BlockStateCall to process.
@param ws The MutableWorldState to use for the simulation.
@return A BlockSimulationResult from processing the BlockStateCall.
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/transaction/BlockSimulator.java