diff --git a/src/state_transition/block/process_block.zig b/src/state_transition/block/process_block.zig
index fb2c227d..61486063 100644
--- a/src/state_transition/block/process_block.zig
+++ b/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);
     }
diff --git a/src/state_transition/block/process_block_header.zig b/src/state_transition/block/process_block_header.zig
index 710e3ebf..dcd009c8 100644
--- a/src/state_transition/block/process_block_header.zig
+++ b/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();
diff --git a/src/state_transition/block/process_execution_payload.zig b/src/state_transition/block/process_execution_payload.zig
index 63cca597..67bc1800 100644
--- a/src/state_transition/block/process_execution_payload.zig
+++ b/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;
diff --git a/src/state_transition/block/process_operations.zig b/src/state_transition/block/process_operations.zig
index a53f7995..f3a6373b 100644
--- a/src/state_transition/block/process_operations.zig
+++ b/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;
diff --git a/src/state_transition/block/process_randao.zig b/src/state_transition/block/process_randao.zig
index 7aeb8b2b..027524ef 100644
--- a/src/state_transition/block/process_randao.zig
+++ b/src/state_transition/block/process_randao.zig
@@ -5,7 +5,7 @@ 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;
@@ -13,7 +13,7 @@ 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 {
diff --git a/src/state_transition/block/process_sync_committee.zig b/src/state_transition/block/process_sync_committee.zig
index 14c012f3..7bd876fd 100644
--- a/src/state_transition/block/process_sync_committee.zig
+++ b/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();
diff --git a/src/state_transition/root.zig b/src/state_transition/root.zig
index 30b50dbf..f4675f42 100644
--- a/src/state_transition/root.zig
+++ b/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;
diff --git a/src/state_transition/signature_sets/proposer.zig b/src/state_transition/signature_sets/proposer.zig
index 5ebc5252..c19b1a64 100644
--- a/src/state_transition/signature_sets/proposer.zig
+++ b/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(),
     };
diff --git a/src/state_transition/signature_sets/proposer_slashings.zig b/src/state_transition/signature_sets/proposer_slashings.zig
index bd4083db..aa7e74ef 100644
--- a/src/state_transition/signature_sets/proposer_slashings.zig
+++ b/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;
 
