main stf skeleton

Author: spiral-ladder

src/config/beacon_config.zig

@@ -15,7 +15,7 @@ const ForkInfo = params.ForkInfo;
 const TOTAL_FORKS = params.TOTAL_FORKS;
 const getForkSeqByForkName = params.getForkSeqByForkName;
 
-const DomainByTypeHashMap = std.AutoHashMap([]const u8, []const u8);
+const DomainByTypeHashMap = std.StringHashMap([]const u8);
 const DomainByTypeByFork = std.ArrayList(DomainByTypeHashMap);
 
 pub const ChainConfig = @import("./chain/chain_config.zig").ChainConfig;
@@ -173,7 +173,7 @@ pub const BeaconConfig = struct {
         return if (fork.isForkPostElectra()) self.chain.MAX_REQUEST_BLOB_SIDECARS_ELECTRA else self.chain.MAX_REQUEST_BLOB_SIDECARS;
     }
 
-    pub fn getDomain(self: *BeaconConfig, state_slot: Slot, domain_type: DomainType, message_slot: ?Slot) ![32]u8 {
+    pub fn getDomain(self: *const BeaconConfig, state_slot: Slot, domain_type: DomainType, message_slot: ?Slot) ![32]u8 {
         const slot = if (message_slot) |s| s else state_slot;
         const epoch = @divFloor(slot, preset.SLOTS_PER_EPOCH);
         const state_fork_info = self.getForkInfo(state_slot);
@@ -183,27 +183,29 @@ pub const BeaconConfig = struct {
     }
 
     // TODO: may not need this method
-    pub fn getDomainByForkName(self: *BeaconConfig, fork_name: []const u8, domain_type: DomainType) ![32]u8 {
+    pub fn getDomainByForkName(self: *const BeaconConfig, fork_name: []const u8, domain_type: DomainType) ![32]u8 {
         const fork_seq = getForkSeqByForkName(fork_name);
         return try self.getDomainByForkSeq(fork_seq, domain_type);
     }
 
-    pub fn getDomainByForkSeq(self: *BeaconConfig, fork_seq: ForkSeq, domain_type: DomainType) ![32]u8 {
-        if (fork_seq >= TOTAL_FORKS) return error.ForkSeqOutOfRange;
+    pub fn getDomainByForkSeq(self: *const BeaconConfig, fork_seq: ForkSeq, domain_type: DomainType) ![32]u8 {
+        if (@intFromEnum(fork_seq) >= TOTAL_FORKS) return error.ForkSeqOutOfRange;
 
-        const domain_by_type = self.domain_cache.items[@intFromEnum(fork_seq)];
-        const domain = domain_by_type.get(domain_type) orelse {
+        var domain_by_type = self.domain_cache.items[@intFromEnum(fork_seq)];
+        var domain: [32]u8 = undefined;
+
+        if (domain_by_type.get(&domain_type)) |d| @memcpy(&domain, d) else {
             const out = try self.allocator.create([32]u8);
             const fork_info = self.forks_ascending_epoch_order[@intFromEnum(fork_seq)];
-            computeDomain(domain_type, fork_info.version, self.genesis_validator_root, out);
-            try domain_by_type.put(domain_type, out);
-            return out;
-        };
+            try computeDomain(domain_type, fork_info.version, self.genesis_validator_root, out);
+            try domain_by_type.put(&domain_type, out);
+            @memcpy(&domain, out);
+        }
 
-        return domain.*;
+        return domain;
     }
 
-    pub fn getDomainForVoluntaryExit(self: *BeaconConfig, state_slot: Slot, message_slot: ?Slot) ![32]u8 {
+    pub fn getDomainForVoluntaryExit(self: *const BeaconConfig, state_slot: Slot, message_slot: ?Slot) ![32]u8 {
         const domain = if (state_slot < self.chain.DENEB_FORK_EPOCH * preset.SLOTS_PER_EPOCH) {
             return self.getDomain(state_slot, DOMAIN_VOLUNTARY_EXIT, message_slot);
         } else {
@@ -217,17 +219,17 @@ pub const BeaconConfig = struct {
     // may not need it for state-transition
 };
 
-fn computeDomain(domain_type: DomainType, fork_version: Version, genesis_validators_root: Root, out: *[32]u8) void {
-    computeForkDataRoot(fork_version, genesis_validators_root, out);
+fn computeDomain(domain_type: DomainType, fork_version: Version, genesis_validators_root: Root, out: *[32]u8) !void {
+    try computeForkDataRoot(fork_version, genesis_validators_root, out);
     std.mem.copyForwards(u8, out[0..], domain_type[0..]);
 }
 
-fn computeForkDataRoot(current_version: Version, genesis_validators_root: Root, out: *[32]u8) void {
+fn computeForkDataRoot(current_version: Version, genesis_validators_root: Root, out: *[32]u8) !void {
     const fork_data: ForkData = .{
         .current_version = current_version,
         .genesis_validators_root = genesis_validators_root,
     };
-    ssz.phase0.ForkData.hashTreeRoot(&fork_data, out);
+    try ssz.phase0.ForkData.hashTreeRoot(&fork_data, out);
 }
 
 // TODO: unit tests

src/state_transition/block/process_block.zig

@@ -5,6 +5,7 @@ const ForkSeq = @import("params").ForkSeq;
 const ssz = @import("consensus_types");
 const preset = ssz.preset;
 const BeaconBlock = @import("../types/beacon_block.zig").BeaconBlock;
+const SignedBlock = @import("../state_transition.zig").SignedBlock;
 const BlockExternalData = @import("external_data.zig").BlockExternalData;
 const processBlobKzgCommitments = @import("./process_blob_kzg_commitments.zig").processBlobKzgCommitments;
 const processBlockHeader = @import("./process_block_header.zig").processBlockHeader;
@@ -22,46 +23,52 @@ const isExecutionEnabled = @import("../utils/execution.zig").isExecutionEnabled;
 // TODO
 pub fn processBlock(
     allocator: Allocator,
-    cached_state: *CachedBeaconStateAllForks,
+    cached_state: *const CachedBeaconStateAllForks,
     // TODO: support BlindedBeaconBlock
-    block: *const BeaconBlock,
+    block: *const SignedBlock,
     external_data: BlockExternalData,
     opts: ?ProcessBlockOpts,
     // TODO: metrics
 ) !void {
     const state = cached_state.state;
-    const verify_signature = if (opts) |o| {
-        o.verify_signature orelse true;
-    } else true;
 
     try processBlockHeader(allocator, cached_state, block);
 
     // The call to the process_execution_payload must happen before the call to the process_randao as the former depends
     // on the randao_mix computed with the reveal of the previous block.
-    if (state.isPostBellatrix() and isExecutionEnabled(cached_state, block)) {
+    if (state.isPostBellatrix() and isExecutionEnabled(cached_state.state, block)) {
         // 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()) {
             try processWithdrawals(
                 allocator,
-                state,
+                cached_state,
                 &block.getBeaconBlockBody().getExecutionPayload(),
             );
         }
 
-        try processExecutionPayload(
-            allocator,
-            state,
-            block.getBeaconBlockBody(),
-            external_data,
-        );
+        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 processRandao(state, block, verify_signature);
+    try processRandao(state, block, opts.verify_signature);
     try processEth1Data(state, block.getBeaconBlockBody().getEth1Data());
     try processOperations(cached_state, block.getBeaconBlockBody(), external_data);
     if (state.isPostAltair()) {
-        try processSyncAggregate(cached_state, block, verify_signature);
+        try processSyncAggregate(cached_state, block, opts.verify_signature);
     }
 
     if (state.isPostDeneb()) {

src/state_transition/block/process_block_header.zig

@@ -6,10 +6,11 @@ const BeaconBlock = @import("../types/beacon_block.zig").BeaconBlock;
 const BeaconConfig = @import("config").BeaconConfig;
 const BeaconBlockHeader = @import("../type.zig").BeaconBlockHeader;
 const Root = @import("../type.zig").Root;
+const SignedBlock = @import("../state_transition.zig").SignedBlock;
 const ZERO_HASH = @import("../constants.zig").ZERO_HASH;
 
 // TODO: BlindedBeaconBlock
-pub fn processBlockHeader(allocator: Allocator, cached_state: *CachedBeaconStateAllForks, block: *const BeaconBlock) !void {
+pub fn processBlockHeader(allocator: Allocator, cached_state: *const CachedBeaconStateAllForks, block: *const SignedBlock) !void {
     const state = cached_state.state;
     const epoch_cache = cached_state.getEpochCache();
     const slot = state.getSlot();
@@ -25,38 +26,40 @@ pub fn processBlockHeader(allocator: Allocator, cached_state: *CachedBeaconState
     }
 
     // verify that proposer index is the correct index
-    const proposer_index = epoch_cache.getBeaconProposer(slot);
+    const proposer_index = try epoch_cache.getBeaconProposer(slot);
     if (block.getProposerIndex() != proposer_index) {
         return error.BlockProposerIndexMismatch;
     }
 
     // verify that the parent matches
-    if (!std.mem.eql(u8, &block.getParentRoot(), &ssz.phase0.BeaconBlockHeader.hashTreeRoot(state.getLatestBlockHeader()))) {
+    var header_parent_root: [32]u8 = undefined;
+    try ssz.phase0.BeaconBlockHeader.hashTreeRoot(state.getLatestBlockHeader(), &header_parent_root);
+    if (!std.mem.eql(u8, &block.getParentRoot(), &header_parent_root)) {
         return error.BlockParentRootMismatch;
     }
-
-    var block_header: BeaconBlockHeader = undefined;
-    try blockToHeader(allocator, block, &block_header);
-
-    // cache current block as the new latest block
-    state.setLatestBlockHeader(&.{
+    var body_root: [32]u8 = undefined;
+    try block.hashTreeRoot(allocator, &body_root);
+    const block_header: BeaconBlockHeader = .{
         .slot = slot,
         .proposer_index = proposer_index,
         .parent_root = block.getParentRoot(),
         .state_root = ZERO_HASH,
-        .bodyRoot = block_header.body_root,
-    });
+        .body_root = body_root,
+    };
+
+    // cache current block as the new latest block
+    state.setLatestBlockHeader(block_header);
 
     // verify proposer is not slashed. Only once per block, may use the slower read from tree
     if (state.getValidator(proposer_index).slashed) {
         return error.BlockProposerSlashed;
     }
 }
 
-pub fn blockToHeader(allocator: Allocator, block: *const BeaconBlock, out: *BeaconBlockHeader) !void {
+pub fn blockToHeader(allocator: Allocator, block: *const SignedBlock, out: *BeaconBlockHeader) !void {
     out.slot = block.getSlot();
     out.proposer_index = block.getProposerIndex();
     out.parent_root = block.getParentRoot();
     out.state_root = block.getStateRoot();
-    try block.getBeaconBlockBody().hashTreeRoot(allocator, &out.bodyRoot);
+    try block.hashTreeRoot(allocator, &out.body_root);
 }

src/state_transition/block/process_eth1_data.zig

@@ -12,7 +12,7 @@ pub fn processEth1Data(cached_state: *const CachedBeaconStateAllForks, eth1_data
     state.getEth1DataVotes().append(eth1_data.*);
 }
 
-pub fn becomesNewEth1Data(cached_state: *const CachedBeaconStateAllForks, new_eth1_data: *const Eth1Data) boolean {
+pub fn becomesNewEth1Data(cached_state: *const CachedBeaconStateAllForks, new_eth1_data: *const Eth1Data) bool {
     const state = cached_state.state;
     const SLOTS_PER_ETH1_VOTING_PERIOD = preset.EPOCHS_PER_ETH1_VOTING_PERIOD * preset.SLOTS_PER_EPOCH;
 

src/state_transition/block/process_execution_payload.zig

@@ -7,13 +7,83 @@ const params = @import("params");
 const ForkSeq = @import("params").ForkSeq;
 const BeaconBlockBody = @import("../types/beacon_block.zig").BeaconBlockBody;
 const ExecutionPayloadStatus = @import("./external_data.zig").ExecutionPayloadStatus;
+const SignedBlindedBeaconBlock = @import("types/beacon_block.zig").SignedBlindedBeaconBlock;
 const BeaconConfig = @import("config").BeaconConfig;
 const isMergeTransitionComplete = @import("../utils/execution.zig").isMergeTransitionComplete;
 const computeEpochAtSlot = @import("../utils/epoch.zig").computeEpochAtSlot;
 const getRandaoMix = @import("../utils/seed.zig").getRandaoMix;
 
 // TODO: support BlindedBeaconBlockBody
-pub fn processExecutionPayload(allocator: Allocator, cached_state: *CachedBeaconStateAllForks, body: BeaconBlockBody, external_data: ExecutionPayloadStatus) !void {
+pub fn processExecutionPayload(
+    allocator: Allocator,
+    cached_state: *const CachedBeaconStateAllForks,
+    body: BeaconBlockBody,
+    external_data: ExecutionPayloadStatus,
+) !void {
+    const state = cached_state.state;
+    const epoch_cache = cached_state.getEpochCache();
+    const config = epoch_cache.config;
+    const payload = body.getExecutionPayload();
+    // Verify consistency of the parent hash, block number, base fee per gas and gas limit
+    // with respect to the previous execution payload header
+    if (isMergeTransitionComplete(state)) {
+        const execution_payload_header = state.getLatestExecutionPayloadHeader();
+        if (!std.mem.eql(u8, &payload.getParentHash(), &execution_payload_header.getBlockHash())) {
+            return error.InvalidExecutionPayloadParentHash;
+        }
+    }
+
+    // Verify random
+    const expected_random = getRandaoMix(state.*, epoch_cache.epoch);
+    if (!std.mem.eql(u8, &payload.getPrevRandao(), &expected_random)) {
+        return error.InvalidExecutionPayloadRandom;
+    }
+
+    // Verify timestamp
+    //
+    // Note: inlined function in if statement
+    // def compute_timestamp_at_slot(state: BeaconState, slot: Slot) -> uint64:
+    //   slots_since_genesis = slot - GENESIS_SLOT
+    //   return uint64(state.genesis_time + slots_since_genesis * SECONDS_PER_SLOT)
+    if (payload.getTimestamp() != state.getGenesisTime() + state.getSlot() * config.chain.SECONDS_PER_SLOT) {
+        return error.InvalidExecutionPayloadTimestamp;
+    }
+
+    if (state.isPostDeneb()) {
+        const max_blobs_per_block = config.getMaxBlobsPerBlock(computeEpochAtSlot(state.getSlot()));
+        const blob_kzg_commitments_len = body.getBlobKzgCommitments().items.len;
+        if (blob_kzg_commitments_len > max_blobs_per_block) {
+            return error.BlobKzgCommitmentsExceedsLimit;
+        }
+    }
+
+    // Verify the execution payload is valid
+    //
+    // if executionEngine is null, executionEngine.onPayload MUST be called after running processBlock to get the
+    // correct randao mix. Since executionEngine will be an async call in most cases it is called afterwards to keep
+    // the state transition sync
+    //
+    // Equivalent to `assert executionEngine.notifyNewPayload(payload)
+    if (external_data == ExecutionPayloadStatus.pre_merge) {
+        return error.ExecutionPayloadStatusPreMerge;
+    } else if (external_data == ExecutionPayloadStatus.invalid) {
+        return error.InvalidExecutionPayload;
+    }
+
+    const payload_header = try payload.toPayloadHeader(allocator);
+    state.setLatestExecutionPayloadHeader(payload_header);
+}
+
+pub fn processExecutionPayloadHeader(
+    allocator: Allocator,
+    cached_state: *const CachedBeaconStateAllForks,
+    block: SignedBlindedBeaconBlock,
+) !void {
+    var signed_header = block.getBeaconBlock().getBeaconBlockBody().signed_execution_payload_header;
+    try verifyExecutionPayloadHeader(state, signed_header);
+
+    const header = signed_header.message;
+
     const state = cached_state.state;
     const epoch_cache = cached_state.getEpochCache();
     const config = epoch_cache.config;