feat: add slashing cache

bench/state_transition/process_block.zig

@@ -187,6 +187,7 @@ fn ProcessOperationsBench(comptime fork: ForkSeq, comptime opts: BenchOpts) type
                 cloned.config,
                 cloned.getEpochCache(),
                 cloned.state.castToFork(fork),
+                &cloned.slashings_cache,
                 .full,
                 self.body,
                 .{ .verify_signature = opts.verify_signature },
@@ -237,6 +238,7 @@ fn ProcessBlockBench(comptime fork: ForkSeq, comptime opts: BenchOpts) type {
                 cloned.config,
                 cloned.getEpochCache(),
                 cloned.state.castToFork(fork),
+                &cloned.slashings_cache,
                 .full,
                 self.block,
                 external_data,
@@ -401,6 +403,7 @@ fn ProcessBlockSegmentedBench(comptime fork: ForkSeq) type {
                 cloned.config,
                 epoch_cache,
                 state,
+                &cloned.slashings_cache,
                 .full,
                 self.body,
                 .{ .verify_signature = true },
@@ -506,6 +509,7 @@ fn runBenchmark(comptime fork: ForkSeq, allocator: std.mem.Allocator, pool: *Nod
         .{},
     );
     try cached_state.state.commit();
+    try state_transition.buildSlashingsCacheFromStateIfNeeded(allocator, cached_state.state, &cached_state.slashings_cache);
     try stdout.print("State: slot={}, validators={}\n", .{ try cached_state.state.slot(), try beacon_state.validatorsCount() });
 
     var bench = zbench.Benchmark.init(allocator, .{

src/state_transition/block/process_attestation_altair.zig

@@ -8,6 +8,7 @@ const ForkSeq = @import("config").ForkSeq;
 const EpochCache = @import("../cache/epoch_cache.zig").EpochCache;
 const ForkTypes = @import("fork_types").ForkTypes;
 const BeaconState = @import("fork_types").BeaconState;
+const SlashingsCache = @import("../cache/slashings_cache.zig").SlashingsCache;
 const c = @import("constants");
 const RootCache = @import("../cache/root_cache.zig").RootCache;
 const validateAttestation = @import("./process_attestation_phase0.zig").validateAttestation;
@@ -35,6 +36,7 @@ pub fn processAttestationsAltair(
     config: *const BeaconConfig,
     epoch_cache: *EpochCache,
     state: *BeaconState(fork),
+    slashings_cache: *const SlashingsCache,
     attestations: []const ForkTypes(fork).Attestation.Type,
     verify_signature: bool,
 ) !void {
@@ -84,7 +86,6 @@ pub fn processAttestationsAltair(
         // For each participant, update their participation
         // In epoch processing, this participation info is used to calculate balance updates
         var total_balance_increments_with_weight: u64 = 0;
-        var validators = try state.validators();
         for (attesting_indices.items) |validator_index| {
             const flags = try epoch_participation.get(validator_index);
 
@@ -113,9 +114,7 @@ pub fn processAttestationsAltair(
             // TODO: describe issue. Compute progressive target balances
             // When processing each attestation, increase the cummulative target balance. Only applies post-altair
             if ((flags_new_set & TIMELY_TARGET) == TIMELY_TARGET) {
-                var validator = try validators.get(validator_index);
-                const slashed = try validator.get("slashed");
-                if (!slashed) {
+                if (!slashings_cache.isSlashed(validator_index)) {
                     if (in_current_epoch) {
                         epoch_cache.current_target_unslashed_balance_increments += effective_balance_increments[validator_index];
                     } else {

src/state_transition/block/process_attestations.zig

@@ -7,6 +7,8 @@ const BeaconConfig = @import("config").BeaconConfig;
 const ForkTypes = @import("fork_types").ForkTypes;
 const BeaconState = @import("fork_types").BeaconState;
 const EpochCache = @import("../cache/epoch_cache.zig").EpochCache;
+const SlashingsCache = @import("../cache/slashings_cache.zig").SlashingsCache;
+const buildSlashingsCacheIfNeeded = @import("../cache/slashings_cache.zig").buildFromStateIfNeeded;
 const processAttestationPhase0 = @import("./process_attestation_phase0.zig").processAttestationPhase0;
 const processAttestationsAltair = @import("./process_attestation_altair.zig").processAttestationsAltair;
 const Node = @import("persistent_merkle_tree").Node;
@@ -17,9 +19,11 @@ pub fn processAttestations(
     config: *const BeaconConfig,
     epoch_cache: *EpochCache,
     state: *BeaconState(fork),
+    slashings_cache: *SlashingsCache,
     attestations: []const ForkTypes(fork).Attestation.Type,
     verify_signatures: bool,
 ) !void {
+    try buildSlashingsCacheIfNeeded(allocator, state, slashings_cache);
     if (comptime fork == .phase0) {
         for (attestations) |attestation| {
             try processAttestationPhase0(
@@ -38,6 +42,7 @@ pub fn processAttestations(
             config,
             epoch_cache,
             state,
+            slashings_cache,
             attestations,
             verify_signatures,
         );
@@ -64,6 +69,7 @@ test "process attestations - sanity" {
             test_state.cached_state.config,
             test_state.cached_state.getEpochCache(),
             test_state.cached_state.state.castToFork(.electra),
+            &test_state.cached_state.slashings_cache,
             electra.items,
             true,
         ),

src/state_transition/block/process_attester_slashing.zig

@@ -6,6 +6,8 @@ const ForkTypes = @import("fork_types").ForkTypes;
 const BeaconState = @import("fork_types").BeaconState;
 const types = @import("consensus_types");
 const EpochCache = @import("../cache/epoch_cache.zig").EpochCache;
+const SlashingsCache = @import("../cache/slashings_cache.zig").SlashingsCache;
+const buildSlashingsCacheIfNeeded = @import("../cache/slashings_cache.zig").buildFromStateIfNeeded;
 const isSlashableAttestationData = @import("../utils/attestation.zig").isSlashableAttestationData;
 const getAttesterSlashableIndices = @import("../utils/attestation.zig").getAttesterSlashableIndices;
 const isValidIndexedAttestation = @import("./is_valid_indexed_attestation.zig").isValidIndexedAttestation;
@@ -21,10 +23,12 @@ pub fn processAttesterSlashing(
     config: *const BeaconConfig,
     epoch_cache: *EpochCache,
     state: *BeaconState(fork),
+    slashings_cache: *SlashingsCache,
     current_epoch: u64,
     attester_slashing: *const ForkTypes(fork).AttesterSlashing.Type,
     verify_signature: bool,
 ) !void {
+    try buildSlashingsCacheIfNeeded(allocator, state, slashings_cache);
     try assertValidAttesterSlashing(
         fork,
         allocator,
@@ -46,7 +50,7 @@ pub fn processAttesterSlashing(
         try validators.getValue(undefined, validator_index, &validator);
 
         if (isSlashableValidator(&validator, current_epoch)) {
-            try slashValidator(fork, config, epoch_cache, state, validator_index, null);
+            try slashValidator(fork, config, epoch_cache, state, slashings_cache, validator_index, null);
             slashed_any = true;
         }
     }

src/state_transition/block/process_block.zig

@@ -2,6 +2,8 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const BeaconConfig = @import("config").BeaconConfig;
 const EpochCache = @import("../cache/epoch_cache.zig").EpochCache;
+const SlashingsCache = @import("../cache/slashings_cache.zig").SlashingsCache;
+const buildSlashingsCacheIfNeeded = @import("../cache/slashings_cache.zig").buildFromStateIfNeeded;
 const BeaconState = @import("fork_types").BeaconState;
 const BlockType = @import("fork_types").BlockType;
 const BeaconBlock = @import("fork_types").BeaconBlock;
@@ -37,13 +39,18 @@ pub fn processBlock(
     config: *const BeaconConfig,
     epoch_cache: *EpochCache,
     state: *BeaconState(fork),
+    slashings_cache: *SlashingsCache,
     comptime block_type: BlockType,
     block: *const BeaconBlock(block_type, fork),
     external_data: BlockExternalData,
     opts: ProcessBlockOpts,
     // TODO: metrics
 ) !void {
+    // Build slashings cache against the *current* latest_block_header slot (pre-header update).
+    try buildSlashingsCacheIfNeeded(allocator, state, slashings_cache);
     try processBlockHeader(fork, allocator, epoch_cache, state, block_type, block);
+    // Keep cache slot in sync with latest_block_header without forcing a rebuild.
+    slashings_cache.updateLatestBlockSlot(block.slot());
     const body = block.body();
     const current_epoch = epoch_cache.epoch;
 
@@ -100,7 +107,7 @@ pub fn processBlock(
 
     try processRandao(fork, config, epoch_cache, state, block_type, body, block.proposerIndex(), opts.verify_signature);
     try processEth1Data(fork, state, body.eth1Data());
-    try processOperations(fork, allocator, config, epoch_cache, state, block_type, body, opts);
+    try processOperations(fork, allocator, config, epoch_cache, state, slashings_cache, block_type, body, opts);
     if (comptime fork.gte(.altair)) {
         try processSyncAggregate(fork, allocator, config, epoch_cache, state, body.syncAggregate(), opts.verify_signature);
     }

src/state_transition/block/process_operations.zig

@@ -7,6 +7,7 @@ const BlockType = @import("fork_types").BlockType;
 const BeaconBlockBody = @import("fork_types").BeaconBlockBody;
 const ForkTypes = @import("fork_types").ForkTypes;
 const ct = @import("consensus_types");
+const SlashingsCache = @import("../cache/slashings_cache.zig").SlashingsCache;
 
 const getEth1DepositCount = @import("../utils/deposit.zig").getEth1DepositCount;
 const processAttestations = @import("./process_attestations.zig").processAttestations;
@@ -27,6 +28,7 @@ pub fn processOperations(
     config: *const BeaconConfig,
     epoch_cache: *EpochCache,
     state: *BeaconState(fork),
+    slashings_cache: *SlashingsCache,
     comptime block_type: BlockType,
     body: *const BeaconBlockBody(block_type, fork),
     opts: ProcessBlockOpts,
@@ -40,7 +42,7 @@ pub fn processOperations(
     const current_epoch = epoch_cache.epoch;
 
     for (body.inner.proposer_slashings.items) |*proposer_slashing| {
-        try processProposerSlashing(fork, config, epoch_cache, state, proposer_slashing, opts.verify_signature);
+        try processProposerSlashing(fork, allocator, config, epoch_cache, state, slashings_cache, proposer_slashing, opts.verify_signature);
     }
 
     for (body.inner.attester_slashings.items) |*attester_slashing| {
@@ -50,13 +52,14 @@ pub fn processOperations(
             config,
             epoch_cache,
             state,
+            slashings_cache,
             current_epoch,
             attester_slashing,
             opts.verify_signature,
         );
     }
 
-    try processAttestations(fork, allocator, config, epoch_cache, state, body.inner.attestations.items, opts.verify_signature);
+    try processAttestations(fork, allocator, config, epoch_cache, state, slashings_cache, body.inner.attestations.items, opts.verify_signature);
 
     for (body.inner.deposits.items) |*deposit| {
         try processDeposit(fork, allocator, config, epoch_cache, state, deposit);
@@ -109,6 +112,7 @@ test "process operations" {
         test_state.cached_state.config,
         test_state.cached_state.getEpochCache(),
         try test_state.cached_state.state.tryCastToFork(.electra),
+        &test_state.cached_state.slashings_cache,
         .full,
         beacon_block.beaconBlockBody().castToFork(.full, .electra),
         .{},

src/state_transition/block/process_proposer_slashing.zig

@@ -4,6 +4,8 @@ const ForkSeq = @import("config").ForkSeq;
 const ForkTypes = @import("fork_types").ForkTypes;
 const BeaconState = @import("fork_types").BeaconState;
 const EpochCache = @import("../cache/epoch_cache.zig").EpochCache;
+const SlashingsCache = @import("../cache/slashings_cache.zig").SlashingsCache;
+const buildSlashingsCacheIfNeeded = @import("../cache/slashings_cache.zig").buildFromStateIfNeeded;
 const types = @import("consensus_types");
 const isSlashableValidator = @import("../utils/validator.zig").isSlashableValidator;
 const getProposerSlashingSignatureSets = @import("../signature_sets/proposer_slashings.zig").getProposerSlashingSignatureSets;
@@ -12,15 +14,18 @@ const slashValidator = @import("./slash_validator.zig").slashValidator;
 
 pub fn processProposerSlashing(
     comptime fork: ForkSeq,
+    allocator: std.mem.Allocator,
     config: *const BeaconConfig,
     epoch_cache: *EpochCache,
     state: *BeaconState(fork),
+    slashings_cache: *SlashingsCache,
     proposer_slashing: *const ForkTypes(fork).ProposerSlashing.Type,
     verify_signatures: bool,
 ) !void {
+    try buildSlashingsCacheIfNeeded(allocator, state, slashings_cache);
     try assertValidProposerSlashing(fork, config, epoch_cache, state, proposer_slashing, verify_signatures);
     const proposer_index = proposer_slashing.signed_header_1.message.proposer_index;
-    try slashValidator(fork, config, epoch_cache, state, proposer_index, null);
+    try slashValidator(fork, config, epoch_cache, state, slashings_cache, proposer_index, null);
 }
 
 pub fn assertValidProposerSlashing(

src/state_transition/block/slash_validator.zig

@@ -6,6 +6,7 @@ const c = @import("constants");
 const ValidatorIndex = types.primitive.ValidatorIndex.Type;
 const BeaconState = @import("fork_types").BeaconState;
 const EpochCache = @import("../cache/epoch_cache.zig").EpochCache;
+const SlashingsCache = @import("../cache/slashings_cache.zig").SlashingsCache;
 const decreaseBalance = @import("../utils/balance.zig").decreaseBalance;
 const increaseBalance = @import("../utils/balance.zig").increaseBalance;
 const initiateValidatorExit = @import("./initiate_validator_exit.zig").initiateValidatorExit;
@@ -21,6 +22,7 @@ pub fn slashValidator(
     config: *const BeaconConfig,
     epoch_cache: *EpochCache,
     state: *BeaconState(fork),
+    slashings_cache: *SlashingsCache,
     slashed_index: ValidatorIndex,
     whistle_blower_index: ?ValidatorIndex,
 ) !void {
@@ -35,6 +37,9 @@ pub fn slashValidator(
     try initiateValidatorExit(fork, config, epoch_cache, state, &validator);
 
     try validator.set("slashed", true);
+    var latest_block_header = try state.latestBlockHeader();
+    const latest_block_slot = try latest_block_header.get("slot");
+    try slashings_cache.recordValidatorSlashing(latest_block_slot, slashed_index);
     const cur_withdrawable_epoch = try validator.get("withdrawable_epoch");
     try validator.set(
         "withdrawable_epoch",

src/state_transition/cache/slashings_cache.zig

@@ -0,0 +1,102 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const DynamicBitSet = std.DynamicBitSet;
+const types = @import("consensus_types");
+const Slot = types.primitive.Slot.Type;
+const ValidatorIndex = types.primitive.ValidatorIndex.Type;
+const Validator = types.phase0.Validator.Type;
+
+/// Cache of slashed validator indices with an initialization slot.
+pub const SlashingsCache = struct {
+    latest_block_slot: ?Slot,
+    slashed_validators: DynamicBitSet,
+
+    pub fn initEmpty(allocator: Allocator) !SlashingsCache {
+        return .{
+            .latest_block_slot = null,
+            .slashed_validators = try DynamicBitSet.initEmpty(allocator, 0),
+        };
+    }
+
+    pub fn initFromValidators(
+        allocator: Allocator,
+        latest_block_slot: Slot,
+        validators: []const Validator,
+    ) !SlashingsCache {
+        var slashed_validators = try DynamicBitSet.initEmpty(allocator, validators.len);
+        errdefer slashed_validators.deinit();
+        for (validators, 0..) |validator, i| {
+            if (validator.slashed) {
+                slashed_validators.set(i);
+            }
+        }
+
+        return .{
+            .latest_block_slot = latest_block_slot,
+            .slashed_validators = slashed_validators,
+        };
+    }
+
+    pub fn clone(self: *const SlashingsCache, allocator: Allocator) !SlashingsCache {
+        var slashed_validators = try self.slashed_validators.clone(allocator);
+        errdefer slashed_validators.deinit();
+
+        return .{
+            .latest_block_slot = self.latest_block_slot,
+            .slashed_validators = slashed_validators,
+        };
+    }
+
+    pub fn deinit(self: *SlashingsCache) void {
+        self.slashed_validators.deinit();
+        self.* = undefined;
+    }
+
+    pub fn isInitialized(self: *const SlashingsCache, latest_block_slot: Slot) bool {
+        return self.latest_block_slot != null and self.latest_block_slot.? == latest_block_slot;
+    }
+
+    pub fn checkInitialized(self: *const SlashingsCache, latest_block_slot: Slot) !void {
+        if (self.isInitialized(latest_block_slot)) return;
+        return error.SlashingsCacheUninitialized;
+    }
+
+    pub fn recordValidatorSlashing(self: *SlashingsCache, block_slot: Slot, validator_index: ValidatorIndex) !void {
+        try self.checkInitialized(block_slot);
+        const idx: usize = @intCast(validator_index);
+        if (idx >= self.slashed_validators.capacity()) {
+            try self.slashed_validators.resize(idx + 1, false);
+        }
+        self.slashed_validators.set(idx);
+    }
+
+    pub fn isSlashed(self: *const SlashingsCache, validator_index: ValidatorIndex) bool {
+        const idx: usize = @intCast(validator_index);
+        if (idx >= self.slashed_validators.capacity()) return false;
+        return self.slashed_validators.isSet(idx);
+    }
+
+    pub fn updateLatestBlockSlot(self: *SlashingsCache, latest_block_slot: Slot) void {
+        self.latest_block_slot = latest_block_slot;
+    }
+};
+
+/// Rebuilds the cache if it's not initialized for the state's latest block slot.
+pub fn buildFromStateIfNeeded(
+    allocator: Allocator,
+    state: anytype,
+    slashings_cache: *SlashingsCache,
+) !void {
+    var latest_block_header = try state.latestBlockHeader();
+    const latest_block_slot = try latest_block_header.get("slot");
+    if (slashings_cache.isInitialized(latest_block_slot)) return;
+
+    var validators_view = try state.validators();
+    try validators_view.commit();
+    const validators = try validators_view.getAllReadonlyValues(allocator);
+    defer allocator.free(validators);
+    var new_cache = try SlashingsCache.initFromValidators(allocator, latest_block_slot, validators);
+    errdefer new_cache.deinit();
+    slashings_cache.deinit();
+    slashings_cache.* = new_cache;
+}