build.zig

// This file is generated by zbuild. Do not edit manually.

const std = @import("std");

pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    const options_build_options = b.addOptions();
    const option_zero_hash_max_depth = b.option(u8, "zero_hash_max_depth", "");
    options_build_options.addOption(?u8, "zero_hash_max_depth", option_zero_hash_max_depth);
    const option_preset = b.option([]const u8, "preset", "") orelse "mainnet";
    options_build_options.addOption([]const u8, "preset", option_preset);
    const options_module_build_options = options_build_options.createModule();

    const options_download_era_options = b.addOptions();
    const option_era_base_url = b.option([]const u8, "era_base_url", "") orelse "https://mainnet.era.nimbus.team";
    options_download_era_options.addOption([]const u8, "era_base_url", option_era_base_url);
    const option_era_files = b.option([]const []const u8, "era_files", "") orelse &[_][]const u8{ "mainnet-01628-47ac89fb.era", "mainnet-01629-f4b834bc.era" };
    options_download_era_options.addOption([]const []const u8, "era_files", option_era_files);
    const option_era_out_dir = b.option([]const u8, "era_out_dir", "") orelse "fixtures/era";
    options_download_era_options.addOption([]const u8, "era_out_dir", option_era_out_dir);
    const options_module_download_era_options = options_download_era_options.createModule();

    const options_spec_test_options = b.addOptions();
    const option_spec_test_url = b.option([]const u8, "spec_test_url", "") orelse "https://github.com/ethereum/consensus-specs";
    options_spec_test_options.addOption([]const u8, "spec_test_url", option_spec_test_url);
    const option_spec_test_version = b.option([]const u8, "spec_test_version", "") orelse "v1.6.0-beta.2";
    options_spec_test_options.addOption([]const u8, "spec_test_version", option_spec_test_version);
    const option_spec_test_out_dir = b.option([]const u8, "spec_test_out_dir", "") orelse "test/spec/spec_tests";
    options_spec_test_options.addOption([]const u8, "spec_test_out_dir", option_spec_test_out_dir);
    const options_module_spec_test_options = options_spec_test_options.createModule();

    const dep_blst = b.dependency("blst", .{
        .optimize = optimize,
        .target = target,
    });

    const dep_hashtree = b.dependency("hashtree", .{
        .optimize = optimize,
        .target = target,
    });

    const dep_snappy = b.dependency("snappy", .{
        .optimize = optimize,
        .target = target,
    });

    const dep_yaml = b.dependency("yaml", .{
        .optimize = optimize,
        .target = target,
    });

    const dep_zbench = b.dependency("zbench", .{
        .optimize = optimize,
        .target = target,
    });

    const dep_metrics = b.dependency("metrics", .{
        .optimize = optimize,
        .target = target,
    });

    const dep_httpz = b.dependency("httpz", .{
        .optimize = optimize,
        .target = target,
    });

    const module_constants = b.createModule(.{
        .root_source_file = b.path("src/constants/root.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("constants"), module_constants) catch @panic("OOM");

    const module_config = b.createModule(.{
        .root_source_file = b.path("src/config/root.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("config"), module_config) catch @panic("OOM");

    const module_consensus_types = b.createModule(.{
        .root_source_file = b.path("src/consensus_types/root.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("consensus_types"), module_consensus_types) catch @panic("OOM");

    const module_era = b.createModule(.{
        .root_source_file = b.path("src/era/root.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("era"), module_era) catch @panic("OOM");

    const module_hashing = b.createModule(.{
        .root_source_file = b.path("src/hashing/root.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("hashing"), module_hashing) catch @panic("OOM");

    const module_hex = b.createModule(.{
        .root_source_file = b.path("src/hex.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("hex"), module_hex) catch @panic("OOM");

    const module_fork_types = b.createModule(.{
        .root_source_file = b.path("src/fork_types/root.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("fork_types"), module_fork_types) catch @panic("OOM");

    const module_persistent_merkle_tree = b.createModule(.{
        .root_source_file = b.path("src/persistent_merkle_tree/root.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("persistent_merkle_tree"), module_persistent_merkle_tree) catch @panic("OOM");

    const module_preset = b.createModule(.{
        .root_source_file = b.path("src/preset/root.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("preset"), module_preset) catch @panic("OOM");

    const module_ssz = b.createModule(.{
        .root_source_file = b.path("src/ssz/root.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("ssz"), module_ssz) catch @panic("OOM");

    const module_state_transition = b.createModule(.{
        .root_source_file = b.path("src/state_transition/root.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("state_transition"), module_state_transition) catch @panic("OOM");

    const module_download_era_files = b.createModule(.{
        .root_source_file = b.path("scripts/download_era_files.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("download_era_files"), module_download_era_files) catch @panic("OOM");

    const exe_download_era_files = b.addExecutable(.{
        .name = "download_era_files",
        .root_module = module_download_era_files,
    });

    const install_exe_download_era_files = b.addInstallArtifact(exe_download_era_files, .{});

    const tls_install_exe_download_era_files = b.step("build-exe:download_era_files", "Install the download_era_files executable");
    tls_install_exe_download_era_files.dependOn(&install_exe_download_era_files.step);
    b.getInstallStep().dependOn(&install_exe_download_era_files.step);

    const run_exe_download_era_files = b.addRunArtifact(exe_download_era_files);
    if (b.args) |args| run_exe_download_era_files.addArgs(args);
    const tls_run_exe_download_era_files = b.step("run:download_era_files", "Run the download_era_files executable");
    tls_run_exe_download_era_files.dependOn(&run_exe_download_era_files.step);

    const module_metrics_era = b.createModule(.{
        .root_source_file = b.path("examples/metrics_era.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("metrics_era"), module_metrics_era) catch @panic("OOM");

    const exe_metrics_era = b.addExecutable(.{
        .name = "metrics_era",
        .root_module = module_metrics_era,
    });

    const install_exe_metrics_era = b.addInstallArtifact(exe_metrics_era, .{});

    const tls_install_exe_metrics_era = b.step("build-exe:metrics_era", "Install the metrics_era executable");
    tls_install_exe_metrics_era.dependOn(&install_exe_metrics_era.step);
    b.getInstallStep().dependOn(&install_exe_metrics_era.step);

    const run_exe_metrics_era = b.addRunArtifact(exe_metrics_era);
    if (b.args) |args| run_exe_metrics_era.addArgs(args);
    const tls_run_exe_metrics_era = b.step("run:metrics_era", "Run the metrics_era executable");
    tls_run_exe_metrics_era.dependOn(&run_exe_metrics_era.step);

    const module_download_spec_tests = b.createModule(.{
        .root_source_file = b.path("test/spec/download_spec_tests.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("download_spec_tests"), module_download_spec_tests) catch @panic("OOM");

    const exe_download_spec_tests = b.addExecutable(.{
        .name = "download_spec_tests",
        .root_module = module_download_spec_tests,
    });

    const install_exe_download_spec_tests = b.addInstallArtifact(exe_download_spec_tests, .{});

    const tls_install_exe_download_spec_tests = b.step("build-exe:download_spec_tests", "Install the download_spec_tests executable");
    tls_install_exe_download_spec_tests.dependOn(&install_exe_download_spec_tests.step);
    b.getInstallStep().dependOn(&install_exe_download_spec_tests.step);

    const run_exe_download_spec_tests = b.addRunArtifact(exe_download_spec_tests);
    if (b.args) |args| run_exe_download_spec_tests.addArgs(args);
    const tls_run_exe_download_spec_tests = b.step("run:download_spec_tests", "Run the download_spec_tests executable");
    tls_run_exe_download_spec_tests.dependOn(&run_exe_download_spec_tests.step);

    const module_write_spec_tests = b.createModule(.{
        .root_source_file = b.path("test/spec/write_spec_tests.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("write_spec_tests"), module_write_spec_tests) catch @panic("OOM");

    const exe_write_spec_tests = b.addExecutable(.{
        .name = "write_spec_tests",
        .root_module = module_write_spec_tests,
    });

    const install_exe_write_spec_tests = b.addInstallArtifact(exe_write_spec_tests, .{});

    const tls_install_exe_write_spec_tests = b.step("build-exe:write_spec_tests", "Install the write_spec_tests executable");
    tls_install_exe_write_spec_tests.dependOn(&install_exe_write_spec_tests.step);
    b.getInstallStep().dependOn(&install_exe_write_spec_tests.step);

    const run_exe_write_spec_tests = b.addRunArtifact(exe_write_spec_tests);
    if (b.args) |args| run_exe_write_spec_tests.addArgs(args);
    const tls_run_exe_write_spec_tests = b.step("run:write_spec_tests", "Run the write_spec_tests executable");
    tls_run_exe_write_spec_tests.dependOn(&run_exe_write_spec_tests.step);

    const module_write_ssz_generic_spec_tests = b.createModule(.{
        .root_source_file = b.path("test/spec/ssz/write_generic_tests.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("write_ssz_generic_spec_tests"), module_write_ssz_generic_spec_tests) catch @panic("OOM");

    const exe_write_ssz_generic_spec_tests = b.addExecutable(.{
        .name = "write_ssz_generic_spec_tests",
        .root_module = module_write_ssz_generic_spec_tests,
    });

    const install_exe_write_ssz_generic_spec_tests = b.addInstallArtifact(exe_write_ssz_generic_spec_tests, .{});

    const tls_install_exe_write_ssz_generic_spec_tests = b.step("build-exe:write_ssz_generic_spec_tests", "Install the write_ssz_generic_spec_tests executable");
    tls_install_exe_write_ssz_generic_spec_tests.dependOn(&install_exe_write_ssz_generic_spec_tests.step);
    b.getInstallStep().dependOn(&install_exe_write_ssz_generic_spec_tests.step);

    const run_exe_write_ssz_generic_spec_tests = b.addRunArtifact(exe_write_ssz_generic_spec_tests);
    if (b.args) |args| run_exe_write_ssz_generic_spec_tests.addArgs(args);
    const tls_run_exe_write_ssz_generic_spec_tests = b.step("run:write_ssz_generic_spec_tests", "Run the write_ssz_generic_spec_tests executable");
    tls_run_exe_write_ssz_generic_spec_tests.dependOn(&run_exe_write_ssz_generic_spec_tests.step);

    const module_write_ssz_static_spec_tests = b.createModule(.{
        .root_source_file = b.path("test/spec/ssz/write_static_tests.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("write_ssz_static_spec_tests"), module_write_ssz_static_spec_tests) catch @panic("OOM");

    const exe_write_ssz_static_spec_tests = b.addExecutable(.{
        .name = "write_ssz_static_spec_tests",
        .root_module = module_write_ssz_static_spec_tests,
    });

    const install_exe_write_ssz_static_spec_tests = b.addInstallArtifact(exe_write_ssz_static_spec_tests, .{});

    const tls_install_exe_write_ssz_static_spec_tests = b.step("build-exe:write_ssz_static_spec_tests", "Install the write_ssz_static_spec_tests executable");
    tls_install_exe_write_ssz_static_spec_tests.dependOn(&install_exe_write_ssz_static_spec_tests.step);
    b.getInstallStep().dependOn(&install_exe_write_ssz_static_spec_tests.step);

    const run_exe_write_ssz_static_spec_tests = b.addRunArtifact(exe_write_ssz_static_spec_tests);
    if (b.args) |args| run_exe_write_ssz_static_spec_tests.addArgs(args);
    const tls_run_exe_write_ssz_static_spec_tests = b.step("run:write_ssz_static_spec_tests", "Run the write_ssz_static_spec_tests executable");
    tls_run_exe_write_ssz_static_spec_tests.dependOn(&run_exe_write_ssz_static_spec_tests.step);

    const module_bench_ssz_attestation = b.createModule(.{
        .root_source_file = b.path("bench/ssz/attestation.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("bench_ssz_attestation"), module_bench_ssz_attestation) catch @panic("OOM");

    const exe_bench_ssz_attestation = b.addExecutable(.{
        .name = "bench_ssz_attestation",
        .root_module = module_bench_ssz_attestation,
    });

    const install_exe_bench_ssz_attestation = b.addInstallArtifact(exe_bench_ssz_attestation, .{});

    const tls_install_exe_bench_ssz_attestation = b.step("build-exe:bench_ssz_attestation", "Install the bench_ssz_attestation executable");
    tls_install_exe_bench_ssz_attestation.dependOn(&install_exe_bench_ssz_attestation.step);
    b.getInstallStep().dependOn(&install_exe_bench_ssz_attestation.step);

    const run_exe_bench_ssz_attestation = b.addRunArtifact(exe_bench_ssz_attestation);
    if (b.args) |args| run_exe_bench_ssz_attestation.addArgs(args);
    const tls_run_exe_bench_ssz_attestation = b.step("run:bench_ssz_attestation", "Run the bench_ssz_attestation executable");
    tls_run_exe_bench_ssz_attestation.dependOn(&run_exe_bench_ssz_attestation.step);

    const module_bench_ssz_block = b.createModule(.{
        .root_source_file = b.path("bench/ssz/block.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("bench_ssz_block"), module_bench_ssz_block) catch @panic("OOM");

    const exe_bench_ssz_block = b.addExecutable(.{
        .name = "bench_ssz_block",
        .root_module = module_bench_ssz_block,
    });

    const install_exe_bench_ssz_block = b.addInstallArtifact(exe_bench_ssz_block, .{});

    const tls_install_exe_bench_ssz_block = b.step("build-exe:bench_ssz_block", "Install the bench_ssz_block executable");
    tls_install_exe_bench_ssz_block.dependOn(&install_exe_bench_ssz_block.step);
    b.getInstallStep().dependOn(&install_exe_bench_ssz_block.step);

    const run_exe_bench_ssz_block = b.addRunArtifact(exe_bench_ssz_block);
    if (b.args) |args| run_exe_bench_ssz_block.addArgs(args);
    const tls_run_exe_bench_ssz_block = b.step("run:bench_ssz_block", "Run the bench_ssz_block executable");
    tls_run_exe_bench_ssz_block.dependOn(&run_exe_bench_ssz_block.step);

    const module_bench_ssz_state = b.createModule(.{
        .root_source_file = b.path("bench/ssz/state.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("bench_ssz_state"), module_bench_ssz_state) catch @panic("OOM");

    const exe_bench_ssz_state = b.addExecutable(.{
        .name = "bench_ssz_state",
        .root_module = module_bench_ssz_state,
    });

    const install_exe_bench_ssz_state = b.addInstallArtifact(exe_bench_ssz_state, .{});

    const tls_install_exe_bench_ssz_state = b.step("build-exe:bench_ssz_state", "Install the bench_ssz_state executable");
    tls_install_exe_bench_ssz_state.dependOn(&install_exe_bench_ssz_state.step);
    b.getInstallStep().dependOn(&install_exe_bench_ssz_state.step);

    const run_exe_bench_ssz_state = b.addRunArtifact(exe_bench_ssz_state);
    if (b.args) |args| run_exe_bench_ssz_state.addArgs(args);
    const tls_run_exe_bench_ssz_state = b.step("run:bench_ssz_state", "Run the bench_ssz_state executable");
    tls_run_exe_bench_ssz_state.dependOn(&run_exe_bench_ssz_state.step);

    const module_bench_merkle_gindex = b.createModule(.{
        .root_source_file = b.path("bench/ssz/gindex.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("bench_merkle_gindex"), module_bench_merkle_gindex) catch @panic("OOM");

    const exe_bench_merkle_gindex = b.addExecutable(.{
        .name = "bench_merkle_gindex",
        .root_module = module_bench_merkle_gindex,
    });

    const install_exe_bench_merkle_gindex = b.addInstallArtifact(exe_bench_merkle_gindex, .{});

    const tls_install_exe_bench_merkle_gindex = b.step("build-exe:bench_merkle_gindex", "Install the bench_merkle_gindex executable");
    tls_install_exe_bench_merkle_gindex.dependOn(&install_exe_bench_merkle_gindex.step);
    b.getInstallStep().dependOn(&install_exe_bench_merkle_gindex.step);

    const run_exe_bench_merkle_gindex = b.addRunArtifact(exe_bench_merkle_gindex);
    if (b.args) |args| run_exe_bench_merkle_gindex.addArgs(args);
    const tls_run_exe_bench_merkle_gindex = b.step("run:bench_merkle_gindex", "Run the bench_merkle_gindex executable");
    tls_run_exe_bench_merkle_gindex.dependOn(&run_exe_bench_merkle_gindex.step);

    const module_bench_merkle_node = b.createModule(.{
        .root_source_file = b.path("src/persistent_merkle_tree/node_bench.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("bench_merkle_node"), module_bench_merkle_node) catch @panic("OOM");

    const exe_bench_merkle_node = b.addExecutable(.{
        .name = "bench_merkle_node",
        .root_module = module_bench_merkle_node,
    });

    const install_exe_bench_merkle_node = b.addInstallArtifact(exe_bench_merkle_node, .{});

    const tls_install_exe_bench_merkle_node = b.step("build-exe:bench_merkle_node", "Install the bench_merkle_node executable");
    tls_install_exe_bench_merkle_node.dependOn(&install_exe_bench_merkle_node.step);
    b.getInstallStep().dependOn(&install_exe_bench_merkle_node.step);

    const run_exe_bench_merkle_node = b.addRunArtifact(exe_bench_merkle_node);
    if (b.args) |args| run_exe_bench_merkle_node.addArgs(args);
    const tls_run_exe_bench_merkle_node = b.step("run:bench_merkle_node", "Run the bench_merkle_node executable");
    tls_run_exe_bench_merkle_node.dependOn(&run_exe_bench_merkle_node.step);

    const module_bench_hashing = b.createModule(.{
        .root_source_file = b.path("bench/ssz/hashing.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("bench_hashing"), module_bench_hashing) catch @panic("OOM");

    const exe_bench_hashing = b.addExecutable(.{
        .name = "bench_hashing",
        .root_module = module_bench_hashing,
    });

    const install_exe_bench_hashing = b.addInstallArtifact(exe_bench_hashing, .{});

    const tls_install_exe_bench_hashing = b.step("build-exe:bench_hashing", "Install the bench_hashing executable");
    tls_install_exe_bench_hashing.dependOn(&install_exe_bench_hashing.step);
    b.getInstallStep().dependOn(&install_exe_bench_hashing.step);

    const run_exe_bench_hashing = b.addRunArtifact(exe_bench_hashing);
    if (b.args) |args| run_exe_bench_hashing.addArgs(args);
    const tls_run_exe_bench_hashing = b.step("run:bench_hashing", "Run the bench_hashing executable");
    tls_run_exe_bench_hashing.dependOn(&run_exe_bench_hashing.step);

    const module_bench_process_block = b.createModule(.{
        .root_source_file = b.path("bench/state_transition/process_block.zig"),
        .target = target,
        .optimize = optimize,
        .strip = false,
        .omit_frame_pointer = false,
    });
    b.modules.put(b.dupe("bench_process_block"), module_bench_process_block) catch @panic("OOM");

    const exe_bench_process_block = b.addExecutable(.{
        .name = "bench_process_block",
        .root_module = module_bench_process_block,
    });

    const install_exe_bench_process_block = b.addInstallArtifact(exe_bench_process_block, .{});

    const tls_install_exe_bench_process_block = b.step("build-exe:bench_process_block", "Install the bench_process_block executable");
    tls_install_exe_bench_process_block.dependOn(&install_exe_bench_process_block.step);
    b.getInstallStep().dependOn(&install_exe_bench_process_block.step);

    const run_exe_bench_process_block = b.addRunArtifact(exe_bench_process_block);
    if (b.args) |args| run_exe_bench_process_block.addArgs(args);
    const tls_run_exe_bench_process_block = b.step("run:bench_process_block", "Run the bench_process_block executable");
    tls_run_exe_bench_process_block.dependOn(&run_exe_bench_process_block.step);

    const module_bench_process_epoch = b.createModule(.{
        .root_source_file = b.path("bench/state_transition/process_epoch.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("bench_process_epoch"), module_bench_process_epoch) catch @panic("OOM");

    const exe_bench_process_epoch = b.addExecutable(.{
        .name = "bench_process_epoch",
        .root_module = module_bench_process_epoch,
    });

    const install_exe_bench_process_epoch = b.addInstallArtifact(exe_bench_process_epoch, .{});

    const tls_install_exe_bench_process_epoch = b.step("build-exe:bench_process_epoch", "Install the bench_process_epoch executable");
    tls_install_exe_bench_process_epoch.dependOn(&install_exe_bench_process_epoch.step);
    b.getInstallStep().dependOn(&install_exe_bench_process_epoch.step);

    const run_exe_bench_process_epoch = b.addRunArtifact(exe_bench_process_epoch);
    if (b.args) |args| run_exe_bench_process_epoch.addArgs(args);
    const tls_run_exe_bench_process_epoch = b.step("run:bench_process_epoch", "Run the bench_process_epoch executable");
    tls_run_exe_bench_process_epoch.dependOn(&run_exe_bench_process_epoch.step);

    const tls_run_test = b.step("test", "Run all tests");

    const test_constants = b.addTest(.{
        .name = "constants",
        .root_module = module_constants,
        .filters = b.option([][]const u8, "constants.filters", "constants test filters") orelse &[_][]const u8{},
    });
    const install_test_constants = b.addInstallArtifact(test_constants, .{});
    const tls_install_test_constants = b.step("build-test:constants", "Install the constants test");
    tls_install_test_constants.dependOn(&install_test_constants.step);

    const run_test_constants = b.addRunArtifact(test_constants);
    const tls_run_test_constants = b.step("test:constants", "Run the constants test");
    tls_run_test_constants.dependOn(&run_test_constants.step);
    tls_run_test.dependOn(&run_test_constants.step);

    const test_config = b.addTest(.{
        .name = "config",
        .root_module = module_config,
        .filters = b.option([][]const u8, "config.filters", "config test filters") orelse &[_][]const u8{},
    });
    const install_test_config = b.addInstallArtifact(test_config, .{});
    const tls_install_test_config = b.step("build-test:config", "Install the config test");
    tls_install_test_config.dependOn(&install_test_config.step);

    const run_test_config = b.addRunArtifact(test_config);
    const tls_run_test_config = b.step("test:config", "Run the config test");
    tls_run_test_config.dependOn(&run_test_config.step);
    tls_run_test.dependOn(&run_test_config.step);

    const test_consensus_types = b.addTest(.{
        .name = "consensus_types",
        .root_module = module_consensus_types,
        .filters = b.option([][]const u8, "consensus_types.filters", "consensus_types test filters") orelse &[_][]const u8{},
    });
    const install_test_consensus_types = b.addInstallArtifact(test_consensus_types, .{});
    const tls_install_test_consensus_types = b.step("build-test:consensus_types", "Install the consensus_types test");
    tls_install_test_consensus_types.dependOn(&install_test_consensus_types.step);

    const run_test_consensus_types = b.addRunArtifact(test_consensus_types);
    const tls_run_test_consensus_types = b.step("test:consensus_types", "Run the consensus_types test");
    tls_run_test_consensus_types.dependOn(&run_test_consensus_types.step);
    tls_run_test.dependOn(&run_test_consensus_types.step);

    const test_era = b.addTest(.{
        .name = "era",
        .root_module = module_era,
        .filters = b.option([][]const u8, "era.filters", "era test filters") orelse &[_][]const u8{},
    });
    const install_test_era = b.addInstallArtifact(test_era, .{});
    const tls_install_test_era = b.step("build-test:era", "Install the era test");
    tls_install_test_era.dependOn(&install_test_era.step);

    const run_test_era = b.addRunArtifact(test_era);
    const tls_run_test_era = b.step("test:era", "Run the era test");
    tls_run_test_era.dependOn(&run_test_era.step);
    tls_run_test.dependOn(&run_test_era.step);

    const test_hashing = b.addTest(.{
        .name = "hashing",
        .root_module = module_hashing,
        .filters = b.option([][]const u8, "hashing.filters", "hashing test filters") orelse &[_][]const u8{},
    });
    const install_test_hashing = b.addInstallArtifact(test_hashing, .{});
    const tls_install_test_hashing = b.step("build-test:hashing", "Install the hashing test");
    tls_install_test_hashing.dependOn(&install_test_hashing.step);

    const run_test_hashing = b.addRunArtifact(test_hashing);
    const tls_run_test_hashing = b.step("test:hashing", "Run the hashing test");
    tls_run_test_hashing.dependOn(&run_test_hashing.step);
    tls_run_test.dependOn(&run_test_hashing.step);

    const test_hex = b.addTest(.{
        .name = "hex",
        .root_module = module_hex,
        .filters = b.option([][]const u8, "hex.filters", "hex test filters") orelse &[_][]const u8{},
    });
    const install_test_hex = b.addInstallArtifact(test_hex, .{});
    const tls_install_test_hex = b.step("build-test:hex", "Install the hex test");
    tls_install_test_hex.dependOn(&install_test_hex.step);

    const run_test_hex = b.addRunArtifact(test_hex);
    const tls_run_test_hex = b.step("test:hex", "Run the hex test");
    tls_run_test_hex.dependOn(&run_test_hex.step);
    tls_run_test.dependOn(&run_test_hex.step);

    const test_fork_types = b.addTest(.{
        .name = "fork_types",
        .root_module = module_fork_types,
        .filters = b.option([][]const u8, "fork_types.filters", "fork_types test filters") orelse &[_][]const u8{},
    });
    const install_test_fork_types = b.addInstallArtifact(test_fork_types, .{});
    const tls_install_test_fork_types = b.step("build-test:fork_types", "Install the fork_types test");
    tls_install_test_fork_types.dependOn(&install_test_fork_types.step);

    const run_test_fork_types = b.addRunArtifact(test_fork_types);
    const tls_run_test_fork_types = b.step("test:fork_types", "Run the fork_types test");
    tls_run_test_fork_types.dependOn(&run_test_fork_types.step);
    tls_run_test.dependOn(&run_test_fork_types.step);

    const test_persistent_merkle_tree = b.addTest(.{
        .name = "persistent_merkle_tree",
        .root_module = module_persistent_merkle_tree,
        .filters = b.option([][]const u8, "persistent_merkle_tree.filters", "persistent_merkle_tree test filters") orelse &[_][]const u8{},
    });
    const install_test_persistent_merkle_tree = b.addInstallArtifact(test_persistent_merkle_tree, .{});
    const tls_install_test_persistent_merkle_tree = b.step("build-test:persistent_merkle_tree", "Install the persistent_merkle_tree test");
    tls_install_test_persistent_merkle_tree.dependOn(&install_test_persistent_merkle_tree.step);

    const run_test_persistent_merkle_tree = b.addRunArtifact(test_persistent_merkle_tree);
    const tls_run_test_persistent_merkle_tree = b.step("test:persistent_merkle_tree", "Run the persistent_merkle_tree test");
    tls_run_test_persistent_merkle_tree.dependOn(&run_test_persistent_merkle_tree.step);
    tls_run_test.dependOn(&run_test_persistent_merkle_tree.step);

    const test_preset = b.addTest(.{
        .name = "preset",
        .root_module = module_preset,
        .filters = b.option([][]const u8, "preset.filters", "preset test filters") orelse &[_][]const u8{},
    });
    const install_test_preset = b.addInstallArtifact(test_preset, .{});
    const tls_install_test_preset = b.step("build-test:preset", "Install the preset test");
    tls_install_test_preset.dependOn(&install_test_preset.step);

    const run_test_preset = b.addRunArtifact(test_preset);
    const tls_run_test_preset = b.step("test:preset", "Run the preset test");
    tls_run_test_preset.dependOn(&run_test_preset.step);
    tls_run_test.dependOn(&run_test_preset.step);

    const test_ssz = b.addTest(.{
        .name = "ssz",
        .root_module = module_ssz,
        .filters = b.option([][]const u8, "ssz.filters", "ssz test filters") orelse &[_][]const u8{},
    });
    const install_test_ssz = b.addInstallArtifact(test_ssz, .{});
    const tls_install_test_ssz = b.step("build-test:ssz", "Install the ssz test");
    tls_install_test_ssz.dependOn(&install_test_ssz.step);

    const run_test_ssz = b.addRunArtifact(test_ssz);
    const tls_run_test_ssz = b.step("test:ssz", "Run the ssz test");
    tls_run_test_ssz.dependOn(&run_test_ssz.step);
    tls_run_test.dependOn(&run_test_ssz.step);

    const test_state_transition = b.addTest(.{
        .name = "state_transition",
        .root_module = module_state_transition,
        .filters = b.option([][]const u8, "state_transition.filters", "state_transition test filters") orelse &[_][]const u8{},
    });
    const install_test_state_transition = b.addInstallArtifact(test_state_transition, .{});
    const tls_install_test_state_transition = b.step("build-test:state_transition", "Install the state_transition test");
    tls_install_test_state_transition.dependOn(&install_test_state_transition.step);

    const run_test_state_transition = b.addRunArtifact(test_state_transition);
    const tls_run_test_state_transition = b.step("test:state_transition", "Run the state_transition test");
    tls_run_test_state_transition.dependOn(&run_test_state_transition.step);
    tls_run_test.dependOn(&run_test_state_transition.step);

    const test_download_era_files = b.addTest(.{
        .name = "download_era_files",
        .root_module = module_download_era_files,
        .filters = b.option([][]const u8, "download_era_files.filters", "download_era_files test filters") orelse &[_][]const u8{},
    });
    const install_test_download_era_files = b.addInstallArtifact(test_download_era_files, .{});
    const tls_install_test_download_era_files = b.step("build-test:download_era_files", "Install the download_era_files test");
    tls_install_test_download_era_files.dependOn(&install_test_download_era_files.step);

    const run_test_download_era_files = b.addRunArtifact(test_download_era_files);
    const tls_run_test_download_era_files = b.step("test:download_era_files", "Run the download_era_files test");
    tls_run_test_download_era_files.dependOn(&run_test_download_era_files.step);
    tls_run_test.dependOn(&run_test_download_era_files.step);

    const test_metrics_era = b.addTest(.{
        .name = "metrics_era",
        .root_module = module_metrics_era,
        .filters = b.option([][]const u8, "metrics_era.filters", "metrics_era test filters") orelse &[_][]const u8{},
    });
    const install_test_metrics_era = b.addInstallArtifact(test_metrics_era, .{});
    const tls_install_test_metrics_era = b.step("build-test:metrics_era", "Install the metrics_era test");
    tls_install_test_metrics_era.dependOn(&install_test_metrics_era.step);

    const run_test_metrics_era = b.addRunArtifact(test_metrics_era);
    const tls_run_test_metrics_era = b.step("test:metrics_era", "Run the metrics_era test");
    tls_run_test_metrics_era.dependOn(&run_test_metrics_era.step);
    tls_run_test.dependOn(&run_test_metrics_era.step);

    const test_download_spec_tests = b.addTest(.{
        .name = "download_spec_tests",
        .root_module = module_download_spec_tests,
        .filters = b.option([][]const u8, "download_spec_tests.filters", "download_spec_tests test filters") orelse &[_][]const u8{},
    });
    const install_test_download_spec_tests = b.addInstallArtifact(test_download_spec_tests, .{});
    const tls_install_test_download_spec_tests = b.step("build-test:download_spec_tests", "Install the download_spec_tests test");
    tls_install_test_download_spec_tests.dependOn(&install_test_download_spec_tests.step);

    const run_test_download_spec_tests = b.addRunArtifact(test_download_spec_tests);
    const tls_run_test_download_spec_tests = b.step("test:download_spec_tests", "Run the download_spec_tests test");
    tls_run_test_download_spec_tests.dependOn(&run_test_download_spec_tests.step);
    tls_run_test.dependOn(&run_test_download_spec_tests.step);

    const test_write_spec_tests = b.addTest(.{
        .name = "write_spec_tests",
        .root_module = module_write_spec_tests,
        .filters = b.option([][]const u8, "write_spec_tests.filters", "write_spec_tests test filters") orelse &[_][]const u8{},
    });
    const install_test_write_spec_tests = b.addInstallArtifact(test_write_spec_tests, .{});
    const tls_install_test_write_spec_tests = b.step("build-test:write_spec_tests", "Install the write_spec_tests test");
    tls_install_test_write_spec_tests.dependOn(&install_test_write_spec_tests.step);

    const run_test_write_spec_tests = b.addRunArtifact(test_write_spec_tests);
    const tls_run_test_write_spec_tests = b.step("test:write_spec_tests", "Run the write_spec_tests test");
    tls_run_test_write_spec_tests.dependOn(&run_test_write_spec_tests.step);
    tls_run_test.dependOn(&run_test_write_spec_tests.step);

    const test_write_ssz_generic_spec_tests = b.addTest(.{
        .name = "write_ssz_generic_spec_tests",
        .root_module = module_write_ssz_generic_spec_tests,
        .filters = b.option([][]const u8, "write_ssz_generic_spec_tests.filters", "write_ssz_generic_spec_tests test filters") orelse &[_][]const u8{},
    });
    const install_test_write_ssz_generic_spec_tests = b.addInstallArtifact(test_write_ssz_generic_spec_tests, .{});
    const tls_install_test_write_ssz_generic_spec_tests = b.step("build-test:write_ssz_generic_spec_tests", "Install the write_ssz_generic_spec_tests test");
    tls_install_test_write_ssz_generic_spec_tests.dependOn(&install_test_write_ssz_generic_spec_tests.step);

    const run_test_write_ssz_generic_spec_tests = b.addRunArtifact(test_write_ssz_generic_spec_tests);
    const tls_run_test_write_ssz_generic_spec_tests = b.step("test:write_ssz_generic_spec_tests", "Run the write_ssz_generic_spec_tests test");
    tls_run_test_write_ssz_generic_spec_tests.dependOn(&run_test_write_ssz_generic_spec_tests.step);
    tls_run_test.dependOn(&run_test_write_ssz_generic_spec_tests.step);

    const test_write_ssz_static_spec_tests = b.addTest(.{
        .name = "write_ssz_static_spec_tests",
        .root_module = module_write_ssz_static_spec_tests,
        .filters = b.option([][]const u8, "write_ssz_static_spec_tests.filters", "write_ssz_static_spec_tests test filters") orelse &[_][]const u8{},
    });
    const install_test_write_ssz_static_spec_tests = b.addInstallArtifact(test_write_ssz_static_spec_tests, .{});
    const tls_install_test_write_ssz_static_spec_tests = b.step("build-test:write_ssz_static_spec_tests", "Install the write_ssz_static_spec_tests test");
    tls_install_test_write_ssz_static_spec_tests.dependOn(&install_test_write_ssz_static_spec_tests.step);

    const run_test_write_ssz_static_spec_tests = b.addRunArtifact(test_write_ssz_static_spec_tests);
    const tls_run_test_write_ssz_static_spec_tests = b.step("test:write_ssz_static_spec_tests", "Run the write_ssz_static_spec_tests test");
    tls_run_test_write_ssz_static_spec_tests.dependOn(&run_test_write_ssz_static_spec_tests.step);
    tls_run_test.dependOn(&run_test_write_ssz_static_spec_tests.step);

    const test_bench_ssz_attestation = b.addTest(.{
        .name = "bench_ssz_attestation",
        .root_module = module_bench_ssz_attestation,
        .filters = b.option([][]const u8, "bench_ssz_attestation.filters", "bench_ssz_attestation test filters") orelse &[_][]const u8{},
    });
    const install_test_bench_ssz_attestation = b.addInstallArtifact(test_bench_ssz_attestation, .{});
    const tls_install_test_bench_ssz_attestation = b.step("build-test:bench_ssz_attestation", "Install the bench_ssz_attestation test");
    tls_install_test_bench_ssz_attestation.dependOn(&install_test_bench_ssz_attestation.step);

    const run_test_bench_ssz_attestation = b.addRunArtifact(test_bench_ssz_attestation);
    const tls_run_test_bench_ssz_attestation = b.step("test:bench_ssz_attestation", "Run the bench_ssz_attestation test");
    tls_run_test_bench_ssz_attestation.dependOn(&run_test_bench_ssz_attestation.step);
    tls_run_test.dependOn(&run_test_bench_ssz_attestation.step);

    const test_bench_ssz_block = b.addTest(.{
        .name = "bench_ssz_block",
        .root_module = module_bench_ssz_block,
        .filters = b.option([][]const u8, "bench_ssz_block.filters", "bench_ssz_block test filters") orelse &[_][]const u8{},
    });
    const install_test_bench_ssz_block = b.addInstallArtifact(test_bench_ssz_block, .{});
    const tls_install_test_bench_ssz_block = b.step("build-test:bench_ssz_block", "Install the bench_ssz_block test");
    tls_install_test_bench_ssz_block.dependOn(&install_test_bench_ssz_block.step);

    const run_test_bench_ssz_block = b.addRunArtifact(test_bench_ssz_block);
    const tls_run_test_bench_ssz_block = b.step("test:bench_ssz_block", "Run the bench_ssz_block test");
    tls_run_test_bench_ssz_block.dependOn(&run_test_bench_ssz_block.step);
    tls_run_test.dependOn(&run_test_bench_ssz_block.step);

    const test_bench_ssz_state = b.addTest(.{
        .name = "bench_ssz_state",
        .root_module = module_bench_ssz_state,
        .filters = b.option([][]const u8, "bench_ssz_state.filters", "bench_ssz_state test filters") orelse &[_][]const u8{},
    });
    const install_test_bench_ssz_state = b.addInstallArtifact(test_bench_ssz_state, .{});
    const tls_install_test_bench_ssz_state = b.step("build-test:bench_ssz_state", "Install the bench_ssz_state test");
    tls_install_test_bench_ssz_state.dependOn(&install_test_bench_ssz_state.step);

    const run_test_bench_ssz_state = b.addRunArtifact(test_bench_ssz_state);
    const tls_run_test_bench_ssz_state = b.step("test:bench_ssz_state", "Run the bench_ssz_state test");
    tls_run_test_bench_ssz_state.dependOn(&run_test_bench_ssz_state.step);
    tls_run_test.dependOn(&run_test_bench_ssz_state.step);

    const test_bench_merkle_gindex = b.addTest(.{
        .name = "bench_merkle_gindex",
        .root_module = module_bench_merkle_gindex,
        .filters = b.option([][]const u8, "bench_merkle_gindex.filters", "bench_merkle_gindex test filters") orelse &[_][]const u8{},
    });
    const install_test_bench_merkle_gindex = b.addInstallArtifact(test_bench_merkle_gindex, .{});
    const tls_install_test_bench_merkle_gindex = b.step("build-test:bench_merkle_gindex", "Install the bench_merkle_gindex test");
    tls_install_test_bench_merkle_gindex.dependOn(&install_test_bench_merkle_gindex.step);

    const run_test_bench_merkle_gindex = b.addRunArtifact(test_bench_merkle_gindex);
    const tls_run_test_bench_merkle_gindex = b.step("test:bench_merkle_gindex", "Run the bench_merkle_gindex test");
    tls_run_test_bench_merkle_gindex.dependOn(&run_test_bench_merkle_gindex.step);
    tls_run_test.dependOn(&run_test_bench_merkle_gindex.step);

    const test_bench_merkle_node = b.addTest(.{
        .name = "bench_merkle_node",
        .root_module = module_bench_merkle_node,
        .filters = b.option([][]const u8, "bench_merkle_node.filters", "bench_merkle_node test filters") orelse &[_][]const u8{},
    });
    const install_test_bench_merkle_node = b.addInstallArtifact(test_bench_merkle_node, .{});
    const tls_install_test_bench_merkle_node = b.step("build-test:bench_merkle_node", "Install the bench_merkle_node test");
    tls_install_test_bench_merkle_node.dependOn(&install_test_bench_merkle_node.step);

    const run_test_bench_merkle_node = b.addRunArtifact(test_bench_merkle_node);
    const tls_run_test_bench_merkle_node = b.step("test:bench_merkle_node", "Run the bench_merkle_node test");
    tls_run_test_bench_merkle_node.dependOn(&run_test_bench_merkle_node.step);
    tls_run_test.dependOn(&run_test_bench_merkle_node.step);

    const test_bench_hashing = b.addTest(.{
        .name = "bench_hashing",
        .root_module = module_bench_hashing,
        .filters = b.option([][]const u8, "bench_hashing.filters", "bench_hashing test filters") orelse &[_][]const u8{},
    });
    const install_test_bench_hashing = b.addInstallArtifact(test_bench_hashing, .{});
    const tls_install_test_bench_hashing = b.step("build-test:bench_hashing", "Install the bench_hashing test");
    tls_install_test_bench_hashing.dependOn(&install_test_bench_hashing.step);

    const run_test_bench_hashing = b.addRunArtifact(test_bench_hashing);
    const tls_run_test_bench_hashing = b.step("test:bench_hashing", "Run the bench_hashing test");
    tls_run_test_bench_hashing.dependOn(&run_test_bench_hashing.step);
    tls_run_test.dependOn(&run_test_bench_hashing.step);

    const test_bench_process_block = b.addTest(.{
        .name = "bench_process_block",
        .root_module = module_bench_process_block,
        .filters = b.option([][]const u8, "bench_process_block.filters", "bench_process_block test filters") orelse &[_][]const u8{},
    });
    const install_test_bench_process_block = b.addInstallArtifact(test_bench_process_block, .{});
    const tls_install_test_bench_process_block = b.step("build-test:bench_process_block", "Install the bench_process_block test");
    tls_install_test_bench_process_block.dependOn(&install_test_bench_process_block.step);

    const run_test_bench_process_block = b.addRunArtifact(test_bench_process_block);
    const tls_run_test_bench_process_block = b.step("test:bench_process_block", "Run the bench_process_block test");
    tls_run_test_bench_process_block.dependOn(&run_test_bench_process_block.step);
    tls_run_test.dependOn(&run_test_bench_process_block.step);

    const test_bench_process_epoch = b.addTest(.{
        .name = "bench_process_epoch",
        .root_module = module_bench_process_epoch,
        .filters = b.option([][]const u8, "bench_process_epoch.filters", "bench_process_epoch test filters") orelse &[_][]const u8{},
    });
    const install_test_bench_process_epoch = b.addInstallArtifact(test_bench_process_epoch, .{});
    const tls_install_test_bench_process_epoch = b.step("build-test:bench_process_epoch", "Install the bench_process_epoch test");
    tls_install_test_bench_process_epoch.dependOn(&install_test_bench_process_epoch.step);

    const run_test_bench_process_epoch = b.addRunArtifact(test_bench_process_epoch);
    const tls_run_test_bench_process_epoch = b.step("test:bench_process_epoch", "Run the bench_process_epoch test");
    tls_run_test_bench_process_epoch.dependOn(&run_test_bench_process_epoch.step);
    tls_run_test.dependOn(&run_test_bench_process_epoch.step);

    const module_int = b.createModule(.{
        .root_source_file = b.path("test/int/era/root.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("int"), module_int) catch @panic("OOM");

    const test_int = b.addTest(.{
        .name = "int",
        .root_module = module_int,
        .filters = b.option([][]const u8, "int.filters", "int test filters") orelse &[_][]const u8{},
    });
    const install_test_int = b.addInstallArtifact(test_int, .{});
    const tls_install_test_int = b.step("build-test:int", "Install the int test");
    tls_install_test_int.dependOn(&install_test_int.step);

    const run_test_int = b.addRunArtifact(test_int);
    const tls_run_test_int = b.step("test:int", "Run the int test");
    tls_run_test_int.dependOn(&run_test_int.step);
    tls_run_test.dependOn(&run_test_int.step);

    const module_spec_tests = b.createModule(.{
        .root_source_file = b.path("test/spec/root.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("spec_tests"), module_spec_tests) catch @panic("OOM");

    const test_spec_tests = b.addTest(.{
        .name = "spec_tests",
        .root_module = module_spec_tests,
        .filters = b.option([][]const u8, "spec_tests.filters", "spec_tests test filters") orelse &[_][]const u8{},
    });
    const install_test_spec_tests = b.addInstallArtifact(test_spec_tests, .{});
    const tls_install_test_spec_tests = b.step("build-test:spec_tests", "Install the spec_tests test");
    tls_install_test_spec_tests.dependOn(&install_test_spec_tests.step);

    const run_test_spec_tests = b.addRunArtifact(test_spec_tests);
    const tls_run_test_spec_tests = b.step("test:spec_tests", "Run the spec_tests test");
    tls_run_test_spec_tests.dependOn(&run_test_spec_tests.step);
    tls_run_test.dependOn(&run_test_spec_tests.step);

    const module_ssz_generic_spec_tests = b.createModule(.{
        .root_source_file = b.path("test/spec/ssz/generic_tests.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("ssz_generic_spec_tests"), module_ssz_generic_spec_tests) catch @panic("OOM");

    const test_ssz_generic_spec_tests = b.addTest(.{
        .name = "ssz_generic_spec_tests",
        .root_module = module_ssz_generic_spec_tests,
        .filters = b.option([][]const u8, "ssz_generic_spec_tests.filters", "ssz_generic_spec_tests test filters") orelse &[_][]const u8{},
    });
    const install_test_ssz_generic_spec_tests = b.addInstallArtifact(test_ssz_generic_spec_tests, .{});
    const tls_install_test_ssz_generic_spec_tests = b.step("build-test:ssz_generic_spec_tests", "Install the ssz_generic_spec_tests test");
    tls_install_test_ssz_generic_spec_tests.dependOn(&install_test_ssz_generic_spec_tests.step);

    const run_test_ssz_generic_spec_tests = b.addRunArtifact(test_ssz_generic_spec_tests);
    const tls_run_test_ssz_generic_spec_tests = b.step("test:ssz_generic_spec_tests", "Run the ssz_generic_spec_tests test");
    tls_run_test_ssz_generic_spec_tests.dependOn(&run_test_ssz_generic_spec_tests.step);
    tls_run_test.dependOn(&run_test_ssz_generic_spec_tests.step);

    const module_ssz_static_spec_tests = b.createModule(.{
        .root_source_file = b.path("test/spec/ssz/static_tests.zig"),
        .target = target,
        .optimize = optimize,
    });
    b.modules.put(b.dupe("ssz_static_spec_tests"), module_ssz_static_spec_tests) catch @panic("OOM");

    const test_ssz_static_spec_tests = b.addTest(.{
        .name = "ssz_static_spec_tests",
        .root_module = module_ssz_static_spec_tests,
        .filters = b.option([][]const u8, "ssz_static_spec_tests.filters", "ssz_static_spec_tests test filters") orelse &[_][]const u8{},
    });
    const install_test_ssz_static_spec_tests = b.addInstallArtifact(test_ssz_static_spec_tests, .{});
    const tls_install_test_ssz_static_spec_tests = b.step("build-test:ssz_static_spec_tests", "Install the ssz_static_spec_tests test");
    tls_install_test_ssz_static_spec_tests.dependOn(&install_test_ssz_static_spec_tests.step);

    const run_test_ssz_static_spec_tests = b.addRunArtifact(test_ssz_static_spec_tests);
    const tls_run_test_ssz_static_spec_tests = b.step("test:ssz_static_spec_tests", "Run the ssz_static_spec_tests test");
    tls_run_test_ssz_static_spec_tests.dependOn(&run_test_ssz_static_spec_tests.step);
    tls_run_test.dependOn(&run_test_ssz_static_spec_tests.step);

    module_config.addImport("build_options", options_module_build_options);
    module_config.addImport("preset", module_preset);
    module_config.addImport("consensus_types", module_consensus_types);
    module_config.addImport("hex", module_hex);
    module_config.addImport("constants", module_constants);

    module_consensus_types.addImport("build_options", options_module_build_options);
    module_consensus_types.addImport("ssz", module_ssz);
    module_consensus_types.addImport("constants", module_constants);
    module_consensus_types.addImport("preset", module_preset);

    module_era.addImport("consensus_types", module_consensus_types);
    module_era.addImport("config", module_config);
    module_era.addImport("fork_types", module_fork_types);
    module_era.addImport("preset", module_preset);
    module_era.addImport("state_transition", module_state_transition);
    module_era.addImport("snappy", dep_snappy.module("snappy"));
    module_era.addImport("persistent_merkle_tree", module_persistent_merkle_tree);

    module_hashing.addImport("build_options", options_module_build_options);
    module_hashing.addImport("hex", module_hex);
    module_hashing.addImport("hashtree", dep_hashtree.module("hashtree"));

    module_fork_types.addImport("consensus_types", module_consensus_types);
    module_fork_types.addImport("config", module_config);
    module_fork_types.addImport("persistent_merkle_tree", module_persistent_merkle_tree);
    module_fork_types.addImport("preset", module_preset);
    module_fork_types.addImport("ssz", module_ssz);

    module_persistent_merkle_tree.addImport("build_options", options_module_build_options);
    module_persistent_merkle_tree.addImport("hex", module_hex);
    module_persistent_merkle_tree.addImport("hashing", module_hashing);

    module_preset.addImport("build_options", options_module_build_options);
    module_preset.addImport("constants", module_constants);

    module_ssz.addImport("build_options", options_module_build_options);
    module_ssz.addImport("hex", module_hex);
    module_ssz.addImport("hashing", module_hashing);
    module_ssz.addImport("persistent_merkle_tree", module_persistent_merkle_tree);

    module_state_transition.addImport("build_options", options_module_build_options);
    module_state_transition.addImport("ssz", module_ssz);
    module_state_transition.addImport("config", module_config);
    module_state_transition.addImport("consensus_types", module_consensus_types);
    module_state_transition.addImport("blst", dep_blst.module("blst"));
    module_state_transition.addImport("fork_types", module_fork_types);
    module_state_transition.addImport("preset", module_preset);
    module_state_transition.addImport("constants", module_constants);
    module_state_transition.addImport("hex", module_hex);
    module_state_transition.addImport("persistent_merkle_tree", module_persistent_merkle_tree);
    module_state_transition.addImport("metrics", dep_metrics.module("metrics"));

    module_download_era_files.addImport("download_era_options", options_module_download_era_options);

    module_metrics_era.addImport("consensus_types", module_consensus_types);
    module_metrics_era.addImport("state_transition", module_state_transition);
    module_metrics_era.addImport("download_era_options", options_module_download_era_options);
    module_metrics_era.addImport("era", module_era);
    module_metrics_era.addImport("config", module_config);
    module_metrics_era.addImport("preset", module_preset);
    module_metrics_era.addImport("httpz", dep_httpz.module("httpz"));

    module_download_spec_tests.addImport("spec_test_options", options_module_spec_test_options);

    module_write_spec_tests.addImport("spec_test_options", options_module_spec_test_options);
    module_write_spec_tests.addImport("config", module_config);
    module_write_spec_tests.addImport("preset", module_preset);
    module_write_spec_tests.addImport("consensus_types", module_consensus_types);
    module_write_spec_tests.addImport("state_transition", module_state_transition);

    module_write_ssz_generic_spec_tests.addImport("spec_test_options", options_module_spec_test_options);

    module_write_ssz_static_spec_tests.addImport("spec_test_options", options_module_spec_test_options);

    module_bench_ssz_attestation.addImport("consensus_types", module_consensus_types);
    module_bench_ssz_attestation.addImport("ssz", module_ssz);
    module_bench_ssz_attestation.addImport("zbench", dep_zbench.module("zbench"));

    module_bench_ssz_block.addImport("consensus_types", module_consensus_types);
    module_bench_ssz_block.addImport("ssz", module_ssz);
    module_bench_ssz_block.addImport("zbench", dep_zbench.module("zbench"));

    module_bench_ssz_state.addImport("consensus_types", module_consensus_types);
    module_bench_ssz_state.addImport("ssz", module_ssz);
    module_bench_ssz_state.addImport("zbench", dep_zbench.module("zbench"));

    module_bench_merkle_gindex.addImport("hashing", module_hashing);
    module_bench_merkle_gindex.addImport("persistent_merkle_tree", module_persistent_merkle_tree);
    module_bench_merkle_gindex.addImport("zbench", dep_zbench.module("zbench"));

    module_bench_merkle_node.addImport("hashing", module_hashing);
    module_bench_merkle_node.addImport("zbench", dep_zbench.module("zbench"));

    module_bench_hashing.addImport("hashing", module_hashing);
    module_bench_hashing.addImport("zbench", dep_zbench.module("zbench"));

    module_bench_process_block.addImport("state_transition", module_state_transition);
    module_bench_process_block.addImport("fork_types", module_fork_types);
    module_bench_process_block.addImport("consensus_types", module_consensus_types);
    module_bench_process_block.addImport("config", module_config);
    module_bench_process_block.addImport("zbench", dep_zbench.module("zbench"));
    module_bench_process_block.addImport("persistent_merkle_tree", module_persistent_merkle_tree);
    module_bench_process_block.addImport("download_era_options", options_module_download_era_options);
    module_bench_process_block.addImport("era", module_era);

    module_bench_process_epoch.addImport("state_transition", module_state_transition);
    module_bench_process_epoch.addImport("fork_types", module_fork_types);
    module_bench_process_epoch.addImport("consensus_types", module_consensus_types);
    module_bench_process_epoch.addImport("config", module_config);
    module_bench_process_epoch.addImport("zbench", dep_zbench.module("zbench"));
    module_bench_process_epoch.addImport("persistent_merkle_tree", module_persistent_merkle_tree);
    module_bench_process_epoch.addImport("download_era_options", options_module_download_era_options);
    module_bench_process_epoch.addImport("era", module_era);

    module_int.addImport("config", module_config);
    module_int.addImport("download_era_options", options_module_download_era_options);
    module_int.addImport("era", module_era);

    module_spec_tests.addImport("spec_test_options", options_module_spec_test_options);
    module_spec_tests.addImport("consensus_types", module_consensus_types);
    module_spec_tests.addImport("config", module_config);
    module_spec_tests.addImport("fork_types", module_fork_types);
    module_spec_tests.addImport("preset", module_preset);
    module_spec_tests.addImport("snappy", dep_snappy.module("snappy"));
    module_spec_tests.addImport("state_transition", module_state_transition);
    module_spec_tests.addImport("ssz", module_ssz);
    module_spec_tests.addImport("blst", dep_blst.module("blst"));
    module_spec_tests.addImport("persistent_merkle_tree", module_persistent_merkle_tree);
    module_spec_tests.addImport("hex", module_hex);

    module_ssz_generic_spec_tests.addImport("hex", module_hex);
    module_ssz_generic_spec_tests.addImport("snappy", dep_snappy.module("snappy"));
    module_ssz_generic_spec_tests.addImport("persistent_merkle_tree", module_persistent_merkle_tree);
    module_ssz_generic_spec_tests.addImport("ssz", module_ssz);
    module_ssz_generic_spec_tests.addImport("spec_test_options", options_module_spec_test_options);
    module_ssz_generic_spec_tests.addImport("yaml", dep_yaml.module("yaml"));

    module_ssz_static_spec_tests.addImport("hex", module_hex);
    module_ssz_static_spec_tests.addImport("snappy", dep_snappy.module("snappy"));
    module_ssz_static_spec_tests.addImport("persistent_merkle_tree", module_persistent_merkle_tree);
    module_ssz_static_spec_tests.addImport("ssz", module_ssz);
    module_ssz_static_spec_tests.addImport("build_options", options_module_build_options);
    module_ssz_static_spec_tests.addImport("spec_test_options", options_module_spec_test_options);
    module_ssz_static_spec_tests.addImport("consensus_types", module_consensus_types);
    module_ssz_static_spec_tests.addImport("yaml", dep_yaml.module("yaml"));
}