feat: implement devnet3 committee aggregation spec

pkgs/cli/src/main.zig

@@ -69,6 +69,7 @@ pub const NodeCommand = struct {
     @"network-dir": []const u8 = "./network",
     @"data-dir": []const u8 = constants.DEFAULT_DATA_DIR,
     @"checkpoint-sync-url": ?[]const u8 = null,
+    @"is-aggregator": bool = false,
 
     pub const __shorts__ = .{
         .help = .h,
@@ -88,6 +89,7 @@ pub const NodeCommand = struct {
         .@"sig-keys-dir" = "Relative path of custom genesis to signature key directory",
         .@"data-dir" = "Path to the data directory",
         .@"checkpoint-sync-url" = "URL to fetch finalized checkpoint state from for checkpoint sync (e.g., http://localhost:5052/lean/v0/states/finalized)",
+        .@"is-aggregator" = "Enable aggregator mode for committee signature aggregation",
         .help = "Show help information for the node command",
     };
 };
@@ -98,15 +100,15 @@ const BeamCmd = struct {
     @"api-port": u16 = constants.DEFAULT_API_PORT,
     @"metrics-port": u16 = constants.DEFAULT_METRICS_PORT,
     data_dir: []const u8 = constants.DEFAULT_DATA_DIR,
+    @"is-aggregator": bool = true,
 
-    pub fn format(self: BeamCmd, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
-        _ = fmt;
-        _ = options;
-        try writer.print("BeamCmd{{ mockNetwork={}, api-port={d}, metrics-port={d}, data_dir=\"{s}\" }}", .{
+    pub fn format(self: BeamCmd, writer: anytype) !void {
+        try writer.print("BeamCmd{{ mockNetwork={}, api-port={d}, metrics-port={d}, data_dir=\"{s}\", is-aggregator={} }}", .{
             self.mockNetwork,
             self.@"api-port",
             self.@"metrics-port",
             self.data_dir,
+            self.@"is-aggregator",
         });
     }
 };
@@ -222,7 +224,7 @@ const ZeamArgs = struct {
             .prometheus => |cmd| switch (cmd.__commands__) {
                 .genconfig => |genconfig| try writer.print("prometheus.genconfig(api_port={d}, filename=\"{s}\")", .{ genconfig.@"api-port", genconfig.filename }),
             },
-            .node => |cmd| try writer.print("node(node-id=\"{s}\", custom_genesis=\"{s}\", validator_config=\"{s}\", data-dir=\"{s}\", api_port={d})", .{ cmd.@"node-id", cmd.custom_genesis, cmd.validator_config, cmd.@"data-dir", cmd.@"api-port" }),
+            .node => |cmd| try writer.print("node(node-id=\"{s}\", custom_genesis=\"{s}\", validator_config=\"{s}\", data-dir=\"{s}\", api_port={d}), is-aggregator={}", .{ cmd.@"node-id", cmd.custom_genesis, cmd.validator_config, cmd.@"data-dir", cmd.@"api-port", cmd.@"is-aggregator" }),
             .testsig => |cmd| try writer.print("testsig(epoch={d}, slot={d})", .{ cmd.epoch, cmd.slot }),
         }
         try writer.writeAll(")");
@@ -502,6 +504,7 @@ fn mainInner() !void {
                     .listen_addresses = listen_addresses1,
                     .connect_peers = null,
                     .node_registry = test_registry1,
+                    .attestation_committee_count = chain_config.spec.attestation_committee_count,
                 }, logger1_config.logger(.network));
                 backend1 = network1.getNetworkInterface();
 
@@ -525,6 +528,7 @@ fn mainInner() !void {
                     .listen_addresses = listen_addresses2,
                     .connect_peers = connect_peers,
                     .node_registry = test_registry2,
+                    .attestation_committee_count = chain_config.spec.attestation_committee_count,
                 }, logger2_config.logger(.network));
                 backend2 = network2.getNetworkInterface();
 
@@ -547,6 +551,7 @@ fn mainInner() !void {
                     .listen_addresses = listen_addresses3,
                     .connect_peers = connect_peers3,
                     .node_registry = test_registry3,
+                    .attestation_committee_count = chain_config.spec.attestation_committee_count,
                 }, logger3_config.logger(.network));
                 backend3 = network3.getNetworkInterface();
                 logger1_config.logger(null).debug("--- ethlibp2p gossip {any}", .{backend1.gossip});
@@ -592,6 +597,7 @@ fn mainInner() !void {
                 .db = db_1,
                 .logger_config = &logger1_config,
                 .node_registry = registry_1,
+                .is_aggregator = beamcmd.@"is-aggregator",
             });
 
             if (api_server_handle) |handle| {
@@ -611,6 +617,7 @@ fn mainInner() !void {
                 .db = db_2,
                 .logger_config = &logger2_config,
                 .node_registry = registry_2,
+                .is_aggregator = beamcmd.@"is-aggregator",
             });
 
             // Node 3 setup - delayed start for initial sync testing
