bench: Add benchmark for block and Epoch Processing (#121)

tracks #102 
- Adds benchmark for block and epoch transition
- fix a bug in [`getAttestationDataSigningRoot`
](https://github.com/ChainSafe/lodestar/blob/688d5584ead0c6245007ece33175f6658169b662/packages/state-transition/src/signatureSets/indexedAttestation.ts#L15)
- Unlock spec tests to test for proposer and signatures in state
transition which was probably failing because of the above issue

Author: guha-rahul

bench/state_transition/process_block.zig

@@ -0,0 +1,45 @@
+//! Shared utilities for state transition benchmarks
+
+const std = @import("std");
+const types = @import("consensus_types");
+const config = @import("config");
+const state_transition = @import("state_transition");
+
+const ForkSeq = config.ForkSeq;
+const BeaconStateAllForks = state_transition.BeaconStateAllForks;
+const Slot = types.primitive.Slot.Type;
+
+/// Read slot from raw BeaconState SSZ bytes (offset 40)
+pub fn slotFromStateBytes(state_bytes: []const u8) Slot {
+    std.debug.assert(state_bytes.len >= 48);
+    return std.mem.readInt(u64, state_bytes[40..48], .little);
+}
+
+/// Read slot from raw SignedBeaconBlock SSZ bytes (offset 100)
+pub fn slotFromBlockBytes(block_bytes: []const u8) Slot {
+    std.debug.assert(block_bytes.len >= 108);
+    return std.mem.readInt(u64, block_bytes[100..108], .little);
+}
+
+/// Load and deserialize BeaconState from SSZ bytes for a specific fork
+pub fn loadState(comptime fork: ForkSeq, allocator: std.mem.Allocator, state_bytes: []const u8) !*BeaconStateAllForks {
+    const BeaconState = @field(types, @tagName(fork)).BeaconState;
+    const state_data = try allocator.create(BeaconState.Type);
+    errdefer allocator.destroy(state_data);
+    state_data.* = BeaconState.default_value;
+    try BeaconState.deserializeFromBytes(allocator, state_bytes, state_data);
+
+    const beacon_state = try allocator.create(BeaconStateAllForks);
+    beacon_state.* = @unionInit(BeaconStateAllForks, @tagName(fork), state_data);
+    return beacon_state;
+}
+
+/// Load and deserialize SignedBeaconBlock from SSZ bytes for a specific fork
+pub fn loadBlock(comptime fork: ForkSeq, allocator: std.mem.Allocator, block_bytes: []const u8) !state_transition.SignedBeaconBlock {
+    const SignedBeaconBlock = @field(types, @tagName(fork)).SignedBeaconBlock;
+    const block_data = try allocator.create(SignedBeaconBlock.Type);
+    errdefer allocator.destroy(block_data);
+    block_data.* = SignedBeaconBlock.default_value;
+    try SignedBeaconBlock.deserializeFromBytes(allocator, block_bytes, block_data);
+    return @unionInit(state_transition.SignedBeaconBlock, @tagName(fork), block_data);
+}

bench/state_transition/process_epoch.zig

@@ -379,6 +379,52 @@ pub fn build(b: *std.Build) void {
     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,
+    });
+    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(.{
@@ -675,6 +721,34 @@ pub fn build(b: *std.Build) void {
     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/root.zig"),
         .target = target,
@@ -858,6 +932,16 @@ pub fn build(b: *std.Build) void {
     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("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_epoch.addImport("state_transition", module_state_transition);
+    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_int.addImport("build_options", options_module_build_options);
     module_int.addImport("ssz", module_ssz);
     module_int.addImport("state_transition", module_state_transition);

bench/state_transition/utils.zig

@@ -56,6 +56,7 @@ pub const processEth1Data = @import("./block/process_eth1_data.zig").processEth1
 pub const processOperations = @import("./block/process_operations.zig").processOperations;
 pub const processSyncAggregate = @import("./block/process_sync_committee.zig").processSyncAggregate;
 pub const processBlobKzgCommitments = @import("./block/process_blob_kzg_commitments.zig").processBlobKzgCommitments;
+pub const processBlock = @import("./block/process_block.zig").processBlock;
 pub const processAttestations = @import("./block/process_attestations.zig").processAttestations;
 pub const processAttesterSlashing = @import("./block/process_attester_slashing.zig").processAttesterSlashing;
 pub const processDeposit = @import("./block/process_deposit.zig").processDeposit;
@@ -78,9 +79,12 @@ pub const test_utils = @import("test_utils/root.zig");
 pub const bls = @import("utils/bls.zig");
 const seed = @import("./utils/seed.zig");
 pub const state_transition = @import("./state_transition.zig");
+pub const BlockExternalData = state_transition.BlockExternalData;
+pub const preset = @import("preset").preset;
 const EpochShuffling = @import("./utils/epoch_shuffling.zig");
 pub const SignedBlock = @import("./types/block.zig").SignedBlock;
 pub const Block = @import("./types/block.zig").Block;
+pub const Body = @import("./types/block.zig").Body;
 pub const SignedBeaconBlock = @import("./types/beacon_block.zig").SignedBeaconBlock;
 pub const Attestations = @import("./types/attestation.zig").Attestations;
 pub const processProposerLookahead = @import("./epoch/process_proposer_lookahead.zig").processProposerLookahead;

build.zig

@@ -5,11 +5,10 @@ const PublicKey = blst.PublicKey;
 const CachedBeaconStateAllForks = @import("../cache/state_cache.zig").CachedBeaconStateAllForks;
 const BeaconBlock = @import("../types/beacon_block.zig").BeaconBlock;
 const SignedBeaconBlock = @import("../types/beacon_block.zig").SignedBeaconBlock;
-const computeEpochAtSlot = @import("../utils/epoch.zig").computeEpochAtSlot;
 const c = @import("constants");
 const computeSigningRoot = @import("../utils/signing_root.zig").computeSigningRoot;
+const computeStartSlotAtEpoch = @import("../utils/epoch.zig").computeStartSlotAtEpoch;
 const types = @import("consensus_types");
-
 const AttestationData = types.phase0.AttestationData.Type;
 const Attestation = types.primitive.Attestation.Type;
 const BLSSignature = types.primitive.BLSSignature.Type;
@@ -19,7 +18,7 @@ const createAggregateSignatureSetFromComponents = @import("../utils/signature_se
 const IndexedAttestation = @import("../types/attestation.zig").IndexedAttestation;
 
 pub fn getAttestationDataSigningRoot(cached_state: *const CachedBeaconStateAllForks, data: *const AttestationData, out: *[32]u8) !void {
-    const slot = computeEpochAtSlot(data.target.epoch);
+    const slot = computeStartSlotAtEpoch(data.target.epoch);
     const config = cached_state.config;
     const state = cached_state.state;
     const domain = try config.getDomain(state.slot(), c.DOMAIN_BEACON_ATTESTER, slot);

src/state_transition/root.zig

@@ -14,7 +14,7 @@ const Slot = types.primitive.Slot.Type;
 const CachedBeaconStateAllForks = @import("cache/state_cache.zig").CachedBeaconStateAllForks;
 pub const SignedBeaconBlock = @import("types/beacon_block.zig").SignedBeaconBlock;
 const verifyProposerSignature = @import("./signature_sets/proposer.zig").verifyProposerSignature;
-const processBlock = @import("./block/process_block.zig").processBlock;
+pub const processBlock = @import("./block/process_block.zig").processBlock;
 const BeaconBlock = @import("types/beacon_block.zig").BeaconBlock;
 const SignedVoluntaryExit = types.phase0.SignedVoluntaryExit.Type;
 const Attestation = @import("types/attestation.zig").Attestation;

src/state_transition/signature_sets/indexed_attestation.zig

@@ -129,8 +129,8 @@ pub fn Transition(comptime fork: ForkSeq) type {
                     },
                     .{
                         .verify_state_root = true,
-                        .verify_proposer = false,
-                        .verify_signatures = false,
+                        .verify_proposer = true,
+                        .verify_signatures = true,
                     },
                 );
 

src/state_transition/state_transition.zig

@@ -183,6 +183,18 @@
                 .imports = .{ .hashing, .zbench },
             },
         },
+        .bench_process_block = .{
+            .root_module = .{
+                .root_source_file = "bench/state_transition/process_block.zig",
+                .imports = .{ .state_transition, .consensus_types, .config, .zbench },
+            },
+        },
+        .bench_process_epoch = .{
+            .root_module = .{
+                .root_source_file = "bench/state_transition/process_epoch.zig",
+                .imports = .{ .state_transition, .consensus_types, .config, .zbench },
+            },
+        },
     },
     .tests = .{
         .int = .{