fix: add Block functions

src/state_transition/block/process_block.zig

@@ -6,7 +6,7 @@ const ssz = @import("consensus_types");
 const ValidatorIndex = ssz.primitive.ValidatorIndex.Type;
 const preset = @import("preset").preset;
 const BeaconBlock = @import("../types/beacon_block.zig").BeaconBlock;
-const SignedBlock = @import("../types/signed_block.zig").SignedBlock;
+const Block = @import("../types/signed_block.zig").Block;
 const BlockExternalData = @import("../state_transition.zig").BlockExternalData;
 const Withdrawals = ssz.capella.Withdrawals.Type;
 const WithdrawalsResult = @import("./process_withdrawals.zig").WithdrawalsResult;
@@ -27,15 +27,17 @@ pub const ProcessBlockOpts = struct {
     verify_signature: bool = true,
 };
 
+/// Process a block and update the state following Ethereum Consensus specifications.
 pub fn processBlock(
     allocator: Allocator,
     cached_state: *CachedBeaconStateAllForks,
-    block: *const SignedBlock,
+    block: Block,
     external_data: BlockExternalData,
     opts: ProcessBlockOpts,
     // TODO: metrics
 ) !void {
     const state = cached_state.state;
+    const body = block.beaconBlockBody();
 
     try processBlockHeader(allocator, cached_state, block);
 
@@ -55,7 +57,6 @@ pub fn processBlock(
             try getExpectedWithdrawals(allocator, &withdrawals_result, &withdrawal_balances, cached_state);
             defer withdrawals_result.withdrawals.clearRetainingCapacity();
 
-            const body = block.beaconBlockBody();
             switch (body) {
                 .regular => |b| {
                     const actual_withdrawals = b.executionPayload().getWithdrawals();
@@ -78,14 +79,14 @@ pub fn processBlock(
         try processExecutionPayload(
             allocator,
             cached_state,
-            block.beaconBlockBody(),
+            body,
             external_data,
         );
     }
 
-    try processRandao(cached_state, &block.beaconBlockBody(), block.proposerIndex(), opts.verify_signature);
-    try processEth1Data(allocator, cached_state, block.beaconBlockBody().eth1Data());
-    try processOperations(allocator, cached_state, &block.beaconBlockBody(), opts);
+    try processRandao(cached_state, body, block.proposerIndex(), opts.verify_signature);
+    try processEth1Data(allocator, cached_state, body.eth1Data());
+    try processOperations(allocator, cached_state, body, opts);
     if (state.isPostAltair()) {
         try processSyncAggregate(allocator, cached_state, block, opts.verify_signature);
     }

src/state_transition/block/process_block_header.zig

@@ -8,8 +8,9 @@ const BeaconBlockHeader = ssz.phase0.BeaconBlockHeader.Type;
 const Root = ssz.primitive.Root;
 const SignedBlock = @import("../types/signed_block.zig").SignedBlock;
 const ZERO_HASH = @import("constants").ZERO_HASH;
+const Block = @import("../types/signed_block.zig").Block;
 
-pub fn processBlockHeader(allocator: Allocator, cached_state: *const CachedBeaconStateAllForks, block: *const SignedBlock) !void {
+pub fn processBlockHeader(allocator: Allocator, cached_state: *const CachedBeaconStateAllForks, block: Block) !void {
     const state = cached_state.state;
     const epoch_cache = cached_state.getEpochCache();
     const slot = state.slot();
@@ -55,7 +56,8 @@ pub fn processBlockHeader(allocator: Allocator, cached_state: *const CachedBeaco
     }
 }
 
-pub fn blockToHeader(allocator: Allocator, block: *const SignedBlock, out: *BeaconBlockHeader) !void {
+pub fn blockToHeader(allocator: Allocator, signed_block: SignedBlock, out: *BeaconBlockHeader) !void {
+    const block = signed_block.message();
     out.slot = block.slot();
     out.proposer_index = block.proposerIndex();
     out.parent_root = block.parentRoot();

src/state_transition/block/process_execution_payload.zig

@@ -5,6 +5,7 @@ const ssz = @import("consensus_types");
 const preset = @import("preset").preset;
 const ForkSeq = @import("config").ForkSeq;
 const SignedBlock = @import("../types/signed_block.zig").SignedBlock;
+const Body = @import("../types/signed_block.zig").Body;
 const ExecutionPayloadStatus = @import("../state_transition.zig").ExecutionPayloadStatus;
 const SignedBlindedBeaconBlock = @import("../types/beacon_block.zig").SignedBlindedBeaconBlock;
 const BlockExternalData = @import("../state_transition.zig").BlockExternalData;
@@ -23,7 +24,7 @@ const PartialPayload = struct {
 pub fn processExecutionPayload(
     allocator: Allocator,
     cached_state: *const CachedBeaconStateAllForks,
-    body: SignedBlock.Body,
+    body: Body,
     external_data: BlockExternalData,
 ) !void {
     const state = cached_state.state;

src/state_transition/block/process_operations.zig

@@ -2,7 +2,7 @@ const std = @import("std");
 const CachedBeaconStateAllForks = @import("../cache/state_cache.zig").CachedBeaconStateAllForks;
 const ssz = @import("consensus_types");
 const preset = @import("preset").preset;
-const Body = @import("../types/signed_block.zig").SignedBlock.Body;
+const Body = @import("../types/signed_block.zig").Body;
 
 const getEth1DepositCount = @import("../utils/deposit.zig").getEth1DepositCount;
 const processAttestations = @import("./process_attestations.zig").processAttestations;
@@ -19,7 +19,7 @@ const ProcessBlockOpts = @import("./process_block.zig").ProcessBlockOpts;
 pub fn processOperations(
     allocator: std.mem.Allocator,
     cached_state: *CachedBeaconStateAllForks,
-    body: *const Body,
+    body: Body,
     opts: ProcessBlockOpts,
 ) !void {
     const state = cached_state.state;

src/state_transition/block/process_randao.zig

@@ -5,15 +5,15 @@ const ssz = @import("consensus_types");
 const preset = @import("preset").preset;
 const ForkSeq = @import("config").ForkSeq;
 const BeaconBlock = @import("../types/beacon_block.zig").BeaconBlock;
-const Body = @import("../types/signed_block.zig").SignedBlock.Body;
+const Body = @import("../types/signed_block.zig").Body;
 const Bytes32 = ssz.primitive.Bytes32.Type;
 const getRandaoMix = @import("../utils/seed.zig").getRandaoMix;
 const verifyRandaoSignature = @import("../signature_sets/randao.zig").verifyRandaoSignature;
 const digest = @import("../utils/sha256.zig").digest;
 
 pub fn processRandao(
     cached_state: *const CachedBeaconStateAllForks,
-    body: *const Body,
+    body: Body,
     proposer_idx: u64,
     verify_signature: bool,
 ) !void {

src/state_transition/block/process_sync_committee.zig

@@ -2,7 +2,7 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const CachedBeaconStateAllForks = @import("../cache/state_cache.zig").CachedBeaconStateAllForks;
 const BeaconBlock = @import("../types/beacon_block.zig").BeaconBlock;
-const SignedBlock = @import("../types/signed_block.zig").SignedBlock;
+const Block = @import("../types/signed_block.zig").Block;
 const ValidatorIndex = ssz.primitive.ValidatorIndex.Type;
 const AggregatedSignatureSet = @import("../utils/signature_sets.zig").AggregatedSignatureSet;
 const ssz = @import("consensus_types");
@@ -21,16 +21,17 @@ const decreaseBalance = balance_utils.decreaseBalance;
 pub fn processSyncAggregate(
     allocator: Allocator,
     cached_state: *CachedBeaconStateAllForks,
-    block: *const SignedBlock,
+    block: Block,
     verify_signatures: bool,
 ) !void {
     const state = cached_state.state;
     const epoch_cache = cached_state.getEpochCache();
     const committee_indices = @as(*const [preset.SYNC_COMMITTEE_SIZE]u64, @ptrCast(epoch_cache.current_sync_committee_indexed.get().getValidatorIndices()));
+    const body = block.beaconBlockBody();
 
     // different from the spec but not sure how to get through signature verification for default/empty SyncAggregate in the spec test
     if (verify_signatures) {
-        const participant_indices = try block.beaconBlockBody().syncAggregate().sync_committee_bits.intersectValues(
+        const participant_indices = try body.syncAggregate().sync_committee_bits.intersectValues(
             ValidatorIndex,
             allocator,
             committee_indices,
@@ -47,7 +48,7 @@ pub fn processSyncAggregate(
 
     const sync_participant_reward = epoch_cache.sync_participant_reward;
     const sync_proposer_reward = epoch_cache.sync_proposer_reward;
-    const sync_comittee_bits = block.beaconBlockBody().syncAggregate().sync_committee_bits;
+    const sync_comittee_bits = body.syncAggregate().sync_committee_bits;
     const proposer_index = try epoch_cache.getBeaconProposer(state.slot());
     const balances = state.balances();
     var proposer_balance = balances.items[proposer_index];
@@ -81,7 +82,7 @@ pub fn processSyncAggregate(
 }
 
 /// Consumers should deinit the returned pubkeys
-pub fn getSyncCommitteeSignatureSet(allocator: Allocator, cached_state: *const CachedBeaconStateAllForks, block: *const SignedBlock, participant_indices: ?[]usize) !?AggregatedSignatureSet {
+pub fn getSyncCommitteeSignatureSet(allocator: Allocator, cached_state: *const CachedBeaconStateAllForks, block: Block, participant_indices: ?[]usize) !?AggregatedSignatureSet {
     const state = cached_state.state;
     const epoch_cache = cached_state.getEpochCache();
     const sync_aggregate = block.beaconBlockBody().syncAggregate();

src/state_transition/root.zig

@@ -71,6 +71,7 @@ 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");
+pub const Block = @import("./types/signed_block.zig").Block;
 pub const SignedBlock = @import("./types/signed_block.zig").SignedBlock;
 pub const SignedBeaconBlock = @import("./types/beacon_block.zig").SignedBeaconBlock;
 pub const Attestations = @import("./types/attestation.zig").Attestations;

src/state_transition/signature_sets/proposer.zig

@@ -11,24 +11,25 @@ const computeSigningRoot = @import("../utils/signing_root.zig").computeSigningRo
 const verifySignatureSet = @import("../utils/signature_sets.zig").verifySingleSignatureSet;
 const SignedBlock = @import("../types/signed_block.zig").SignedBlock;
 
-pub fn verifyProposerSignature(cached_state: *CachedBeaconStateAllForks, signed_block: *const SignedBlock) !bool {
+pub fn verifyProposerSignature(cached_state: *CachedBeaconStateAllForks, signed_block: SignedBlock) !bool {
     const signature_set = try getBlockProposerSignatureSet(cached_state.allocator, cached_state, signed_block);
     return try verifySignatureSet(&signature_set);
 }
 
 // TODO: support SignedBlindedBeaconBlock
-pub fn getBlockProposerSignatureSet(allocator: Allocator, cached_state: *CachedBeaconStateAllForks, signed_block: *const SignedBlock) !SingleSignatureSet {
+pub fn getBlockProposerSignatureSet(allocator: Allocator, cached_state: *CachedBeaconStateAllForks, signed_block: SignedBlock) !SingleSignatureSet {
     const config = cached_state.config;
     const state = cached_state.state;
     const epoch_cache = cached_state.getEpochCache();
-    const domain = try config.getDomain(state.slot(), c.DOMAIN_BEACON_PROPOSER, signed_block.slot());
+    const block = signed_block.message();
+    const domain = try config.getDomain(state.slot(), c.DOMAIN_BEACON_PROPOSER, block.slot());
     // var signing_root: Root = undefined;
     var signing_root_buf: [32]u8 = undefined;
-    try computeBlockSigningRoot(allocator, signed_block, domain, &signing_root_buf);
+    try computeBlockSigningRoot(allocator, block, domain, &signing_root_buf);
 
     // Root.uncompressFromBytes(&signing_root_buf, &signing_root);
     return .{
-        .pubkey = epoch_cache.index_to_pubkey.items[signed_block.proposerIndex()],
+        .pubkey = epoch_cache.index_to_pubkey.items[block.proposerIndex()],
         .signing_root = signing_root_buf,
         .signature = signed_block.signature(),
     };

src/state_transition/signature_sets/proposer_slashings.zig

@@ -6,7 +6,6 @@ const SingleSignatureSet = @import("../utils/signature_sets.zig").SingleSignatur
 const c = @import("constants");
 const ssz = @import("consensus_types");
 const Root = ssz.primitive.Root;
-const computeBlockSigningRoot = @import("../utils/signing_root.zig").computeBlockSigningRoot;
 const computeSigningRoot = @import("../utils/signing_root.zig").computeSigningRoot;
 const verifySignatureSet = @import("../utils/signature_sets.zig").verifySingleSignatureSet;
 

src/state_transition/signature_sets/randao.zig

@@ -3,7 +3,7 @@ const Slot = ssz.primitive.Slot.Type;
 const CachedBeaconStateAllForks = @import("../cache/state_cache.zig").CachedBeaconStateAllForks;
 const Root = ssz.primitive.Root.Type;
 const Epoch = ssz.primitive.Epoch.Type;
-const Body = @import("../types/signed_block.zig").SignedBlock.Body;
+const Body = @import("../types/signed_block.zig").Body;
 const SingleSignatureSet = @import("../utils/signature_sets.zig").SingleSignatureSet;
 const computeEpochAtSlot = @import("../utils/epoch.zig").computeEpochAtSlot;
 const c = @import("constants");
@@ -12,7 +12,7 @@ const verifySingleSignatureSet = @import("../utils/signature_sets.zig").verifySi
 
 pub fn verifyRandaoSignature(
     state: *const CachedBeaconStateAllForks,
-    body: *const Body,
+    body: Body,
     slot: Slot,
     proposer_idx: u64,
 ) !bool {
@@ -22,7 +22,7 @@ pub fn verifyRandaoSignature(
 
 pub fn randaoRevealSignatureSet(
     cached_state: *const CachedBeaconStateAllForks,
-    body: *const Body,
+    body: Body,
     slot: Slot,
     proposer_idx: u64,
 ) !SingleSignatureSet {

src/state_transition/state_transition.zig

@@ -132,7 +132,7 @@ pub fn stateTransition(
     try processSlotsWithTransientCache(allocator, post_state, block_slot, .{});
 
     // Verify proposer signature only
-    if (opts.verify_proposer and !try verifyProposerSignature(post_state, &signed_block)) {
+    if (opts.verify_proposer and !try verifyProposerSignature(post_state, signed_block)) {
         return error.InvalidBlockSignature;
     }
 
@@ -142,7 +142,7 @@ pub fn stateTransition(
     try processBlock(
         allocator,
         post_state,
-        &signed_block,
+        block,
         BlockExternalData{
             .execution_payload_status = .valid,
             .data_availability_status = .available,