more compilation fixes

Author: spiral-ladder

src/config/beacon_config.zig

@@ -162,10 +162,9 @@ pub const BeaconConfig = struct {
         return switch (fork) {
             .deneb => self.chain.MAX_BLOBS_PER_BLOCK,
             .electra => self.chain.MAX_BLOBS_PER_BLOCK_ELECTRA,
-            else => {
-                // For forks before Deneb, we assume no blobs
-                0;
-            },
+            else =>
+            // For forks before Deneb, we assume no blobs
+            0,
         };
     }
 

src/state_transition/block/initiate_validator_exit.zig

@@ -25,7 +25,7 @@ const computeExitEpochAndUpdateChurn = @import("../utils/epoch.zig").computeExit
 /// ```
 /// Forcing consumers to pass the SubTree of `validator` directly mitigates this issue.
 ///
-pub fn initiateValidatorExit(cached_state: *CachedBeaconStateAllForks, validator: *Validator) !void {
+pub fn initiateValidatorExit(cached_state: *const CachedBeaconStateAllForks, validator: *Validator) !void {
     const config = cached_state.config.chain;
     const epoch_cache = cached_state.getEpochCache();
     const state = cached_state.state;

src/state_transition/block/is_valid_indexed_attestation.zig

@@ -1,32 +1,33 @@
+const std = @import("std");
 const CachedBeaconStateAllForks = @import("../cache/state_cache.zig").CachedBeaconStateAllForks;
 const ValidatorIndex = @import("../type.zig").ValidatorIndex;
 const ForkSeq = @import("params").ForkSeq;
 const ssz = @import("consensus_types");
 const preset = ssz.preset;
-const IndexedAttestation = @import("../types/attestation.zig").IndexedAttestation;
 const verifySingleSignatureSet = @import("../utils/signature_sets.zig").verifySingleSignatureSet;
 const verifyAggregatedSignatureSet = @import("../utils/signature_sets.zig").verifyAggregatedSignatureSet;
 const getIndexedAttestationSignatureSet = @import("../signature_sets/indexed_attestation.zig").getIndexedAttestationSignatureSet;
 
-pub fn isValidIndexedAttestation(cached_state: *const CachedBeaconStateAllForks, indexed_attestation: *const IndexedAttestation, verify_signature: ?bool) !bool {
+pub fn isValidIndexedAttestation(comptime IA: type, allocator: std.mem.Allocator, cached_state: *const CachedBeaconStateAllForks, indexed_attestation: *const IA, verify_signature: ?bool) !bool {
     if (!isValidIndexedAttestationIndices(cached_state, indexed_attestation.attesting_indices.items)) {
         return false;
     }
 
-    if (verify_signature orelse true) {
-        const signature_set = try getIndexedAttestationSignatureSet(cached_state.allocator, cached_state, indexed_attestation);
-        return verifyAggregatedSignatureSet(signature_set);
+    if (verify_signature) |_| {
+        const signature_set = try getIndexedAttestationSignatureSet(IA, cached_state.allocator, cached_state, indexed_attestation);
+        return verifyAggregatedSignatureSet(allocator, &signature_set);
+    } else {
+        return true;
     }
 }
 
 pub fn isValidIndexedAttestationIndices(cached_state: *const CachedBeaconStateAllForks, indices: []const ValidatorIndex) bool {
     // verify max number of indices
-    const fork_seq = cached_state.state.config.getForkSeq(cached_state.state.slot);
-    const max_indices = if (fork_seq >= ForkSeq.electra) {
-        preset.MAX_VALIDATORS_PER_COMMITTEE * preset.MAX_COMMITTEES_PER_SLOT;
-    } else {
+    const fork_seq = cached_state.state.getForkSeq();
+    const max_indices: usize = if (fork_seq.isPostElectra())
+        preset.MAX_VALIDATORS_PER_COMMITTEE * preset.MAX_COMMITTEES_PER_SLOT
+    else
         preset.MAX_VALIDATORS_PER_COMMITTEE;
-    };
 
     if (!(indices.len > 0 and indices.len <= max_indices)) {
         return false;
@@ -35,7 +36,7 @@ pub fn isValidIndexedAttestationIndices(cached_state: *const CachedBeaconStateAl
     // verify indices are sorted and unique.
     // Just check if they are monotonically increasing,
     // instead of creating a set and sorting it. Should be (O(n)) instead of O(n log(n))
-    var prev: ValidatorIndex = -1;
+    var prev: ValidatorIndex = 0;
     for (indices) |index| {
         if (index <= prev) return false;
         prev = index;

src/state_transition/block/process_attestation_altair.zig

@@ -49,7 +49,7 @@ pub fn processAttestationsAltair(allocator: Allocator, cached_state: *const Cach
         try validateAttestation(AT, cached_state, attestation);
 
         // Retrieve the validator indices from the attestation participation bitfield
-        const attesting_indices = if (AT == Phase0Attestation) epoch_cache.getAttestingIndicesPhase0(&attestation) else epoch_cache.getAttestingIndicesElectra(&attestation);
+        const attesting_indices = try if (AT == Phase0Attestation) epoch_cache.getAttestingIndicesPhase0(&attestation) else epoch_cache.getAttestingIndicesElectra(&attestation);
         defer attesting_indices.deinit();
 
         // this check is done last because its the most expensive (if signature verification is toggled on)

src/state_transition/block/process_attestation_phase0.zig

@@ -53,7 +53,7 @@ pub fn validateAttestation(comptime AT: type, cached_state: *const CachedBeaconS
     const data = attestation.data;
     const computed_epoch = computeEpochAtSlot(data.slot);
     const committee_count = try epoch_cache.getCommitteeCountPerSlot(computed_epoch);
-    if (data.target.epoch != epoch_cache.previous_shuffling.epoch and data.target.epoch != epoch_cache.epoch) {
+    if (data.target.epoch != epoch_cache.previous_shuffling.get().epoch and data.target.epoch != epoch_cache.epoch) {
         // TODO: print to stderr?
         return error.InvalidAttestationTargetEpochNotInPreviousOrCurrentEpoch;
     }

src/state_transition/block/process_attestations.zig

@@ -10,7 +10,7 @@ const Attestations = @import("../types/attestation.zig").Attestations;
 const processAttestationPhase0 = @import("./process_attestation_phase0.zig").processAttestationPhase0;
 const processAttestationsAltair = @import("./process_attestation_altair.zig").processAttestationsAltair;
 
-pub fn processAttestations(allocator: Allocator, cached_state: *CachedBeaconStateAllForks, attestations: Attestations, verify_signatures: ?bool) !void {
+pub fn processAttestations(allocator: Allocator, cached_state: *const CachedBeaconStateAllForks, attestations: Attestations, verify_signatures: ?bool) !void {
     const state = cached_state.state;
     switch (attestations) {
         .phase0 => |attestations_phase0| {

src/state_transition/block/process_attester_slashing.zig

@@ -1,3 +1,4 @@
+const std = @import("std");
 const CachedBeaconStateAllForks = @import("../cache/state_cache.zig").CachedBeaconStateAllForks;
 const ForkSeq = @import("params").ForkSeq;
 const ssz = @import("consensus_types");
@@ -11,10 +12,10 @@ const slashValidator = @import("./slash_validator.zig").slashValidator;
 /// AS is the AttesterSlashing type
 /// - for phase0 it is `ssz.phase0.AttesterSlashing.Type`
 /// - for electra it is `ssz.electra.AttesterSlashing.Type`
-pub fn processAttesterSlashing(comptime AS: type, cached_state: *CachedBeaconStateAllForks, attester_slashing: *const AS, verify_signature: ?bool) !void {
+pub fn processAttesterSlashing(comptime AS: type, allocator: std.mem.Allocator, cached_state: *const CachedBeaconStateAllForks, attester_slashing: *const AS, verify_signature: ?bool) !void {
     const state = cached_state.state;
     const epoch = cached_state.getEpochCache().epoch;
-    try assertValidAttesterSlashing(AS, cached_state, attester_slashing, verify_signature);
+    try assertValidAttesterSlashing(AS, allocator, cached_state, attester_slashing, verify_signature);
 
     const intersecting_indices = try getAttesterSlashableIndices(cached_state.allocator, attester_slashing);
     defer intersecting_indices.deinit();
@@ -23,7 +24,7 @@ pub fn processAttesterSlashing(comptime AS: type, cached_state: *CachedBeaconSta
     // Spec requires to sort indices beforehand but we validated sorted asc AttesterSlashing in the above functions
     for (intersecting_indices.items) |validator_index| {
         const validator = state.getValidator(validator_index);
-        if (isSlashableValidator(&validator, epoch)) {
+        if (isSlashableValidator(validator, epoch)) {
             try slashValidator(cached_state, validator_index, null);
             slashed_any = true;
         }
@@ -37,14 +38,15 @@ pub fn processAttesterSlashing(comptime AS: type, cached_state: *CachedBeaconSta
 /// AS is the AttesterSlashing type
 /// - for phase0 it is `ssz.phase0.AttesterSlashing.Type`
 /// - for electra it is `ssz.electra.AttesterSlashing.Type`
-pub fn assertValidAttesterSlashing(comptime AS: type, cached_state: *CachedBeaconStateAllForks, attester_slashing: *const AS, verify_signatures: ?bool) !void {
+pub fn assertValidAttesterSlashing(comptime AS: type, allocator: std.mem.Allocator, cached_state: *const CachedBeaconStateAllForks, attester_slashing: *const AS, verify_signatures: ?bool) !void {
     const attestations = &.{ attester_slashing.attestation_1, attester_slashing.attestation_2 };
     if (!isSlashableAttestationData(&attestations[0].data, &attestations[1].data)) {
         return error.InvalidAttesterSlashingNotSlashable;
     }
 
-    inline for (0..2) |i| {
-        if (!try isValidIndexedAttestation(cached_state, attestations[i], verify_signatures)) {
+    inline for (@typeInfo(AS).@"struct".fields, 0..2) |f, i| {
+        @compileLog(f.type);
+        if (!try isValidIndexedAttestation(f.type, allocator, cached_state, &attestations[i], verify_signatures)) {
             return error.InvalidAttesterSlashingAttestationInvalid;
         }
     }

src/state_transition/block/process_block.zig

@@ -15,6 +15,7 @@ const processOperations = @import("./process_operations.zig").processOperations;
 const processRandao = @import("./process_randao.zig").processRandao;
 const processSyncAggregate = @import("./process_sync_committee.zig").processSyncAggregate;
 const processWithdrawals = @import("./process_withdrawals.zig").processWithdrawals;
+const getExpectedWithdrawals = @import("./process_withdrawals.zig").getExpectedWithdrawals;
 const ProcessBlockOpts = @import("./types.zig").ProcessBlockOpts;
 const isExecutionEnabled = @import("../utils/execution.zig").isExecutionEnabled;
 // TODO: proposer reward api
@@ -27,7 +28,7 @@ pub fn processBlock(
     // TODO: support BlindedBeaconBlock
     block: *const SignedBlock,
     external_data: BlockExternalData,
-    opts: ?ProcessBlockOpts,
+    opts: ProcessBlockOpts,
     // TODO: metrics
 ) !void {
     const state = cached_state.state;
@@ -40,33 +41,45 @@ pub fn processBlock(
         // TODO Deneb: Allow to disable withdrawals for interop testing
         // https://github.com/ethereum/consensus-specs/blob/b62c9e877990242d63aa17a2a59a49bc649a2f2e/specs/eip4844/beacon-chain.md#disabling-withdrawals
         if (state.isPostCapella()) {
+            const expected_withdrawals_result = try getExpectedWithdrawals(allocator, cached_state);
+            const body = block.getBeaconBlockBody();
+            switch (body) {
+                .unblinded => |b| {
+                    const actual_withdrawals = b.getExecutionPayload().getWithdrawals();
+                    std.debug.assert(expected_withdrawals_result.withdrawals.items.len == actual_withdrawals.items.len);
+                    for (expected_withdrawals_result.withdrawals.items, actual_withdrawals.items) |ew, pw| {
+                        _ = ew;
+                        _ = pw;
+                        // TODO(bing): equals API
+                        // assert(ew == pw)
+                    }
+                },
+                .blinded => |b| {
+                    const header = b.getExecutionPayloadHeader();
+                    var expected: [32]u8 = undefined;
+                    try ssz.capella.Withdrawals.hashTreeRoot(allocator, &expected_withdrawals_result.withdrawals, &expected);
+                    var actual = header.getWithdrawalsRoot();
+                    std.debug.assert(std.mem.eql(u8, &expected, &actual));
+                },
+            }
             try processWithdrawals(
                 allocator,
                 cached_state,
-                &block.getBeaconBlockBody().getExecutionPayload(),
+                expected_withdrawals_result,
             );
         }
 
-        switch (block) {
-            .signed_beacon_block => |b| try processExecutionPayload(
-                allocator,
-                cached_state,
-                b.getBeaconBlockBody(),
-                external_data,
-            ),
-            .signed_blinded_beacon_block => |b| try processExecutionPayloadHeader(
-                allocator,
-                cached_state,
-                b,
-                external_data,
-            ),
-        }
-        try processExecutionPayload();
+        try processExecutionPayload(
+            allocator,
+            cached_state,
+            block.getBeaconBlockBody(),
+            external_data,
+        );
     }
 
-    try processRandao(state, block, opts.verify_signature);
-    try processEth1Data(state, block.getBeaconBlockBody().getEth1Data());
-    try processOperations(cached_state, block.getBeaconBlockBody(), external_data);
+    try processRandao(cached_state, &block.getBeaconBlockBody(), block.getProposerIndex(), opts.verify_signature);
+    try processEth1Data(allocator, cached_state, block.getBeaconBlockBody().getEth1Data());
+    try processOperations(allocator, cached_state, &block.getBeaconBlockBody(), opts);
     if (state.isPostAltair()) {
         try processSyncAggregate(cached_state, block, opts.verify_signature);
     }

src/state_transition/block/process_eth1_data.zig

@@ -1,15 +1,16 @@
+const std = @import("std");
 const ssz = @import("consensus_types");
 const Eth1Data = ssz.phase0.Eth1Data.Type;
 const CachedBeaconStateAllForks = @import("../cache/state_cache.zig").CachedBeaconStateAllForks;
 const preset = ssz.preset;
 
-pub fn processEth1Data(cached_state: *const CachedBeaconStateAllForks, eth1_data: *const Eth1Data) void {
+pub fn processEth1Data(allocator: std.mem.Allocator, cached_state: *const CachedBeaconStateAllForks, eth1_data: *const Eth1Data) !void {
     const state = cached_state.state;
     if (becomesNewEth1Data(cached_state, eth1_data)) {
         state.setEth1Data(eth1_data.*);
     }
 
-    state.getEth1DataVotes().append(eth1_data.*);
+    try state.getEth1DataVotes().append(allocator, eth1_data.*);
 }
 
 pub fn becomesNewEth1Data(cached_state: *const CachedBeaconStateAllForks, new_eth1_data: *const Eth1Data) bool {
@@ -18,12 +19,12 @@ pub fn becomesNewEth1Data(cached_state: *const CachedBeaconStateAllForks, new_et
 
     // If there are not more than 50% votes, then we do not have to count to find a winner.
     const state_eth1_data_votes = state.getEth1DataVotes().items;
-    if ((state_eth1_data_votes.length + 1) * 2 <= SLOTS_PER_ETH1_VOTING_PERIOD) {
+    if ((state_eth1_data_votes.len + 1) * 2 <= SLOTS_PER_ETH1_VOTING_PERIOD) {
         return false;
     }
 
     // Nothing to do if the state already has this as eth1data (happens a lot after majority vote is in)
-    if (isEqualEth1DataView(state.getEth1Data(), new_eth1_data.*)) {
+    if (isEqualEth1DataView(state.getEth1Data().*, new_eth1_data.*)) {
         return false;
     }
 
@@ -47,7 +48,8 @@ pub fn becomesNewEth1Data(cached_state: *const CachedBeaconStateAllForks, new_et
 }
 
 // TODO: should have a different implement in TreeView
-fn isEqualEth1DataView(eth1_data_a: Eth1Data, eth1_data_b: Eth1Data) bool {
-    // TODO(ssz): implement equals api
-    return ssz.phase0.Eth1Data.equals(eth1_data_a, eth1_data_b);
+fn isEqualEth1DataView(_: Eth1Data, _: Eth1Data) bool {
+    // TODO(bing): implement equals api, for now return true
+    // return ssz.phase0.Eth1Data.equals(eth1_data_a, eth1_data_b);
+    return true;
 }