static ProtocolSpecBuilder pragueDefinition(
      final Optional<BigInteger> chainId,
      final boolean enableRevertReason,
      final GenesisConfigOptions genesisConfigOptions,
      final EvmConfiguration evmConfiguration,
      final MiningConfiguration miningConfiguration,
      final boolean isParallelTxProcessingEnabled,
      final MetricsSystem metricsSystem) {
    ProtocolSpecBuilder pragueSpecBuilder =
        cancunDefinition(
                chainId,
                enableRevertReason,
                genesisConfigOptions,
                evmConfiguration,
                miningConfiguration,
                isParallelTxProcessingEnabled,
                metricsSystem)
            .blobSchedule(
                genesisConfigOptions
                    .getBlobScheduleOptions()
                    .flatMap(BlobScheduleOptions::getPrague)
                    .orElse(BlobSchedule.PRAGUE_DEFAULT))
            .gasCalculator(PragueGasCalculator::new)
            // EIP-3074 AUTH and AUTHCALL
            .evmBuilder(
                (gasCalculator, jdCacheConfig) ->
                    MainnetEVMs.prague(
                        gasCalculator, chainId.orElse(BigInteger.ZERO), evmConfiguration))

            // EIP-2537 BLS12-381 precompiles
            .precompileContractRegistryBuilder(MainnetPrecompiledContractRegistries::prague)

            // EIP-7002 Withdrawals / EIP-6610 Deposits / EIP-7685 Requests
            .requestsValidator(new MainnetRequestsValidator())

            // change to accept EIP-7702 transactions
            .transactionValidatorFactoryBuilder(
                (evm, gasLimitCalculator, feeMarket) ->
                    new TransactionValidatorFactory(
                        evm.getGasCalculator(),
                        gasLimitCalculator,
                        feeMarket,
                        true,
                        chainId,
                        Set.of(
                            TransactionType.FRONTIER,
                            TransactionType.ACCESS_LIST,
                            TransactionType.EIP1559,
                            TransactionType.BLOB,
                            TransactionType.DELEGATE_CODE),
                        Set.of(BlobType.KZG_PROOF),
                        evm.getMaxInitcodeSize()))
            // CodeDelegationProcessor
            .transactionProcessorBuilder(
                (gasCalculator,
                    feeMarket,
                    transactionValidator,
                    contractCreationProcessor,
                    messageCallProcessor) ->
                    MainnetTransactionProcessor.builder()
                        .gasCalculator(gasCalculator)
                        .transactionValidatorFactory(transactionValidator)
                        .contractCreationProcessor(contractCreationProcessor)
                        .messageCallProcessor(messageCallProcessor)
                        .clearEmptyAccounts(true)
                        .warmCoinbase(true)
                        .maxStackSize(evmConfiguration.evmStackSize())
                        .feeMarket(feeMarket)
                        .coinbaseFeePriceCalculator(CoinbaseFeePriceCalculator.eip1559())
                        .codeDelegationProcessor(
                            new CodeDelegationProcessor(
                                chainId,
                                SIGNATURE_ALGORITHM.get().getHalfCurveOrder(),
                                new CodeDelegationService()))
                        .build())
            // EIP-2935 Blockhash processor
            .blockHashProcessor(new PragueBlockHashProcessor())
            .name("Prague");
    try {
      RequestContractAddresses requestContractAddresses =
          RequestContractAddresses.fromGenesis(genesisConfigOptions);

      pragueSpecBuilder.requestProcessorCoordinator(
          pragueRequestsProcessors(requestContractAddresses));
    } catch (NoSuchElementException nsee) {
      LOG.warn("Prague definitions require system contract addresses in genesis");
      throw nsee;
    }

    return pragueSpecBuilder;
  }
Provides the various {@link ProtocolSpec}s on mainnet hard forks.
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetProtocolSpecs.java