diff --git a/src/state_transition/signature_sets/randao.zig b/src/state_transition/signature_sets/randao.zig
index 9ef9fe38..d71197cf 100644
--- a/src/state_transition/signature_sets/randao.zig
+++ b/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 {
diff --git a/src/state_transition/state_transition.zig b/src/state_transition/state_transition.zig
index 414d2c71..08404b41 100644
--- a/src/state_transition/state_transition.zig
+++ b/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,
diff --git a/src/state_transition/types/signed_block.zig b/src/state_transition/types/signed_block.zig
index 840d5fa4..26f47524 100644
--- a/src/state_transition/types/signed_block.zig
+++ b/src/state_transition/types/signed_block.zig
@@ -1,136 +1,137 @@
+pub const SignedBlock = union(enum) {
+    regular: SignedBeaconBlock,
+    blinded: SignedBlindedBeaconBlock,
+
+    pub fn message(self: *const SignedBlock) Block {
+        return switch (self.*) {
+            .regular => |b| .{ .regular = b.beaconBlock() },
+            .blinded => |b| .{ .blinded = b.beaconBlock() },
+        };
+    }
+
+    pub fn signature(self: *const SignedBlock) ssz.primitive.BLSSignature.Type {
+        return switch (self.*) {
+            inline .regular, .blinded => |b| b.signature(),
+        };
+    }
+};
+
 pub const Block = union(enum) {
     regular: BeaconBlock,
     blinded: BlindedBeaconBlock,
+
+    pub fn beaconBlockBody(self: *const Block) Body {
+        return switch (self.*) {
+            .regular => |b| .{ .regular = b.beaconBlockBody() },
+            .blinded => |b| .{ .blinded = b.beaconBlockBody() },
+        };
+    }
+
+    pub fn parentRoot(self: *const Block) [32]u8 {
+        return switch (self.*) {
+            .regular => |b| b.parentRoot(),
+            .blinded => |b| b.parentRoot(),
+        };
+    }
+
+    pub fn slot(self: *const Block) Slot {
+        return switch (self.*) {
+            .regular => |b| b.slot(),
+            .blinded => |b| b.slot(),
+        };
+    }
+
+    pub fn hashTreeRoot(self: *const Block, allocator: std.mem.Allocator, out: *[32]u8) !void {
+        return switch (self.*) {
+            .regular => |b| b.hashTreeRoot(allocator, out),
+            .blinded => |b| b.hashTreeRoot(allocator, out),
+        };
+    }
+
+    pub fn proposerIndex(self: *const Block) u64 {
+        return switch (self.*) {
+            .regular => |b| b.proposerIndex(),
+            .blinded => |b| b.proposerIndex(),
+        };
+    }
 };
 
-pub const SignedBlock = union(enum) {
-    regular: *const SignedBeaconBlock,
-    blinded: *const SignedBlindedBeaconBlock,
-
-    pub const Body = union(enum) {
-        regular: BeaconBlockBody,
-        blinded: BlindedBeaconBlockBody,
-
-        pub fn blobKzgCommitmentsLen(self: *const Body) usize {
-            return switch (self.*) {
-                inline .regular, .blinded => |b| b.blobKzgCommitments().items.len,
-            };
-        }
-
-        pub fn eth1Data(self: *const Body) *const ssz.phase0.Eth1Data.Type {
-            return switch (self.*) {
-                inline .regular, .blinded => |b| b.eth1Data(),
-            };
-        }
-
-        pub fn randaoReveal(self: *const Body) ssz.primitive.BLSSignature.Type {
-            return switch (self.*) {
-                inline .regular, .blinded => |b| b.randaoReveal(),
-            };
-        }
-
-        pub fn deposits(self: *const Body) []Deposit {
-            return switch (self.*) {
-                inline .regular, .blinded => |b| b.deposits(),
-            };
-        }
-        pub fn depositRequests(self: *const Body) []DepositRequest {
-            return switch (self.*) {
-                inline .regular, .blinded => |b| b.depositRequests(),
-            };
-        }
-        pub fn withdrawalRequests(self: *const Body) []WithdrawalRequest {
-            return switch (self.*) {
-                inline .regular, .blinded => |b| b.withdrawalRequests(),
-            };
-        }
-        pub fn consolidationRequests(self: *const Body) []ConsolidationRequest {
-            return switch (self.*) {
-                inline .regular, .blinded => |b| b.consolidationRequests(),
-            };
-        }
-
-        pub fn syncAggregate(self: *const Body) *const ssz.altair.SyncAggregate.Type {
-            return switch (self.*) {
-                inline .regular, .blinded => |b| b.syncAggregate(),
-            };
-        }
-
-        pub fn attesterSlashings(self: *const Body) AttesterSlashings {
-            return switch (self.*) {
-                inline .regular, .blinded => |b| b.attesterSlashings(),
-            };
-        }
-
-        pub fn attestations(self: *const Body) Attestations {
-            return switch (self.*) {
-                inline .regular, .blinded => |b| b.attestations(),
-            };
-        }
-
-        pub fn voluntaryExits(self: *const Body) []SignedVoluntaryExit {
-            return switch (self.*) {
-                inline .regular, .blinded => |b| b.voluntaryExits(),
-            };
-        }
-
-        pub fn proposerSlashings(self: *const Body) []ProposerSlashing {
-            return switch (self.*) {
-                inline .regular, .blinded => |b| b.proposerSlashings(),
-            };
-        }
-
-        pub fn blsToExecutionChanges(self: *const Body) []SignedBLSToExecutionChange {
-            return switch (self.*) {
-                inline .regular, .blinded => |b| b.blsToExecutionChanges(),
-            };
-        }
-    };
+pub const Body = union(enum) {
+    regular: BeaconBlockBody,
+    blinded: BlindedBeaconBlockBody,
 
-    pub fn message(self: *const SignedBlock) Block {
+    pub fn blobKzgCommitmentsLen(self: *const Body) usize {
         return switch (self.*) {
-            .regular => |b| .{ .regular = b.beaconBlock() },
-            .blinded => |b| .{ .blinded = b.beaconBlock() },
+            inline .regular, .blinded => |b| b.blobKzgCommitments().items.len,
+        };
+    }
+
+    pub fn eth1Data(self: *const Body) *const ssz.phase0.Eth1Data.Type {
+        return switch (self.*) {
+            inline .regular, .blinded => |b| b.eth1Data(),
+        };
+    }
+
+    pub fn randaoReveal(self: *const Body) ssz.primitive.BLSSignature.Type {
+        return switch (self.*) {
+            inline .regular, .blinded => |b| b.randaoReveal(),
         };
     }
-    pub fn beaconBlockBody(self: *const SignedBlock) Body {
+
+    pub fn deposits(self: *const Body) []Deposit {
+        return switch (self.*) {
+            inline .regular, .blinded => |b| b.deposits(),
+        };
+    }
+    pub fn depositRequests(self: *const Body) []DepositRequest {
+        return switch (self.*) {
+            inline .regular, .blinded => |b| b.depositRequests(),
+        };
+    }
+    pub fn withdrawalRequests(self: *const Body) []WithdrawalRequest {
+        return switch (self.*) {
+            inline .regular, .blinded => |b| b.withdrawalRequests(),
+        };
+    }
+    pub fn consolidationRequests(self: *const Body) []ConsolidationRequest {
         return switch (self.*) {
-            .regular => |b| .{ .regular = b.beaconBlock().beaconBlockBody() },
-            .blinded => |b| .{ .blinded = b.beaconBlock().beaconBlockBody() },
+            inline .regular, .blinded => |b| b.consolidationRequests(),
         };
     }
 
-    pub fn parentRoot(self: *const SignedBlock) [32]u8 {
+    pub fn syncAggregate(self: *const Body) *const ssz.altair.SyncAggregate.Type {
         return switch (self.*) {
-            .regular => |b| b.beaconBlock().parentRoot(),
-            .blinded => |b| b.beaconBlock().parentRoot(),
+            inline .regular, .blinded => |b| b.syncAggregate(),
         };
     }
 
-    pub fn slot(self: *const SignedBlock) Slot {
+    pub fn attesterSlashings(self: *const Body) AttesterSlashings {
         return switch (self.*) {
-            .regular => |b| b.beaconBlock().slot(),
-            .blinded => |b| b.beaconBlock().slot(),
+            inline .regular, .blinded => |b| b.attesterSlashings(),
         };
     }
 
-    pub fn hashTreeRoot(self: *const SignedBlock, allocator: std.mem.Allocator, out: *[32]u8) !void {
+    pub fn attestations(self: *const Body) Attestations {
         return switch (self.*) {
-            .regular => |b| b.beaconBlock().hashTreeRoot(allocator, out),
-            .blinded => |b| b.beaconBlock().hashTreeRoot(allocator, out),
+            inline .regular, .blinded => |b| b.attestations(),
         };
     }
 
-    pub fn proposerIndex(self: *const SignedBlock) u64 {
+    pub fn voluntaryExits(self: *const Body) []SignedVoluntaryExit {
         return switch (self.*) {
-            .regular => |b| b.beaconBlock().proposerIndex(),
-            .blinded => |b| b.beaconBlock().proposerIndex(),
+            inline .regular, .blinded => |b| b.voluntaryExits(),
         };
     }
 
-    pub fn signature(self: *const SignedBlock) ssz.primitive.BLSSignature.Type {
+    pub fn proposerSlashings(self: *const Body) []ProposerSlashing {
         return switch (self.*) {
-            inline .regular, .blinded => |b| b.signature(),
+            inline .regular, .blinded => |b| b.proposerSlashings(),
+        };
+    }
+
+    pub fn blsToExecutionChanges(self: *const Body) []SignedBLSToExecutionChange {
+        return switch (self.*) {
+            inline .regular, .blinded => |b| b.blsToExecutionChanges(),
         };
     }
 };
diff --git a/src/state_transition/utils/execution.zig b/src/state_transition/utils/execution.zig
index 6c977120..f0a999b1 100644
--- a/src/state_transition/utils/execution.zig
+++ b/src/state_transition/utils/execution.zig
@@ -2,23 +2,23 @@ const std = @import("std");
 const ForkSeq = @import("config").ForkSeq;
 const ssz = @import("consensus_types");
 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 BeaconBlockBody = @import("../types/beacon_block.zig").BeaconBlockBody;
 const ExecutionPayload = @import("../types/beacon_block.zig").ExecutionPayload;
 // const ExecutionPayloadHeader
 const CachedBeaconStateAllForks = @import("../cache/state_cache.zig").CachedBeaconStateAllForks;
 const BeaconStateAllForks = @import("../types/beacon_state.zig").BeaconStateAllForks;
 
-pub fn isExecutionEnabled(state: *const BeaconStateAllForks, block: *const SignedBlock) bool {
+pub fn isExecutionEnabled(state: *const BeaconStateAllForks, block: Block) bool {
     if (!state.isPostBellatrix()) return false;
     if (isMergeTransitionComplete(state)) return true;
 
     // TODO(bing): in lodestar prod, state root comparison should be enough but spec tests were failing. This switch block is a failsafe for that.
     //
     // Ref: https://github.com/ChainSafe/lodestar/blob/7f2271a1e2506bf30378da98a0f548290441bdc5/packages/state-transition/src/util/execution.ts#L37-L42
-    switch (block.*) {
+    switch (block) {
         .blinded => |b| {
-            const body = b.beaconBlock().beaconBlockBody();
+            const body = b.beaconBlockBody();
 
             return switch (body) {
                 .capella => |bd| ssz.capella.ExecutionPayloadHeader.equals(&bd.execution_payload_header, &ssz.capella.ExecutionPayloadHeader.default_value),
@@ -27,7 +27,7 @@ pub fn isExecutionEnabled(state: *const BeaconStateAllForks, block: *const Signe
             };
         },
         .regular => |b| {
-            const body = b.beaconBlock().beaconBlockBody();
+            const body = b.beaconBlockBody();
 
             return switch (body) {
                 .phase0, .altair => @panic("Unsupported"),
diff --git a/src/state_transition/utils/signing_root.zig b/src/state_transition/utils/signing_root.zig
index 084d8bcb..0aef57da 100644
--- a/src/state_transition/utils/signing_root.zig
+++ b/src/state_transition/utils/signing_root.zig
@@ -5,8 +5,7 @@ const Root = ssz.primitive.Root.Type;
 const ssz = @import("consensus_types");
 const BeaconBlock = @import("../types/beacon_block.zig").BeaconBlock;
 const SignedBeaconBlock = @import("../state_transition.zig").SignedBeaconBlock;
-const Block = @import("../state_transition.zig").Block;
-const SignedBlock = @import("../types/signed_block.zig").SignedBlock;
+const Block = @import("../types/signed_block.zig").Block;
 
 const SigningData = ssz.phase0.SigningData.Type;
 
@@ -22,7 +21,7 @@ pub fn computeSigningRoot(comptime T: type, ssz_object: *const T.Type, domain: D
     try ssz.phase0.SigningData.hashTreeRoot(&domain_wrapped_object, out);
 }
 
-pub fn computeBlockSigningRoot(allocator: Allocator, block: *const SignedBlock, domain: Domain, out: *[32]u8) !void {
+pub fn computeBlockSigningRoot(allocator: Allocator, block: Block, domain: Domain, out: *[32]u8) !void {
     var object_root: Root = undefined;
     try block.hashTreeRoot(allocator, &object_root);
     const domain_wrapped_object: SigningData = .{
@@ -48,12 +47,10 @@ test "computeBlockSigningRoot - sanity" {
     const allocator = std.testing.allocator;
     var electra_block = ssz.electra.BeaconBlock.default_value;
     electra_block.slot = 2025;
-    var signed_electra_block = ssz.electra.SignedBeaconBlock.default_value;
-    signed_electra_block.message = electra_block;
     const domain = [_]u8{0x01} ** 32;
     var out: [32]u8 = undefined;
 
-    const signed_beacon_block = SignedBeaconBlock{ .electra = &signed_electra_block };
-    const signed_block = SignedBlock{ .regular = &signed_beacon_block };
-    try computeBlockSigningRoot(allocator, &signed_block, domain, &out);
+    const beacon_block = BeaconBlock{ .electra = &electra_block };
+    const block = Block{ .regular = beacon_block };
+    try computeBlockSigningRoot(allocator, block, domain, &out);
 }
diff --git a/test/int/process_block_header.zig b/test/int/process_block_header.zig
index 96838cc0..835e1e26 100644
--- a/test/int/process_block_header.zig
+++ b/test/int/process_block_header.zig
@@ -17,22 +17,18 @@ test "process block header - sanity" {
     message.proposer_index = proposer_index;
     message.parent_root = header_parent_root;
 
-    var beacon_block: ssz.electra.SignedBeaconBlock.Type = ssz.electra.SignedBeaconBlock.default_value;
-    beacon_block.message = message;
-    const signed_beacon_block = SignedBeaconBlock{ .electra = &beacon_block };
-    const block = SignedBlock{ .regular = &signed_beacon_block };
-    try processBlockHeader(allocator, test_state.cached_state, &block);
+    const beacon_block = BeaconBlock{ .electra = &message };
+
+    const block = Block{ .regular = beacon_block };
+    try processBlockHeader(allocator, test_state.cached_state, block);
 }
 
 const std = @import("std");
 const ssz = @import("consensus_types");
 const config = @import("config");
-
 const state_transition = @import("state_transition");
 const TestCachedBeaconStateAllForks = state_transition.test_utils.TestCachedBeaconStateAllForks;
-
 const preset = @import("preset").preset;
-
 const processBlockHeader = state_transition.processBlockHeader;
-const SignedBlock = state_transition.SignedBlock;
-const SignedBeaconBlock = state_transition.SignedBeaconBlock;
+const Block = state_transition.Block;
+const BeaconBlock = state_transition.BeaconBlock;
diff --git a/test/int/process_eth1_data.zig b/test/int/process_eth1_data.zig
index d1998e4f..562bc46a 100644
--- a/test/int/process_eth1_data.zig
+++ b/test/int/process_eth1_data.zig
@@ -4,10 +4,8 @@ test "process eth1 data - sanity" {
     var test_state = try TestCachedBeaconStateAllForks.init(allocator, 256);
     defer test_state.deinit();
 
-    const beacon_block: ssz.electra.SignedBeaconBlock.Type = ssz.electra.SignedBeaconBlock.default_value;
-    const signed_beacon_block = SignedBeaconBlock{ .electra = &beacon_block };
-    const block = SignedBlock{ .regular = &signed_beacon_block };
-    try processEth1Data(allocator, test_state.cached_state, block.beaconBlockBody().eth1Data());
+    const block = ssz.electra.BeaconBlock.default_value;
+    try processEth1Data(allocator, test_state.cached_state, &block.body.eth1_data);
 }
 
 const std = @import("std");
diff --git a/test/int/process_execution_payload.zig b/test/int/process_execution_payload.zig
index 988a8052..2b7c11ee 100644
--- a/test/int/process_execution_payload.zig
+++ b/test/int/process_execution_payload.zig
@@ -12,11 +12,8 @@ test "process execution payload - sanity" {
     var message: ssz.electra.BeaconBlock.Type = ssz.electra.BeaconBlock.default_value;
     message.body = body;
 
-    var beacon_block: ssz.electra.SignedBeaconBlock.Type = ssz.electra.SignedBeaconBlock.default_value;
-    beacon_block.message = message;
-
-    const signed_beacon_block = SignedBeaconBlock{ .electra = &beacon_block };
-    const block = SignedBlock{ .regular = &signed_beacon_block };
+    const beacon_block = BeaconBlock{ .electra = &message };
+    const block = Block{ .regular = beacon_block };
 
     try processExecutionPayload(
         allocator,
@@ -34,4 +31,6 @@ const state_transition = @import("state_transition");
 const TestCachedBeaconStateAllForks = state_transition.test_utils.TestCachedBeaconStateAllForks;
 const processExecutionPayload = state_transition.processExecutionPayload;
 const SignedBlock = state_transition.SignedBlock;
+const Block = state_transition.Block;
 const SignedBeaconBlock = state_transition.SignedBeaconBlock;
+const BeaconBlock = state_transition.BeaconBlock;
diff --git a/test/int/process_operations.zig b/test/int/process_operations.zig
index bfb897b4..c0cf65b1 100644
--- a/test/int/process_operations.zig
+++ b/test/int/process_operations.zig
@@ -4,10 +4,11 @@ test "process operations" {
     var test_state = try TestCachedBeaconStateAllForks.init(allocator, 256);
     defer test_state.deinit();
 
-    const beacon_block: ssz.electra.SignedBeaconBlock.Type = ssz.electra.SignedBeaconBlock.default_value;
-    const signed_beacon_block = SignedBeaconBlock{ .electra = &beacon_block };
-    const block = SignedBlock{ .regular = &signed_beacon_block };
-    try processOperations(allocator, test_state.cached_state, &block.beaconBlockBody(), .{});
+    const electra_block = ssz.electra.BeaconBlock.default_value;
+    const beacon_block = BeaconBlock{ .electra = &electra_block };
+
+    const block = Block{ .regular = beacon_block };
+    try processOperations(allocator, test_state.cached_state, block.beaconBlockBody(), .{});
 }
 
 const std = @import("std");
@@ -16,5 +17,5 @@ const ssz = @import("consensus_types");
 const state_transition = @import("state_transition");
 const TestCachedBeaconStateAllForks = state_transition.test_utils.TestCachedBeaconStateAllForks;
 const processOperations = state_transition.processOperations;
-const SignedBlock = state_transition.SignedBlock;
-const SignedBeaconBlock = state_transition.SignedBeaconBlock;
+const Block = state_transition.Block;
+const BeaconBlock = state_transition.BeaconBlock;
diff --git a/test/int/process_randao.zig b/test/int/process_randao.zig
index 96f0ba56..11e65921 100644
--- a/test/int/process_randao.zig
+++ b/test/int/process_randao.zig
@@ -17,11 +17,9 @@ test "process randao - sanity" {
     message.proposer_index = proposer_index;
     message.parent_root = header_parent_root;
 
-    var beacon_block: ssz.electra.SignedBeaconBlock.Type = ssz.electra.SignedBeaconBlock.default_value;
-    beacon_block.message = message;
-    const signed_beacon_block = SignedBeaconBlock{ .electra = &beacon_block };
-    const block = SignedBlock{ .regular = &signed_beacon_block };
-    try processRandao(test_state.cached_state, &block.beaconBlockBody(), block.proposerIndex(), false);
+    const beacon_block = BeaconBlock{ .electra = &message };
+    const block = Block{ .regular = beacon_block };
+    try processRandao(test_state.cached_state, block.beaconBlockBody(), block.proposerIndex(), false);
 }
 
 const std = @import("std");
@@ -35,5 +33,5 @@ const TestCachedBeaconStateAllForks = state_transition.test_utils.TestCachedBeac
 const preset = @import("preset").preset;
 
 const processRandao = state_transition.processRandao;
-const SignedBlock = state_transition.SignedBlock;
-const SignedBeaconBlock = state_transition.SignedBeaconBlock;
+const Block = state_transition.Block;
+const BeaconBlock = state_transition.BeaconBlock;
diff --git a/test/int/process_sync_aggregate.zig b/test/int/process_sync_aggregate.zig
index 205765c1..a0583dec 100644
--- a/test/int/process_sync_aggregate.zig
+++ b/test/int/process_sync_aggregate.zig
@@ -12,12 +12,9 @@ test "process sync aggregate - sanity" {
     var message: ssz.electra.BeaconBlock.Type = ssz.electra.BeaconBlock.default_value;
     message.body = body;
 
-    var beacon_block: ssz.electra.SignedBeaconBlock.Type = ssz.electra.SignedBeaconBlock.default_value;
-    beacon_block.message = message;
-    const signed_beacon_block = SignedBeaconBlock{ .electra = &beacon_block };
-    const block = SignedBlock{ .regular = &signed_beacon_block };
-
-    try processSyncAggregate(allocator, test_state.cached_state, &block, true);
+    const beacon_block = BeaconBlock{ .electra = &message };
+    const block = Block{ .regular = beacon_block };
+    try processSyncAggregate(allocator, test_state.cached_state, block, true);
 }
 
 const std = @import("std");
@@ -29,6 +26,8 @@ const TestCachedBeaconStateAllForks = @import("state_transition").test_utils.Tes
 
 const state_transition = @import("state_transition");
 const processSyncAggregate = state_transition.processSyncAggregate;
+const Block = state_transition.Block;
 const SignedBlock = state_transition.SignedBlock;
+const BeaconBlock = state_transition.BeaconBlock;
 const SignedBeaconBlock = state_transition.SignedBeaconBlock;
 const G2_POINT_AT_INFINITY = @import("constants").G2_POINT_AT_INFINITY;
diff --git a/test/int/state_transition.zig b/test/int/state_transition.zig
index 9484ef2a..03c55744 100644
--- a/test/int/state_transition.zig
+++ b/test/int/state_transition.zig
@@ -40,7 +40,7 @@ test "state transition - electra block" {
         }
 
         const signed_beacon_block = SignedBeaconBlock{ .electra = electra_block_ptr };
-        const signed_block = SignedBlock{ .regular = &signed_beacon_block };
+        const signed_block = SignedBlock{ .regular = signed_beacon_block };
 
         // this returns the error so no need to handle returned post_state
         // TODO: if blst can publish BlstError.BadEncoding, can just use testing.expectError
diff --git a/test/spec/runner/Sanity.zig b/test/spec/runner/Sanity.zig
index 4852f0c9..0acfab38 100644
--- a/test/spec/runner/Sanity.zig
+++ b/test/spec/runner/Sanity.zig
@@ -199,7 +199,7 @@ pub fn BlocksTestCase(comptime fork: ForkSeq, comptime valid: bool) type {
                     self.pre.allocator,
                     state,
                     .{
-                        .regular = &signed_block,
+                        .regular = signed_block,
                     },
                     .{},
                 );