@@ -628,6 +635,7 @@ fn mainInner() !void {
                 .db = db_3,
                 .logger_config = &logger3_config,
                 .node_registry = registry_3,
+                .is_aggregator = beamcmd.@"is-aggregator",
             });
 
             // Delayed runner - starts both network3 and node3 together
@@ -736,6 +744,7 @@ fn mainInner() !void {
                 .validator_config = leancmd.validator_config,
                 .node_key_index = undefined,
                 .metrics_enable = leancmd.metrics_enable,
+                .is_aggregator = leancmd.@"is-aggregator",
                 .api_port = leancmd.@"api-port",
                 .metrics_port = leancmd.@"metrics-port",
                 .bootnodes = &.{}, // Initialize to empty slice to avoid segfault in deinit

pkgs/cli/src/node.zig

@@ -80,6 +80,7 @@ pub const NodeOptions = struct {
     validator_assignments: []ValidatorAssignment,
     genesis_spec: types.GenesisSpec,
     metrics_enable: bool,
+    is_aggregator: bool,
     api_port: u16,
     metrics_port: u16,
     local_priv_key: []const u8,
@@ -171,6 +172,7 @@ pub const Node = struct {
             .connect_peers = addresses.connect_peers,
             .local_private_key = options.local_priv_key,
             .node_registry = options.node_registry,
+            .attestation_committee_count = chain_config.spec.attestation_committee_count,
         }, options.logger_config.logger(.network));
         errdefer self.network.deinit();
         self.clock = try Clock.init(allocator, chain_config.genesis.genesis_time, &self.loop);
@@ -244,6 +246,7 @@ pub const Node = struct {
             .db = db,
             .logger_config = options.logger_config,
             .node_registry = options.node_registry,
+            .is_aggregator = options.is_aggregator,
         });
         errdefer self.beam_node.deinit();
 
@@ -377,7 +380,12 @@ pub const Node = struct {
             defer enr_fields.deinit(self.allocator);
 
             // Construct ENR from fields and private key
-            self.enr = try constructENRFromFields(self.allocator, self.options.local_priv_key, enr_fields);
+            self.enr = try constructENRFromFields(
+                self.allocator,
+                self.options.local_priv_key,
+                enr_fields,
+                self.options.is_aggregator,
+            );
         }
 
         // Overriding the IP to 0.0.0.0 to listen on all interfaces
@@ -565,6 +573,7 @@ pub fn buildStartOptions(
     opts.node_key_index = node_key_index;
     opts.hash_sig_key_dir = hash_sig_key_dir;
     opts.checkpoint_sync_url = node_cmd.@"checkpoint-sync-url";
+    opts.is_aggregator = node_cmd.@"is-aggregator";
 }
 
 /// Downloads finalized checkpoint state from the given URL and deserializes it
