diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml
new file mode 100644
index 0000000..f45e715
--- /dev/null
+++ b/.github/workflows/check.yml
@@ -0,0 +1,51 @@
+name: Zig Test and Benchmark
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  ZIG_VERSION: 0.13.0
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Cache Zig
+        uses: actions/cache@v3
+        with:
+          path: ~/zig
+          key: ${{ runner.os }}-zig-${{ env.ZIG_VERSION }}
+
+      - name: Install Zig
+        if: steps.cache.outputs.cache-hit != 'true'
+        run: |
+          wget https://ziglang.org/builds/zig-linux-x86_64-${{ env.ZIG_VERSION }}.tar.xz
+          tar -xf zig-linux-x86_64-${{ env.ZIG_VERSION }}.tar.xz
+          mv zig-linux-x86_64-${{ env.ZIG_VERSION }} ~/zig
+
+      - name: Add Zig to PATH
+        run: echo "${HOME}/zig" >> $GITHUB_PATH
+
+      - name: Cache Zig build artifacts
+        uses: actions/cache@v3
+        with:
+          path: |
+            zig-cache
+            ~/.cache/zig
+          key: ${{ runner.os }}-zig-build-${{ hashFiles('**/*.zig') }}
+          restore-keys: |
+            ${{ runner.os }}-zig-build-
+      - name: Formatting
+        run: zig fmt --check --color on .
+
+      - name: Unit testing
+        run: zig build test --summary all
+
+      - name: Building
+        run: zig build -Doptimize=ReleaseFast
diff --git a/src/consensus/bellatrix/types.zig b/src/consensus/bellatrix/types.zig
index dc4f222..17591c1 100644
--- a/src/consensus/bellatrix/types.zig
+++ b/src/consensus/bellatrix/types.zig
@@ -2,9 +2,8 @@ const std = @import("std");
 pub const primitives = @import("../../primitives/types.zig");
 const preset = @import("../../presets/preset.zig");
 
