feat: support spec test using test sig scheme

build.zig

@@ -319,6 +319,7 @@ pub fn build(b: *Builder) !void {
     zeam_spectests.addImport("build_options", build_options_module);
     zeam_spectests.addImport("@zeam/state-transition", zeam_state_transition);
     zeam_spectests.addImport("@zeam/node", zeam_beam_node);
+    zeam_spectests.addImport("@zeam/xmss", zeam_xmss);
 
     // Add the cli executable
     const cli_exe = b.addExecutable(.{
@@ -570,6 +571,10 @@ pub fn build(b: *Builder) !void {
     spectests.root_module.addImport("@zeam/metrics", zeam_metrics);
     spectests.root_module.addImport("@zeam/state-transition", zeam_state_transition);
     spectests.root_module.addImport("ssz", ssz);
+    spectests.root_module.addImport("@zeam/xmss", zeam_xmss);
+
+    spectests.step.dependOn(&build_rust_lib_steps.step);
+    addRustGlueLib(b, spectests, target, prover);
 
     manager_tests.step.dependOn(&build_rust_lib_steps.step);
 

pkgs/key-manager/src/lib.zig

@@ -4,6 +4,170 @@ const types = @import("@zeam/types");
 const zeam_metrics = @import("@zeam/metrics");
 const ssz = @import("ssz");
 const Allocator = std.mem.Allocator;
+const JsonValue = std.json.Value;
+
+pub const XmssTestConfig = struct {
+    scheme: xmss.HashSigScheme,
+    signature_ssz_len: usize,
+    allow_placeholder_aggregated_proof: bool,
+
+    pub fn fromLeanEnv(lean_env: ?[]const u8) XmssTestConfig {
+        const scheme = schemeFromLeanEnv(lean_env);
+        return .{
+            .scheme = scheme,
+            .signature_ssz_len = xmss.signatureSszLenForScheme(scheme),
+            .allow_placeholder_aggregated_proof = scheme == .@"test",
+        };
+    }
+};
+
+pub const TestKeyManagerError = error{
+    DuplicateKeyIndex,
+    InvalidKeyFile,
+    InvalidKeyIndex,
+    InvalidPublicKey,
+    NoKeysFound,
+    PublicKeyNotFound,
+};
+
+pub const TestKeyManager = struct {
+    allocator: Allocator,
+    config: XmssTestConfig,
+    pubkeys: std.AutoHashMap(usize, types.Bytes52),
+
+    const Self = @This();
+
+    pub fn init(allocator: Allocator, lean_env: ?[]const u8) Self {
+        return Self{
+            .allocator = allocator,
+            .config = XmssTestConfig.fromLeanEnv(lean_env),
+            .pubkeys = std.AutoHashMap(usize, types.Bytes52).init(allocator),
+        };
+    }
+
+    pub fn deinit(self: *Self) void {
+        self.pubkeys.deinit();
+    }
+
+    pub fn loadLeanSpecKeys(self: *Self, keys_root: []const u8) !void {
+        const scheme_dir_name = switch (self.config.scheme) {
+            .@"test" => "test_scheme",
+            .prod => "prod_scheme",
+        };
+        const scheme_dir_path = try std.fs.path.join(self.allocator, &.{ keys_root, scheme_dir_name });
+        defer self.allocator.free(scheme_dir_path);
+        try self.loadKeysFromDir(scheme_dir_path);
+    }
+
+    pub fn loadKeysFromDir(self: *Self, keys_dir_path: []const u8) !void {
+        var dir = try std.fs.cwd().openDir(keys_dir_path, .{ .iterate = true });
+        defer dir.close();
+
+        self.pubkeys.clearRetainingCapacity();
+
+        var it = dir.iterate();
+        while (try it.next()) |entry| {
+            if (entry.kind != .file) continue;
+            const index = parseKeyIndex(entry.name) catch continue;
+            const pubkey = try readPublicKeyFromJson(self.allocator, dir, entry.name);
+
+            const gop = try self.pubkeys.getOrPut(index);
+            if (gop.found_existing) {
+                return TestKeyManagerError.DuplicateKeyIndex;
+            }
+            gop.value_ptr.* = pubkey;
+        }
+
+        if (self.pubkeys.count() == 0) {
+            return TestKeyManagerError.NoKeysFound;
+        }
+    }
+
+    pub fn getPublicKeyBytes(self: *const Self, validator_index: usize) !types.Bytes52 {
+        return self.pubkeys.get(validator_index) orelse TestKeyManagerError.PublicKeyNotFound;
+    }
+
+    pub fn getAllPubkeys(
+        self: *const Self,
+        allocator: Allocator,
+        num_validators: usize,
+    ) ![]types.Bytes52 {
+        const pubkeys = try allocator.alloc(types.Bytes52, num_validators);
+        errdefer allocator.free(pubkeys);
+
+        for (0..num_validators) |i| {
+            pubkeys[i] = try self.getPublicKeyBytes(i);
+        }
+
+        return pubkeys;
+    }
+
+    pub fn signatureSszLen(self: *const Self) usize {
+        return self.config.signature_ssz_len;
+    }
+
+    pub fn allowPlaceholderAggregatedProof(self: *const Self) bool {
+        return self.config.allow_placeholder_aggregated_proof;
+    }
+};
+
+fn schemeFromLeanEnv(lean_env: ?[]const u8) xmss.HashSigScheme {
+    const env = lean_env orelse return .prod;
+    if (std.ascii.eqlIgnoreCase(env, "test")) return .@"test";
+    return .prod;
+}
+
+fn parseKeyIndex(file_name: []const u8) !usize {
+    if (!std.mem.endsWith(u8, file_name, ".json")) {
+        return TestKeyManagerError.InvalidKeyIndex;
+    }
+    const stem = file_name[0 .. file_name.len - ".json".len];
+    if (stem.len == 0) {
+        return TestKeyManagerError.InvalidKeyIndex;
+    }
+    return std.fmt.parseInt(usize, stem, 10) catch TestKeyManagerError.InvalidKeyIndex;
+}
+
+fn readPublicKeyFromJson(
+    allocator: Allocator,
+    dir: std.fs.Dir,
+    file_name: []const u8,
+) !types.Bytes52 {
+    const max_bytes: usize = 2 * 1024 * 1024;
+    const payload = dir.readFileAlloc(allocator, file_name, max_bytes) catch {
+        return TestKeyManagerError.InvalidKeyFile;
+    };
+    defer allocator.free(payload);
+
+    var parsed = std.json.parseFromSlice(JsonValue, allocator, payload, .{ .ignore_unknown_fields = true }) catch {
+        return TestKeyManagerError.InvalidKeyFile;
+    };
+    defer parsed.deinit();
+
+    const obj = switch (parsed.value) {
+        .object => |map| map,
+        else => return TestKeyManagerError.InvalidKeyFile,
+    };
+    const pub_val = obj.get("public") orelse return TestKeyManagerError.InvalidKeyFile;
+    const pub_hex = switch (pub_val) {
+        .string => |s| s,
+        else => return TestKeyManagerError.InvalidKeyFile,
+    };
+
+    return parsePublicKeyHex(pub_hex);
+}
+
+fn parsePublicKeyHex(input: []const u8) !types.Bytes52 {
+    const hex_str = if (std.mem.startsWith(u8, input, "0x")) input[2..] else input;
+    if (hex_str.len != 104) {
+        return TestKeyManagerError.InvalidPublicKey;
+    }
+    var bytes: types.Bytes52 = undefined;
+    _ = std.fmt.hexToBytes(&bytes, hex_str) catch {
+        return TestKeyManagerError.InvalidPublicKey;
+    };
+    return bytes;
+}
 
 const KeyManagerError = error{
     ValidatorKeyNotFound,

pkgs/spectest/src/fixture_kind.zig

@@ -1,20 +1,23 @@
 pub const FixtureKind = enum {
     state_transition,
     fork_choice,
+    verify_signatures,
 
     pub fn runnerModule(self: FixtureKind) []const u8 {
         return switch (self) {
             .state_transition => "state_transition",
             .fork_choice => "fork_choice",
+            .verify_signatures => "verify_signatures",
         };
     }
 
     pub fn handlerSubdir(self: FixtureKind) []const u8 {
         return switch (self) {
             .state_transition => "state_transition",
             .fork_choice => "fc",
+            .verify_signatures => "verify_signatures",
         };
     }
 };
 
-pub const all = [_]FixtureKind{ .state_transition, .fork_choice };
+pub const all = [_]FixtureKind{ .state_transition, .fork_choice, .verify_signatures };

pkgs/spectest/src/json_expect.zig

@@ -245,6 +245,23 @@ pub fn expectArrayValue(
     };
 }
 
+pub fn expectArrayField(
+    comptime FixtureError: type,
+    obj: std.json.ObjectMap,
+    field_names: []const []const u8,
+    context: Context,
+    label: []const u8,
+) FixtureError!std.json.Array {
+    const value = getField(obj, field_names) orelse {
+        std.debug.print(
+            "fixture {s} case {s}{}: missing field {s}\n",
+            .{ context.fixture_label, context.case_name, context.formatStep(), label },
+        );
+        return FixtureError.InvalidFixture;
+    };
+    return expectArrayValue(FixtureError, value, context, label);
+}
+
 pub fn appendBytesDataField(
     comptime FixtureError: type,
     comptime T: type,

pkgs/spectest/src/runner/fork_choice_runner.zig

@@ -633,7 +633,10 @@ fn processBlockStep(
     }
     try types.sszClone(ctx.allocator, types.BeamState, parent_state_ptr.*, new_state_ptr);
 
-    state_transition.apply_transition(ctx.allocator, new_state_ptr, block, .{ .logger = ctx.fork_logger, .validateResult = false }) catch |err| {
+    state_transition.apply_transition(ctx.allocator, new_state_ptr, block, .{
+        .logger = ctx.fork_logger,
+        .validateResult = false,
+    }) catch |err| {
         std.debug.print(
             "fixture {s} case {s}{}: state transition failed {s}\n",
             .{ fixture_path, case_name, formatStep(step_index), @errorName(err) },

pkgs/spectest/src/runner/state_transition_runner.zig

@@ -277,7 +277,11 @@ fn runCase(
             }
         }
 
-        state_transition.apply_transition(allocator, &pre_state, block, .{ .logger = logger }) catch |err| {
+        const validate_result = expect_exception != null;
+        state_transition.apply_transition(allocator, &pre_state, block, .{
+            .logger = logger,
+            .validateResult = validate_result,
+        }) catch |err| {
             encountered_error = true;
             if (expect_exception == null) {
                 std.debug.print(