@@ -829,6 +838,30 @@ fn getPrivateKeyFromValidatorConfig(allocator: std.mem.Allocator, node_key: []co
     return error.InvalidNodeKey;
 }
 
+fn getIsAggregatorFromValidatorConfig(node_key: []const u8, validator_config: Yaml) !bool {
+    for (validator_config.docs.items[0].map.get("validators").?.list) |entry| {
+        const name_value = entry.map.get("name").?;
+        if (name_value == .scalar and std.mem.eql(u8, name_value.scalar, node_key)) {
+            const value = entry.map.get("is_aggregator") orelse return false;
+            return switch (value) {
+                .boolean => |b| b,
+                .scalar => |s| blk: {
+                    if (std.ascii.eqlIgnoreCase(s, "true")) break :blk true;
+                    if (std.ascii.eqlIgnoreCase(s, "false")) break :blk false;
+                    const i = std.fmt.parseInt(i64, s, 10) catch break :blk error.InvalidAggregatorFlag;
+                    return switch (i) {
+                        0 => false,
+                        1 => true,
+                        else => error.InvalidAggregatorFlag,
+                    };
+                },
+                else => error.InvalidAggregatorFlag,
+            };
+        }
+    }
+    return error.InvalidNodeKey;
+}
+
 fn getEnrFieldsFromValidatorConfig(allocator: std.mem.Allocator, node_key: []const u8, validator_config: Yaml) !EnrFields {
     for (validator_config.docs.items[0].map.get("validators").?.list) |entry| {
         const name_value = entry.map.get("name").?;
@@ -913,7 +946,12 @@ fn getEnrFieldsFromValidatorConfig(allocator: std.mem.Allocator, node_key: []con
     return error.InvalidNodeKey;
 }
 
-fn constructENRFromFields(allocator: std.mem.Allocator, private_key: []const u8, enr_fields: EnrFields) !ENR {
+fn constructENRFromFields(
+    allocator: std.mem.Allocator,
+    private_key: []const u8,
+    enr_fields: EnrFields,
+    is_aggregator: bool,
+) !ENR {
     // Clean up private key (remove 0x prefix if present)
     const secret_key_str = if (std.mem.startsWith(u8, private_key, "0x"))
         private_key[2..]
@@ -987,6 +1025,13 @@ fn constructENRFromFields(allocator: std.mem.Allocator, private_key: []const u8,
         };
     }
 
+    // Advertise aggregator capability in ENR.
+    // 0x00 = false, 0x01 = true.
+    const is_aggregator_bytes = [_]u8{if (is_aggregator) 0x01 else 0x00};
+    signable_enr.set("is_aggregator", &is_aggregator_bytes) catch {
+        return error.ENRSetIsAggregatorFailed;
+    };
+
     // Set custom fields
     var custom_iterator = enr_fields.custom_fields.iterator();
     while (custom_iterator.next()) |kv| {
@@ -1075,9 +1120,10 @@ pub fn populateNodeNameRegistry(
                 if (privkey_value == .scalar) {
                     const enr_fields_value = entry.map.get("enrFields");
                     if (enr_fields_value != null) {
+                        const is_aggregator = getIsAggregatorFromValidatorConfig(node_name, parsed_validator_config) catch break :blk null;
                         var enr_fields = getEnrFieldsFromValidatorConfig(allocator, node_name, parsed_validator_config) catch break :blk null;
                         defer enr_fields.deinit(allocator);
-                        var enr = constructENRFromFields(allocator, privkey_value.scalar, enr_fields) catch break :blk null;
+                        var enr = constructENRFromFields(allocator, privkey_value.scalar, enr_fields, is_aggregator) catch break :blk null;
                         defer enr.deinit();
                         const pid = enr.peerId(allocator) catch break :blk null;
                         const pid_str_slice = pid.toBase58(&peer_id_buf) catch break :blk null;
@@ -1198,7 +1244,7 @@ test "ENR construction from fields" {
     defer std.testing.allocator.free(private_key);
 
     // Construct ENR from fields
-    const constructed_enr = try constructENRFromFields(std.testing.allocator, private_key, enr_fields);
+    const constructed_enr = try constructENRFromFields(std.testing.allocator, private_key, enr_fields, true);
 
     // Verify the ENR was constructed successfully
     // We can't easily verify the exact ENR content without knowing the exact signature,
@@ -1207,6 +1253,7 @@ test "ENR construction from fields" {
     try std.testing.expect(constructed_enr.kvs.get("quic") != null);
     try std.testing.expect(constructed_enr.kvs.get("tcp") != null);
     try std.testing.expect(constructed_enr.kvs.get("seq") != null);
+    try std.testing.expect(constructed_enr.kvs.get("is_aggregator") != null);
 }
 
 test "compare roots from genGensisBlock and genGenesisState and genStateBlockHeader" {
@@ -1334,6 +1381,7 @@ test "NodeOptions checkpoint_sync_url field is optional" {
         .validator_assignments = &[_]ValidatorAssignment{},
         .genesis_spec = genesis_spec,
         .metrics_enable = false,
+        .is_aggregator = false,
         .api_port = 5052,
         .metrics_port = 5053,
         .local_priv_key = try allocator.dupe(u8, "test"),

pkgs/cli/test/integration.zig

@@ -52,7 +52,7 @@ fn getZeamExecutable() ![]const u8 {
 /// Returns the process handle for cleanup, or error if startup fails
 fn spinBeamSimNode(allocator: std.mem.Allocator, exe_path: []const u8) !*process.Child {
     // Set up process with beam command and mock network
-    const args = [_][]const u8{ exe_path, "beam", "--mockNetwork", "true" };
+    const args = [_][]const u8{ exe_path, "beam", "--mockNetwork", "true", "--is-aggregator", "true" };
     const cli_process = try allocator.create(process.Child);
     cli_process.* = process.Child.init(&args, allocator);
 

pkgs/configs/src/configs/mainnet.zig

@@ -4,4 +4,5 @@ pub const mainnet = types.ChainSpec{
     // 10 minutes slot for proving purposes
     .preset = types.Preset.mainnet,
     .name = "mainnet",
+    .attestation_committee_count = 1,
 };

pkgs/configs/src/lib.zig

@@ -24,7 +24,11 @@ pub const ChainConfig = struct {
     pub fn init(chainId: Chain, chainOptsOrNull: ?ChainOptions) !Self {
         switch (chainId) {
             .custom => {
-                if (chainOptsOrNull) |*chainOpts| {
+                if (chainOptsOrNull) |chain_opts_in| {
+                    var chainOpts = chain_opts_in;
+                    if (chainOpts.attestation_committee_count == null) {
+                        chainOpts.attestation_committee_count = 1;
+                    }
                     const genesis = utils.Cast(types.GenesisSpec, chainOpts);
                     // transfer ownership of any allocated memory in chainOpts to spec
                     const spec = utils.Cast(types.ChainSpec, chainOpts);

pkgs/database/src/interface.zig

@@ -6,12 +6,12 @@ const zeam_utils = @import("@zeam/utils");
 
 /// Helper function to format block keys consistently
 pub fn formatBlockKey(allocator: Allocator, block_root: *const types.Root) ![]const u8 {
-    return std.fmt.allocPrint(allocator, "block:{x}", .{block_root});
+    return std.fmt.allocPrint(allocator, "block:{x}", .{block_root.*});
 }
 
 /// Helper function to format state keys consistently
 pub fn formatStateKey(allocator: Allocator, state_root: *const types.Root) ![]const u8 {
-    return std.fmt.allocPrint(allocator, "state:{x}", .{state_root});
+    return std.fmt.allocPrint(allocator, "state:{x}", .{state_root.*});
 }
 
 /// Helper function to format finalized slot index keys