-pub fn ExecutionPayloadHeader(comptime T: preset.BeaconPreset) type {
+pub fn ExecutionPayloadHeaderType(comptime T: preset.BeaconPreset) type {
     return struct {
-        // Execution block header fields
         parent_hash: primitives.Hash32,
         fee_recipient: primitives.ExecutionAddress,
         state_root: primitives.Root,
@@ -19,15 +18,20 @@ pub fn ExecutionPayloadHeader(comptime T: preset.BeaconPreset) type {
         base_fee_per_gas: u256,
         // Extra payload fields
         block_hash: primitives.Hash32,
-        // transactions: [T.MAX_TRANSACTIONS_PER_PAYLOAD]primitives.Transaction(T),
+        transactions_root: primitives.Root,
     };
 }
 
-pub const ExecutionPayloadHeaderMainnet = ExecutionPayloadHeader(preset.mainnet_preset);
+pub const ExecutionPayloadHeaderMainnet = ExecutionPayloadHeaderType(preset.mainnet_preset);
 
-pub const ExecutionPayloadHeaderMinimal = ExecutionPayloadHeader(preset.mininal_preset);
+pub const ExecutionPayloadHeaderMinimal = ExecutionPayloadHeaderType(preset.minimal_preset);
 
-test "ExecutionPayloadHeader" {
+pub const ExecutionPayloadHeader = union(preset.Presets) {
+    mainnet: ExecutionPayloadHeaderMainnet,
+    minimal: ExecutionPayloadHeaderMinimal,
+};
+
+test "test ExecutionPayloadHeaderMainnet" {
     const header = ExecutionPayloadHeaderMainnet{
         .parent_hash = undefined,
         .fee_recipient = undefined,
@@ -42,8 +46,9 @@ test "ExecutionPayloadHeader" {
         .extra_data = undefined,
         .base_fee_per_gas = 0,
         .block_hash = undefined,
-        // .transactions = undefined,
+        .transactions_root = undefined,
     };
+
     try std.testing.expectEqual(header.parent_hash.len, 32);
     try std.testing.expectEqual(header.block_number, 21);
 }
diff --git a/src/consensus/capella/types.zig b/src/consensus/capella/types.zig
index e69de29..c23e789 100644
--- a/src/consensus/capella/types.zig
+++ b/src/consensus/capella/types.zig
@@ -0,0 +1,56 @@
+const std = @import("std");
+pub const primitives = @import("../../primitives/types.zig");
+const preset = @import("../../presets/preset.zig");
+
+pub fn ExecutionPayloadHeaderType(comptime T: preset.BeaconPreset) type {
+    return struct {
+        parent_hash: primitives.Hash32,
+        fee_recipient: primitives.ExecutionAddress,
+        state_root: primitives.Root,
+        receipts_root: primitives.Root,
+        logs_bloom: [T.BYTES_PER_LOGS_BLOOM]u8,
+        prev_randao: primitives.Bytes32,
+        block_number: u64,
+        gas_used: u64,
+        gas_limit: u64,
+        timestamp: u64,
+        extra_data: [T.MAX_EXTRA_DATA_BYTES]u8,
+        base_fee_per_gas: u256,
+        // Extra payload fields
+        block_hash: primitives.Hash32,
+        transactions_root: primitives.Root,
+        withdrawals_root: primitives.Root,
+    };
+}
+
+pub const ExecutionPayloadHeaderMainnet = ExecutionPayloadHeaderType(preset.mainnet_preset);
+
+pub const ExecutionPayloadHeaderMinimal = ExecutionPayloadHeaderType(preset.minimal_preset);
+
+pub const ExecutionPayloadHeader = union(preset.Presets) {
+    mainnet: ExecutionPayloadHeaderMainnet,
+    minimal: ExecutionPayloadHeaderMinimal,
+};
+
+test "test ExecutionPayloadHeaderMainnet" {
+    const header = ExecutionPayloadHeaderMainnet{
+        .parent_hash = undefined,
+        .fee_recipient = undefined,
+        .state_root = undefined,
+        .receipts_root = undefined,
+        .logs_bloom = undefined,
+        .prev_randao = undefined,
+        .block_number = 21,
+        .gas_used = 0,
+        .gas_limit = 0,
+        .timestamp = 0,
+        .extra_data = undefined,
+        .base_fee_per_gas = 0,
+        .block_hash = undefined,
+        .transactions_root = undefined,
+        .withdrawals_root = undefined,
+    };
+
+    try std.testing.expectEqual(header.parent_hash.len, 32);
+    try std.testing.expectEqual(header.block_number, 21);
+}
diff --git a/src/consensus/deneb/types.zig b/src/consensus/deneb/types.zig
index e69de29..3c5fd26 100644
--- a/src/consensus/deneb/types.zig
+++ b/src/consensus/deneb/types.zig
@@ -0,0 +1,60 @@
+const std = @import("std");
+pub const primitives = @import("../../primitives/types.zig");
+const preset = @import("../../presets/preset.zig");
+
+pub fn ExecutionPayloadHeaderType(comptime T: preset.BeaconPreset) type {
+    return struct {
+        parent_hash: primitives.Hash32,
+        fee_recipient: primitives.ExecutionAddress,
+        state_root: primitives.Root,
+        receipts_root: primitives.Root,
+        logs_bloom: [T.BYTES_PER_LOGS_BLOOM]u8,
+        prev_randao: primitives.Bytes32,
+        block_number: u64,
+        gas_used: u64,
+        gas_limit: u64,
+        timestamp: u64,
+        extra_data: [T.MAX_EXTRA_DATA_BYTES]u8,
+        base_fee_per_gas: u256,
+        // Extra payload fields
+        block_hash: primitives.Hash32,
+        transactions_root: primitives.Root,
+        withdrawals_root: primitives.Root,
+        blob_gas_used: u64,
+        excess_blob_gas: u64,
+    };
+}
+
+pub const ExecutionPayloadHeaderMainnet = ExecutionPayloadHeaderType(preset.mainnet_preset);
+
+pub const ExecutionPayloadHeaderMinimal = ExecutionPayloadHeaderType(preset.minimal_preset);
+
+pub const ExecutionPayloadHeader = union(preset.Presets) {
+    mainnet: ExecutionPayloadHeaderMainnet,
+    minimal: ExecutionPayloadHeaderMinimal,
+};
+
+test "test ExecutionPayloadHeaderMainnet" {
+    const header = ExecutionPayloadHeaderMainnet{
+        .parent_hash = undefined,
+        .fee_recipient = undefined,
+        .state_root = undefined,
+        .receipts_root = undefined,
+        .logs_bloom = undefined,
+        .prev_randao = undefined,
+        .block_number = 21,
+        .gas_used = 0,
+        .gas_limit = 0,
+        .timestamp = 0,
+        .extra_data = undefined,
+        .base_fee_per_gas = 0,
+        .block_hash = undefined,
+        .transactions_root = undefined,
+        .withdrawals_root = undefined,
+        .blob_gas_used = 0,
+        .excess_blob_gas = 0,
+    };
+
+    try std.testing.expectEqual(header.parent_hash.len, 32);
+    try std.testing.expectEqual(header.block_number, 21);
+}
diff --git a/src/consensus/electra/types.zig b/src/consensus/electra/types.zig
index e69de29..c0001f0 100644
--- a/src/consensus/electra/types.zig
+++ b/src/consensus/electra/types.zig
@@ -0,0 +1,66 @@
+const std = @import("std");
+pub const primitives = @import("../../primitives/types.zig");
+const preset = @import("../../presets/preset.zig");
+
+pub fn ExecutionPayloadHeaderType(comptime T: preset.BeaconPreset) type {
+    return struct {
+        parent_hash: primitives.Hash32,
+        fee_recipient: primitives.ExecutionAddress,
+        state_root: primitives.Root,
+        receipts_root: primitives.Root,
+        logs_bloom: [T.BYTES_PER_LOGS_BLOOM]u8,
+        prev_randao: primitives.Bytes32,
+        block_number: u64,
+        gas_used: u64,
+        gas_limit: u64,
+        timestamp: u64,
+        extra_data: [T.MAX_EXTRA_DATA_BYTES]u8,
+        base_fee_per_gas: u256,
+        // Extra payload fields
+        block_hash: primitives.Hash32,
+        transactions_root: primitives.Root,
+        withdrawals_root: primitives.Root,
+        blob_gas_used: u64,
+        excess_blob_gas: u64,
+        deposit_requests_root: primitives.Root,
+        withdrawal_requests_root: primitives.Root,
+        consolidation_requests_root: primitives.Root,
+    };
+}
+
+pub const ExecutionPayloadHeaderMainnet = ExecutionPayloadHeaderType(preset.mainnet_preset);
+
+pub const ExecutionPayloadHeaderMinimal = ExecutionPayloadHeaderType(preset.minimal_preset);
+
+pub const ExecutionPayloadHeader = union(preset.Presets) {
+    mainnet: ExecutionPayloadHeaderMainnet,
+    minimal: ExecutionPayloadHeaderMinimal,
+};
+
+test "test ExecutionPayloadHeaderMainnet" {
+    const header = ExecutionPayloadHeaderMainnet{
+        .parent_hash = undefined,
+        .fee_recipient = undefined,
+        .state_root = undefined,
+        .receipts_root = undefined,
+        .logs_bloom = undefined,
+        .prev_randao = undefined,
+        .block_number = 21,
+        .gas_used = 0,
+        .gas_limit = 0,
+        .timestamp = 0,
+        .extra_data = undefined,
+        .base_fee_per_gas = 0,
+        .block_hash = undefined,
+        .transactions_root = undefined,
+        .withdrawals_root = undefined,
+        .blob_gas_used = 0,
+        .excess_blob_gas = 0,
+        .deposit_requests_root = undefined,
+        .withdrawal_requests_root = undefined,
+        .consolidation_requests_root = undefined,
+    };
+
+    try std.testing.expectEqual(header.parent_hash.len, 32);
+    try std.testing.expectEqual(header.block_number, 21);
+}
diff --git a/src/consensus/types.zig b/src/consensus/types.zig
index 6982fa7..af19b0e 100644
--- a/src/consensus/types.zig
+++ b/src/consensus/types.zig
@@ -1,6 +1,11 @@
 const std = @import("std");
 const primitives = @import("../primitives/types.zig");
 const preset = @import("../presets/preset.zig");
+const constants = @import("../primitives/constants.zig");
+const bellatrix = @import("../consensus/bellatrix/types.zig");
+const capella = @import("../consensus/capella/types.zig");
+const deneb = @import("../consensus/deneb/types.zig");
+const electra = @import("../consensus/electra/types.zig");
 
 pub const Fork = struct {
     previous_version: primitives.Version,
@@ -39,7 +44,7 @@ pub const AttestationData = struct {
     target: ?*Checkpoint,
 };
 
-pub fn IndexedAttestation(comptime T: preset.BeaconPreset) type {
+pub fn IndexedAttestationType(comptime T: preset.BeaconPreset) type {
     return struct {
         attesting_indices: [T.MAX_VALIDATORS_PER_COMMITTEE * T.MAX_COMMITTEES_PER_SLOT]primitives.ValidatorIndex,
         data: ?*AttestationData,
@@ -47,7 +52,14 @@ pub fn IndexedAttestation(comptime T: preset.BeaconPreset) type {
     };
 }
 
-pub fn PendingAttestation(comptime T: preset.BeaconPreset) type {
+pub const IndexedAttestationMainnet = IndexedAttestationType(preset.mainnet_preset);
+pub const IndexedAttestationMininal = IndexedAttestationType(preset.minimal_preset);
+pub const IndexedAttestation = union(preset.Presets) {
+    mainnet: IndexedAttestationMainnet,
+    minimal: IndexedAttestationMininal,
+};
+
+pub fn PendingAttestationType(comptime T: preset.BeaconPreset) type {
     return struct {
         aggregation_bits: std.StaticBitSet(T.MAX_VALIDATORS_PER_COMMITTEE),
         data: AttestationData,
@@ -56,21 +68,34 @@ pub fn PendingAttestation(comptime T: preset.BeaconPreset) type {
     };
 }
 
+pub const PendingAttestationMainnet = PendingAttestationType(preset.mainnet_preset);
+pub const PendingAttestationMinimal = PendingAttestationType(preset.minimal_preset);
+
+pub const PendingAttestation = union(preset.Presets) {
+    mainnet: PendingAttestationMainnet,
+    minimal: PendingAttestationMinimal,
+};
+
 pub const Eth1Data = struct {
     deposit_root: primitives.Root,
     deposit_count: u64,
     block_hash: primitives.Hash32,
 };
 
-pub fn HistoricalBatch(comptime T: preset.BeaconPreset) type {
+pub fn HistoricalBatchType(comptime T: preset.BeaconPreset) type {
     return struct {
         block_roots: [T.SLOTS_PER_HISTORICAL_ROOT]primitives.Root,
         state_roots: [T.SLOTS_PER_HISTORICAL_ROOT]primitives.Root,
     };
 }
 
-pub const HistoricalBatchMainnet = HistoricalBatch(preset.mainnet_preset);
-pub const HistoricalBatchMininal = HistoricalBatch(preset.mininal_preset);
+pub const HistoricalBatchMainnet = HistoricalBatchType(preset.mainnet_preset);
+pub const HistoricalBatchMininal = HistoricalBatchType(preset.minimal_preset);
+
+pub const HistoricalBatch = union(preset.Presets) {
+    mainnet: HistoricalBatchMainnet,
+    minimal: HistoricalBatchMininal,
+};
 
 pub const DepositMessage = struct {
     pubkey: primitives.BLSPubkey,
@@ -98,14 +123,12 @@ pub const SigningData = struct {
     domain: primitives.Domain,
 };
 
-pub fn AttesterSlashing(comptime T: preset.BeaconPreset) type {
-    return struct {
-        attestation_1: ?*IndexedAttestation(T),
-        attestation_2: ?*IndexedAttestation(T),
-    };
-}
+pub const AttesterSlashing = struct {
+    attestation_1: ?*IndexedAttestation,
+    attestation_2: ?*IndexedAttestation,
+};
 
-pub fn Attestation(comptime T: preset.BeaconPreset) type {
+pub fn AttestationType(comptime T: preset.BeaconPreset) type {
     return struct {
         aggregation_bits: std.StaticBitSet(T.MAX_VALIDATORS_PER_COMMITTEE),
         data: ?*AttestationData,
@@ -114,12 +137,18 @@ pub fn Attestation(comptime T: preset.BeaconPreset) type {
     };
 }
 
-pub fn Deposit(comptime T: preset.BeaconPreset) type {
-    return struct {
-        proof: [T.DEPOSIT_CONTRACT_TREE_DEPTH + 1]primitives.Bytes32,
-        data: ?*DepositData,
-    };
-}
+pub const AttestationMainnet = AttestationType(preset.mainnet_preset);
+pub const AttestationMinimal = AttestationType(preset.minimal_preset);
+
+pub const Attestation = union(preset.Presets) {
+    mainnet: AttestationMainnet,
+    minimal: AttestationMinimal,
+};
+
+pub const Deposit = struct {
+    proof: [constants.DEPOSIT_CONTRACT_TREE_DEPTH + 1]primitives.Bytes32,
+    data: ?*DepositData,
+};
 
 pub const VoluntaryExit = struct {
     epoch: primitives.Epoch,
@@ -147,28 +176,42 @@ pub const Eth1Block = struct {
     deposit_count: u64,
 };
 
-pub fn AggregateAndProof(comptime T: preset.BeaconPreset) type {
-    return struct {
-        aggregator_index: primitives.ValidatorIndex,
-        aggregate: ?*Attestation(T),
-        selection_proof: primitives.BLSSignature,
-    };
-}
+pub const AggregateAndProof = struct {
+    aggregator_index: primitives.ValidatorIndex,
+    aggregate: ?*Attestation,
+    selection_proof: primitives.BLSSignature,
+};
 
-pub fn SyncAggregate(comptime T: preset.BeaconPreset) type {
+pub fn SyncAggregateType(comptime T: preset.BeaconPreset) type {
     return struct {
         sync_committee_bits: std.StaticBitSet(T.SYNC_COMMITTEE_SIZE),
         sync_committee_signature: primitives.BLSSignature,
     };
 }
 
-pub fn SyncCommittee(comptime T: preset.BeaconPreset) type {
+pub const SyncAggregateMainnet = SyncAggregateType(preset.mainnet_preset);
+pub const SyncAggregateMinimal = SyncAggregateType(preset.minimal_preset);
+
+pub const SyncAggregate = union(preset.Presets) {
+    mainnet: SyncAggregateMainnet,
+    minimal: SyncAggregateMinimal,
+};
+
+pub fn SyncCommitteeType(comptime T: preset.BeaconPreset) type {
     return struct {
         pubkeys: [T.SYNC_COMMITTEE_SIZE]primitives.BLSPubkey,
         aggregate_pubkey: primitives.BLSPubkey,
     };
 }
 
+pub const SyncCommitteeMainnet = SyncCommitteeType(preset.mainnet_preset);
+pub const SyncCommitteeMinimal = SyncCommitteeType(preset.minimal_preset);
+
+pub const SyncCommittee = union(preset.Presets) {
+    mainnet: SyncCommitteeMainnet,
+    minimal: SyncCommitteeMinimal,
+};
+
 pub const SyncCommitteeMessage = struct {
     slot: primitives.Slot,
     beacon_block_root: primitives.Root,
@@ -176,108 +219,84 @@ pub const SyncCommitteeMessage = struct {
     signature: primitives.BLSSignature,
 };
 
-pub fn SyncCommitteeContribution(comptime T: preset.BeaconPreset) type {
+pub fn SyncCommitteeContributionType(comptime T: preset.BeaconPreset) type {
     return struct {
         slot: primitives.Slot,
         beacon_block_root: primitives.Root,
         subcommittee_index: u64,
-        aggregation_bits: std.StaticBitSet(T.SYNC_COMMITTEE_SIZE / T.SYNC_COMMITTEE_SUBNET_COUNT),
+        aggregation_bits: std.StaticBitSet(T.SYNC_COMMITTEE_SIZE / constants.SYNC_COMMITTEE_SUBNET_COUNT),
         signature: primitives.BLSSignature,
     };
 }
 
-pub fn ContributionAndProof(comptime T: preset.BeaconPreset) type {
-    return struct {
-        aggregator_index: primitives.ValidatorIndex,
-        aggregate: ?*SyncCommitteeContribution(T),
-        selection_proof: primitives.BLSSignature,
-    };
-}
+pub const SyncCommitteeContributionMainnet = SyncCommitteeContributionType(preset.mainnet_preset);
+pub const SyncCommitteeContributionMinimal = SyncCommitteeContributionType(preset.minimal_preset);
 
-pub fn SignedBeaconBlock(comptime T: preset.BeaconPreset) type {
-    return struct {
-        message: ?*ContributionAndProof(T),
-        signature: primitives.BLSSignature,
-    };
-}
+pub const SyncCommitteeContribution = union(preset.Presets) {
+    mainnet: SyncCommitteeContributionMainnet,
+    minimal: SyncCommitteeContributionMinimal,
+};
+
+pub const ContributionAndProof = struct {
+    aggregator_index: primitives.ValidatorIndex,
+    aggregate: ?*SyncCommitteeContribution,
+    selection_proof: primitives.BLSSignature,
+};
+
+pub const SignedBeaconBlock = struct {
+    message: ?*ContributionAndProof,
+    signature: primitives.BLSSignature,
+};
 
 pub const SyncAggregatorSelectionData = struct {
     slot: primitives.Slot,
     subcommittee_index: u64,
 };
 
-pub fn ExecutionPayloadHeader(comptime T: preset.BeaconPreset) type {
-    return struct {
-        // Execution block header fields
-        parent_hash: primitives.Hash32,
-        fee_recipient: primitives.ExecutionAddress,
-        state_root: primitives.Root,
-        receipts_root: primitives.Root,
-        logs_bloom: [T.BYTES_PER_LOGS_BLOOM]u8,
-        prev_randao: primitives.Bytes32,
-        block_number: u64,
-        gas_used: u64,
-        gas_limit: u64,
-        timestamp: u64,
-        extra_data: [T.MAX_EXTRA_DATA_BYTES]u8,
-        base_fee_per_gas: u256,
-        // Extra payload fields
-        block_hash: primitives.Hash32,
-        transactions_root: primitives.Root,
-        withdrawals_root: primitives.Root,
-        blob_gas_used: u64,
-        excess_blob_gas: u64,
-        deposit_requests_root: primitives.Root,
-        withdrawal_requests_root: primitives.Root,
-        consolidation_requests_root: primitives.Root,
-    };
-}
+pub const ExecutionPayloadHeader = union(primitives.ForkType) {
+    phase0: type,
+    altair: type,
+    bellatrix: bellatrix.ExecutionPayloadHeader,
+    capella: capella.ExecutionPayloadHeader,
+    deneb: deneb.ExecutionPayloadHeader,
+    electra: electra.ExecutionPayloadHeader,
+};
 
-pub fn LightClientHeader(comptime T: preset.BeaconPreset) type {
-    return struct {
-        beacon: ?*BeaconBlockHeader,
-        execution: ?*ExecutionPayloadHeader(T),
-        execution_branch: primitives.ExecutionBranch,
-    };
-}
+pub const LightClientHeader = struct {
+    beacon: ?*BeaconBlockHeader,
+    execution: ?*ExecutionPayloadHeader,
+    execution_branch: primitives.ExecutionBranch,
+};
 
-pub fn LightClientOptimisticUpdate(comptime T: preset.BeaconPreset) type {
-    return struct {
-        attested_header: ?*LightClientHeader(T),
-        sync_aggregate: ?*SyncAggregate(T),
-        signature_slot: primitives.Slot,
-    };
-}
+pub const LightClientOptimisticUpdate = struct {
+    attested_header: ?*LightClientHeader,
+    sync_aggregate: ?*SyncAggregate,
+    signature_slot: primitives.Slot,
+};
 
-pub fn LightClientFinalityUpdate(comptime T: preset.BeaconPreset) type {
-    return struct {
-        attested_header: ?*LightClientHeader(T),
-        finalized_header: ?*LightClientHeader(T),
-        finality_branch: primitives.FinalityBranch,
-        sync_aggregate: ?*SyncAggregate(T),
-        signature_slot: primitives.Slot,
-    };
-}
+pub const LightClientFinalityUpdate = struct {
+    attested_header: ?*LightClientHeader,
+    finalized_header: ?*LightClientHeader,
+    finality_branch: primitives.FinalityBranch,
+    sync_aggregate: ?*SyncAggregate,
+    signature_slot: primitives.Slot,
+};
 
-pub fn LightClientUpdate(comptime T: preset.BeaconPreset) type {
-    return struct {
-        attested_header: ?*LightClientHeader(T),
-        next_sync_committee: ?*SyncCommittee(T),
-        next_sync_committee_branch: primitives.NextSyncCommitteeBranch,
-        finalized_header: ?*LightClientHeader(T),
-        finality_branch: primitives.FinalityBranch,
-        sync_aggregate: ?*SyncAggregate(T),
-        signature_slot: primitives.Slot,
-    };
-}
+pub const LightClientUpdate = struct {
+    attested_header: ?*LightClientHeader,
+    next_sync_committee: ?*SyncCommittee,
+    next_sync_committee_branch: primitives.NextSyncCommitteeBranch,
+    finalized_header: ?*LightClientHeader,
+    finality_branch: primitives.FinalityBranch,
+    sync_aggregate: ?*SyncAggregate,
+    signature_slot: primitives.Slot,
+};
 
-pub fn LightClientBootstrap(comptime T: preset.BeaconPreset) type {
-    return struct {
-        header: ?*LightClientHeader(T),
-        current_sync_committee: ?*SyncCommittee(T),
-        current_sync_committee_branch: primitives.CurrentSyncCommitteeBranch,
-    };
-}
+pub const LightClientBootstrap = struct {
+    header: ?*LightClientHeader,
+    current_sync_committee: ?*SyncCommittee,
+    current_sync_committee_branch: primitives.CurrentSyncCommitteeBranch,
+};
 
 pub const PowBlock = struct {
     block_hash: primitives.Hash32,
diff --git a/src/main.zig b/src/main.zig
index eb0626a..c3a44e3 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -39,6 +39,7 @@ pub fn main() !void {
         .extra_data = undefined,
         .base_fee_per_gas = 0,
         .block_hash = undefined,
+        .transactions_root = undefined,
     };
     try stdout.print("{}\n", .{a});
     try stdout.print("{}\n", .{b});
diff --git a/src/presets/preset.zig b/src/presets/preset.zig
index b2add1c..cd00249 100644
--- a/src/presets/preset.zig
+++ b/src/presets/preset.zig
@@ -1,6 +1,11 @@
 const std = @import("std");
 const primitives = @import("../primitives/types.zig");
 
+pub const Presets = enum {
+    mainnet,
+    minimal,
+};
+
 /// Compile-time chain configuration
 pub const BeaconPreset = struct {
     // Misc
@@ -190,7 +195,7 @@ pub const mainnet_preset = BeaconPreset{
 
 /// Minimal preset for testing
 /// https://github.com/ethereum/consensus-specs/tree/dev/presets/minimal
-pub const mininal_preset = BeaconPreset{
+pub const minimal_preset = BeaconPreset{
     // Misc
     .MAX_COMMITTEES_PER_SLOT = 4,
     .TARGET_COMMITTEE_SIZE = 4,
@@ -303,23 +308,23 @@ test "mainnet preset" {
 }
 
 test "minimal preset" {
-    try std.testing.expectEqual(mininal_preset.MAX_BYTES_PER_TRANSACTION, 1073741824);
-    try std.testing.expectEqual(mininal_preset.MAX_TRANSACTIONS_PER_PAYLOAD, 1048576);
-    try std.testing.expectEqual(mininal_preset.BYTES_PER_LOGS_BLOOM, 256);
-    try std.testing.expectEqual(mininal_preset.MAX_EXTRA_DATA_BYTES, 32);
-    try std.testing.expectEqual(mininal_preset.MAX_BLS_TO_EXECUTION_CHANGES, 16);
-    try std.testing.expectEqual(mininal_preset.MAX_WITHDRAWALS_PER_PAYLOAD, 4);
-    try std.testing.expectEqual(mininal_preset.MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP, 16);
-    try std.testing.expectEqual(mininal_preset.FIELD_ELEMENTS_PER_BLOB, 4096);
-    try std.testing.expectEqual(mininal_preset.MAX_BLOB_COMMITMENTS_PER_BLOCK, 16);
-    try std.testing.expectEqual(mininal_preset.MAX_BLOBS_PER_BLOCK, 6);
-    try std.testing.expectEqual(mininal_preset.KZG_COMMITMENT_INCLUSION_PROOF_DEPTH, 9);
-    try std.testing.expectEqual(mininal_preset.MAX_DEPOSIT_REQUESTS_PER_PAYLOAD, 4);
-    try std.testing.expectEqual(mininal_preset.MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD, 2);
-    try std.testing.expectEqual(mininal_preset.MAX_ATTESTER_SLASHINGS_ELECTRA, 1);
-    try std.testing.expectEqual(mininal_preset.MAX_ATTESTATIONS_ELECTRA, 8);
-    try std.testing.expectEqual(mininal_preset.MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP, 1);
-    try std.testing.expectEqual(mininal_preset.MAX_EFFECTIVE_BALANCE_ELECTRA, 2048000000000);
-    try std.testing.expectEqual(mininal_preset.MIN_SLASHING_PENALTY_QUOTIENT_ELECTRA, 4096);
-    try std.testing.expectEqual(mininal_preset.MIN_ACTIVATION_BALANCE, 32000000000);
+    try std.testing.expectEqual(minimal_preset.MAX_BYTES_PER_TRANSACTION, 1073741824);
+    try std.testing.expectEqual(minimal_preset.MAX_TRANSACTIONS_PER_PAYLOAD, 1048576);
+    try std.testing.expectEqual(minimal_preset.BYTES_PER_LOGS_BLOOM, 256);
+    try std.testing.expectEqual(minimal_preset.MAX_EXTRA_DATA_BYTES, 32);
+    try std.testing.expectEqual(minimal_preset.MAX_BLS_TO_EXECUTION_CHANGES, 16);
+    try std.testing.expectEqual(minimal_preset.MAX_WITHDRAWALS_PER_PAYLOAD, 4);
+    try std.testing.expectEqual(minimal_preset.MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP, 16);
+    try std.testing.expectEqual(minimal_preset.FIELD_ELEMENTS_PER_BLOB, 4096);
+    try std.testing.expectEqual(minimal_preset.MAX_BLOB_COMMITMENTS_PER_BLOCK, 16);
+    try std.testing.expectEqual(minimal_preset.MAX_BLOBS_PER_BLOCK, 6);
+    try std.testing.expectEqual(minimal_preset.KZG_COMMITMENT_INCLUSION_PROOF_DEPTH, 9);
+    try std.testing.expectEqual(minimal_preset.MAX_DEPOSIT_REQUESTS_PER_PAYLOAD, 4);
+    try std.testing.expectEqual(minimal_preset.MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD, 2);
+    try std.testing.expectEqual(minimal_preset.MAX_ATTESTER_SLASHINGS_ELECTRA, 1);
+    try std.testing.expectEqual(minimal_preset.MAX_ATTESTATIONS_ELECTRA, 8);
+    try std.testing.expectEqual(minimal_preset.MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP, 1);
+    try std.testing.expectEqual(minimal_preset.MAX_EFFECTIVE_BALANCE_ELECTRA, 2048000000000);
+    try std.testing.expectEqual(minimal_preset.MIN_SLASHING_PENALTY_QUOTIENT_ELECTRA, 4096);
+    try std.testing.expectEqual(minimal_preset.MIN_ACTIVATION_BALANCE, 32000000000);
 }
diff --git a/src/primitives/constants.zig b/src/primitives/constants.zig
index 25c47e6..8a9871b 100644
--- a/src/primitives/constants.zig
+++ b/src/primitives/constants.zig
@@ -8,6 +8,7 @@ pub const GENESIS_EPOCH: types.Epoch = 0;
 pub const FAR_FUTURE_EPOCH: types.Epoch = std.math.maxInt(u64);
 pub const BASE_REWARDS_PER_EPOCH: u64 = 4;
 pub const DEPOSIT_CONTRACT_TREE_DEPTH: u64 = 32;
+pub const SYNC_COMMITTEE_SUBNET_COUNT: usize = 4;
 pub const JUSTIFICATION_BITS_LENGTH: u64 = 4;
 pub const ENDIANNESS = .little;
 pub const BLS_WITHDRAWAL_PREFIX: types.Bytes1 = .{0x00};
diff --git a/src/primitives/types.zig b/src/primitives/types.zig
index 37943cb..a84065e 100644
--- a/src/primitives/types.zig
+++ b/src/primitives/types.zig
@@ -49,28 +49,31 @@ pub const CurrentSyncCommitteeBranchAltair = [utils.floorLog2(constants.CURRENT_
 
 pub const CurrentSyncCommitteeBranchElectra = [utils.floorLog2(constants.CURRENT_SYNC_COMMITTEE_GINDEX_ELECTRA)]Bytes32;
 
-pub const FinalityBranch = union(enum) {
-    Altair: FinalityBranchAltair,
-    Bellatrix: FinalityBranchAltair,
-    Capella: FinalityBranchAltair,
-    Deneb: FinalityBranchAltair,
-    Electra: FinalityBranchElectra,
+pub const FinalityBranch = union(ForkType) {
+    phase0: type,
+    altair: FinalityBranchAltair,
+    bellatrix: FinalityBranchAltair,
+    capella: FinalityBranchAltair,
+    deneb: FinalityBranchAltair,
+    electra: FinalityBranchElectra,
 };
 
-pub const NextSyncCommitteeBranch = union(enum) {
-    Altair: NextSyncCommitteeBranchAltair,
-    Bellatrix: NextSyncCommitteeBranchAltair,
-    Capella: NextSyncCommitteeBranchAltair,
-    Deneb: NextSyncCommitteeBranchAltair,
-    Electra: NextSyncCommitteeBranchElectra,
+pub const NextSyncCommitteeBranch = union(ForkType) {
+    phase0: type,
+    altair: NextSyncCommitteeBranchAltair,
+    bellatrix: NextSyncCommitteeBranchAltair,
+    capella: NextSyncCommitteeBranchAltair,
+    deneb: NextSyncCommitteeBranchAltair,
+    electra: NextSyncCommitteeBranchElectra,
 };
 
-pub const CurrentSyncCommitteeBranch = union(enum) {
-    Altair: CurrentSyncCommitteeBranchAltair,
-    Bellatrix: CurrentSyncCommitteeBranchAltair,
-    Capella: CurrentSyncCommitteeBranchAltair,
-    Deneb: CurrentSyncCommitteeBranchAltair,
-    Electra: CurrentSyncCommitteeBranchElectra,
+pub const CurrentSyncCommitteeBranch = union(ForkType) {
+    phase0: type,
+    altair: CurrentSyncCommitteeBranchAltair,
+    bellatrix: CurrentSyncCommitteeBranchAltair,
+    capella: CurrentSyncCommitteeBranchAltair,
+    deneb: CurrentSyncCommitteeBranchAltair,
+    electra: CurrentSyncCommitteeBranchElectra,
 };
 
 pub fn Transaction(comptime T: preset.BeaconPreset) type {
@@ -78,12 +81,12 @@ pub fn Transaction(comptime T: preset.BeaconPreset) type {
 }
 
 pub const ForkType = enum {
-    Phase0,
-    Altair,
-    Bellatrix,
-    Capella,
-    Deneb,
-    Electra,
+    phase0,
+    altair,
+    bellatrix,
+    capella,
+    deneb,
+    electra,
 };
 
 test "test ExecutionBranch length" {
@@ -102,15 +105,15 @@ test "test FinalityBranch length" {
 }
 
 test "test FinalityBranch Union length" {
-    const FinalityBranchLength = @typeInfo(@typeInfo(FinalityBranch).Union.fields[0].type).Array.len;
+    const FinalityBranchLength = @typeInfo(@typeInfo(FinalityBranch).Union.fields[1].type).Array.len;
     try std.testing.expectEqual(6, FinalityBranchLength);
-    const FinalityBranchLength2 = @typeInfo(@typeInfo(FinalityBranch).Union.fields[1].type).Array.len;
+    const FinalityBranchLength2 = @typeInfo(@typeInfo(FinalityBranch).Union.fields[2].type).Array.len;
     try std.testing.expectEqual(6, FinalityBranchLength2);
-    const FinalityBranchLength3 = @typeInfo(@typeInfo(FinalityBranch).Union.fields[2].type).Array.len;
+    const FinalityBranchLength3 = @typeInfo(@typeInfo(FinalityBranch).Union.fields[3].type).Array.len;
     try std.testing.expectEqual(6, FinalityBranchLength3);
-    const FinalityBranchLength4 = @typeInfo(@typeInfo(FinalityBranch).Union.fields[3].type).Array.len;
+    const FinalityBranchLength4 = @typeInfo(@typeInfo(FinalityBranch).Union.fields[4].type).Array.len;
     try std.testing.expectEqual(6, FinalityBranchLength4);
-    const FinalityBranchLength5 = @typeInfo(@typeInfo(FinalityBranch).Union.fields[4].type).Array.len;
+    const FinalityBranchLength5 = @typeInfo(@typeInfo(FinalityBranch).Union.fields[5].type).Array.len;
     try std.testing.expectEqual(7, FinalityBranchLength5);
 }