Add configurable preset using flags

build.zig

@@ -94,12 +94,22 @@ pub fn build(b: *Builder) !void {
     zeam_utils.addImport("datetime", datetime);
     zeam_utils.addImport("yaml", yaml);
 
+    const build_options = b.addOptions();
+    build_options.addOption([]const u8, "version", git_version);
+
+    // Add preset as a build option
+    const preset_option = b.option([]const u8, "preset", "Preset configuration (mainnet or minimal)") orelse "mainnet";
+    build_options.addOption([]const u8, "preset", preset_option);
+
+    const build_options_module = build_options.createModule();
+
     // add zeam-params
     const zeam_params = b.addModule("@zeam/params", .{
         .target = target,
         .optimize = optimize,
         .root_source_file = b.path("pkgs/params/src/lib.zig"),
     });
+    zeam_params.addImport("build_options", build_options_module);
 
     // add zeam-types
     const zeam_types = b.addModule("@zeam/types", .{
@@ -216,11 +226,6 @@ pub fn build(b: *Builder) !void {
     zeam_spectests.addImport("@zeam/params", zeam_params);
     zeam_spectests.addImport("ssz", ssz);
 
-    // Create build options
-    const build_options = b.addOptions();
-    build_options.addOption([]const u8, "version", git_version);
-    const build_options_module = build_options.createModule();
-
     // Add the cli executable
     const cli_exe = b.addExecutable(.{
         .name = "zeam",
@@ -254,7 +259,7 @@ pub fn build(b: *Builder) !void {
 
     b.installArtifact(cli_exe);
 
-    try build_zkvm_targets(b, &cli_exe.step, target);
+    try build_zkvm_targets(b, &cli_exe.step, target, build_options_module);
 
     var zkvm_host_cmd = build_rust_project(b, "rust");
     cli_exe.step.dependOn(&zkvm_host_cmd.step);
@@ -460,7 +465,7 @@ fn build_rust_project(b: *Builder, path: []const u8) *Builder.Step.Run {
     });
 }
 
-fn build_zkvm_targets(b: *Builder, main_exe: *Builder.Step, host_target: std.Build.ResolvedTarget) !void {
+fn build_zkvm_targets(b: *Builder, main_exe: *Builder.Step, host_target: std.Build.ResolvedTarget, build_options_module: *std.Build.Module) !void {
     const optimize = .ReleaseFast;
 
     for (zkvm_targets) |zkvm_target| {
@@ -479,6 +484,7 @@ fn build_zkvm_targets(b: *Builder, main_exe: *Builder.Step, host_target: std.Bui
             .optimize = optimize,
             .root_source_file = b.path("pkgs/params/src/lib.zig"),
         });
+        zeam_params.addImport("build_options", build_options_module);
 
         // add zeam-utils
         const zeam_utils = b.addModule("@zeam/utils", .{

pkgs/cli/src/main.zig

@@ -17,6 +17,8 @@ const configs = @import("@zeam/configs");
 const ChainConfig = configs.ChainConfig;
 const Chain = configs.Chain;
 const ChainOptions = configs.ChainOptions;
+const params = @import("@zeam/params");
+const Preset = params.Preset;
 
 const utils_lib = @import("@zeam/utils");
 
@@ -94,6 +96,8 @@ const ZeamArgs = struct {
             mockNetwork: bool = false,
             metricsPort: u16 = constants.DEFAULT_METRICS_PORT,
             data_dir: []const u8 = constants.DEFAULT_DATA_DIR,
+
+            pub const __messages__ = .{};
         },
         prove: struct {
             dist_dir: []const u8 = "zig-out/bin",
@@ -229,10 +233,11 @@ pub fn main() !void {
 
             const mock_network = beamcmd.mockNetwork;
 
-            // some base mainnet spec would be loaded to build this up
-            const chain_spec =
-                \\{"preset": "mainnet", "name": "beamdev"}
-            ;
+            // Create chain spec based on compile-time preset
+            const preset_name = @tagName(params.activePreset);
+            const chain_spec = try std.fmt.allocPrint(allocator, "{{\"preset\": \"{s}\", \"name\": \"beamdev\"}}", .{preset_name});
+            defer allocator.free(chain_spec);
+
             const options = json.ParseOptions{
                 .ignore_unknown_fields = true,
                 .allocate = .alloc_if_needed,
@@ -400,6 +405,7 @@ pub fn main() !void {
                 .validator_indices = undefined,
                 .local_priv_key = undefined,
                 .logger_config = &zeam_logger_config,
+                .preset = params.activePreset,
                 .database_path = leancmd.@"data-dir",
             };
 

pkgs/cli/src/node.zig

@@ -10,6 +10,7 @@ const json = std.json;
 const ChainConfig = configs.ChainConfig;
 const Chain = configs.Chain;
 const ChainOptions = configs.ChainOptions;
+const params = @import("@zeam/params");
 const sft = @import("@zeam/state-transition");
 const xev = @import("xev");
 const networks = @import("@zeam/network");
@@ -65,6 +66,7 @@ pub const NodeOptions = struct {
     metrics_port: u16,
     local_priv_key: []const u8,
     logger_config: *LoggerConfig,
+    preset: params.Preset,
     database_path: []const u8,
 
     pub fn deinit(self: *NodeOptions, allocator: std.mem.Allocator) void {
@@ -99,10 +101,11 @@ pub const Node = struct {
             try api_server.startAPIServer(allocator, options.metrics_port);
         }
 
-        // some base mainnet spec would be loaded to build this up
-        const chain_spec =
-            \\{"preset": "mainnet", "name": "devnet0"}
-        ;
+        // Create chain spec based on selected preset
+        const preset_name = @tagName(options.preset);
+        const chain_spec = try std.fmt.allocPrint(allocator, "{{\"preset\": \"{s}\", \"name\": \"beamdev\"}}", .{preset_name});
+        defer allocator.free(chain_spec);
+
         const json_options = json.ParseOptions{
             .ignore_unknown_fields = true,
             .allocate = .alloc_if_needed,

pkgs/configs/src/configs/minimal.zig

@@ -0,0 +1,6 @@
+const types = @import("zeam-types");
+
+pub const minimal = types.ChainSpec{
+    .preset = types.Preset.minimal,
+    .name = "minimal",
+};

pkgs/configs/src/lib.zig

@@ -8,7 +8,8 @@ const types = @import("@zeam/types");
 const utils = @import("@zeam/utils");
 pub const ChainOptions = utils.Partial(utils.MixIn(types.GenesisSpec, types.ChainSpec));
 
-const configs = @import("./configs/mainnet.zig");
+const mainnetConfig = @import("./configs/mainnet.zig");
+const minimalConfig = @import("./configs/minimal.zig");
 const Yaml = @import("yaml").Yaml;
 
 pub const Chain = enum { custom };
@@ -59,6 +60,13 @@ pub fn genesisConfigFromYAML(config: Yaml, override_genesis_time: ?u64) !types.G
     return genesis_spec;
 }
 
+pub fn getChainSpecByPreset(preset: params.Preset) types.ChainSpec {
+    return switch (preset) {
+        .mainnet => mainnetConfig.mainnet,
+        .minimal => minimalConfig.minimal,
+    };
+}
+
 test "load genesis config from yaml" {
     const yaml_content =
         \\# Genesis Settings

pkgs/node/src/clock.zig

@@ -4,6 +4,7 @@ const Allocator = std.mem.Allocator;
 const xev = @import("xev");
 
 const constants = @import("./constants.zig");
+const params = @import("@zeam/params");
 
 const utils = @import("./utils.zig");
 const OnIntervalCbWrapper = utils.OnIntervalCbWrapper;
@@ -19,6 +20,7 @@ pub const Clock = struct {
     on_interval_cbs: std.ArrayList(*OnIntervalCbWrapper),
 
     timer: xev.Timer,
+    seconds_per_interval_ms: isize,
 
     const Self = @This();
 
@@ -30,9 +32,12 @@ pub const Clock = struct {
         const events = try utils.EventLoop.init(loop);
         const timer = try xev.Timer.init();
 
+        // Use compile-time constant for seconds per interval
+        const seconds_per_interval_ms = constants.SECONDS_PER_INTERVAL_MS;
+
         const genesis_time_ms: isize = @intCast(genesis_time * std.time.ms_per_s);
-        const current_interval = @divFloor(@as(isize, @intCast(std.time.milliTimestamp())) + CLOCK_DISPARITY_MS - genesis_time_ms, constants.SECONDS_PER_INTERVAL_MS);
-        const current_interval_time_ms = genesis_time_ms + current_interval * constants.SECONDS_PER_INTERVAL_MS;
+        const current_interval = @divFloor(@as(isize, @intCast(std.time.milliTimestamp())) + CLOCK_DISPARITY_MS - genesis_time_ms, seconds_per_interval_ms);
+        const current_interval_time_ms = genesis_time_ms + current_interval * seconds_per_interval_ms;
 
         return Self{
             .genesis_time_ms = genesis_time_ms,
@@ -41,6 +46,7 @@ pub const Clock = struct {
             .events = events,
             .timer = timer,
             .on_interval_cbs = std.ArrayList(*OnIntervalCbWrapper).init(allocator),
+            .seconds_per_interval_ms = seconds_per_interval_ms,
         };
     }
 
@@ -54,12 +60,12 @@ pub const Clock = struct {
 
     pub fn tickInterval(self: *Self) void {
         const time_now_ms: isize = @intCast(std.time.milliTimestamp());
-        while (self.current_interval_time_ms + constants.SECONDS_PER_INTERVAL_MS < time_now_ms + CLOCK_DISPARITY_MS) {
-            self.current_interval_time_ms += constants.SECONDS_PER_INTERVAL_MS;
+        while (self.current_interval_time_ms + self.seconds_per_interval_ms < time_now_ms + CLOCK_DISPARITY_MS) {
+            self.current_interval_time_ms += self.seconds_per_interval_ms;
             self.current_interval += 1;
         }
 
-        const next_interval_time_ms: isize = self.current_interval_time_ms + constants.SECONDS_PER_INTERVAL_MS;
+        const next_interval_time_ms: isize = self.current_interval_time_ms + self.seconds_per_interval_ms;
         const time_to_next_interval_ms: usize = @intCast(next_interval_time_ms - time_now_ms);
 
         for (0..self.on_interval_cbs.items.len) |i| {

pkgs/node/src/node.zig

@@ -309,7 +309,7 @@ test "Node peer tracking on connect/disconnect" {
         .id = configs.Chain.custom,
         .genesis = genesis_config,
         .spec = .{
-            .preset = params.Preset.minimal,
+            .preset = params.activePreset,
             .name = spec_name,
         },
     };

pkgs/params/src/lib.zig

@@ -1,14 +1,24 @@
-// figure out a way to dynamically load these constants based on env
+// Compile-time preset configuration
 const std = @import("std");
+const build_options = @import("build_options");
 const mainnetPreset = @import("./presets/mainnet.zig");
+const minimalPreset = @import("./presets/minimal.zig");
+const types = @import("./types.zig");
+const PresetConfig = types.PresetConfig;
+
 pub const Preset = enum {
     mainnet,
     minimal,
 };
 
-const presets = .{ .mainnet = mainnetPreset.preset };
-// figure out a way to set active preset
-pub const activePreset = Preset.mainnet;
+const presets = .{
+    .mainnet = mainnetPreset.preset,
+    .minimal = minimalPreset.preset,
+};
+
+// Get preset from build options at compile time
+const preset_name = build_options.preset;
+pub const activePreset = std.meta.stringToEnum(Preset, preset_name) orelse @panic("Invalid preset specified in build options");
 const activePresetValues = @field(presets, @tagName(activePreset));
 
 pub const SECONDS_PER_SLOT = activePresetValues.SECONDS_PER_SLOT;
@@ -18,6 +28,57 @@ pub const HISTORICAL_ROOTS_LIMIT = activePresetValues.HISTORICAL_ROOTS_LIMIT;
 pub const VALIDATOR_REGISTRY_LIMIT = activePresetValues.VALIDATOR_REGISTRY_LIMIT;
 pub const MAX_REQUEST_BLOCKS = activePresetValues.MAX_REQUEST_BLOCKS;
 
+// Function to get preset values dynamically
+pub fn getPresetValues(preset_type: Preset) PresetConfig {
+    return switch (preset_type) {
+        .mainnet => presets.mainnet,
+        .minimal => presets.minimal,
+    };
+}
+
 test "test preset loading" {
     try std.testing.expect(SECONDS_PER_SLOT == mainnetPreset.preset.SECONDS_PER_SLOT);
 }
+
+test "test preset values" {
+    const mainnet_values = getPresetValues(.mainnet);
+    const minimal_values = getPresetValues(.minimal);
+
+    // Test that different presets have different values
+    try std.testing.expect(mainnet_values.SECONDS_PER_SLOT == 4);
+    try std.testing.expect(minimal_values.SECONDS_PER_SLOT == 4);
+
+    // Test that minimal has smaller limits
+    try std.testing.expect(minimal_values.HISTORICAL_ROOTS_LIMIT < mainnet_values.HISTORICAL_ROOTS_LIMIT);
+    try std.testing.expect(minimal_values.VALIDATOR_REGISTRY_LIMIT < mainnet_values.VALIDATOR_REGISTRY_LIMIT);
+    try std.testing.expect(minimal_values.MAX_REQUEST_BLOCKS < mainnet_values.MAX_REQUEST_BLOCKS);
+}
+
+test "test compile-time preset configuration" {
+    // Test that activePreset matches the build option
+    const expected_preset = std.meta.stringToEnum(Preset, build_options.preset) orelse @panic("Invalid preset in build options");
+    try std.testing.expect(activePreset == expected_preset);
+
+    // Test that constants match the active preset
+    const expected_values = getPresetValues(activePreset);
+    try std.testing.expect(SECONDS_PER_SLOT == expected_values.SECONDS_PER_SLOT);
+    try std.testing.expect(HISTORICAL_ROOTS_LIMIT == expected_values.HISTORICAL_ROOTS_LIMIT);
+    try std.testing.expect(VALIDATOR_REGISTRY_LIMIT == expected_values.VALIDATOR_REGISTRY_LIMIT);
+    try std.testing.expect(MAX_REQUEST_BLOCKS == expected_values.MAX_REQUEST_BLOCKS);
+}
+
+test "test preset-specific values" {
+    // Test mainnet preset values
+    if (activePreset == .mainnet) {
+        try std.testing.expect(HISTORICAL_ROOTS_LIMIT == 262144);
+        try std.testing.expect(VALIDATOR_REGISTRY_LIMIT == 4096);
+        try std.testing.expect(MAX_REQUEST_BLOCKS == 1024);
+    }
+
+    // Test minimal preset values
+    if (activePreset == .minimal) {
+        try std.testing.expect(HISTORICAL_ROOTS_LIMIT == 1024);
+        try std.testing.expect(VALIDATOR_REGISTRY_LIMIT == 256);
+        try std.testing.expect(MAX_REQUEST_BLOCKS == 64);
+    }
+}

pkgs/params/src/presets/minimal.zig

@@ -0,0 +1,10 @@
+const types = @import("../types.zig");
+
+pub const preset = types.PresetConfig{
+    .SECONDS_PER_SLOT = 4,
+
+    // SSZ capacity constants - minimal values for testing
+    .HISTORICAL_ROOTS_LIMIT = 1 << 10, // 2^10 = 1024
+    .VALIDATOR_REGISTRY_LIMIT = 1 << 8, // 2^8 = 256
+    .MAX_REQUEST_BLOCKS = 64,
+};