main stf

fix import

undo panic dedup deletion

Author: spiral-ladder

build.zig

@@ -161,12 +161,14 @@ pub fn build(b: *std.Build) void {
 
     const run_config_unit_tests = b.addRunArtifact(config_unit_tests);
 
+    const filters = b.option([]const []const u8, "filters", "Test filters");
     // Creates a step for unit testing. This only builds the test executable
     // but does not run it.
     const state_transition_unit_tests = b.addTest(.{
         .root_source_file = b.path("src/state_transition/root.zig"),
         .target = target,
         .optimize = optimize,
+        .filters = filters orelse &.{},
     });
     state_transition_unit_tests.root_module.addImport("ssz", module_ssz);
     state_transition_unit_tests.root_module.addImport("consensus_types", module_consensus_types);
@@ -210,7 +212,7 @@ pub fn build(b: *std.Build) void {
     const test_int_tests = b.addTest(.{
         .name = "int",
         .root_module = module_test_int,
-        .filters = &[_][]const u8{},
+        .filters = filters orelse &.{},
     });
 
     const run_test_int_tests = b.addRunArtifact(test_int_tests);

src/state_transition/cache/epoch_transition_cache.zig

@@ -95,6 +95,13 @@ pub const ReusedEpochTransitionCache = struct {
     }
 };
 
+pub const EpochTransitionCacheOpts = struct {
+    /// Assert progressive balances the same in the cache.
+    assert_correct_progressive_balances: bool = false,
+    ///  Do not queue shuffling calculation async. Forces sync JIT calculation in afterProcessEpoch
+    async_shuffling_calculation: bool = false,
+};
+
 pub const EpochTransitionCache = struct {
     prev_epoch: Epoch,
     current_epoch: Epoch,

src/state_transition/epoch/process_inactivity_updates.zig

@@ -1,6 +1,7 @@
 const CachedBeaconStateAllForks = @import("../cache/state_cache.zig").CachedBeaconStateAllForks;
-const ssz = @import("consensus_types");
-const Epoch = ssz.primitive.Epoch.Type;
+
+const types = @import("../type.zig");
+const Epoch = types.Epoch;
 const EpochTransitionCache = @import("../cache/epoch_transition_cache.zig").EpochTransitionCache;
 const params = @import("params");
 const GENESIS_EPOCH = params.GENESIS_EPOCH;

src/state_transition/epoch/process_justification_and_finalization.zig

@@ -1,4 +1,6 @@
 const CachedBeaconStateAllForks = @import("../cache/state_cache.zig").CachedBeaconStateAllForks;
+const types = @import("../type.zig");
+const Epoch = types.Epoch;
 const EpochTransitionCache = @import("../cache/epoch_transition_cache.zig").EpochTransitionCache;
 const params = @import("params");
 const GENESIS_EPOCH = params.GENESIS_EPOCH;

src/state_transition/epoch/process_registry_updates.zig

@@ -1,6 +1,6 @@
 const CachedBeaconStateAllForks = @import("../cache/state_cache.zig").CachedBeaconStateAllForks;
-const ssz = @import("consensus_types");
-const Epoch = ssz.primitive.Epoch.Type;
+const types = @import("../type.zig");
+const Epoch = types.Epoch;
 const EpochTransitionCache = @import("../cache/epoch_transition_cache.zig").EpochTransitionCache;
 const ForkSeq = @import("params").ForkSeq;
 const computeActivationExitEpoch = @import("../utils/epoch.zig").computeActivationExitEpoch;

src/state_transition/root.zig

@@ -36,10 +36,12 @@ pub const processSyncCommitteeUpdates = @import("./epoch/process_sync_committee_
 
 pub const bls = @import("utils/bls.zig");
 const seed = @import("./utils/seed.zig");
+pub const state_transition = @import("./state_transition.zig");
 const EpochShuffling = @import("./utils/epoch_shuffling.zig");
 
 test {
     testing.refAllDecls(@This());
     testing.refAllDecls(seed);
+    testing.refAllDecls(state_transition);
     testing.refAllDecls(EpochShuffling);
 }

src/state_transition/slot/process_slot.zig

@@ -6,7 +6,7 @@ const preset = ssz.preset;
 const Root = ssz.primitive.Root.Type;
 const ZERO_HASH = @import("../constants.zig").ZERO_HASH;
 
-pub fn processSlot(allocator: Allocator, cached_state: *CachedBeaconStateAllForks) void {
+pub fn processSlot(allocator: Allocator, cached_state: *CachedBeaconStateAllForks) !void {
     const state = cached_state.state;
 
     // Cache state root
@@ -16,7 +16,7 @@ pub fn processSlot(allocator: Allocator, cached_state: *CachedBeaconStateAllFork
 
     // Cache latest block header state root
     var latest_block_header = state.getLatestBlockHeader();
-    if (!std.mem.allEqual(u8, &latest_block_header.state_root, &ZERO_HASH)) {
+    if (!std.mem.eql(u8, &latest_block_header.state_root, &ZERO_HASH)) {
         latest_block_header.state_root = previous_state_root;
     }
 

src/state_transition/slot/upgrade_state.zig

@@ -0,0 +1,26 @@
+const CachedBeaconStateAllForks = @import("../cache/state_cache.zig").CachedBeaconStateAllForks;
+const BeaconStateAllForks = @import("../types/beacon_state.zig").BeaconStateAllForks;
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+
+const assert = std.debug.assert;
+
+pub fn upgradeStateToAltair(_: *CachedBeaconStateAllForks) CachedBeaconStateAllForks {
+    @panic("unimplemented");
+}
+pub fn upgradeStateToBellatrix(_: *CachedBeaconStateAllForks) CachedBeaconStateAllForks {
+    @panic("unimplemented");
+}
+pub fn upgradeStateToCapella(_: *CachedBeaconStateAllForks) CachedBeaconStateAllForks {
+    @panic("unimplemented");
+}
+pub fn upgradeStateToDeneb(_: *CachedBeaconStateAllForks) CachedBeaconStateAllForks {
+    @panic("unimplemented");
+}
+pub fn upgradeStateToElectra(_: *CachedBeaconStateAllForks) CachedBeaconStateAllForks {
+    @panic("unimplemented");
+}
+pub fn upgradeStateToFulu(_: *CachedBeaconStateAllForks) CachedBeaconStateAllForks {
+    @panic("unimplemented");
+}

src/state_transition/state_transition.zig

@@ -0,0 +1,107 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+
+const ssz = @import("consensus_types");
+const preset = ssz.preset;
+const Root = ssz.primitive.Root.Type;
+const ZERO_HASH = @import("../constants.zig").ZERO_HASH;
+const Slot = ssz.primitive.Slot.Type;
+
+const CachedBeaconStateAllForks = @import("cache/state_cache.zig").CachedBeaconStateAllForks;
+pub const SignedBeaconBlock = @import("types/beacon_block.zig").SignedBeaconBlock;
+const BeaconBlock = @import("types/beacon_block.zig").BeaconBlock;
+const BlindedBeaconBlock = @import("types/beacon_block.zig").BlindedBeaconBlock;
+const SignedBlindedBeaconBlock = @import("types/beacon_block.zig").SignedBlindedBeaconBlock;
+const TestCachedBeaconStateAllForks = @import("../../test/int/generate_state.zig").TestCachedBeaconStateAllForks;
+const EpochTransitionCacheOpts = @import("cache/epoch_transition_cache.zig").EpochTransitionCacheOpts;
+const EpochTransitionCache = @import("cache/epoch_transition_cache.zig").EpochTransitionCache;
+const process_epoch = @import("epoch/process_epoch.zig").process_epoch;
+const computeEpochAtSlot = @import("utils/epoch.zig").computeEpochAtSlot;
+const processSlot = @import("slot/process_slot.zig").processSlot;
+
+const Options = struct {
+    verify_state_root: bool = true,
+    verify_proposer: bool = true,
+    verify_signatures: bool = false,
+    do_not_transfer_cache: bool = false,
+};
+
+const Block = union(enum) {
+    block: BeaconBlock,
+    blinded_block: BlindedBeaconBlock,
+};
+
+pub const SignedBlock = union(enum) {
+    signed_beacon_block: *const SignedBeaconBlock,
+    signed_blinded_beacon_block: *const SignedBlindedBeaconBlock,
+
+    fn getMessage(self: *const SignedBlock) Block {
+        return switch (self.*) {
+            .signed_beacon_block => |b| Block{ .block = b.getBeaconBlock() },
+            .signed_blinded_beacon_block => |b| Block{ .blinded_block = b.getBeaconBlock() },
+        };
+    }
+};
+
+fn processSlotsWithTransientCache(
+    allocator: std.mem.Allocator,
+    post_state: *CachedBeaconStateAllForks,
+    slot: Slot,
+    _: EpochTransitionCacheOpts,
+) !void {
+    var post_state_slot = post_state.state.getSlot();
+    if (post_state_slot > slot) return error.outdatedSlot;
+
+    while (post_state_slot < slot) {
+        try processSlot(allocator, post_state);
+
+        if ((post_state_slot + 1) % preset.SLOTS_PER_EPOCH == 0) {
+            _ = post_state.config.getForkSeq(post_state_slot);
+            // TODO(bing): implement
+            // const epochTransitionTimer = metrics?.epochTransitionTime.startTimer();
+            // var epoch_transition_cache = beforeProcessEpoch(post_state, epoch_transition_cache_opts);
+            // process_epoch(allocator, post_state, epoch_transition_cache);
+
+            // registerValidatorStatuses
+
+            post_state_slot += 1;
+
+            // afterProcessEpoch
+            // post_state.commit
+        }
+
+        //epochTransitionTimer
+        // upgrade state
+        _ = computeEpochAtSlot(post_state_slot);
+        _ = post_state.config;
+
+        //TODO(bing): upgradeState to forks
+        //switch (true) {
+        //    state_epoch == config.chain.DENEB_FORK_EPOCH => post_state = upgradeState();
+        //
+        //}
+    }
+}
+
+pub fn stateTransition(
+    allocator: std.mem.Allocator,
+    state: *CachedBeaconStateAllForks,
+    signed_block: SignedBlock,
+    options: Options,
+) !*CachedBeaconStateAllForks {
+    _ = options;
+
+    //TODO(bing): deep clone
+    // const post_state = state.clone();
+    //
+    const post_state = state;
+    const block = signed_block.getMessage();
+    const block_slot = switch (block) {
+        .block => |b| b.getSlot(),
+        .blinded_block => |b| b.getSlot(),
+    };
+
+    try processSlotsWithTransientCache(allocator, post_state, block_slot, .{});
+
+    return state;
+}

src/state_transition/types/beacon_state.zig

@@ -1,7 +1,7 @@
 const std = @import("std");
+const panic = std.debug.panic;
 const Allocator = std.mem.Allocator;
 const expect = std.testing.expect;
-const panic = std.debug.panic;
 const ssz = @import("consensus_types");
 const preset = ssz.preset;
 const BeaconStatePhase0 = ssz.phase0.BeaconState.Type;
@@ -301,7 +301,7 @@ pub const BeaconStateAllForks = union(enum) {
 
     pub fn setBlockRoot(self: *BeaconStateAllForks, index: usize, root: Root) void {
         switch (self.*) {
-            inline .phase0, .altair, .bellatrix, .capella, .deneb, .electra => |state| state.block_roots.items[index] = root,
+            inline .phase0, .altair, .bellatrix, .capella, .deneb, .electra => |state| state.block_roots[index] = root,
         }
     }
 
@@ -319,7 +319,7 @@ pub const BeaconStateAllForks = union(enum) {
 
     pub fn setStateRoot(self: *BeaconStateAllForks, index: usize, root: Root) void {
         switch (self.*) {
-            inline .phase0, .altair, .bellatrix, .capella, .deneb, .electra => |state| state.state_roots.items[index] = root,
+            inline .phase0, .altair, .bellatrix, .capella, .deneb, .electra => |state| state.state_roots[index] = root,
         }
     }