public CompletableFuture<?> start() {
    LOG.info("Starting GraphQL HTTP service on {}:{}", config.getHost(), config.getPort());
    // Create the HTTP server and a router object.
    HttpServerOptions options =
        new HttpServerOptions()
            .setHost(config.getHost())
            .setPort(config.getPort())
            .setHandle100ContinueAutomatically(true)
            .setCompressionSupported(true);

    if (config.isTlsEnabled()) {
      try {
        options
            .setSsl(true)
            .setKeyCertOptions(
                new JksOptions()
                    .setPath(config.getTlsKeyStorePath())
                    .setPassword(config.getTlsKeyStorePassword()));
      } catch (Exception e) {
        LOG.error("Failed to get TLS keystore password", e);
        return CompletableFuture.failedFuture(e);
      }

      if (config.isMtlsEnabled()) {
        try {
          options
              .setTrustOptions(
                  new JksOptions()
                      .setPath(config.getTlsTrustStorePath())
                      .setPassword(config.getTlsTrustStorePassword()))
              .setClientAuth(ClientAuth.REQUIRED);
        } catch (Exception e) {
          LOG.error("Failed to get TLS truststore password", e);
          return CompletableFuture.failedFuture(e);
        }
      }
    }

    LOG.info("Options {}", options);
    httpServer = vertx.createHttpServer(options);

    // Handle graphql http requests
    final Router router = Router.router(vertx);

    // Verify Host header to avoid rebind attack.
    router.route().handler(checkAllowlistHostHeader());

    router
        .route()
        .handler(
            CorsHandler.create(buildCorsRegexFromConfig())
                .allowedHeader("*")
                .allowedHeader("content-type"));
    router
        .route()
        .handler(
            BodyHandler.create()
                .setUploadsDirectory(dataDir.resolve("uploads").toString())
                .setDeleteUploadedFilesOnEnd(true)
                .setPreallocateBodyBuffer(true));
    router.route("/").method(GET).method(POST).handler(this::handleEmptyRequestAndRedirect);
    router
        .route(GRAPH_QL_ROUTE)
        .method(GET)
        .method(POST)
        .produces(APPLICATION_JSON)
        .handler(
            TimeoutHandler.create(
                TimeUnit.SECONDS.toMillis(config.getHttpTimeoutSec()),
                TimeoutOptions.DEFAULT_ERROR_CODE))
        .handler(this::handleGraphQLRequest);

    final CompletableFuture<?> resultFuture = new CompletableFuture<>();
    httpServer
        .requestHandler(router)
        .listen(
            res -> {
              if (!res.failed()) {
                resultFuture.complete(null);
                LOG.info(
                    "GraphQL HTTP service started and listening on {}:{}",
                    config.getHost(),
                    httpServer.actualPort());
                return;
              }
              httpServer = null;
              final Throwable cause = res.cause();
              if (cause instanceof SocketException) {
                resultFuture.completeExceptionally(
                    new GraphQLServiceException(
                        String.format(
                            "Failed to bind Ethereum GraphQL HTTP listener to %s:%s: %s",
                            config.getHost(), config.getPort(), cause.getMessage())));
                return;
              }
              resultFuture.completeExceptionally(cause);
            });

    return resultFuture;
  }
Starts the GraphQL HTTP service.

<p>This method initializes the HTTP server and sets up the necessary routes for handling
GraphQL requests. It also validates the configuration and sets up the necessary handlers for
different types of requests.

@return a CompletableFuture that will be completed when the server is successfully started.
ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/graphql/GraphQLHttpService.java