diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml
index 54b355e631d..d1a8c9f6144 100644
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@@ -15,8 +15,6 @@ concurrency:
 env:
     DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
     DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
-    IMAGE_NAME: ${{ github.repository_owner}}/lighthouse
-    LCLI_IMAGE_NAME: ${{ github.repository_owner }}/lcli
     # Enable self-hosted runners for the sigp repo only.
     SELF_HOSTED_RUNNERS: ${{ github.repository == 'sigp/lighthouse' }}
 
@@ -49,19 +47,15 @@ jobs:
             VERSION: ${{ env.VERSION }}
             VERSION_SUFFIX: ${{ env.VERSION_SUFFIX }}
     build-docker-single-arch:
-        name: build-docker-${{ matrix.binary }}${{ matrix.features.version_suffix }}
+        name: build-docker-${{ matrix.binary }}-${{ matrix.cpu_arch }}${{ matrix.features.version_suffix }}
         # Use self-hosted runners only on the sigp repo.
         runs-on: ${{ github.repository == 'sigp/lighthouse' && fromJson('["self-hosted", "linux", "release"]') || 'ubuntu-22.04'  }}
         strategy:
             matrix:
-                binary: [aarch64,
-                         aarch64-portable,
-                         x86_64,
-                         x86_64-portable]
-                features: [
-                    {version_suffix: "", env: "gnosis,slasher-lmdb,slasher-mdbx,jemalloc"},
-                    {version_suffix: "-dev", env: "jemalloc,spec-minimal"}
-                ]
+                binary:   [lighthouse,
+                           lcli]
+                cpu_arch: [aarch64,
+                           x86_64]
                 include:
                     - profile: maxperf
 
@@ -69,7 +63,6 @@ jobs:
         env:
             VERSION: ${{ needs.extract-version.outputs.VERSION }}
             VERSION_SUFFIX: ${{ needs.extract-version.outputs.VERSION_SUFFIX }}
-            FEATURE_SUFFIX: ${{ matrix.features.version_suffix }}
         steps:
             - uses: actions/checkout@v4
             - name: Update Rust
@@ -78,27 +71,40 @@ jobs:
             - name: Dockerhub login
               run: |
                   echo "${DOCKER_PASSWORD}" | docker login --username ${DOCKER_USERNAME} --password-stdin
-            - name: Cross build Lighthouse binary
+
+            - name: Sets env vars for Lighthouse
+              if: startsWith(matrix.binary, 'lighthouse')
+              run: |
+                echo "CROSS_FEATURES=gnosis,spec-minimal,slasher-lmdb,jemalloc" >> $GITHUB_ENV
+
+            - name: Set `make` command for lighthouse
+              if: startsWith(matrix.binary, 'lighthouse')
+              run: |
+                echo "MAKE_CMD=build-${{ matrix.cpu_arch }}-portable" >> $GITHUB_ENV
+
+            - name: Set `make` command for lcli
+              if: startsWith(matrix.binary, 'lcli')
+              run: |
+                echo "MAKE_CMD=build-lcli-${{ matrix.cpu_arch }}" >> $GITHUB_ENV
+
+            - name: Cross build binaries
               run: |
                   cargo install cross
-                  env CROSS_PROFILE=${{ matrix.profile }} CROSS_FEATURES=${{ matrix.features.env }} make build-${{ matrix.binary }}
+                  env CROSS_PROFILE=${{ matrix.profile }} CROSS_FEATURES=${{ env.CROSS_FEATURES }} make ${{ env.MAKE_CMD }}
+
             - name: Make bin dir
               run: mkdir ./bin
-            - name: Move cross-built binary into Docker scope (if ARM)
-              if: startsWith(matrix.binary, 'aarch64')
-              run: mv ./target/aarch64-unknown-linux-gnu/${{ matrix.profile }}/lighthouse ./bin
-            - name: Move cross-built binary into Docker scope (if x86_64)
-              if: startsWith(matrix.binary, 'x86_64')
-              run: mv ./target/x86_64-unknown-linux-gnu/${{ matrix.profile }}/lighthouse ./bin
+
+            - name: Move cross-built binary into Docker scope
+              run: mv ./target/${{ matrix.cpu_arch }}-unknown-linux-gnu/${{ matrix.profile }}/${{ matrix.binary }} ./bin
+
             - name: Map aarch64 to arm64 short arch
-              if: startsWith(matrix.binary, 'aarch64')
+              if: startsWith(matrix.cpu_arch, 'aarch64')
               run: echo "SHORT_ARCH=arm64" >> $GITHUB_ENV
+
             - name: Map x86_64 to amd64 short arch
-              if: startsWith(matrix.binary, 'x86_64')
+              if: startsWith(matrix.cpu_arch, 'x86_64')
               run: echo "SHORT_ARCH=amd64" >> $GITHUB_ENV;
-            - name: Set modernity suffix
-              if: endsWith(matrix.binary, '-portable') != true
-              run: echo "MODERNITY_SUFFIX=-modern" >> $GITHUB_ENV;
 
             - name: Install QEMU
               if: env.SELF_HOSTED_RUNNERS == 'false'
@@ -108,22 +114,41 @@ jobs:
               if: env.SELF_HOSTED_RUNNERS == 'false'
               uses: docker/setup-buildx-action@v3
 
-            - name: Build and push
+            - name: Build and push (Lighthouse)
+              if: startsWith(matrix.binary, 'lighthouse')
               uses: docker/build-push-action@v5
               with:
                 file: ./Dockerfile.cross
                 context: .
                 platforms: linux/${{ env.SHORT_ARCH }}
                 push: true
-                tags: ${{ env.IMAGE_NAME }}:${{ env.VERSION }}-${{ env.SHORT_ARCH }}${{ env.VERSION_SUFFIX }}${{ env.MODERNITY_SUFFIX }}${{ env.FEATURE_SUFFIX }}
+                tags: |
+                  ${{ github.repository_owner}}/${{ matrix.binary }}:${{ env.VERSION }}-${{ env.SHORT_ARCH }}${{ env.VERSION_SUFFIX }}
+                  ${{ github.repository_owner}}/${{ matrix.binary }}:${{ env.VERSION }}-${{ env.SHORT_ARCH }}${{ env.VERSION_SUFFIX }}-dev
+                  ${{ github.repository_owner}}/${{ matrix.binary }}:${{ env.VERSION }}-${{ env.SHORT_ARCH }}${{ env.VERSION_SUFFIX }}-modern
+                  ${{ github.repository_owner}}/${{ matrix.binary }}:${{ env.VERSION }}-${{ env.SHORT_ARCH }}${{ env.VERSION_SUFFIX }}-modern-dev
+
+            - name: Build and push (lcli)
+              if: startsWith(matrix.binary, 'lcli')
+              uses: docker/build-push-action@v5
+              with:
+                file: ./lcli/Dockerfile.cross
+                context: .
+                platforms: linux/${{ env.SHORT_ARCH }}
+                push: true
+
+                tags: |
+                  ${{ github.repository_owner}}/${{ matrix.binary }}:${{ env.VERSION }}-${{ env.SHORT_ARCH }}${{ env.VERSION_SUFFIX }}
+
 
     build-docker-multiarch:
-        name: build-docker-multiarch${{ matrix.modernity }}
+        name: build-docker-${{ matrix.binary }}-multiarch
         runs-on: ubuntu-22.04
-        needs: [build-docker-single-arch, extract-version]
         strategy:
             matrix:
-                modernity: ["", "-modern"]
+                binary: [lighthouse,
+                         lcli]
+        needs: [build-docker-single-arch, extract-version]
         env:
             VERSION: ${{ needs.extract-version.outputs.VERSION }}
             VERSION_SUFFIX: ${{ needs.extract-version.outputs.VERSION_SUFFIX }}
@@ -135,29 +160,9 @@ jobs:
               run: |
                   echo "${DOCKER_PASSWORD}" | docker login --username ${DOCKER_USERNAME} --password-stdin
 
-            - name: Create and push multiarch manifest
+            - name: Create and push multiarch manifests
               run: |
-                  docker buildx imagetools create -t ${IMAGE_NAME}:${VERSION}${VERSION_SUFFIX}${{ matrix.modernity }} \
-                      ${IMAGE_NAME}:${VERSION}-arm64${VERSION_SUFFIX}${{ matrix.modernity }} \
-                      ${IMAGE_NAME}:${VERSION}-amd64${VERSION_SUFFIX}${{ matrix.modernity }};
+                  docker buildx imagetools create -t ${{ github.repository_owner}}/${{ matrix.binary }}:${VERSION}${VERSION_SUFFIX} \
+                      ${{ github.repository_owner}}/${{ matrix.binary }}:${VERSION}-arm64${VERSION_SUFFIX} \
+                      ${{ github.repository_owner}}/${{ matrix.binary }}:${VERSION}-amd64${VERSION_SUFFIX};
 
-    build-docker-lcli:
-        runs-on: ubuntu-22.04
-        needs: [extract-version]
-        env:
-            VERSION: ${{ needs.extract-version.outputs.VERSION }}
-            VERSION_SUFFIX: ${{ needs.extract-version.outputs.VERSION_SUFFIX }}
-        steps:
-            - uses: actions/checkout@v4
-            - name: Dockerhub login
-              run: |
-                  echo "${DOCKER_PASSWORD}" | docker login --username ${DOCKER_USERNAME} --password-stdin
-            - name: Build lcli and push
-              uses: docker/build-push-action@v5
-              with:
-                  build-args: |
-                      FEATURES=portable
-                  context: .
-                  push: true
-                  file: ./lcli/Dockerfile
-                  tags: ${{ env.LCLI_IMAGE_NAME }}:${{ env.VERSION }}${{ env.VERSION_SUFFIX }}
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 3d23b4110e7..476b3cf1798 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -31,38 +31,22 @@ jobs:
         strategy:
             matrix:
                 arch: [aarch64-unknown-linux-gnu,
-                       aarch64-unknown-linux-gnu-portable,
                        x86_64-unknown-linux-gnu,
-                       x86_64-unknown-linux-gnu-portable,
                        x86_64-apple-darwin,
-                       x86_64-apple-darwin-portable,
-                       x86_64-windows,
-                       x86_64-windows-portable]
+                       x86_64-windows]
                 include:
                     -   arch: aarch64-unknown-linux-gnu
                         runner: ${{ github.repository == 'sigp/lighthouse' && fromJson('["self-hosted", "linux", "release", "large"]') || 'ubuntu-latest'  }}
                         profile: maxperf
-                    -   arch: aarch64-unknown-linux-gnu-portable
-                        runner: ${{ github.repository == 'sigp/lighthouse' && fromJson('["self-hosted", "linux", "release", "large"]') || 'ubuntu-latest'  }}
-                        profile: maxperf
                     -   arch: x86_64-unknown-linux-gnu
                         runner: ${{ github.repository == 'sigp/lighthouse' && fromJson('["self-hosted", "linux", "release", "large"]') || 'ubuntu-latest'  }}
                         profile: maxperf
-                    -   arch: x86_64-unknown-linux-gnu-portable
-                        runner: ${{ github.repository == 'sigp/lighthouse' && fromJson('["self-hosted", "linux", "release", "large"]') || 'ubuntu-latest'  }}
-                        profile: maxperf
                     -   arch: x86_64-apple-darwin
-                        runner: macos-latest
-                        profile: maxperf
-                    -   arch: x86_64-apple-darwin-portable
-                        runner: macos-latest
+                        runner: macos-13
                         profile: maxperf
                     -   arch: x86_64-windows
                         runner: ${{ github.repository == 'sigp/lighthouse' && fromJson('["self-hosted", "windows", "release"]') || 'windows-2019'  }}
                         profile: maxperf
-                    -   arch: x86_64-windows-portable
-                        runner: ${{ github.repository == 'sigp/lighthouse' && fromJson('["self-hosted", "windows", "release"]') || 'windows-2019'  }}
-                        profile: maxperf
 
         runs-on:    ${{ matrix.runner }}
         needs: extract-version
@@ -90,53 +74,29 @@ jobs:
             #       Builds
             # ==============================
 
-            - name: Build Lighthouse for aarch64-unknown-linux-gnu-portable
-              if:   matrix.arch == 'aarch64-unknown-linux-gnu-portable'
-              run:  |
-                cargo install cross
-                env CROSS_PROFILE=${{ matrix.profile }} make build-aarch64-portable
-
             - name: Build Lighthouse for aarch64-unknown-linux-gnu
               if:   matrix.arch == 'aarch64-unknown-linux-gnu'
               run:  |
                 cargo install cross
-                env CROSS_PROFILE=${{ matrix.profile }} make build-aarch64
-
-            - name: Build Lighthouse for x86_64-unknown-linux-gnu-portable
-              if:   matrix.arch == 'x86_64-unknown-linux-gnu-portable'
-              run:  |
-                cargo install cross
-                env CROSS_PROFILE=${{ matrix.profile }} make build-x86_64-portable
+                env CROSS_PROFILE=${{ matrix.profile }} make build-aarch64-portable
 
             - name: Build Lighthouse for x86_64-unknown-linux-gnu
               if:   matrix.arch == 'x86_64-unknown-linux-gnu'
               run:  |
                 cargo install cross
-                env CROSS_PROFILE=${{ matrix.profile }} make build-x86_64
-
-            - name: Move cross-compiled binary
-              if:  startsWith(matrix.arch, 'aarch64')
-              run: mv target/aarch64-unknown-linux-gnu/${{ matrix.profile }}/lighthouse ~/.cargo/bin/lighthouse
+                env CROSS_PROFILE=${{ matrix.profile }} make build-x86_64-portable
 
             - name: Move cross-compiled binary
-              if:  startsWith(matrix.arch, 'x86_64-unknown-linux-gnu')
-              run: mv target/x86_64-unknown-linux-gnu/${{ matrix.profile }}/lighthouse ~/.cargo/bin/lighthouse
-
-            - name: Build Lighthouse for x86_64-apple-darwin portable
-              if:   matrix.arch == 'x86_64-apple-darwin-portable'
-              run:  cargo install --path lighthouse --force --locked --features portable,gnosis --profile ${{ matrix.profile }}
+              if:  contains(matrix.arch, 'unknown-linux-gnu')
+              run: mv target/${{ matrix.arch }}/${{ matrix.profile }}/lighthouse ~/.cargo/bin/lighthouse
 
-            - name: Build Lighthouse for x86_64-apple-darwin modern
+            - name: Build Lighthouse for x86_64-apple-darwin
               if:   matrix.arch == 'x86_64-apple-darwin'
-              run:  cargo install --path lighthouse --force --locked --features modern,gnosis --profile ${{ matrix.profile }}
-
-            - name: Build Lighthouse for Windows portable
-              if:   matrix.arch == 'x86_64-windows-portable'
               run:  cargo install --path lighthouse --force --locked --features portable,gnosis --profile ${{ matrix.profile }}
 
-            - name: Build Lighthouse for Windows modern
+            - name: Build Lighthouse for Windows
               if:   matrix.arch == 'x86_64-windows'
-              run:  cargo install --path lighthouse --force --locked --features modern,gnosis --profile ${{ matrix.profile }}
+              run:  cargo install --path lighthouse --force --locked --features portable,gnosis --profile ${{ matrix.profile }}
 
             - name: Configure GPG and create artifacts
               if: startsWith(matrix.arch, 'x86_64-windows') != true
@@ -151,6 +111,11 @@ jobs:
                   cd artifacts
                   tar -czf lighthouse-${{ needs.extract-version.outputs.VERSION }}-${{ matrix.arch }}.tar.gz lighthouse
                   echo "$GPG_PASSPHRASE" | gpg --passphrase-fd 0 --pinentry-mode loopback --batch -ab lighthouse-${{ needs.extract-version.outputs.VERSION }}-${{ matrix.arch }}.tar.gz
+                  for ext in "tar.gz" "tar.gz.asc";\
+                  do for f in *.$ext;\
+                    do cp $f "../${f%.$ext}-portable.$ext";\
+                    done;\
+                  done
                   mv *tar.gz* ..
 
             - name: Configure GPG and create artifacts Windows
@@ -179,6 +144,14 @@ jobs:
                   path: lighthouse-${{ needs.extract-version.outputs.VERSION }}-${{ matrix.arch }}.tar.gz
                   compression-level: 0
 
+            - name: Upload artifact (copy)
+              if: startsWith(matrix.arch, 'x86_64-windows') != true
+              uses: actions/upload-artifact@v4
+              with:
+                  name: lighthouse-${{ needs.extract-version.outputs.VERSION }}-${{ matrix.arch }}-portable.tar.gz
+                  path: lighthouse-${{ needs.extract-version.outputs.VERSION }}-${{ matrix.arch }}-portable.tar.gz
+                  compression-level: 0
+
             - name: Upload signature
               uses: actions/upload-artifact@v4
               with:
@@ -186,6 +159,14 @@ jobs:
                   path: lighthouse-${{ needs.extract-version.outputs.VERSION }}-${{ matrix.arch }}.tar.gz.asc
                   compression-level: 0
 
+            - name: Upload signature (copy)
+              if: startsWith(matrix.arch, 'x86_64-windows') != true
+              uses: actions/upload-artifact@v4
+              with:
+                  name: lighthouse-${{ needs.extract-version.outputs.VERSION }}-${{ matrix.arch }}-portable.tar.gz.asc
+                  path: lighthouse-${{ needs.extract-version.outputs.VERSION }}-${{ matrix.arch }}-portable.tar.gz.asc
+                  compression-level: 0
+
     draft-release:
         name:   Draft Release
         needs:  [build, extract-version]
diff --git a/.github/workflows/test-suite.yml b/.github/workflows/test-suite.yml
index a8db6fab8fd..84ef42dc3fc 100644
--- a/.github/workflows/test-suite.yml
+++ b/.github/workflows/test-suite.yml
@@ -29,6 +29,31 @@ env:
   # Enable portable to prevent issues with caching `blst` for the wrong CPU type
   TEST_FEATURES: portable
 jobs:
+  check-labels:
+    runs-on: ubuntu-latest
+    name: Check for 'skip-ci' label
+    outputs:
+      skip_ci: ${{ steps.set-output.outputs.SKIP_CI }}
+    steps:
+     - name: check for skip-ci label
+       id: set-output
+       env:
+         LABELS: ${{ toJson(github.event.pull_request.labels) }}
+       run: |
+         SKIP_CI="false"
+         if [ -z "${LABELS}" ]; then
+           LABELS="none";
+         else
+           LABELS=$(echo ${LABELS} | jq -r '.[].name')
+         fi
+         for label in ${LABELS}; do
+           if [ "$label" = "skip-ci" ]; then
+             SKIP_CI="true"
+             break
+           fi
+         done
+         echo "::set-output name=skip_ci::$SKIP_CI"
+
   target-branch-check:
     name: target-branch-check
     runs-on: ubuntu-latest
@@ -38,6 +63,8 @@ jobs:
           run: test ${{ github.base_ref }} != "stable"
   release-tests-ubuntu:
     name: release-tests-ubuntu
+    needs: [check-labels]
+    if: needs.check-labels.outputs.skip_ci != 'true'
     # Use self-hosted runners only on the sigp repo.
     runs-on: ${{ github.repository == 'sigp/lighthouse' && fromJson('["self-hosted", "linux", "CI", "large"]') || 'ubuntu-latest'  }}
     steps:
@@ -63,6 +90,8 @@ jobs:
       run: sccache --show-stats
   release-tests-windows:
     name: release-tests-windows
+    needs: [check-labels]
+    if: needs.check-labels.outputs.skip_ci != 'true'
     runs-on: ${{ github.repository == 'sigp/lighthouse' && fromJson('["self-hosted", "windows", "CI"]') || 'windows-2019'  }}
     steps:
     - uses: actions/checkout@v4
@@ -97,6 +126,8 @@ jobs:
       run: sccache --show-stats
   beacon-chain-tests:
     name: beacon-chain-tests
+    needs: [check-labels]
+    if: needs.check-labels.outputs.skip_ci != 'true'
     # Use self-hosted runners only on the sigp repo.
     runs-on: ${{ github.repository == 'sigp/lighthouse' && fromJson('["self-hosted", "linux", "CI", "large"]') || 'ubuntu-latest'  }}
     env:
@@ -117,6 +148,8 @@ jobs:
       run: sccache --show-stats
   op-pool-tests:
     name: op-pool-tests
+    needs: [check-labels]
+    if: needs.check-labels.outputs.skip_ci != 'true'
     runs-on: ubuntu-latest
     env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -132,6 +165,8 @@ jobs:
       run: make test-op-pool
   network-tests:
     name: network-tests
+    needs: [check-labels]
+    if: needs.check-labels.outputs.skip_ci != 'true'
     runs-on: ubuntu-latest
     env:
       GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -147,6 +182,8 @@ jobs:
       run: make test-network
   slasher-tests:
     name: slasher-tests
+    needs: [check-labels]
+    if: needs.check-labels.outputs.skip_ci != 'true'
     runs-on: ubuntu-latest
     env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -162,6 +199,8 @@ jobs:
       run: make test-slasher
   debug-tests-ubuntu:
     name: debug-tests-ubuntu
+    needs: [check-labels]
+    if: needs.check-labels.outputs.skip_ci != 'true'
     # Use self-hosted runners only on the sigp repo.
     runs-on: ${{ github.repository == 'sigp/lighthouse' && fromJson('["self-hosted", "linux", "CI", "large"]') || 'ubuntu-latest'  }}
     env:
@@ -186,6 +225,8 @@ jobs:
       run: sccache --show-stats
   state-transition-vectors-ubuntu:
     name: state-transition-vectors-ubuntu
+    needs: [check-labels]
+    if: needs.check-labels.outputs.skip_ci != 'true'
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
@@ -198,6 +239,8 @@ jobs:
       run: make run-state-transition-tests
   ef-tests-ubuntu:
     name: ef-tests-ubuntu
+    needs: [check-labels]
+    if: needs.check-labels.outputs.skip_ci != 'true'
     # Use self-hosted runners only on the sigp repo.
     runs-on: ${{ github.repository == 'sigp/lighthouse' && fromJson('["self-hosted", "linux", "CI", "small"]') || 'ubuntu-latest'  }}
     env:
@@ -218,6 +261,8 @@ jobs:
       run: sccache --show-stats
   dockerfile-ubuntu:
     name: dockerfile-ubuntu
+    needs: [check-labels]
+    if: needs.check-labels.outputs.skip_ci != 'true'
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
@@ -225,40 +270,10 @@ jobs:
       run: docker build --build-arg FEATURES=portable -t lighthouse:local .
     - name: Test the built image
       run: docker run -t lighthouse:local lighthouse --version
-  eth1-simulator-ubuntu:
-    name: eth1-simulator-ubuntu
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - name: Get latest version of stable Rust
-      uses: moonrepo/setup-rust@v1
-      with:
-          channel: stable
-          cache-target: release
-    - name: Install Foundry (anvil)
-      uses: foundry-rs/foundry-toolchain@v1
-      with:
-        version: nightly-ca67d15f4abd46394b324c50e21e66f306a1162d
-    - name: Run the beacon chain sim that starts from an eth1 contract
-      run: cargo run --release --bin simulator eth1-sim
-  merge-transition-ubuntu:
-    name: merge-transition-ubuntu
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - name: Get latest version of stable Rust
-      uses: moonrepo/setup-rust@v1
-      with:
-          channel: stable
-          cache-target: release
-    - name: Install Foundry (anvil)
-      uses: foundry-rs/foundry-toolchain@v1
-      with:
-        version: nightly-ca67d15f4abd46394b324c50e21e66f306a1162d
-    - name: Run the beacon chain sim and go through the merge transition
-      run: cargo run --release --bin simulator eth1-sim --post-merge
-  no-eth1-simulator-ubuntu:
-    name: no-eth1-simulator-ubuntu
+  basic-simulator-ubuntu:
+    name: basic-simulator-ubuntu
+    needs: [check-labels]
+    if: needs.check-labels.outputs.skip_ci != 'true'
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
@@ -267,10 +282,12 @@ jobs:
       with:
           channel: stable
           cache-target: release
-    - name: Run the beacon chain sim without an eth1 connection
-      run: cargo run --release --bin simulator no-eth1-sim
-  syncing-simulator-ubuntu:
-    name: syncing-simulator-ubuntu
+    - name: Run a basic beacon chain sim that starts from Bellatrix
+      run: cargo run --release --bin simulator basic-sim
+  fallback-simulator-ubuntu:
+    name: fallback-simulator-ubuntu
+    needs: [check-labels]
+    if: needs.check-labels.outputs.skip_ci != 'true'
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
@@ -279,14 +296,12 @@ jobs:
       with:
           channel: stable
           cache-target: release
-    - name: Install Foundry (anvil)
-      uses: foundry-rs/foundry-toolchain@v1
-      with:
-        version: nightly-ca67d15f4abd46394b324c50e21e66f306a1162d
-    - name: Run the syncing simulator
-      run: cargo run --release --bin simulator syncing-sim
+    - name: Run a beacon chain sim which tests VC fallback behaviour
+      run: cargo run --release --bin simulator fallback-sim
   doppelganger-protection-test:
     name: doppelganger-protection-test
+    needs: [check-labels]
+    if: needs.check-labels.outputs.skip_ci != 'true'
     runs-on: ${{ github.repository == 'sigp/lighthouse' && fromJson('["self-hosted", "linux", "CI", "small"]') || 'ubuntu-latest'  }}
     env:
       # Enable portable to prevent issues with caching `blst` for the wrong CPU type
@@ -309,9 +324,7 @@ jobs:
       run: |
           make
     - name: Install lcli
-      # TODO: uncomment after the version of lcli in https://github.com/sigp/lighthouse/pull/5137
-      # is installed on the runners
-      # if: env.SELF_HOSTED_RUNNERS == 'false'
+      if: env.SELF_HOSTED_RUNNERS == 'false'
       run: make install-lcli
     - name: Run the doppelganger protection failure test script
       run: |
@@ -323,6 +336,8 @@ jobs:
           ./doppelganger_protection.sh success genesis.json
   execution-engine-integration-ubuntu:
     name: execution-engine-integration-ubuntu
+    needs: [check-labels]
+    if: needs.check-labels.outputs.skip_ci != 'true'
     runs-on: ${{ github.repository == 'sigp/lighthouse' && fromJson('["self-hosted", "linux", "CI", "small"]') || 'ubuntu-latest'  }}
     steps:
     - uses: actions/checkout@v4
@@ -382,6 +397,8 @@ jobs:
       run: cargo check --workspace
   cargo-udeps:
     name: cargo-udeps
+    needs: [check-labels]
+    if: needs.check-labels.outputs.skip_ci != 'true'
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
@@ -404,6 +421,8 @@ jobs:
       RUSTFLAGS: ""
   compile-with-beta-compiler:
     name: compile-with-beta-compiler
+    needs: [check-labels]
+    if: needs.check-labels.outputs.skip_ci != 'true'
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
@@ -415,6 +434,8 @@ jobs:
       run: make
   cli-check:
     name: cli-check
+    needs: [check-labels]
+    if: needs.check-labels.outputs.skip_ci != 'true'
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
@@ -429,8 +450,10 @@ jobs:
   # a PR is safe to merge. New jobs should be added here.
   test-suite-success:
     name: test-suite-success
+    if: needs.check-labels.outputs.skip_ci != 'true'
     runs-on: ubuntu-latest
     needs: [
+      'check-labels',
       'target-branch-check',
       'release-tests-ubuntu',
       'release-tests-windows',
@@ -442,10 +465,8 @@ jobs:
       'state-transition-vectors-ubuntu',
       'ef-tests-ubuntu',
       'dockerfile-ubuntu',
-      'eth1-simulator-ubuntu',
-      'merge-transition-ubuntu',
-      'no-eth1-simulator-ubuntu',
-      'syncing-simulator-ubuntu',
+      'basic-simulator-ubuntu',
+      'fallback-simulator-ubuntu',
       'doppelganger-protection-test',
       'execution-engine-integration-ubuntu',
       'check-code',
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a408fcdd52f..3c53558a100 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,12 +1,14 @@
 # Contributors Guide
+
 [![GitPOAP badge](https://public-api.gitpoap.io/v1/repo/sigp/lighthouse/badge)](https://www.gitpoap.io/gh/sigp/lighthouse)
 
-Lighthouse is an open-source Ethereum 2.0 client. We're community driven and
+Lighthouse is an open-source Ethereum consensus client. We're community driven and
 welcome all contribution. We aim to provide a constructive, respectful and fun
 environment for collaboration.
 
-We are active contributors to the [Ethereum 2.0 specification](https://github.com/ethereum/eth2.0-specs) and attend all [Eth
-2.0 implementers calls](https://github.com/ethereum/eth2.0-pm).
+We are active contributors to
+the [Ethereum Proof-of-Stake Consensus specification](https://github.com/ethereum/consensus-specs) and attend
+all [Ethereum implementers calls](https://github.com/ethereum/pm/).
 
 This guide is geared towards beginners. If you're an open-source veteran feel
 free to just skim this document and get straight into crushing issues.
@@ -41,7 +43,7 @@ We recommend the following work-flow for contributors:
 
 1. **Find an issue** to work on, either because it's interesting or suitable to
    your skill-set. Use comments to communicate your intentions and ask
-questions.
+   questions.
 2. **Work in a feature branch** of your personal fork
    (github.com/YOUR_NAME/lighthouse) of the main repository
    (github.com/sigp/lighthouse).
@@ -49,13 +51,13 @@ questions.
    `unstable` as the base branch to merge your changes into the main repository.
 4. Wait for the repository maintainers to **review your changes** to ensure the
    issue is addressed satisfactorily. Optionally, mention your PR on
-[discord](https://discord.gg/cyAszAh).
+   [discord](https://discord.gg/cyAszAh).
 5. If the issue is addressed the repository maintainers will **merge your
    pull-request** and you'll be an official contributor!
 
 Generally, you find an issue you'd like to work on and announce your intentions
 to start work in a comment on the issue. Then, do your work on a separate
-branch (a "feature branch") in your own fork of the main repository.  Once
+branch (a "feature branch") in your own fork of the main repository. Once
 you're happy and you think the issue has been addressed, create a pull request
 into the main repository.
 
@@ -66,18 +68,20 @@ steps:
 
 1. [Create a
    fork](https://help.github.com/articles/fork-a-repo/#fork-an-example-repository)
-and [clone
-it](https://help.github.com/articles/fork-a-repo/#step-2-create-a-local-clone-of-your-fork)
-to your local machine.
+   and [clone
+   it](https://help.github.com/articles/fork-a-repo/#step-2-create-a-local-clone-of-your-fork)
+   to your local machine.
 2. [Add an _"upstream"_
    branch](https://help.github.com/articles/fork-a-repo/#step-3-configure-git-to-sync-your-fork-with-the-original-spoon-knife-repository)
-that tracks github.com/sigp/lighthouse using `$ git remote add upstream
-https://github.com/sigp/lighthouse.git` (pro-tip: [use SSH](https://help.github.com/articles/connecting-to-github-with-ssh/) instead of HTTPS).
+   that tracks github.com/sigp/lighthouse using `$ git remote add upstream
+   https://github.com/sigp/lighthouse.git` (
+   pro-tip: [use SSH](https://help.github.com/articles/connecting-to-github-with-ssh/) instead of HTTPS).
 3. Create a new feature branch with `$ git checkout -b your_feature_name`. The
    name of your branch isn't critical but it should be short and instructive.
-E.g., if you're fixing a bug with serialization, you could name your branch
-`fix_serialization_bug`.
-4. Make sure you sign your commits. See [relevant doc](https://help.github.com/en/github/authenticating-to-github/about-commit-signature-verification).
+   E.g., if you're fixing a bug with serialization, you could name your branch
+   `fix_serialization_bug`.
+4. Make sure you sign your commits.
+   See [relevant doc](https://help.github.com/en/github/authenticating-to-github/about-commit-signature-verification).
 5. Commit your changes and push them to your fork with `$ git push origin
    your_feature_name`.
 6. Go to your fork on github.com and use the web interface to create a pull
@@ -92,22 +96,28 @@ by Rob Allen that provides much more detail on each of these steps, if you're
 having trouble. As always, jump on [discord](https://discord.gg/cyAszAh)
 if you get stuck.
 
+Additionally,
+the ["Contributing to Lighthouse" section](https://lighthouse-book.sigmaprime.io/contributing.html#contributing-to-lighthouse)
+of the Lighthouse Book provides more details on the setup.
 
 ## FAQs
 
 ### I don't think I have anything to add
 
 There's lots to be done and there's all sorts of tasks. You can do anything
-from correcting typos through to writing core consensus code. If you reach out,
+from enhancing documentation through to writing core consensus code. If you reach out,
 we'll include you.
 
+Please note, to maintain project quality, we may not accept PRs for small typos or changes
+with minimal impact.
+
 ### I'm not sure my Rust is good enough
 
 We're open to developers of all levels. If you create a PR and your code
 doesn't meet our standards, we'll help you fix it and we'll share the reasoning
 with you. Contributing to open-source is a great way to learn.
 
-### I'm not sure I know enough about Ethereum 2.0
+### I'm not sure I know enough about Ethereum
 
 No problems, there's plenty of tasks that don't require extensive Ethereum
 knowledge. You can learn about Ethereum as you go.
diff --git a/Cargo.lock b/Cargo.lock
index e37e3903dbd..3a52b854ced 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -126,14 +126,14 @@ dependencies = [
 
 [[package]]
 name = "aes-gcm"
-version = "0.9.4"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df5f85a83a7d8b0442b6aa7b504b8212c1733da07b98aae43d4bc21b2cb3cdf6"
+checksum = "bc3be92e19a7ef47457b8e6f90707e12b6ac5d20c6f3866584fa3be0787d839f"
 dependencies = [
  "aead 0.4.3",
  "aes 0.7.5",
  "cipher 0.3.0",
- "ctr 0.8.0",
+ "ctr 0.7.0",
  "ghash 0.4.4",
  "subtle",
 ]
@@ -148,15 +148,15 @@ dependencies = [
  "aes 0.8.4",
  "cipher 0.4.4",
  "ctr 0.9.2",
- "ghash 0.5.0",
+ "ghash 0.5.1",
  "subtle",
 ]
 
 [[package]]
 name = "ahash"
-version = "0.8.10"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b79b82693f705137f8fb9b37871d99e4f9a7df12b917eed79c3d3954830a60b"
+checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -166,18 +166,18 @@ dependencies = [
 
 [[package]]
 name = "aho-corasick"
-version = "1.1.2"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "allocator-api2"
-version = "0.2.16"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0942ffc6dcaadf03badf6e6a2d0228460359d5e34b57ccdc720b7382dfbd5ec5"
+checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
 
 [[package]]
 name = "alloy-consensus"
@@ -265,7 +265,7 @@ checksum = "1a047897373be4bbb0224c1afdabca92648dc57a9c9ef6e7b0be3aff7a859c83"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -294,9 +294,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.80"
+version = "1.0.82"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ad32ce52e4161730f7098c077cd2ed6229b5804ccf99e5366be1ab72a98b4e1"
+checksum = "f538837af36e6f6a9be0faa67f9a314f8119e4e4b5867c6ab40ed60360142519"
 
 [[package]]
 name = "arbitrary"
@@ -309,9 +309,18 @@ dependencies = [
 
 [[package]]
 name = "arc-swap"
-version = "1.6.0"
+version = "1.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69f7f8c3906b62b754cd5326047894316021dcfe5a194c8ea52bdd94934a3457"
+
+[[package]]
+name = "archery"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bddcadddf5e9015d310179a59bb28c4d4b9920ad0f11e8e14dbadf654890c9a6"
+checksum = "0a8da9bc4c4053ee067669762bcaeea6e241841295a2b6c948312dad6ef4cc02"
+dependencies = [
+ "static_assertions",
+]
 
 [[package]]
 name = "ark-ff"
@@ -437,6 +446,12 @@ dependencies = [
  "rand",
 ]
 
+[[package]]
+name = "arraydeque"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d902e3d592a523def97af8f317b08ce16b7ab854c1985a0c671e6f15cebc236"
+
 [[package]]
 name = "arrayref"
 version = "0.3.7"
@@ -507,9 +522,9 @@ dependencies = [
 
 [[package]]
 name = "async-io"
-version = "2.3.1"
+version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f97ab0c5b00a7cdbe5a371b9a782ee7be1316095885c8a4ea1daf490eb0ef65"
+checksum = "dcccb0f599cfa2f8ace422d3555572f47424da5648a4382a9dd0310ff8210884"
 dependencies = [
  "async-lock",
  "cfg-if",
@@ -518,7 +533,7 @@ dependencies = [
  "futures-lite",
  "parking",
  "polling",
- "rustix 0.38.31",
+ "rustix 0.38.34",
  "slab",
  "tracing",
  "windows-sys 0.52.0",
@@ -537,13 +552,13 @@ dependencies = [
 
 [[package]]
 name = "async-trait"
-version = "0.1.77"
+version = "0.1.80"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c980ee35e870bd1a4d2c8294d4c04d0499e67bca1e4b5cefcc693c2fa00caea9"
+checksum = "c6fa2087f2753a7da8cc1c0dbfcf89579dd57458e36769de5ac750b4671737ca"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -589,7 +604,7 @@ version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8d9a9bf8b79a749ee0b911b91b671cc2b6c670bdbc7e3dfd537576ddc94bb2a2"
 dependencies = [
- "http 0.2.11",
+ "http 0.2.12",
  "log",
  "url",
 ]
@@ -613,29 +628,29 @@ checksum = "3c87f3f15e7794432337fc718554eaa4dc8f04c9677a950ffe366f20a162ae42"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
 name = "autocfg"
-version = "1.1.0"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80"
 
 [[package]]
 name = "axum"
-version = "0.7.4"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1236b4b292f6c4d6dc34604bb5120d85c3fe1d1aa596bd5cc52ca054d13e7b9e"
+checksum = "3a6c9af12842a67734c9a2e355436e5d03b22383ed60cf13cd0c18fbfe3dcbcf"
 dependencies = [
  "async-trait",
  "axum-core",
  "bytes",
  "futures-util",
- "http 1.0.0",
+ "http 1.1.0",
  "http-body 1.0.0",
  "http-body-util",
- "hyper 1.2.0",
+ "hyper 1.3.1",
  "hyper-util",
  "itoa",
  "matchit",
@@ -648,7 +663,7 @@ dependencies = [
  "serde_json",
  "serde_path_to_error",
  "serde_urlencoded",
- "sync_wrapper",
+ "sync_wrapper 1.0.1",
  "tokio",
  "tower",
  "tower-layer",
@@ -665,13 +680,13 @@ dependencies = [
  "async-trait",
  "bytes",
  "futures-util",
- "http 1.0.0",
+ "http 1.1.0",
  "http-body 1.0.0",
  "http-body-util",
  "mime",
  "pin-project-lite",
  "rustversion",
- "sync_wrapper",
+ "sync_wrapper 0.1.2",
  "tower-layer",
  "tower-service",
  "tracing",
@@ -679,9 +694,9 @@ dependencies = [
 
 [[package]]
 name = "backtrace"
-version = "0.3.69"
+version = "0.3.71"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837"
+checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d"
 dependencies = [
  "addr2line",
  "cc",
@@ -722,6 +737,12 @@ version = "0.21.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
 
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
 [[package]]
 name = "base64ct"
 version = "1.6.0"
@@ -753,13 +774,14 @@ dependencies = [
  "kzg",
  "lazy_static",
  "lighthouse_metrics",
+ "lighthouse_version",
  "logging",
  "lru",
  "maplit",
  "merkle_proof",
  "oneshot_broadcast",
  "operation_pool",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "proto_array",
  "rand",
  "rayon",
@@ -806,7 +828,7 @@ dependencies = [
  "genesis",
  "hex",
  "http_api",
- "hyper 1.2.0",
+ "hyper 1.3.1",
  "lighthouse_network",
  "lighthouse_version",
  "monitoring_api",
@@ -838,7 +860,7 @@ dependencies = [
  "lighthouse_network",
  "logging",
  "num_cpus",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "serde",
  "slog",
  "slot_clock",
@@ -877,29 +899,6 @@ dependencies = [
  "shlex",
 ]
 
-[[package]]
-name = "bindgen"
-version = "0.66.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2b84e06fc203107bfbad243f4aba2af864eb7db3b1cf46ea0a023b0b433d2a7"
-dependencies = [
- "bitflags 2.4.2",
- "cexpr",
- "clang-sys",
- "lazy_static",
- "lazycell",
- "log",
- "peeking_take_while",
- "prettyplease",
- "proc-macro2",
- "quote",
- "regex",
- "rustc-hash",
- "shlex",
- "syn 2.0.52",
- "which",
-]
-
 [[package]]
 name = "bit-set"
 version = "0.5.3"
@@ -923,9 +922,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.4.2"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed570934406eb16438a4e976b1b4500774099c13b8cb96eec99f620f05090ddf"
+checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
 
 [[package]]
 name = "bitvec"
@@ -1057,9 +1056,9 @@ checksum = "771fe0050b883fcc3ea2359b1a96bcfbc090b7116eae7c3c512c7a083fdf23d3"
 
 [[package]]
 name = "bs58"
-version = "0.5.0"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5353f36341f7451062466f0b755b96ac3a9547e4d7f6b70d603fc721a7d7896"
+checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4"
 dependencies = [
  "tinyvec",
 ]
@@ -1078,9 +1077,9 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.15.3"
+version = "3.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ea184aa71bb362a1157c896979544cc23974e08fd265f29ea96b59f0b4a555b"
+checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
 
 [[package]]
 name = "byte-slice-cast"
@@ -1096,9 +1095,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "1.5.0"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223"
+checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9"
 dependencies = [
  "serde",
 ]
@@ -1126,16 +1125,15 @@ dependencies = [
 
 [[package]]
 name = "c-kzg"
-version = "0.1.0"
-source = "git+https://github.com/ethereum/c-kzg-4844?rev=748283cced543c486145d5f3f38684becdfe3e1b#748283cced543c486145d5f3f38684becdfe3e1b"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3130f3d8717cc02e668a896af24984d5d5d4e8bf12e278e982e0f1bd88a0f9af"
 dependencies = [
- "bindgen 0.66.1",
  "blst",
  "cc",
  "glob",
  "hex",
  "libc",
- "serde",
 ]
 
 [[package]]
@@ -1164,9 +1162,9 @@ dependencies = [
 
 [[package]]
 name = "cargo-platform"
-version = "0.1.7"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "694c8807f2ae16faecc43dc17d74b3eb042482789fd0eb64b39a2e04e087053f"
+checksum = "24b1f0365a6c6bb4020cd05806fd0d33c44d38046b8bd7f0e40814b9763cabfc"
 dependencies = [
  "serde",
 ]
@@ -1193,12 +1191,13 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.0.90"
+version = "1.0.96"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cd6604a82acf3039f1144f54b8eb34e91ffba622051189e71b781822d5ee1f5"
+checksum = "065a29261d53ba54260972629f9ca6bffa69bac13cd1fed61420f7fa68b9f8bd"
 dependencies = [
  "jobserver",
  "libc",
+ "once_cell",
 ]
 
 [[package]]
@@ -1216,6 +1215,12 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "cfg_aliases"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
+
 [[package]]
 name = "chacha20"
 version = "0.9.1"
@@ -1242,14 +1247,14 @@ dependencies = [
 
 [[package]]
 name = "chrono"
-version = "0.4.34"
+version = "0.4.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5bc015644b92d5890fab7489e49d21f879d5c990186827d42ec511919404f38b"
+checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
  "num-traits",
- "windows-targets 0.52.4",
+ "windows-targets 0.52.5",
 ]
 
 [[package]]
@@ -1341,7 +1346,7 @@ dependencies = [
  "network",
  "num_cpus",
  "operation_pool",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "sensitive_url",
  "serde",
  "serde_yaml",
@@ -1355,6 +1360,7 @@ dependencies = [
  "time",
  "timer",
  "tokio",
+ "tree_hash",
  "types",
 ]
 
@@ -1385,18 +1391,18 @@ dependencies = [
 
 [[package]]
 name = "concurrent-queue"
-version = "2.4.0"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d16048cd947b08fa32c24458a22f5dc5e835264f689f4f5653210c69fd107363"
+checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
 dependencies = [
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "const-hex"
-version = "1.11.1"
+version = "1.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efbd12d49ab0eaf8193ba9175e45f56bbc2e4b27d57b8cfe62aa47942a46b9a9"
+checksum = "5ba00838774b4ab0233e355d26710fbfc8327a05c017f6dc4873f876d1f79f78"
 dependencies = [
  "cfg-if",
  "cpufeatures",
@@ -1589,9 +1595,9 @@ dependencies = [
 
 [[package]]
 name = "crypto-mac"
-version = "0.11.1"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1d1a86f49236c215f271d40892d5fc950490551400b02ef360692c29815c714"
+checksum = "25fab6889090c8133f3deb8f73ba3c65a7f456f66436fc012a1b1e272b1e103e"
 dependencies = [
  "generic-array",
  "subtle",
@@ -1618,6 +1624,15 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "ctr"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a232f92a03f37dd7d7dd2adc67166c77e9cd88de5b019b9a9eecfaeaf7bfd481"
+dependencies = [
+ "cipher 0.3.0",
+]
+
 [[package]]
 name = "ctr"
 version = "0.8.0"
@@ -1638,11 +1653,11 @@ dependencies = [
 
 [[package]]
 name = "ctrlc"
-version = "3.4.2"
+version = "3.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b467862cc8610ca6fc9a1532d7777cee0804e678ab45410897b9396495994a0b"
+checksum = "672465ae37dc1bc6380a6547a8883d5dd397b0f1faaad4f265726cc7042a5345"
 dependencies = [
- "nix 0.27.1",
+ "nix 0.28.0",
  "windows-sys 0.52.0",
 ]
 
@@ -1657,7 +1672,7 @@ dependencies = [
  "curve25519-dalek-derive",
  "digest 0.10.7",
  "fiat-crypto",
- "platforms 3.3.0",
+ "platforms 3.4.0",
  "rustc_version 0.4.0",
  "subtle",
  "zeroize",
@@ -1671,7 +1686,7 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -1737,15 +1752,15 @@ checksum = "7762d17f1241643615821a8455a0b2c3e803784b058693d990b11f2dce25a0ca"
 
 [[package]]
 name = "data-encoding"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e962a19be5cfc3f3bf6dd8f61eb50107f356ad6270fbb3ed41476571db78be5"
+checksum = "e8566979429cf69b49a5c740c60791108e86440e8be149bbea4fe54d2c32d6e2"
 
 [[package]]
 name = "data-encoding-macro"
-version = "0.1.14"
+version = "0.1.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20c01c06f5f429efdf2bae21eb67c28b3df3cf85b7dd2d8ef09c0838dac5d33e"
+checksum = "f1559b6cba622276d6d63706db152618eeb15b89b3e4041446b05876e352e639"
 dependencies = [
  "data-encoding",
  "data-encoding-macro-internal",
@@ -1753,9 +1768,9 @@ dependencies = [
 
 [[package]]
 name = "data-encoding-macro-internal"
-version = "0.1.12"
+version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0047d07f2c89b17dd631c80450d69841a6b5d7fb17278cbc43d7e4cfcf2576f3"
+checksum = "332d754c0af53bc87c108fed664d121ecf59207ec4196041f04d6ab9002ad33f"
 dependencies = [
  "data-encoding",
  "syn 1.0.109",
@@ -1822,9 +1837,9 @@ dependencies = [
 
 [[package]]
 name = "der"
-version = "0.7.8"
+version = "0.7.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fffa369a668c8af7dbf8b5e56c9f744fbd399949ed171606040001947de40b1c"
+checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
 dependencies = [
  "const-oid",
  "pem-rfc7468",
@@ -1873,7 +1888,7 @@ checksum = "67e77553c4162a157adbf834ebae5b415acbecbeafc7a74b0e886657506a7611"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -1891,11 +1906,11 @@ dependencies = [
 
 [[package]]
 name = "diesel"
-version = "2.1.4"
+version = "2.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62c6fcf842f17f8c78ecf7c81d75c5ce84436b41ee07e03f490fbb5f5a8731d8"
+checksum = "ff236accb9a5069572099f0b350a92e9560e8e63a9b8d546162f4a5e03026bb2"
 dependencies = [
- "bitflags 2.4.2",
+ "bitflags 2.5.0",
  "byteorder",
  "diesel_derives",
  "itoa",
@@ -1905,14 +1920,14 @@ dependencies = [
 
 [[package]]
 name = "diesel_derives"
-version = "2.1.2"
+version = "2.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef8337737574f55a468005a83499da720f20c65586241ffea339db9ecdfd2b44"
+checksum = "14701062d6bed917b5c7103bdffaee1e4609279e240488ad24e7bd979ca6866c"
 dependencies = [
  "diesel_table_macro_syntax",
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -1932,7 +1947,7 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc5557efc453706fed5e4fa85006fe9817c224c3f480a34c7e5959fd700921c5"
 dependencies = [
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -2013,7 +2028,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bac33cb3f99889a57e56a8c6ccb77aaf0cfc7787602b7af09783f736d77314e1"
 dependencies = [
  "aes 0.7.5",
- "aes-gcm 0.9.4",
+ "aes-gcm 0.9.2",
  "arrayvec",
  "delay_map",
  "enr",
@@ -2045,7 +2060,7 @@ checksum = "487585f4d0c6655fe74905e2504d8ad6908e4db67f744eb140876906c2f3175d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -2078,7 +2093,7 @@ version = "0.16.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
 dependencies = [
- "der 0.7.8",
+ "der 0.7.9",
  "digest 0.10.7",
  "elliptic-curve 0.13.8",
  "rfc6979 0.4.0",
@@ -2148,9 +2163,9 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.10.0"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a"
+checksum = "a47c1c47d2f5964e29c61246e81db715514cd532db6b5116a25ea3c03d6780a2"
 
 [[package]]
 name = "elliptic-curve"
@@ -2193,9 +2208,9 @@ dependencies = [
 
 [[package]]
 name = "encoding_rs"
-version = "0.8.33"
+version = "0.8.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7268b386296a025e474d5140678f75d6de9493ae55a5d709eeb9dd08149945e1"
+checksum = "b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59"
 dependencies = [
  "cfg-if",
 ]
@@ -2225,10 +2240,10 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5ffccbb6966c05b32ef8fbac435df276c4ae4d3dc55a8cd0eb9745e6c12f546a"
 dependencies = [
- "heck",
+ "heck 0.4.1",
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -2325,7 +2340,7 @@ dependencies = [
  "lazy_static",
  "lighthouse_metrics",
  "merkle_proof",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "reqwest",
  "sensitive_url",
  "serde",
@@ -2585,13 +2600,13 @@ dependencies = [
 
 [[package]]
 name = "ethereum_hashing"
-version = "1.0.0-beta.2"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "233dc6f434ce680dbabf4451ee3380cec46cb3c45d66660445a435619710dd35"
+checksum = "6ea7b408432c13f71af01197b1d3d0069c48a27bfcfbe72a81fc346e47f6defb"
 dependencies = [
  "cpufeatures",
  "lazy_static",
- "ring 0.16.20",
+ "ring 0.17.8",
  "sha2 0.10.8",
 ]
 
@@ -2735,7 +2750,7 @@ dependencies = [
  "getrandom",
  "hashers",
  "hex",
- "http 0.2.11",
+ "http 0.2.12",
  "once_cell",
  "parking_lot 0.11.2",
  "pin-project",
@@ -2831,8 +2846,9 @@ dependencies = [
  "kzg",
  "lazy_static",
  "lighthouse_metrics",
+ "lighthouse_version",
  "lru",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "pretty_reqwest_error",
  "rand",
  "reqwest",
@@ -2881,9 +2897,9 @@ checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
 
 [[package]]
 name = "fastrand"
-version = "2.0.1"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5"
+checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a"
 
 [[package]]
 name = "fastrlp"
@@ -2896,6 +2912,16 @@ dependencies = [
  "bytes",
 ]
 
+[[package]]
+name = "fdlimit"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e182f7dbc2ef73d9ef67351c5fbbea084729c48362d3ce9dd44c28e32e277fe5"
+dependencies = [
+ "libc",
+ "thiserror",
+]
+
 [[package]]
 name = "ff"
 version = "0.12.1"
@@ -2924,9 +2950,9 @@ checksum = "ec54ac60a7f2ee9a97cad9946f9bf629a3bc6a7ae59e68983dc9318f5a54b81a"
 
 [[package]]
 name = "fiat-crypto"
-version = "0.2.6"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1676f435fc1dadde4d03e43f5d62b259e1ce5f40bd4ffb21db2b42ebe59c1382"
+checksum = "38793c55593b33412e3ae40c2c9781ffaa6f438f6f8c10f24e71846fbd7ae01e"
 
 [[package]]
 name = "field-offset"
@@ -2979,9 +3005,9 @@ dependencies = [
 
 [[package]]
 name = "flate2"
-version = "1.0.28"
+version = "1.0.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e"
+checksum = "5f54427cfd1c7829e2a139fcefea601bf088ebca651d2bf53ebc600eac295dae"
 dependencies = [
  "crc32fast",
  "libz-sys",
@@ -3116,9 +3142,9 @@ checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
 
 [[package]]
 name = "futures-lite"
-version = "2.2.0"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "445ba825b27408685aaecefd65178908c36c6e96aaf6d8599419d46e624192ba"
+checksum = "52527eb5074e35e9339c6b4e8d12600c7128b68fb25dcb9fa9dec18f7c25f3a5"
 dependencies = [
  "futures-core",
  "pin-project-lite",
@@ -3132,7 +3158,7 @@ checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -3142,7 +3168,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "35bd3cf68c183738046838e300353e4716c674dc5e56890de4826801a6622a28"
 dependencies = [
  "futures-io",
- "rustls",
+ "rustls 0.21.12",
 ]
 
 [[package]]
@@ -3235,9 +3261,9 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.12"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "190092ea657667030ac6a35e305e62fc4dd69fd98ac98631e5d3a2b1575a12b5"
+checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
 dependencies = [
  "cfg-if",
  "js-sys",
@@ -3258,12 +3284,12 @@ dependencies = [
 
 [[package]]
 name = "ghash"
-version = "0.5.0"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d930750de5717d2dd0b8c0d42c076c0e884c81a73e6cab859bbd2339c71e3e40"
+checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1"
 dependencies = [
  "opaque-debug",
- "polyval 0.6.1",
+ "polyval 0.6.2",
 ]
 
 [[package]]
@@ -3289,7 +3315,7 @@ checksum = "53010ccb100b96a67bc32c0175f0ed1426b31b655d562898e57325f81c023ac0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -3362,27 +3388,8 @@ dependencies = [
  "futures-core",
  "futures-sink",
  "futures-util",
- "http 0.2.11",
- "indexmap 2.2.5",
- "slab",
- "tokio",
- "tokio-util 0.7.10",
- "tracing",
-]
-
-[[package]]
-name = "h2"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "816ec7294445779408f36fe57bc5b7fc1cf59664059096c65f905c1c61f58069"
-dependencies = [
- "bytes",
- "fnv",
- "futures-core",
- "futures-sink",
- "futures-util",
- "http 1.0.0",
- "indexmap 2.2.5",
+ "http 0.2.12",
+ "indexmap 2.2.6",
  "slab",
  "tokio",
  "tokio-util 0.7.10",
@@ -3418,18 +3425,9 @@ checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 
 [[package]]
 name = "hashbrown"
-version = "0.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
-dependencies = [
- "ahash",
-]
-
-[[package]]
-name = "hashbrown"
-version = "0.14.3"
+version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 dependencies = [
  "ahash",
  "allocator-api2",
@@ -3450,7 +3448,7 @@ version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e8094feaf31ff591f651a2664fb9cfd92bba7a60ce3197265e9482ebe753c8f7"
 dependencies = [
- "hashbrown 0.14.3",
+ "hashbrown 0.14.5",
 ]
 
 [[package]]
@@ -3462,7 +3460,7 @@ dependencies = [
  "base64 0.21.7",
  "bytes",
  "headers-core",
- "http 0.2.11",
+ "http 0.2.12",
  "httpdate",
  "mime",
  "sha1",
@@ -3474,7 +3472,7 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e7f66481bfee273957b1f20485a4ff3362987f85b2c236580d81b4eb7a326429"
 dependencies = [
- "http 0.2.11",
+ "http 0.2.12",
 ]
 
 [[package]]
@@ -3483,6 +3481,12 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
 
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
 [[package]]
 name = "hermit-abi"
 version = "0.1.19"
@@ -3521,9 +3525,9 @@ checksum = "b07f60793ff0a4d9cef0f18e63b5357e06209987153a64648c972c1e5aff336f"
 
 [[package]]
 name = "hickory-proto"
-version = "0.24.0"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "091a6fbccf4860009355e3efc52ff4acf37a63489aad7435372d44ceeb6fbbcf"
+checksum = "07698b8420e2f0d6447a436ba999ec85d8fbf2a398bbd737b82cac4a2e96e512"
 dependencies = [
  "async-trait",
  "cfg-if",
@@ -3536,7 +3540,7 @@ dependencies = [
  "ipnet",
  "once_cell",
  "rand",
- "socket2 0.5.6",
+ "socket2 0.5.7",
  "thiserror",
  "tinyvec",
  "tokio",
@@ -3546,9 +3550,9 @@ dependencies = [
 
 [[package]]
 name = "hickory-resolver"
-version = "0.24.0"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35b8f021164e6a984c9030023544c57789c51760065cd510572fedcfb04164e8"
+checksum = "28757f23aa75c98f254cf0405e6d8c25b831b32921b050a66692427679b1f243"
 dependencies = [
  "cfg-if",
  "futures-util",
@@ -3556,7 +3560,7 @@ dependencies = [
  "ipconfig",
  "lru-cache",
  "once_cell",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "rand",
  "resolv-conf",
  "smallvec",
@@ -3590,7 +3594,7 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2a2a2320eb7ec0ebe8da8f744d7812d9fc4cb4d09344ac01898dbcb6a20ae69b"
 dependencies = [
- "crypto-mac 0.11.1",
+ "crypto-mac 0.11.0",
  "digest 0.9.0",
 ]
 
@@ -3614,15 +3618,6 @@ dependencies = [
  "hmac 0.8.1",
 ]
 
-[[package]]
-name = "home"
-version = "0.5.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
-dependencies = [
- "windows-sys 0.52.0",
-]
-
 [[package]]
 name = "hostname"
 version = "0.3.1"
@@ -3636,9 +3631,9 @@ dependencies = [
 
 [[package]]
 name = "http"
-version = "0.2.11"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8947b1a6fad4393052c7ba1f4cd97bed3e953a95c79c92ad9b051a04611d9fbb"
+checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
 dependencies = [
  "bytes",
  "fnv",
@@ -3647,9 +3642,9 @@ dependencies = [
 
 [[package]]
 name = "http"
-version = "1.0.0"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b32afd38673a8016f7c9ae69e5af41a58f81b1d31689040f2f1959594ce194ea"
+checksum = "21b9ddb458710bc376481b842f5da65cdf31522de232c1ca8146abce2a358258"
 dependencies = [
  "bytes",
  "fnv",
@@ -3663,7 +3658,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
 dependencies = [
  "bytes",
- "http 0.2.11",
+ "http 0.2.12",
  "pin-project-lite",
 ]
 
@@ -3674,18 +3669,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1cac85db508abc24a2e48553ba12a996e87244a0395ce011e62b37158745d643"
 dependencies = [
  "bytes",
- "http 1.0.0",
+ "http 1.1.0",
 ]
 
 [[package]]
 name = "http-body-util"
-version = "0.1.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41cb79eb393015dadd30fc252023adb0b2400a0caee0fa2a077e6e21a551e840"
+checksum = "0475f8b2ac86659c21b64320d5d653f9efe42acd2a4e560073ec61a155a34f1d"
 dependencies = [
  "bytes",
- "futures-util",
- "http 1.0.0",
+ "futures-core",
+ "http 1.1.0",
  "http-body 1.0.0",
  "pin-project-lite",
 ]
@@ -3716,7 +3711,7 @@ dependencies = [
  "lru",
  "network",
  "operation_pool",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "proto_array",
  "safe_arith",
  "sensitive_url",
@@ -3786,14 +3781,14 @@ dependencies = [
  "futures-channel",
  "futures-core",
  "futures-util",
- "h2 0.3.26",
- "http 0.2.11",
+ "h2",
+ "http 0.2.12",
  "http-body 0.4.6",
  "httparse",
  "httpdate",
  "itoa",
  "pin-project-lite",
- "socket2 0.4.10",
+ "socket2 0.5.7",
  "tokio",
  "tower-service",
  "tracing",
@@ -3802,15 +3797,14 @@ dependencies = [
 
 [[package]]
 name = "hyper"
-version = "1.2.0"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "186548d73ac615b32a73aafe38fb4f56c0d340e110e5a200bcadbaf2e199263a"
+checksum = "fe575dd17d0862a9a33781c8c4696a55c320909004a67a00fb286ba8b1bc496d"
 dependencies = [
  "bytes",
  "futures-channel",
  "futures-util",
- "h2 0.4.4",
- "http 1.0.0",
+ "http 1.1.0",
  "http-body 1.0.0",
  "httparse",
  "httpdate",
@@ -3827,11 +3821,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
 dependencies = [
  "futures-util",
- "http 0.2.11",
+ "http 0.2.12",
  "hyper 0.14.28",
- "rustls",
+ "rustls 0.21.12",
  "tokio",
- "tokio-rustls",
+ "tokio-rustls 0.24.1",
 ]
 
 [[package]]
@@ -3855,11 +3849,11 @@ checksum = "ca38ef113da30126bbff9cd1705f9273e15d45498615d138b0c20279ac7a76aa"
 dependencies = [
  "bytes",
  "futures-util",
- "http 1.0.0",
+ "http 1.1.0",
  "http-body 1.0.0",
- "hyper 1.2.0",
+ "hyper 1.3.1",
  "pin-project-lite",
- "socket2 0.5.6",
+ "socket2 0.5.7",
  "tokio",
 ]
 
@@ -3951,7 +3945,7 @@ dependencies = [
  "attohttpc",
  "bytes",
  "futures",
- "http 0.2.11",
+ "http 0.2.12",
  "hyper 0.14.28",
  "log",
  "rand",
@@ -4034,12 +4028,12 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.2.5"
+version = "2.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b0b929d511467233429c45a44ac1dcaa21ba0f5ba11e4879e6ed28ddb4f9df4"
+checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
 dependencies = [
  "equivalent",
- "hashbrown 0.14.3",
+ "hashbrown 0.14.5",
 ]
 
 [[package]]
@@ -4069,7 +4063,7 @@ version = "0.2.0"
 dependencies = [
  "bytes",
  "hex",
- "yaml-rust",
+ "yaml-rust2",
 ]
 
 [[package]]
@@ -4098,8 +4092,8 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b58db92f96b720de98181bbbe63c831e87005ab460c1bf306eb2622b4707997f"
 dependencies = [
- "socket2 0.5.6",
- "widestring 1.0.2",
+ "socket2 0.5.7",
+ "widestring 1.1.0",
  "windows-sys 0.48.0",
  "winreg",
 ]
@@ -4132,9 +4126,9 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.10"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c"
+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "jemalloc-ctl"
@@ -4169,18 +4163,18 @@ dependencies = [
 
 [[package]]
 name = "jobserver"
-version = "0.1.28"
+version = "0.1.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab46a6e9526ddef3ae7f787c06f0f2600639ba80ea3eade3d8e670a2230f51d6"
+checksum = "d2b099aaa34a9751c5bf0878add70444e1ed2dd73f347be99003d4577277de6e"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "js-sys"
-version = "0.3.68"
+version = "0.3.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "406cda4b368d531c842222cf9d2600a9a4acce8d29423695379c6868a143a9ee"
+checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
 dependencies = [
  "wasm-bindgen",
 ]
@@ -4351,15 +4345,15 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.153"
+version = "0.2.154"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
+checksum = "ae743338b92ff9146ce83992f766a31066a91a8c84a45e0e9f21e7cf6de6d346"
 
 [[package]]
 name = "libflate"
-version = "2.0.0"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f7d5654ae1795afc7ff76f4365c2c8791b0feb18e8996a96adad8ffd7c3b2bf"
+checksum = "45d9dfdc14ea4ef0900c1cddbc8dcd553fbaacd8a4a282cf4018ae9dd04fb21e"
 dependencies = [
  "adler32",
  "core2",
@@ -4370,23 +4364,23 @@ dependencies = [
 
 [[package]]
 name = "libflate_lz77"
-version = "2.0.0"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be5f52fb8c451576ec6b79d3f4deb327398bc05bbdbd99021a6e77a4c855d524"
+checksum = "e6e0d73b369f386f1c44abd9c570d5318f55ccde816ff4b562fa452e5182863d"
 dependencies = [
  "core2",
- "hashbrown 0.13.2",
+ "hashbrown 0.14.5",
  "rle-decode-fast",
 ]
 
 [[package]]
 name = "libloading"
-version = "0.8.2"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2caa5afb8bf9f3a2652760ce7d4f62d21c4d5a423e68466fca30df82f2330164"
+checksum = "0c2a198fb6b0eada2a8df47933734e6d35d350665a33a3593d7164fa52c75c19"
 dependencies = [
  "cfg-if",
- "windows-targets 0.52.4",
+ "windows-targets 0.52.5",
 ]
 
 [[package]]
@@ -4406,7 +4400,7 @@ dependencies = [
  "indexmap 1.9.3",
  "libc",
  "mdbx-sys",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "thiserror",
 ]
 
@@ -4483,7 +4477,7 @@ dependencies = [
  "multihash",
  "multistream-select",
  "once_cell",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "pin-project",
  "quick-protobuf",
  "rand",
@@ -4506,16 +4500,16 @@ dependencies = [
  "hickory-resolver",
  "libp2p-core",
  "libp2p-identity",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "smallvec",
  "tracing",
 ]
 
 [[package]]
 name = "libp2p-identify"
-version = "0.44.1"
+version = "0.44.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20499a945d2f0221fdc6269b3848892c0f370d2ee3e19c7f65a29d8f860f6126"
+checksum = "b5d635ebea5ca0c3c3e77d414ae9b67eccf2a822be06091b9c1a0d13029a1e2f"
 dependencies = [
  "asynchronous-codec 0.7.0",
  "either",
@@ -4541,7 +4535,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "999ec70441b2fb35355076726a6bc466c932e9bdc66f6a11c6c0aa17c7ab9be0"
 dependencies = [
  "asn1_der",
- "bs58 0.5.0",
+ "bs58 0.5.1",
  "ed25519-dalek",
  "hkdf",
  "libsecp256k1",
@@ -4572,7 +4566,7 @@ dependencies = [
  "libp2p-swarm",
  "rand",
  "smallvec",
- "socket2 0.5.6",
+ "socket2 0.5.7",
  "tokio",
  "tracing",
  "void",
@@ -4606,7 +4600,7 @@ dependencies = [
  "libp2p-core",
  "libp2p-identity",
  "nohash-hasher",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "rand",
  "smallvec",
  "tracing",
@@ -4668,12 +4662,12 @@ dependencies = [
  "libp2p-core",
  "libp2p-identity",
  "libp2p-tls",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "quinn",
  "rand",
  "ring 0.16.20",
- "rustls",
- "socket2 0.5.6",
+ "rustls 0.21.12",
+ "socket2 0.5.7",
  "thiserror",
  "tokio",
  "tracing",
@@ -4681,9 +4675,9 @@ dependencies = [
 
 [[package]]
 name = "libp2p-swarm"
-version = "0.44.1"
+version = "0.44.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e92532fc3c4fb292ae30c371815c9b10103718777726ea5497abc268a4761866"
+checksum = "80cae6cb75f89dbca53862f9ebe0b9f463aa7b302762fcfaafb9e51dcc9b0f7e"
 dependencies = [
  "either",
  "fnv",
@@ -4693,6 +4687,7 @@ dependencies = [
  "libp2p-core",
  "libp2p-identity",
  "libp2p-swarm-derive",
+ "lru",
  "multistream-select",
  "once_cell",
  "rand",
@@ -4704,14 +4699,14 @@ dependencies = [
 
 [[package]]
 name = "libp2p-swarm-derive"
-version = "0.34.1"
+version = "0.34.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b644268b4acfdaa6a6100b31226ee7a36d96ab4c43287d113bfd2308607d8b6f"
+checksum = "5daceb9dd908417b6dfcfe8e94098bc4aac54500c282e78120b885dadc09b999"
 dependencies = [
- "heck",
+ "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -4726,7 +4721,7 @@ dependencies = [
  "libc",
  "libp2p-core",
  "libp2p-identity",
- "socket2 0.5.6",
+ "socket2 0.5.7",
  "tokio",
  "tracing",
 ]
@@ -4743,8 +4738,8 @@ dependencies = [
  "libp2p-identity",
  "rcgen",
  "ring 0.16.20",
- "rustls",
- "rustls-webpki",
+ "rustls 0.21.12",
+ "rustls-webpki 0.101.7",
  "thiserror",
  "x509-parser",
  "yasna",
@@ -4752,9 +4747,9 @@ dependencies = [
 
 [[package]]
 name = "libp2p-upnp"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b49cc89949bf0e06869297cd4fe2c132358c23fe93e76ad43950453df4da3d35"
+checksum = "cccf04b0e3ff3de52d07d5fd6c3b061d0e7f908ffc683c32d9638caedce86fc8"
 dependencies = [
  "futures",
  "futures-timer",
@@ -4778,18 +4773,17 @@ dependencies = [
  "thiserror",
  "tracing",
  "yamux 0.12.1",
- "yamux 0.13.1",
+ "yamux 0.13.2",
 ]
 
 [[package]]
 name = "libredox"
-version = "0.0.1"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85c833ca1e66078851dba29046874e38f08b2c883700aa29a03ddd3b23814ee8"
+checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
 dependencies = [
- "bitflags 2.4.2",
+ "bitflags 2.5.0",
  "libc",
- "redox_syscall 0.4.1",
 ]
 
 [[package]]
@@ -4853,9 +4847,9 @@ dependencies = [
 
 [[package]]
 name = "libz-sys"
-version = "1.1.15"
+version = "1.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "037731f5d3aaa87a5675e895b63ddff1a87624bc29f77004ea829809654e48f6"
+checksum = "5e143b5e666b2695d28f6bca6497720813f699c9602dd7f5cac91008b8ada7f9"
 dependencies = [
  "cc",
  "pkg-config",
@@ -4945,7 +4939,7 @@ dependencies = [
  "lighthouse_version",
  "lru",
  "lru_cache",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "prometheus-client",
  "quickcheck",
  "quickcheck_macros",
@@ -5026,9 +5020,9 @@ dependencies = [
 
 [[package]]
 name = "lock_api"
-version = "0.4.11"
+version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45"
+checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17"
 dependencies = [
  "autocfg",
  "scopeguard",
@@ -5055,7 +5049,7 @@ dependencies = [
  "chrono",
  "lazy_static",
  "lighthouse_metrics",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "serde",
  "serde_json",
  "slog",
@@ -5077,7 +5071,7 @@ version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3262e75e648fce39813cb56ac41f3c3e3f65217ebf3844d818d1f9398cfb0dc"
 dependencies = [
- "hashbrown 0.14.3",
+ "hashbrown 0.14.5",
 ]
 
 [[package]]
@@ -5115,7 +5109,7 @@ dependencies = [
  "lazy_static",
  "libc",
  "lighthouse_metrics",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
 ]
 
 [[package]]
@@ -5166,7 +5160,7 @@ name = "mdbx-sys"
 version = "0.11.6-4"
 source = "git+https://github.com/sigp/libmdbx-rs?tag=v0.1.4#096da80a83d14343f8df833006483f48075cd135"
 dependencies = [
- "bindgen 0.59.2",
+ "bindgen",
  "cc",
  "cmake",
  "libc",
@@ -5180,15 +5174,15 @@ checksum = "8878cd8d1b3c8c8ae4b2ba0a36652b7cf192f618a599a7fbdfa25cffd4ea72dd"
 
 [[package]]
 name = "memchr"
-version = "2.7.1"
+version = "2.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
+checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"
 
 [[package]]
 name = "memoffset"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a634b1c61a95585bd15607c6ab0c4e5b226e695ff2800ba0cdccddf208c406c"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
 dependencies = [
  "autocfg",
 ]
@@ -5249,6 +5243,29 @@ dependencies = [
  "quote",
 ]
 
+[[package]]
+name = "milhouse"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3826d3602a3674b07e080ce1982350e454ec253d73f156bd927ac1b652293f4d"
+dependencies = [
+ "arbitrary",
+ "derivative",
+ "ethereum-types 0.14.1",
+ "ethereum_hashing",
+ "ethereum_ssz",
+ "ethereum_ssz_derive",
+ "itertools",
+ "parking_lot 0.12.2",
+ "rayon",
+ "serde",
+ "smallvec",
+ "tree_hash",
+ "triomphe",
+ "typenum",
+ "vec_map",
+]
+
 [[package]]
 name = "mime"
 version = "0.3.17"
@@ -5449,9 +5466,9 @@ dependencies = [
 
 [[package]]
 name = "netlink-sys"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6471bf08e7ac0135876a9581bf3217ef0333c191c128d34878079f42ee150411"
+checksum = "416060d346fbaf1f23f9512963e3e878f1a78e707cb699ba9215761754244307"
 dependencies = [
  "bytes",
  "futures",
@@ -5492,7 +5509,7 @@ dependencies = [
  "matches",
  "num_cpus",
  "operation_pool",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "rand",
  "rlp",
  "slog",
@@ -5524,12 +5541,13 @@ dependencies = [
 
 [[package]]
 name = "nix"
-version = "0.27.1"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2eb04e9c688eff1c89d72b407f168cf79bb9e867a9d3323ed6c01519eb9cc053"
+checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4"
 dependencies = [
- "bitflags 2.4.2",
+ "bitflags 2.5.0",
  "cfg-if",
+ "cfg_aliases",
  "libc",
 ]
 
@@ -5687,7 +5705,7 @@ checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
 name = "oneshot_broadcast"
 version = "0.1.0"
 dependencies = [
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
 ]
 
 [[package]]
@@ -5733,7 +5751,7 @@ version = "0.10.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95a0481286a310808298130d22dd1fef0fa571e05a8f44ec801801e84b216b1f"
 dependencies = [
- "bitflags 2.4.2",
+ "bitflags 2.5.0",
  "cfg-if",
  "foreign-types",
  "libc",
@@ -5750,7 +5768,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -5770,9 +5788,9 @@ dependencies = [
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.101"
+version = "0.9.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dda2b0f344e78efc2facf7d195d098df0dd72151b26ab98da807afc26c198dff"
+checksum = "c597637d56fbc83893a35eb0dd04b2b8e7a50c91e64e9493e398b5df4fb45fa2"
 dependencies = [
  "cc",
  "libc",
@@ -5794,7 +5812,7 @@ dependencies = [
  "lazy_static",
  "lighthouse_metrics",
  "maplit",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "rand",
  "rayon",
  "serde",
@@ -5893,12 +5911,12 @@ dependencies = [
 
 [[package]]
 name = "parking_lot"
-version = "0.12.1"
+version = "0.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
+checksum = "7e4af0ca4f6caed20e900d564c242b8e5d4903fdacf31d3daf527b66fe6f42fb"
 dependencies = [
  "lock_api",
- "parking_lot_core 0.9.9",
+ "parking_lot_core 0.9.10",
 ]
 
 [[package]]
@@ -5917,15 +5935,15 @@ dependencies = [
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.9"
+version = "0.9.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e"
+checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
 dependencies = [
  "cfg-if",
  "libc",
- "redox_syscall 0.4.1",
+ "redox_syscall 0.5.1",
  "smallvec",
- "windows-targets 0.48.5",
+ "windows-targets 0.52.5",
 ]
 
 [[package]]
@@ -5951,7 +5969,7 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d95f5254224e617595d2cc3cc73ff0a5eaf2637519e25f03388154e9378b6ffa"
 dependencies = [
- "crypto-mac 0.11.1",
+ "crypto-mac 0.11.0",
 ]
 
 [[package]]
@@ -5983,11 +6001,11 @@ dependencies = [
 
 [[package]]
 name = "pem"
-version = "3.0.3"
+version = "3.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b8fcc794035347fb64beda2d3b462595dd2753e3f268d89c5aae77e8cf2c310"
+checksum = "8e459365e590736a54c3fa561947c84837534b8e9af6fc5bf781307e82658fae"
 dependencies = [
- "base64 0.21.7",
+ "base64 0.22.1",
  "serde",
 ]
 
@@ -6008,9 +6026,9 @@ checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
 
 [[package]]
 name = "pest"
-version = "2.7.8"
+version = "2.7.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56f8023d0fb78c8e03784ea1c7f3fa36e68a723138990b8d5a47d916b651e7a8"
+checksum = "560131c633294438da9f7c4b08189194b20946c8274c6b9e38881a7874dc8ee8"
 dependencies = [
  "memchr",
  "thiserror",
@@ -6047,29 +6065,29 @@ dependencies = [
 
 [[package]]
 name = "pin-project"
-version = "1.1.4"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0302c4a0442c456bd56f841aee5c3bfd17967563f6fadc9ceb9f9c23cf3807e0"
+checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3"
 dependencies = [
  "pin-project-internal",
 ]
 
 [[package]]
 name = "pin-project-internal"
-version = "1.1.4"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "266c042b60c9c76b8d53061e52b2e0d1116abc57cefc8c5cd671619a56ac3690"
+checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.13"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58"
+checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
 
 [[package]]
 name = "pin-utils"
@@ -6093,7 +6111,7 @@ version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
 dependencies = [
- "der 0.7.8",
+ "der 0.7.9",
  "spki 0.7.3",
 ]
 
@@ -6111,9 +6129,9 @@ checksum = "e8d0eef3571242013a0d5dc84861c3ae4a652e56e12adf8bdc26ff5f8cb34c94"
 
 [[package]]
 name = "platforms"
-version = "3.3.0"
+version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "626dec3cac7cc0e1577a2ec3fc496277ec2baa084bebad95bb6fdbfae235f84c"
+checksum = "db23d408679286588f4d4644f965003d056e3dd5abcaaa938116871d7ce2fee7"
 
 [[package]]
 name = "plotters"
@@ -6145,14 +6163,15 @@ dependencies = [
 
 [[package]]
 name = "polling"
-version = "3.5.0"
+version = "3.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24f040dee2588b4963afb4e420540439d126f73fdacf4a9c486a96d840bac3c9"
+checksum = "645493cf344456ef24219d02a768cf1fb92ddf8c92161679ae3d91b91a637be3"
 dependencies = [
  "cfg-if",
  "concurrent-queue",
+ "hermit-abi 0.3.9",
  "pin-project-lite",
- "rustix 0.38.31",
+ "rustix 0.38.34",
  "tracing",
  "windows-sys 0.52.0",
 ]
@@ -6177,14 +6196,14 @@ dependencies = [
  "cfg-if",
  "cpufeatures",
  "opaque-debug",
- "universal-hash 0.4.1",
+ "universal-hash 0.4.0",
 ]
 
 [[package]]
 name = "polyval"
-version = "0.6.1"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d52cff9d1d4dee5fe6d03729099f4a310a41179e0a10dbf542039873f2e826fb"
+checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25"
 dependencies = [
  "cfg-if",
  "cpufeatures",
@@ -6250,16 +6269,6 @@ dependencies = [
  "sensitive_url",
 ]
 
-[[package]]
-name = "prettyplease"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a41cf62165e97c7f814d2221421dbb9afcbcdb0a88068e5ea206e19951c2cbb5"
-dependencies = [
- "proc-macro2",
- "syn 2.0.52",
-]
-
 [[package]]
 name = "primeorder"
 version = "0.13.6"
@@ -6317,9 +6326,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.78"
+version = "1.0.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2422ad645d89c99f8f3e6b88a9fdeca7fabeac836b1002371c4367c8f984aae"
+checksum = "3d1597b0c024618f09a9c3b8655b7e430397a36d23fdafec26d6965e9eec3eba"
 dependencies = [
  "unicode-ident",
 ]
@@ -6349,20 +6358,20 @@ dependencies = [
  "fnv",
  "lazy_static",
  "memchr",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "protobuf",
  "thiserror",
 ]
 
 [[package]]
 name = "prometheus-client"
-version = "0.22.1"
+version = "0.22.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f87c10af16e0af74010d2a123d202e8363c04db5acfa91d8747f64a8524da3a"
+checksum = "c1ca959da22a332509f2a73ae9e5f23f9dcfc31fd3a54d71f159495bd5909baa"
 dependencies = [
  "dtoa",
  "itoa",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "prometheus-client-derive-encode",
 ]
 
@@ -6374,7 +6383,7 @@ checksum = "440f724eba9f6996b75d63681b0a92b06947f1457076d503a4d2e2c8f56442b8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -6385,13 +6394,13 @@ checksum = "31b476131c3c86cb68032fdc5cb6d5a1045e3e42d96b69fa599fd77701e1f5bf"
 dependencies = [
  "bit-set",
  "bit-vec",
- "bitflags 2.4.2",
+ "bitflags 2.5.0",
  "lazy_static",
  "num-traits",
  "rand",
  "rand_chacha",
  "rand_xorshift",
- "regex-syntax 0.8.2",
+ "regex-syntax 0.8.3",
  "rusty-fork",
  "tempfile",
  "unarray",
@@ -6510,7 +6519,7 @@ dependencies = [
  "quinn-proto",
  "quinn-udp",
  "rustc-hash",
- "rustls",
+ "rustls 0.21.12",
  "thiserror",
  "tokio",
  "tracing",
@@ -6526,7 +6535,7 @@ dependencies = [
  "rand",
  "ring 0.16.20",
  "rustc-hash",
- "rustls",
+ "rustls 0.21.12",
  "slab",
  "thiserror",
  "tinyvec",
@@ -6541,16 +6550,16 @@ checksum = "055b4e778e8feb9f93c4e439f71dc2156ef13360b432b799e179a8c4cdf0b1d7"
 dependencies = [
  "bytes",
  "libc",
- "socket2 0.5.6",
+ "socket2 0.5.7",
  "tracing",
  "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.35"
+version = "1.0.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
+checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
 dependencies = [
  "proc-macro2",
 ]
@@ -6562,7 +6571,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "51de85fb3fb6524929c8a2eb85e6b6d363de4e8c48f9e2c2eac4944abc181c93"
 dependencies = [
  "log",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "scheduled-thread-pool",
 ]
 
@@ -6629,9 +6638,9 @@ dependencies = [
 
 [[package]]
 name = "rayon"
-version = "1.9.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4963ed1bc86e4f3ee217022bd855b297cef07fb9eac5dfa1f788b220b49b3bd"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
 dependencies = [
  "either",
  "rayon-core",
@@ -6653,7 +6662,7 @@ version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52c4f3084aa3bc7dfbba4eff4fab2a54db4324965d8872ab933565e6fbd83bc6"
 dependencies = [
- "pem 3.0.3",
+ "pem 3.0.4",
  "ring 0.16.20",
  "time",
  "yasna",
@@ -6677,11 +6686,20 @@ dependencies = [
  "bitflags 1.3.2",
 ]
 
+[[package]]
+name = "redox_syscall"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "469052894dcb553421e483e4209ee581a45100d31b4018de03e5a7ad86374a7e"
+dependencies = [
+ "bitflags 2.5.0",
+]
+
 [[package]]
 name = "redox_users"
-version = "0.4.4"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a18479200779601e498ada4e8c1e1f50e3ee19deb0259c25825a98b5603b2cb4"
+checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891"
 dependencies = [
  "getrandom",
  "libredox",
@@ -6690,14 +6708,14 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.10.3"
+version = "1.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
+checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.4.5",
- "regex-syntax 0.8.2",
+ "regex-automata 0.4.6",
+ "regex-syntax 0.8.3",
 ]
 
 [[package]]
@@ -6711,13 +6729,13 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5bb987efffd3c6d0d8f5f89510bb458559eab11e4f869acb20bf845e016259cd"
+checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax 0.8.2",
+ "regex-syntax 0.8.3",
 ]
 
 [[package]]
@@ -6728,23 +6746,23 @@ checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.2"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
+checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56"
 
 [[package]]
 name = "reqwest"
-version = "0.11.24"
+version = "0.11.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6920094eb85afde5e4a138be3f2de8bbdf28000f0029e72c45025a56b042251"
+checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62"
 dependencies = [
  "base64 0.21.7",
  "bytes",
  "encoding_rs",
  "futures-core",
  "futures-util",
- "h2 0.3.26",
- "http 0.2.11",
+ "h2",
+ "http 0.2.12",
  "http-body 0.4.6",
  "hyper 0.14.28",
  "hyper-rustls",
@@ -6757,16 +6775,16 @@ dependencies = [
  "once_cell",
  "percent-encoding",
  "pin-project-lite",
- "rustls",
- "rustls-pemfile",
+ "rustls 0.21.12",
+ "rustls-pemfile 1.0.4",
  "serde",
  "serde_json",
  "serde_urlencoded",
- "sync_wrapper",
+ "sync_wrapper 0.1.2",
  "system-configuration",
  "tokio",
  "tokio-native-tls",
- "tokio-rustls",
+ "tokio-rustls 0.24.1",
  "tokio-util 0.7.10",
  "tower-service",
  "url",
@@ -6876,6 +6894,15 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "rpds"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ef5140bcb576bfd6d56cd2de709a7d17851ac1f3805e67fe9d99e42a11821f"
+dependencies = [
+ "archery",
+]
+
 [[package]]
 name = "rtnetlink"
 version = "0.10.1"
@@ -6893,9 +6920,9 @@ dependencies = [
 
 [[package]]
 name = "ruint"
-version = "1.12.0"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49b1d9521f889713d1221270fdd63370feca7e5c71a18745343402fa86e4f04f"
+checksum = "8f308135fef9fc398342da5472ce7c484529df23743fb7c734e0f3d472971e62"
 dependencies = [
  "alloy-rlp",
  "ark-ff 0.3.0",
@@ -6996,11 +7023,11 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.38.31"
+version = "0.38.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ea3e1a662af26cd7a3ba09c0297a31af215563ecf42817c98df621387f4e949"
+checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
 dependencies = [
- "bitflags 2.4.2",
+ "bitflags 2.5.0",
  "errno",
  "libc",
  "linux-raw-sys 0.4.13",
@@ -7009,16 +7036,30 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.21.10"
+version = "0.21.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9d5a6813c0759e4609cd494e8e725babae6a2ca7b62a5536a13daaec6fcb7ba"
+checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
 dependencies = [
  "log",
  "ring 0.17.8",
- "rustls-webpki",
+ "rustls-webpki 0.101.7",
  "sct",
 ]
 
+[[package]]
+name = "rustls"
+version = "0.22.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf4ef73721ac7bcd79b2b315da7779d8fc09718c6b3d2d1b2d94850eb8c18432"
+dependencies = [
+ "log",
+ "ring 0.17.8",
+ "rustls-pki-types",
+ "rustls-webpki 0.102.3",
+ "subtle",
+ "zeroize",
+]
+
 [[package]]
 name = "rustls-pemfile"
 version = "1.0.4"
@@ -7028,6 +7069,22 @@ dependencies = [
  "base64 0.21.7",
 ]
 
+[[package]]
+name = "rustls-pemfile"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29993a25686778eb88d4189742cd713c9bce943bc54251a33509dc63cbacf73d"
+dependencies = [
+ "base64 0.22.1",
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "beb461507cee2c2ff151784c52762cf4d9ff6a61f3e80968600ed24fa837fa54"
+
 [[package]]
 name = "rustls-webpki"
 version = "0.101.7"
@@ -7038,11 +7095,22 @@ dependencies = [
  "untrusted 0.9.0",
 ]
 
+[[package]]
+name = "rustls-webpki"
+version = "0.102.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3bce581c0dd41bce533ce695a1437fa16a7ab5ac3ccfa99fe1a620a7885eabf"
+dependencies = [
+ "ring 0.17.8",
+ "rustls-pki-types",
+ "untrusted 0.9.0",
+]
+
 [[package]]
 name = "rustversion"
-version = "1.0.14"
+version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
+checksum = "80af6f9131f277a45a3fba6ce8e2258037bb0477a67e610d3c1fe046ab31de47"
 
 [[package]]
 name = "rusty-fork"
@@ -7097,9 +7165,9 @@ dependencies = [
 
 [[package]]
 name = "scale-info"
-version = "2.10.0"
+version = "2.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f7d66a1128282b7ef025a8ead62a4a9fcf017382ec53b8ffbf4d7bf77bd3c60"
+checksum = "7c453e59a955f81fb62ee5d596b450383d699f152d350e9d23a0db2adb78e4c0"
 dependencies = [
  "cfg-if",
  "derive_more",
@@ -7109,9 +7177,9 @@ dependencies = [
 
 [[package]]
 name = "scale-info-derive"
-version = "2.10.0"
+version = "2.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abf2c68b89cafb3b8d918dd07b42be0da66ff202cf1155c5739a4e0c1ea0dc19"
+checksum = "18cf6c6447f813ef19eb450e985bcce6705f9ce7660db221b59093d15c79c4b7"
 dependencies = [
  "proc-macro-crate 1.3.1",
  "proc-macro2",
@@ -7134,7 +7202,7 @@ version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3cbc66816425a074528352f5789333ecff06ca41b36b0b0efdfbb29edc391a19"
 dependencies = [
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
 ]
 
 [[package]]
@@ -7192,7 +7260,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
 dependencies = [
  "base16ct 0.2.0",
- "der 0.7.8",
+ "der 0.7.9",
  "generic-array",
  "pkcs8 0.10.2",
  "subtle",
@@ -7201,9 +7269,9 @@ dependencies = [
 
 [[package]]
 name = "security-framework"
-version = "2.9.2"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05b64fb303737d99b81884b2c63433e9ae28abebe5eb5045dcdd175dc2ecf4de"
+checksum = "770452e37cad93e0a50d5abc3990d2bc351c36d0328f86cefec2f2fb206eaef6"
 dependencies = [
  "bitflags 1.3.2",
  "core-foundation",
@@ -7214,9 +7282,9 @@ dependencies = [
 
 [[package]]
 name = "security-framework-sys"
-version = "2.9.1"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e932934257d3b408ed8f30db49d85ea163bfe74961f017f405b025af298f0c7a"
+checksum = "41f3cc463c0ef97e11c3461a9d3787412d30e8e7eb907c79180c4a57bf7c04ef"
 dependencies = [
  "core-foundation-sys",
  "libc",
@@ -7265,9 +7333,9 @@ dependencies = [
 
 [[package]]
 name = "serde"
-version = "1.0.197"
+version = "1.0.200"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fb1c873e1b9b056a4dc4c0c198b24c3ffa059243875552b2bd0933b1aee4ce2"
+checksum = "ddc6f9cc94d67c0e21aaf7eda3a010fd3af78ebf6e096aa6e2e13c79749cce4f"
 dependencies = [
  "serde_derive",
 ]
@@ -7294,20 +7362,20 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.197"
+version = "1.0.200"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7eb0b34b42edc17f6b7cac84a52a1c5f0e1bb2227e997ca9011ea3dd34e8610b"
+checksum = "856f046b9400cee3c8c94ed572ecdb752444c24528c035cd35882aad6f492bcb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.114"
+version = "1.0.116"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5f09b1bd632ef549eaa9f60a1f8de742bdbc698e6cee2095fc84dde5f549ae0"
+checksum = "3e17db7126d17feb94eb3fad46bf1a96b034e8aacbc2e775fe81505f8b0b2813"
 dependencies = [
  "itoa",
  "ryu",
@@ -7316,9 +7384,9 @@ dependencies = [
 
 [[package]]
 name = "serde_path_to_error"
-version = "0.1.15"
+version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebd154a240de39fdebcf5775d2675c204d7c13cf39a4c697be6493c8e734337c"
+checksum = "af99884400da37c88f5e9146b7f1fd0fbcae8f6eec4e9da38b67d05486f814a6"
 dependencies = [
  "itoa",
  "serde",
@@ -7326,13 +7394,13 @@ dependencies = [
 
 [[package]]
 name = "serde_repr"
-version = "0.1.18"
+version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b2e6b945e9d3df726b65d6ee24060aff8e3533d431f677a9695db04eff9dfdb"
+checksum = "6c64451ba24fc7a6a2d60fc75dd9c83c90903b19028d4eff35e88fc1e86564e9"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -7380,11 +7448,11 @@ dependencies = [
 
 [[package]]
 name = "serde_yaml"
-version = "0.9.32"
+version = "0.9.34+deprecated"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fd075d994154d4a774f95b51fb96bdc2832b0ea48425c92546073816cda1f2f"
+checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
 dependencies = [
- "indexmap 2.2.5",
+ "indexmap 2.2.6",
  "itoa",
  "ryu",
  "serde",
@@ -7475,9 +7543,9 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "signal-hook-registry"
-version = "1.4.1"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1"
+checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1"
 dependencies = [
  "libc",
 ]
@@ -7521,13 +7589,16 @@ dependencies = [
  "clap",
  "env_logger 0.9.3",
  "eth1",
- "eth1_test_rig",
+ "eth2_network_config",
+ "ethereum-types 0.14.1",
  "execution_layer",
  "futures",
  "node_test_rig",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "rayon",
  "sensitive_url",
+ "serde_json",
+ "ssz_types",
  "tokio",
  "types",
 ]
@@ -7565,7 +7636,7 @@ dependencies = [
  "logging",
  "lru",
  "maplit",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "rand",
  "rayon",
  "safe_arith",
@@ -7722,15 +7793,15 @@ version = "0.2.0"
 dependencies = [
  "lazy_static",
  "lighthouse_metrics",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "types",
 ]
 
 [[package]]
 name = "smallvec"
-version = "1.13.1"
+version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6ecd384b10a64542d77071bd64bd7b231f4ed5940fba55e98c3de13824cf3d7"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 
 [[package]]
 name = "snap"
@@ -7767,9 +7838,9 @@ dependencies = [
 
 [[package]]
 name = "socket2"
-version = "0.5.6"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05ffd9c0a93b7543e062e759284fcf5f5e3b098501104bfbdde4d404db792871"
+checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c"
 dependencies = [
  "libc",
  "windows-sys 0.52.0",
@@ -7804,14 +7875,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
 dependencies = [
  "base64ct",
- "der 0.7.8",
+ "der 0.7.9",
 ]
 
 [[package]]
 name = "ssz_types"
-version = "0.5.4"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "382939886cb24ee8ac885d09116a60f6262d827c7a9e36012b4f6d3d0116d0b3"
+checksum = "625b20de2d4b3891e6972f4ce5061cb11bd52b3479270c4b177c134b571194a9"
 dependencies = [
  "arbitrary",
  "derivative",
@@ -7825,6 +7896,12 @@ dependencies = [
  "typenum",
 ]
 
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+
 [[package]]
 name = "state_processing"
 version = "0.2.0"
@@ -7875,6 +7952,7 @@ name = "store"
 version = "0.2.0"
 dependencies = [
  "beacon_chain",
+ "bls",
  "db-key",
  "directory",
  "ethereum_ssz",
@@ -7883,11 +7961,14 @@ dependencies = [
  "lazy_static",
  "leveldb",
  "lighthouse_metrics",
+ "logging",
  "lru",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
+ "safe_arith",
  "serde",
  "slog",
  "sloggers",
+ "smallvec",
  "state_processing",
  "strum",
  "tempfile",
@@ -7932,7 +8013,7 @@ version = "0.24.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59"
 dependencies = [
- "heck",
+ "heck 0.4.1",
  "proc-macro2",
  "quote",
  "rustversion",
@@ -7941,15 +8022,15 @@ dependencies = [
 
 [[package]]
 name = "subtle"
-version = "2.4.1"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"
+checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
 
 [[package]]
 name = "superstruct"
-version = "0.6.0"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75b9e5728aa1a87141cefd4e7509903fc01fa0dcb108022b1e841a67c5159fc5"
+checksum = "6f4e1f478a7728f8855d7e620e9a152cf8932c6614f86564c886f9b8141f3201"
 dependencies = [
  "darling",
  "itertools",
@@ -7981,9 +8062,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.52"
+version = "2.0.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b699d15b36d1f02c3e7c69f8ffef53de37aefae075d8488d4ba1a7788d574a07"
+checksum = "909518bc7b1c9b779f1bbf07f2929d35af9f0f37e47c6e9ef7f9dddc1e1821f3"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -7996,6 +8077,12 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
 
+[[package]]
+name = "sync_wrapper"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7065abeca94b6a8a577f9bd45aa0867a2238b74e8eb67cf10d492bc39351394"
+
 [[package]]
 name = "synstructure"
 version = "0.12.6"
@@ -8049,7 +8136,7 @@ name = "system_health"
 version = "0.1.0"
 dependencies = [
  "lighthouse_network",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "serde",
  "serde_json",
  "sysinfo",
@@ -8089,6 +8176,7 @@ dependencies = [
  "futures",
  "lazy_static",
  "lighthouse_metrics",
+ "logging",
  "slog",
  "sloggers",
  "tokio",
@@ -8102,7 +8190,7 @@ checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
 dependencies = [
  "cfg-if",
  "fastrand",
- "rustix 0.38.31",
+ "rustix 0.38.34",
  "windows-sys 0.52.0",
 ]
 
@@ -8170,22 +8258,22 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.57"
+version = "1.0.59"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e45bcbe8ed29775f228095caf2cd67af7a4ccf756ebff23a306bf3e8b47b24b"
+checksum = "f0126ad08bff79f29fc3ae6a55cc72352056dfff61e3ff8bb7129476d44b23aa"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.57"
+version = "1.0.59"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a953cb265bef375dae3de6663da4d3804eee9682ea80d8e2542529b73c531c81"
+checksum = "d1cd413b5d558b4c5bf3680e324a6fa5014e7b7c067a51e69dbdf47eb7148b66"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -8209,9 +8297,9 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.34"
+version = "0.3.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8248b6521bb14bc45b4067159b9b6ad792e2d6d754d6c41fb50e29fefe38749"
+checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
 dependencies = [
  "deranged",
  "itoa",
@@ -8230,9 +8318,9 @@ checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
 
 [[package]]
 name = "time-macros"
-version = "0.2.17"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ba3a3ef41e6672a2f0f001392bb5dcd3ff0a9992d618ca761a11c3121547774"
+checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
 dependencies = [
  "num-conv",
  "time-core",
@@ -8304,9 +8392,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.36.0"
+version = "1.37.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61285f6515fa018fb2d1e46eb21223fff441ee8db5d0f1435e8ab4f5cdb80931"
+checksum = "1adbebffeca75fcfd058afa480fb6c0b81e165a0323f9c9d39c9697e37c46787"
 dependencies = [
  "backtrace",
  "bytes",
@@ -8315,7 +8403,7 @@ dependencies = [
  "num_cpus",
  "pin-project-lite",
  "signal-hook-registry",
- "socket2 0.5.6",
+ "socket2 0.5.7",
  "tokio-macros",
  "windows-sys 0.48.0",
 ]
@@ -8338,7 +8426,7 @@ checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -8364,14 +8452,14 @@ dependencies = [
  "futures-channel",
  "futures-util",
  "log",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "percent-encoding",
  "phf",
  "pin-project-lite",
  "postgres-protocol",
  "postgres-types",
  "rand",
- "socket2 0.5.6",
+ "socket2 0.5.7",
  "tokio",
  "tokio-util 0.7.10",
  "whoami",
@@ -8383,15 +8471,26 @@ version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
 dependencies = [
- "rustls",
+ "rustls 0.21.12",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "775e0c0f0adb3a2f22a00c4745d728b479985fc15ee7ca6a2608388c5569860f"
+dependencies = [
+ "rustls 0.22.4",
+ "rustls-pki-types",
  "tokio",
 ]
 
 [[package]]
 name = "tokio-stream"
-version = "0.1.14"
+version = "0.1.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "397c988d37662c7dda6d2208364a706264bf3d6138b11d436cbac0ad38832842"
+checksum = "267ac89e0bec6e691e5813911606935d77c476ff49024f98abcea3e7b15e37af"
 dependencies = [
  "futures-core",
  "pin-project-lite",
@@ -8466,7 +8565,7 @@ version = "0.19.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
 dependencies = [
- "indexmap 2.2.5",
+ "indexmap 2.2.6",
  "serde",
  "serde_spanned",
  "toml_datetime",
@@ -8479,7 +8578,7 @@ version = "0.20.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "70f427fce4d84c72b5b732388bf4a9f4531b53f74e2887e3ecb2481f68f66d81"
 dependencies = [
- "indexmap 2.2.5",
+ "indexmap 2.2.6",
  "toml_datetime",
  "winnow",
 ]
@@ -8544,7 +8643,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -8617,9 +8716,9 @@ dependencies = [
 
 [[package]]
 name = "tree_hash"
-version = "0.5.2"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c998ac5fe2b07c025444bdd522e6258110b63861c6698eedc610c071980238d"
+checksum = "134d6b24a5b829f30b5ee7de05ba7384557f5f6b00e29409cdf2392f93201bfa"
 dependencies = [
  "ethereum-types 0.14.1",
  "ethereum_hashing",
@@ -8628,9 +8727,9 @@ dependencies = [
 
 [[package]]
 name = "tree_hash_derive"
-version = "0.5.2"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84303a9c7cda5f085a3ed9cd241d1e95e04d88aab1d679b02f212e653537ba86"
+checksum = "9ce7bccc538359a213436af7bc95804bdbf1c2a21d80e22953cbe9e096837ff1"
 dependencies = [
  "darling",
  "quote",
@@ -8647,6 +8746,16 @@ dependencies = [
  "rlp",
 ]
 
+[[package]]
+name = "triomphe"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "859eb650cfee7434994602c3a68b25d77ad9e68c8a6cd491616ef86661382eb3"
+dependencies = [
+ "serde",
+ "stable_deref_trait",
+]
+
 [[package]]
 name = "try-lock"
 version = "0.2.5"
@@ -8686,12 +8795,14 @@ dependencies = [
  "maplit",
  "merkle_proof",
  "metastruct",
- "parking_lot 0.12.1",
+ "milhouse",
+ "parking_lot 0.12.2",
  "paste",
  "rand",
  "rand_xorshift",
  "rayon",
  "regex",
+ "rpds",
  "rusqlite",
  "safe_arith",
  "serde",
@@ -8774,9 +8885,9 @@ dependencies = [
 
 [[package]]
 name = "unicode-width"
-version = "0.1.11"
+version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85"
+checksum = "68f5e5f3158ecfd4b8ff6fe086db7c8467a2dfdac97fe420f2b7c4aa97af66d6"
 
 [[package]]
 name = "unicode-xid"
@@ -8786,9 +8897,9 @@ checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
 
 [[package]]
 name = "universal-hash"
-version = "0.4.1"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f214e8f697e925001e66ec2c6e37a4ef93f0f78c2eed7814394e10c62025b05"
+checksum = "8326b2c654932e3e4f9196e69d08fdf7cfd718e1dc6f66b347e6024a0c961402"
 dependencies = [
  "generic-array",
  "subtle",
@@ -8806,9 +8917,9 @@ dependencies = [
 
 [[package]]
 name = "unsafe-libyaml"
-version = "0.2.10"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab4c90930b95a82d00dc9e9ac071b4991924390d46cbd0dfe566148667605e4b"
+checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
 
 [[package]]
 name = "unsigned-varint"
@@ -8854,7 +8965,7 @@ version = "0.1.0"
 dependencies = [
  "lazy_static",
  "lru_cache",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
 ]
 
 [[package]]
@@ -8894,10 +9005,11 @@ dependencies = [
  "eth2",
  "eth2_keystore",
  "ethereum_serde_utils",
+ "fdlimit",
  "filesystem",
  "futures",
  "hex",
- "hyper 1.2.0",
+ "hyper 1.3.1",
  "itertools",
  "lazy_static",
  "libsecp256k1",
@@ -8907,7 +9019,7 @@ dependencies = [
  "logging",
  "malloc_utils",
  "monitoring_api",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "rand",
  "reqwest",
  "ring 0.16.20",
@@ -9036,29 +9148,28 @@ dependencies = [
 
 [[package]]
 name = "warp"
-version = "0.3.6"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1e92e22e03ff1230c03a1a8ee37d2f89cd489e2e541b7550d6afad96faed169"
+checksum = "4378d202ff965b011c64817db11d5829506d3404edeadb61f190d111da3f231c"
 dependencies = [
  "bytes",
  "futures-channel",
  "futures-util",
  "headers",
- "http 0.2.11",
+ "http 0.2.12",
  "hyper 0.14.28",
  "log",
  "mime",
  "mime_guess",
  "percent-encoding",
  "pin-project",
- "rustls-pemfile",
+ "rustls-pemfile 2.1.2",
  "scoped-tls",
  "serde",
  "serde_json",
  "serde_urlencoded",
  "tokio",
- "tokio-rustls",
- "tokio-stream",
+ "tokio-rustls 0.25.0",
  "tokio-util 0.7.10",
  "tower-service",
  "tracing",
@@ -9098,9 +9209,9 @@ checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.91"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1e124130aee3fb58c5bdd6b639a0509486b0338acaaae0c84a5124b0f588b7f"
+checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
 dependencies = [
  "cfg-if",
  "wasm-bindgen-macro",
@@ -9108,24 +9219,24 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.91"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9e7e1900c352b609c8488ad12639a311045f40a35491fb69ba8c12f758af70b"
+checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
 dependencies = [
  "bumpalo",
  "log",
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.41"
+version = "0.4.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877b9c3f61ceea0e56331985743b13f3d25c406a7098d45180fb5f09bc19ed97"
+checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0"
 dependencies = [
  "cfg-if",
  "js-sys",
@@ -9135,9 +9246,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.91"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b30af9e2d358182b5c7449424f017eba305ed32a7010509ede96cdc4696c46ed"
+checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -9145,22 +9256,22 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.91"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "642f325be6301eb8107a83d12a8ac6c1e1c54345a7ef1a9261962dfefda09e66"
+checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.91"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f186bd2dcf04330886ce82d6f33dd75a7bfcf69ecf5763b89fcde53b6ac9838"
+checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
 
 [[package]]
 name = "wasm-streams"
@@ -9206,7 +9317,7 @@ dependencies = [
  "eth2",
  "hex",
  "http_api",
- "hyper 1.2.0",
+ "hyper 1.3.1",
  "log",
  "logging",
  "network",
@@ -9227,9 +9338,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.68"
+version = "0.3.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96565907687f7aceb35bc5fc03770a8a0471d82e479f25832f54a0e3f4b28446"
+checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -9246,7 +9357,7 @@ dependencies = [
  "eth2_network_config",
  "futures",
  "lazy_static",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "reqwest",
  "serde",
  "serde_json",
@@ -9267,23 +9378,11 @@ version = "0.25.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1"
 
-[[package]]
-name = "which"
-version = "4.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7"
-dependencies = [
- "either",
- "home",
- "once_cell",
- "rustix 0.38.31",
-]
-
 [[package]]
 name = "whoami"
-version = "1.5.0"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fec781d48b41f8163426ed18e8fc2864c12937df9ce54c88ede7bd47270893e"
+checksum = "a44ab49fad634e88f55bf8f9bb3abd2f27d7204172a112c7c9987e01c1c94ea9"
 dependencies = [
  "redox_syscall 0.4.1",
  "wasite",
@@ -9298,9 +9397,9 @@ checksum = "c168940144dd21fd8046987c16a46a33d5fc84eec29ef9dcddc2ac9e31526b7c"
 
 [[package]]
 name = "widestring"
-version = "1.0.2"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "653f141f39ec16bba3c5abe400a0c60da7468261cc2cbf36805022876bc721a8"
+checksum = "7219d36b6eac893fa81e84ebe06485e7dcbb616177469b142df14f1f4deb1311"
 
 [[package]]
 name = "winapi"
@@ -9320,11 +9419,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.6"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596"
+checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
 dependencies = [
- "winapi",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -9370,7 +9469,7 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
 dependencies = [
- "windows-targets 0.52.4",
+ "windows-targets 0.52.5",
 ]
 
 [[package]]
@@ -9397,7 +9496,7 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets 0.52.4",
+ "windows-targets 0.52.5",
 ]
 
 [[package]]
@@ -9432,17 +9531,18 @@ dependencies = [
 
 [[package]]
 name = "windows-targets"
-version = "0.52.4"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dd37b7e5ab9018759f893a1952c9420d060016fc19a472b4bb20d1bdd694d1b"
+checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb"
 dependencies = [
- "windows_aarch64_gnullvm 0.52.4",
- "windows_aarch64_msvc 0.52.4",
- "windows_i686_gnu 0.52.4",
- "windows_i686_msvc 0.52.4",
- "windows_x86_64_gnu 0.52.4",
- "windows_x86_64_gnullvm 0.52.4",
- "windows_x86_64_msvc 0.52.4",
+ "windows_aarch64_gnullvm 0.52.5",
+ "windows_aarch64_msvc 0.52.5",
+ "windows_i686_gnu 0.52.5",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc 0.52.5",
+ "windows_x86_64_gnu 0.52.5",
+ "windows_x86_64_gnullvm 0.52.5",
+ "windows_x86_64_msvc 0.52.5",
 ]
 
 [[package]]
@@ -9459,9 +9559,9 @@ checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.52.4"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcf46cf4c365c6f2d1cc93ce535f2c8b244591df96ceee75d8e83deb70a9cac9"
+checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263"
 
 [[package]]
 name = "windows_aarch64_msvc"
@@ -9477,9 +9577,9 @@ checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.52.4"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da9f259dd3bcf6990b55bffd094c4f7235817ba4ceebde8e6d11cd0c5633b675"
+checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6"
 
 [[package]]
 name = "windows_i686_gnu"
@@ -9495,9 +9595,15 @@ checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.52.4"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b474d8268f99e0995f25b9f095bc7434632601028cf86590aea5c8a5cb7801d3"
+checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9"
 
 [[package]]
 name = "windows_i686_msvc"
@@ -9513,9 +9619,9 @@ checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.52.4"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1515e9a29e5bed743cb4415a9ecf5dfca648ce85ee42e15873c3cd8610ff8e02"
+checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf"
 
 [[package]]
 name = "windows_x86_64_gnu"
@@ -9531,9 +9637,9 @@ checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.52.4"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5eee091590e89cc02ad514ffe3ead9eb6b660aedca2183455434b93546371a03"
+checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
@@ -9549,9 +9655,9 @@ checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.52.4"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77ca79f2451b49fa9e2af39f0747fe999fcda4f5e241b2898624dca97a1f2177"
+checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596"
 
 [[package]]
 name = "windows_x86_64_msvc"
@@ -9567,9 +9673,9 @@ checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.52.4"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32b752e52a2da0ddfbdbcc6fceadfeede4c939ed16d13e648833a61dfb611ed8"
+checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"
 
 [[package]]
 name = "winnow"
@@ -9655,9 +9761,9 @@ dependencies = [
 
 [[package]]
 name = "xml-rs"
-version = "0.8.19"
+version = "0.8.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fcb9cbac069e033553e8bb871be2fbdffcab578eb25bd0f7c508cedc6dcd75a"
+checksum = "791978798f0597cfc70478424c2b4fdc2b7a8024aaff78497ef00f24ef674193"
 
 [[package]]
 name = "xmltree"
@@ -9669,12 +9775,14 @@ dependencies = [
 ]
 
 [[package]]
-name = "yaml-rust"
-version = "0.4.5"
+name = "yaml-rust2"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
+checksum = "498f4d102a79ea1c9d4dd27573c0fc96ad74c023e8da38484e47883076da25fb"
 dependencies = [
- "linked-hash-map",
+ "arraydeque",
+ "encoding_rs",
+ "hashlink",
 ]
 
 [[package]]
@@ -9686,7 +9794,7 @@ dependencies = [
  "futures",
  "log",
  "nohash-hasher",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "pin-project",
  "rand",
  "static_assertions",
@@ -9694,14 +9802,15 @@ dependencies = [
 
 [[package]]
 name = "yamux"
-version = "0.13.1"
-source = "git+https://github.com/sigp/rust-yamux.git#12a23aa0e34b7807c0c5f87f06b3438f7d6c2ed0"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f97202f6b125031b95d83e01dc57292b529384f80bfae4677e4bbc10178cf72"
 dependencies = [
  "futures",
  "instant",
  "log",
  "nohash-hasher",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.2",
  "pin-project",
  "rand",
  "static_assertions",
@@ -9733,7 +9842,7 @@ checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -9753,7 +9862,7 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.52",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -9797,9 +9906,9 @@ dependencies = [
 
 [[package]]
 name = "zstd-sys"
-version = "2.0.9+zstd.1.5.5"
+version = "2.0.10+zstd.1.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e16efa8a874a0481a574084d34cc26fdb3b99627480f785888deb6386506656"
+checksum = "c253a4914af5bafc8fa8c86ee400827e83cf6ec01195ec1f1ed8441bf00d65aa"
 dependencies = [
  "cc",
  "pkg-config",
diff --git a/Cargo.toml b/Cargo.toml
index 38018c712d5..c70d9459124 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -102,6 +102,9 @@ bincode = "1"
 bitvec = "1"
 byteorder = "1"
 bytes = "1"
+# Turn off c-kzg's default features which include `blst/portable`. We can turn on blst's portable
+# feature ourselves when desired.
+c-kzg = { version = "1", default-features = false }
 clap = "2"
 compare_fields_derive = { path = "common/compare_fields_derive" }
 criterion = "0.3"
@@ -113,7 +116,7 @@ discv5 = { version = "0.4.1", features = ["libp2p"] }
 env_logger = "0.9"
 error-chain = "0.12"
 ethereum-types = "0.14"
-ethereum_hashing = "1.0.0-beta.2"
+ethereum_hashing = "0.6.0"
 ethereum_serde_utils = "0.5.2"
 ethereum_ssz = "0.5"
 ethereum_ssz_derive = "0.5"
@@ -131,6 +134,7 @@ libsecp256k1 = "0.7"
 log = "0.4"
 lru = "0.12"
 maplit = "1"
+milhouse = "0.1"
 num_cpus = "1"
 parking_lot = "0.12"
 paste = "1"
@@ -143,6 +147,7 @@ rayon = "1.7"
 regex = "1"
 reqwest = { version = "0.11", default-features = false, features = ["blocking", "json", "stream", "rustls-tls", "native-tls-vendored"] }
 ring = "0.16"
+rpds = "0.11"
 rusqlite = { version = "0.28", features = ["bundled"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
@@ -155,9 +160,9 @@ slog-term = "2"
 sloggers = { version = "2", features = ["json"] }
 smallvec = "1.11.2"
 snap = "1"
-ssz_types = "0.5"
+ssz_types = "0.6"
 strum = { version = "0.24", features = ["derive"] }
-superstruct = "0.6"
+superstruct = "0.7"
 syn = "1"
 sysinfo = "0.26"
 tempfile = "3"
@@ -169,11 +174,11 @@ tracing-appender = "0.2"
 tracing-core = "0.1"
 tracing-log = "0.2"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-tree_hash = "0.5"
-tree_hash_derive = "0.5"
+tree_hash = "0.6"
+tree_hash_derive = "0.6"
 url = "2"
 uuid = { version = "0.8", features = ["serde", "v4"] }
-warp = { version = "0.3.6", default-features = false, features = ["tls"] }
+warp = { version = "0.3.7", default-features = false, features = ["tls"] }
 zeroize = { version = "1", features = ["zeroize_derive"] }
 zip = "0.6"
 
@@ -181,7 +186,7 @@ zip = "0.6"
 account_utils = { path = "common/account_utils" }
 beacon_chain = { path = "beacon_node/beacon_chain" }
 beacon_node = { path = "beacon_node" }
-beacon_processor =  { path = "beacon_node/beacon_processor" }
+beacon_processor = { path = "beacon_node/beacon_processor" }
 bls = { path = "crypto/bls" }
 cached_tree_hash = { path = "consensus/cached_tree_hash" }
 clap_utils = { path = "common/clap_utils" }
@@ -218,7 +223,7 @@ network = { path = "beacon_node/network" }
 operation_pool = { path = "beacon_node/operation_pool" }
 pretty_reqwest_error = { path = "common/pretty_reqwest_error" }
 proto_array = { path = "consensus/proto_array" }
-safe_arith = {path = "consensus/safe_arith"}
+safe_arith = { path = "consensus/safe_arith" }
 sensitive_url = { path = "common/sensitive_url" }
 slasher = { path = "slasher" }
 slashing_protection = { path = "validator_client/slashing_protection" }
@@ -233,9 +238,6 @@ validator_client = { path = "validator_client" }
 validator_dir = { path = "common/validator_dir" }
 warp_utils = { path = "common/warp_utils" }
 
-[patch.crates-io]
-yamux = { git = "https://github.com/sigp/rust-yamux.git" }
-
 [profile.maxperf]
 inherits = "release"
 lto = "fat"
diff --git a/Makefile b/Makefile
index 4b2d0f6c5d5..12d33cc3a8b 100644
--- a/Makefile
+++ b/Makefile
@@ -39,7 +39,7 @@ PROFILE ?= release
 
 # List of all hard forks. This list is used to set env variables for several tests so that
 # they run for different forks.
-FORKS=phase0 altair merge capella deneb electra
+FORKS=phase0 altair bellatrix capella deneb electra
 
 # Extra flags for Cargo
 CARGO_INSTALL_EXTRA_FLAGS?=
@@ -82,6 +82,11 @@ build-aarch64:
 build-aarch64-portable:
 	cross build --bin lighthouse --target aarch64-unknown-linux-gnu --features "portable,$(CROSS_FEATURES)" --profile "$(CROSS_PROFILE)" --locked
 
+build-lcli-x86_64:
+	cross build --bin lcli --target x86_64-unknown-linux-gnu --features "portable" --profile "$(CROSS_PROFILE)" --locked
+build-lcli-aarch64:
+	cross build --bin lcli --target aarch64-unknown-linux-gnu --features "portable" --profile "$(CROSS_PROFILE)" --locked
+
 # Create a `.tar.gz` containing a binary for a specific target.
 define tarball_release_binary
 	cp $(1)/lighthouse $(BIN_DIR)/lighthouse
diff --git a/account_manager/src/validator/create.rs b/account_manager/src/validator/create.rs
index 8da32531a80..93b041c61c4 100644
--- a/account_manager/src/validator/create.rs
+++ b/account_manager/src/validator/create.rs
@@ -62,7 +62,6 @@ pub fn cli_app<'a, 'b>() -> App<'a, 'b> {
                     "The path where the validator keystore passwords will be stored. \
                     Defaults to ~/.lighthouse/{network}/secrets",
                 )
-                .conflicts_with("datadir")
                 .takes_value(true),
         )
         .arg(
diff --git a/beacon_node/beacon_chain/Cargo.toml b/beacon_node/beacon_chain/Cargo.toml
index 43c2c896f71..32a1056c10e 100644
--- a/beacon_node/beacon_chain/Cargo.toml
+++ b/beacon_node/beacon_chain/Cargo.toml
@@ -19,58 +19,59 @@ environment = { workspace = true }
 serde_json = { workspace = true }
 
 [dependencies]
-serde_json = { workspace = true }
+bitvec = { workspace = true }
+bls = { workspace = true }
+derivative = { workspace = true }
+eth1 = { workspace = true }
+eth2 = { workspace = true }
 eth2_network_config = { workspace = true }
-merkle_proof = { workspace = true }
-store = { workspace = true }
-parking_lot = { workspace = true }
+ethereum_hashing = { workspace = true }
+ethereum_serde_utils = { workspace = true }
+ethereum_ssz = { workspace = true }
+ethereum_ssz_derive = { workspace = true }
+execution_layer = { workspace = true }
+fork_choice = { workspace = true }
+futures = { workspace = true }
+genesis = { workspace = true }
+hex = { workspace = true }
+int_to_bytes = { workspace = true }
+itertools = { workspace = true }
+kzg = { workspace = true }
 lazy_static = { workspace = true }
-smallvec = { workspace = true }
 lighthouse_metrics = { workspace = true }
+lighthouse_version = { workspace = true }
+logging = { workspace = true }
+lru = { workspace = true }
+merkle_proof = { workspace = true }
+oneshot_broadcast = { path = "../../common/oneshot_broadcast/" }
 operation_pool = { workspace = true }
+parking_lot = { workspace = true }
+proto_array = { workspace = true }
+rand = { workspace = true }
 rayon = { workspace = true }
+safe_arith = { workspace = true }
+sensitive_url = { workspace = true }
 serde = { workspace = true }
-ethereum_serde_utils = { workspace = true }
+serde_json = { workspace = true }
+slasher = { workspace = true }
 slog = { workspace = true }
+slog-async = { workspace = true }
+slog-term = { workspace = true }
 sloggers = { workspace = true }
 slot_clock = { workspace = true }
-ethereum_hashing = { workspace = true }
-ethereum_ssz = { workspace = true }
+smallvec = { workspace = true }
 ssz_types = { workspace = true }
-ethereum_ssz_derive = { workspace = true }
 state_processing = { workspace = true }
-tree_hash_derive = { workspace = true }
-tree_hash = { workspace = true }
-types = { workspace = true }
-tokio = { workspace = true }
-tokio-stream = { workspace = true }
-eth1 = { workspace = true }
-futures = { workspace = true }
-genesis = { workspace = true }
-int_to_bytes = { workspace = true }
-rand = { workspace = true }
-proto_array = { workspace = true }
-lru = { workspace = true }
-tempfile = { workspace = true }
-bitvec = { workspace = true }
-bls = { workspace = true }
-kzg = { workspace = true }
-safe_arith = { workspace = true }
-fork_choice = { workspace = true }
-task_executor = { workspace = true }
-derivative = { workspace = true }
-itertools = { workspace = true }
-slasher = { workspace = true }
-eth2 = { workspace = true }
+store = { workspace = true }
 strum = { workspace = true }
-logging = { workspace = true }
-execution_layer = { workspace = true }
-sensitive_url = { workspace = true }
 superstruct = { workspace = true }
-hex = { workspace = true }
-oneshot_broadcast = { path = "../../common/oneshot_broadcast/" }
-slog-term = { workspace = true }
-slog-async = { workspace = true }
+task_executor = { workspace = true }
+tempfile = { workspace = true }
+tokio = { workspace = true }
+tokio-stream = { workspace = true }
+tree_hash = { workspace = true }
+tree_hash_derive = { workspace = true }
+types = { workspace = true }
 
 [[test]]
 name = "beacon_chain_tests"
diff --git a/beacon_node/beacon_chain/src/attestation_rewards.rs b/beacon_node/beacon_chain/src/attestation_rewards.rs
index 491b7ef7da9..d48a83130e6 100644
--- a/beacon_node/beacon_chain/src/attestation_rewards.rs
+++ b/beacon_node/beacon_chain/src/attestation_rewards.rs
@@ -54,7 +54,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         match state {
             BeaconState::Base(_) => self.compute_attestation_rewards_base(state, validators),
             BeaconState::Altair(_)
-            | BeaconState::Merge(_)
+            | BeaconState::Bellatrix(_)
             | BeaconState::Capella(_)
             | BeaconState::Deneb(_)
             | BeaconState::Electra(_) => self.compute_attestation_rewards_altair(state, validators),
diff --git a/beacon_node/beacon_chain/src/attestation_verification.rs b/beacon_node/beacon_chain/src/attestation_verification.rs
index f3bde8678e1..471c43d94f8 100644
--- a/beacon_node/beacon_chain/src/attestation_verification.rs
+++ b/beacon_node/beacon_chain/src/attestation_verification.rs
@@ -1063,7 +1063,9 @@ pub fn verify_propagation_slot_range<S: SlotClock, E: EthSpec>(
     let current_fork =
         spec.fork_name_at_slot::<E>(slot_clock.now().ok_or(BeaconChainError::UnableToReadSlot)?);
     let earliest_permissible_slot = match current_fork {
-        ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => one_epoch_prior,
+        ForkName::Base | ForkName::Altair | ForkName::Bellatrix | ForkName::Capella => {
+            one_epoch_prior
+        }
         // EIP-7045
         ForkName::Deneb | ForkName::Electra => one_epoch_prior
             .epoch(E::slots_per_epoch())
diff --git a/beacon_node/beacon_chain/src/beacon_block_streamer.rs b/beacon_node/beacon_chain/src/beacon_block_streamer.rs
index a1f7c99067e..0c92b7c1f62 100644
--- a/beacon_node/beacon_chain/src/beacon_block_streamer.rs
+++ b/beacon_node/beacon_chain/src/beacon_block_streamer.rs
@@ -1,10 +1,9 @@
-use crate::{BeaconChain, BeaconChainError, BeaconChainTypes};
+use crate::{metrics, BeaconChain, BeaconChainError, BeaconChainTypes};
 use execution_layer::{ExecutionLayer, ExecutionPayloadBodyV1};
-use slog::{crit, debug, Logger};
+use slog::{crit, debug, error, Logger};
 use std::collections::HashMap;
 use std::sync::Arc;
 use store::{DatabaseBlock, ExecutionPayloadDeneb};
-use task_executor::TaskExecutor;
 use tokio::sync::{
     mpsc::{self, UnboundedSender},
     RwLock,
@@ -15,8 +14,8 @@ use types::{
     SignedBlindedBeaconBlock, Slot,
 };
 use types::{
-    ExecutionPayload, ExecutionPayloadCapella, ExecutionPayloadElectra, ExecutionPayloadHeader,
-    ExecutionPayloadMerge,
+    ExecutionPayload, ExecutionPayloadBellatrix, ExecutionPayloadCapella, ExecutionPayloadElectra,
+    ExecutionPayloadHeader,
 };
 
 #[derive(PartialEq)]
@@ -96,7 +95,7 @@ fn reconstruct_default_header_block<E: EthSpec>(
         .map_err(BeaconChainError::InconsistentFork)?;
 
     let payload: ExecutionPayload<E> = match fork {
-        ForkName::Merge => ExecutionPayloadMerge::default().into(),
+        ForkName::Bellatrix => ExecutionPayloadBellatrix::default().into(),
         ForkName::Capella => ExecutionPayloadCapella::default().into(),
         ForkName::Deneb => ExecutionPayloadDeneb::default().into(),
         ForkName::Electra => ExecutionPayloadElectra::default().into(),
@@ -395,55 +394,74 @@ impl<T: BeaconChainTypes> BeaconBlockStreamer<T> {
     pub fn new(
         beacon_chain: &Arc<BeaconChain<T>>,
         check_caches: CheckCaches,
-    ) -> Result<Self, BeaconChainError> {
+    ) -> Result<Arc<Self>, BeaconChainError> {
         let execution_layer = beacon_chain
             .execution_layer
             .as_ref()
             .ok_or(BeaconChainError::ExecutionLayerMissing)?
             .clone();
 
-        Ok(Self {
+        Ok(Arc::new(Self {
             execution_layer,
             check_caches,
             beacon_chain: beacon_chain.clone(),
-        })
+        }))
     }
 
     fn check_caches(&self, root: Hash256) -> Option<Arc<SignedBeaconBlock<T::EthSpec>>> {
         if self.check_caches == CheckCaches::Yes {
             self.beacon_chain
-                .data_availability_checker
-                .get_block(&root)
+                .reqresp_pre_import_cache
+                .read()
+                .get(&root)
+                .map(|block| {
+                    metrics::inc_counter(&metrics::BEACON_REQRESP_PRE_IMPORT_CACHE_HITS);
+                    block.clone()
+                })
                 .or(self.beacon_chain.early_attester_cache.get_block(root))
         } else {
             None
         }
     }
 
-    fn load_payloads(&self, block_roots: Vec<Hash256>) -> Vec<(Hash256, LoadResult<T::EthSpec>)> {
-        let mut db_blocks = Vec::new();
-
-        for root in block_roots {
-            if let Some(cached_block) = self.check_caches(root).map(LoadedBeaconBlock::Full) {
-                db_blocks.push((root, Ok(Some(cached_block))));
-                continue;
-            }
-
-            match self.beacon_chain.store.try_get_full_block(&root) {
-                Err(e) => db_blocks.push((root, Err(e.into()))),
-                Ok(opt_block) => db_blocks.push((
-                    root,
-                    Ok(opt_block.map(|db_block| match db_block {
-                        DatabaseBlock::Full(block) => LoadedBeaconBlock::Full(Arc::new(block)),
-                        DatabaseBlock::Blinded(block) => {
-                            LoadedBeaconBlock::Blinded(Box::new(block))
+    async fn load_payloads(
+        self: &Arc<Self>,
+        block_roots: Vec<Hash256>,
+    ) -> Result<Vec<(Hash256, LoadResult<T::EthSpec>)>, BeaconChainError> {
+        let streamer = self.clone();
+        // Loading from the DB is slow -> spawn a blocking task
+        self.beacon_chain
+            .spawn_blocking_handle(
+                move || {
+                    let mut db_blocks = Vec::new();
+                    for root in block_roots {
+                        if let Some(cached_block) =
+                            streamer.check_caches(root).map(LoadedBeaconBlock::Full)
+                        {
+                            db_blocks.push((root, Ok(Some(cached_block))));
+                            continue;
                         }
-                    })),
-                )),
-            }
-        }
 
-        db_blocks
+                        match streamer.beacon_chain.store.try_get_full_block(&root) {
+                            Err(e) => db_blocks.push((root, Err(e.into()))),
+                            Ok(opt_block) => db_blocks.push((
+                                root,
+                                Ok(opt_block.map(|db_block| match db_block {
+                                    DatabaseBlock::Full(block) => {
+                                        LoadedBeaconBlock::Full(Arc::new(block))
+                                    }
+                                    DatabaseBlock::Blinded(block) => {
+                                        LoadedBeaconBlock::Blinded(Box::new(block))
+                                    }
+                                })),
+                            )),
+                        }
+                    }
+                    db_blocks
+                },
+                "load_beacon_blocks",
+            )
+            .await
     }
 
     /// Pre-process the loaded blocks into execution engine requests.
@@ -544,7 +562,7 @@ impl<T: BeaconChainTypes> BeaconBlockStreamer<T> {
 
     // used when the execution engine doesn't support the payload bodies methods
     async fn stream_blocks_fallback(
-        &self,
+        self: Arc<Self>,
         block_roots: Vec<Hash256>,
         sender: UnboundedSender<(Hash256, Arc<BlockResult<T::EthSpec>>)>,
     ) {
@@ -570,7 +588,7 @@ impl<T: BeaconChainTypes> BeaconBlockStreamer<T> {
     }
 
     async fn stream_blocks(
-        &self,
+        self: Arc<Self>,
         block_roots: Vec<Hash256>,
         sender: UnboundedSender<(Hash256, Arc<BlockResult<T::EthSpec>>)>,
     ) {
@@ -579,7 +597,17 @@ impl<T: BeaconChainTypes> BeaconBlockStreamer<T> {
         let mut n_sent = 0usize;
         let mut engine_requests = 0usize;
 
-        let payloads = self.load_payloads(block_roots);
+        let payloads = match self.load_payloads(block_roots).await {
+            Ok(payloads) => payloads,
+            Err(e) => {
+                error!(
+                    self.beacon_chain.log,
+                    "BeaconBlockStreamer: Failed to load payloads";
+                    "error" => ?e
+                );
+                return;
+            }
+        };
         let requests = self.get_requests(payloads).await;
 
         for (root, request) in requests {
@@ -619,7 +647,7 @@ impl<T: BeaconChainTypes> BeaconBlockStreamer<T> {
     }
 
     pub async fn stream(
-        self,
+        self: Arc<Self>,
         block_roots: Vec<Hash256>,
         sender: UnboundedSender<(Hash256, Arc<BlockResult<T::EthSpec>>)>,
     ) {
@@ -645,9 +673,8 @@ impl<T: BeaconChainTypes> BeaconBlockStreamer<T> {
     }
 
     pub fn launch_stream(
-        self,
+        self: Arc<Self>,
         block_roots: Vec<Hash256>,
-        executor: &TaskExecutor,
     ) -> impl Stream<Item = (Hash256, Arc<BlockResult<T::EthSpec>>)> {
         let (block_tx, block_rx) = mpsc::unbounded_channel();
         debug!(
@@ -655,6 +682,7 @@ impl<T: BeaconChainTypes> BeaconBlockStreamer<T> {
             "Launching a BeaconBlockStreamer";
             "blocks" => block_roots.len(),
         );
+        let executor = self.beacon_chain.task_executor.clone();
         executor.spawn(self.stream(block_roots, block_tx), "get_blocks_sender");
         UnboundedReceiverStream::new(block_rx)
     }
diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs
index 421bc12ee43..9584b2e29f1 100644
--- a/beacon_node/beacon_chain/src/beacon_chain.rs
+++ b/beacon_node/beacon_chain/src/beacon_chain.rs
@@ -30,6 +30,7 @@ use crate::eth1_finalization_cache::{Eth1FinalizationCache, Eth1FinalizationData
 use crate::events::ServerSentEventHandler;
 use crate::execution_payload::{get_execution_payload, NotifyExecutionLayer, PreparePayloadHandle};
 use crate::fork_choice_signal::{ForkChoiceSignalRx, ForkChoiceSignalTx, ForkChoiceWaitResult};
+use crate::graffiti_calculator::GraffitiCalculator;
 use crate::head_tracker::{HeadTracker, HeadTrackerReader, SszHeadTracker};
 use crate::historical_blocks::HistoricalBlockError;
 use crate::light_client_finality_update_verification::{
@@ -58,7 +59,6 @@ use crate::persisted_beacon_chain::{PersistedBeaconChain, DUMMY_CANONICAL_HEAD_B
 use crate::persisted_fork_choice::PersistedForkChoice;
 use crate::pre_finalization_cache::PreFinalizationBlockCache;
 use crate::shuffling_cache::{BlockShufflingIds, ShufflingCache};
-use crate::snapshot_cache::{BlockProductionPreState, SnapshotCache};
 use crate::sync_committee_verification::{
     Error as SyncCommitteeError, VerifiedSyncCommitteeMessage, VerifiedSyncContribution,
 };
@@ -103,8 +103,7 @@ use state_processing::{
     },
     per_slot_processing,
     state_advance::{complete_state_advance, partial_state_advance},
-    BlockSignatureStrategy, ConsensusContext, SigVerifiedOp, StateProcessingStrategy,
-    VerifyBlockRoot, VerifyOperation,
+    BlockSignatureStrategy, ConsensusContext, SigVerifiedOp, VerifyBlockRoot, VerifyOperation,
 };
 use std::borrow::Cow;
 use std::cmp::Ordering;
@@ -130,9 +129,6 @@ pub type ForkChoiceError = fork_choice::Error<crate::ForkChoiceStoreError>;
 /// Alias to appease clippy.
 type HashBlockTuple<E> = (Hash256, RpcBlock<E>);
 
-/// The time-out before failure during an operation to take a read/write RwLock on the block
-/// processing cache.
-pub const BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT: Duration = Duration::from_secs(1);
 /// The time-out before failure during an operation to take a read/write RwLock on the
 /// attestation cache.
 pub const ATTESTATION_CACHE_LOCK_TIMEOUT: Duration = Duration::from_secs(1);
@@ -176,6 +172,7 @@ pub const INVALID_FINALIZED_MERGE_TRANSITION_BLOCK_SHUTDOWN_REASON: &str =
     "Finalized merge transition block is invalid.";
 
 /// Defines the behaviour when a block/block-root for a skipped slot is requested.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum WhenSlotSkipped {
     /// If the slot is a skip slot, return `None`.
     ///
@@ -359,6 +356,9 @@ pub type BeaconStore<T> = Arc<
     >,
 >;
 
+/// Cache gossip verified blocks to serve over ReqResp before they are imported
+type ReqRespPreImportCache<E> = HashMap<Hash256, Arc<SignedBeaconBlock<E>>>;
+
 /// Represents the "Beacon Chain" component of Ethereum 2.0. Allows import of blocks and block
 /// operations and chooses a canonical head.
 pub struct BeaconChain<T: BeaconChainTypes> {
@@ -447,8 +447,6 @@ pub struct BeaconChain<T: BeaconChainTypes> {
     pub event_handler: Option<ServerSentEventHandler<T::EthSpec>>,
     /// Used to track the heads of the beacon chain.
     pub(crate) head_tracker: Arc<HeadTracker>,
-    /// A cache dedicated to block processing.
-    pub(crate) snapshot_cache: TimeoutRwLock<SnapshotCache<T::EthSpec>>,
     /// Caches the attester shuffling for a given epoch and shuffling key root.
     pub shuffling_cache: TimeoutRwLock<ShufflingCache>,
     /// A cache of eth1 deposit data at epoch boundaries for deposit finalization
@@ -461,6 +459,8 @@ pub struct BeaconChain<T: BeaconChainTypes> {
     pub(crate) attester_cache: Arc<AttesterCache>,
     /// A cache used when producing attestations whilst the head block is still being imported.
     pub early_attester_cache: EarlyAttesterCache<T::EthSpec>,
+    /// Cache gossip verified blocks to serve over ReqResp before they are imported
+    pub reqresp_pre_import_cache: Arc<RwLock<ReqRespPreImportCache<T::EthSpec>>>,
     /// A cache used to keep track of various block timings.
     pub block_times_cache: Arc<RwLock<BlockTimesCache>>,
     /// A cache used to track pre-finalization block roots for quick rejection.
@@ -475,7 +475,7 @@ pub struct BeaconChain<T: BeaconChainTypes> {
     /// Logging to CLI, etc.
     pub(crate) log: Logger,
     /// Arbitrary bytes included in the blocks.
-    pub(crate) graffiti: Graffiti,
+    pub(crate) graffiti_calculator: GraffitiCalculator<T>,
     /// Optional slasher.
     pub slasher: Option<Arc<Slasher<T::EthSpec>>>,
     /// Provides monitoring of a set of explicitly defined validators.
@@ -487,11 +487,6 @@ pub struct BeaconChain<T: BeaconChainTypes> {
     pub data_availability_checker: Arc<DataAvailabilityChecker<T>>,
     /// The KZG trusted setup used by this chain.
     pub kzg: Option<Arc<Kzg>>,
-    /// State with complete tree hash cache, ready for block production.
-    ///
-    /// NB: We can delete this once we have tree-states.
-    #[allow(clippy::type_complexity)]
-    pub block_production_state: Arc<Mutex<Option<(Hash256, BlockProductionPreState<T::EthSpec>)>>>,
 }
 
 pub enum BeaconBlockResponseWrapper<E: EthSpec> {
@@ -768,7 +763,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
 
         let iter = self.store.forwards_block_roots_iterator(
             start_slot,
-            local_head.beacon_state.clone_with(CloneConfig::none()),
+            local_head.beacon_state.clone(),
             local_head.beacon_block_root,
             &self.spec,
         )?;
@@ -798,12 +793,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             let iter = self.store.forwards_block_roots_iterator_until(
                 start_slot,
                 end_slot,
-                || {
-                    Ok((
-                        head.beacon_state.clone_with_only_committee_caches(),
-                        head.beacon_block_root,
-                    ))
-                },
+                || Ok((head.beacon_state.clone(), head.beacon_block_root)),
                 &self.spec,
             )?;
             Ok(iter
@@ -874,7 +864,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         let iter = self.store.forwards_state_roots_iterator(
             start_slot,
             local_head.beacon_state_root(),
-            local_head.beacon_state.clone_with(CloneConfig::none()),
+            local_head.beacon_state.clone(),
             &self.spec,
         )?;
 
@@ -895,12 +885,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             let iter = self.store.forwards_state_roots_iterator_until(
                 start_slot,
                 end_slot,
-                || {
-                    Ok((
-                        head.beacon_state.clone_with_only_committee_caches(),
-                        head.beacon_state_root(),
-                    ))
-                },
+                || Ok((head.beacon_state.clone(), head.beacon_state_root())),
                 &self.spec,
             )?;
             Ok(iter
@@ -1134,7 +1119,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     pub fn get_blocks_checking_caches(
         self: &Arc<Self>,
         block_roots: Vec<Hash256>,
-        executor: &TaskExecutor,
     ) -> Result<
         impl Stream<
             Item = (
@@ -1144,14 +1128,12 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         >,
         Error,
     > {
-        Ok(BeaconBlockStreamer::<T>::new(self, CheckCaches::Yes)?
-            .launch_stream(block_roots, executor))
+        Ok(BeaconBlockStreamer::<T>::new(self, CheckCaches::Yes)?.launch_stream(block_roots))
     }
 
     pub fn get_blocks(
         self: &Arc<Self>,
         block_roots: Vec<Hash256>,
-        executor: &TaskExecutor,
     ) -> Result<
         impl Stream<
             Item = (
@@ -1161,8 +1143,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         >,
         Error,
     > {
-        Ok(BeaconBlockStreamer::<T>::new(self, CheckCaches::No)?
-            .launch_stream(block_roots, executor))
+        Ok(BeaconBlockStreamer::<T>::new(self, CheckCaches::No)?.launch_stream(block_roots))
     }
 
     pub fn get_blobs_checking_early_attester_cache(
@@ -2441,6 +2422,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         proposer_slashing: ProposerSlashing,
     ) -> Result<ObservationOutcome<ProposerSlashing, T::EthSpec>, Error> {
         let wall_clock_state = self.wall_clock_state()?;
+
         Ok(self.observed_proposer_slashings.lock().verify_and_observe(
             proposer_slashing,
             &wall_clock_state,
@@ -2453,6 +2435,14 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         &self,
         proposer_slashing: SigVerifiedOp<ProposerSlashing, T::EthSpec>,
     ) {
+        if let Some(event_handler) = self.event_handler.as_ref() {
+            if event_handler.has_proposer_slashing_subscribers() {
+                event_handler.register(EventKind::ProposerSlashing(Box::new(
+                    proposer_slashing.clone().into_inner(),
+                )));
+            }
+        }
+
         if self.eth1_chain.is_some() {
             self.op_pool.insert_proposer_slashing(proposer_slashing)
         }
@@ -2464,6 +2454,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         attester_slashing: AttesterSlashing<T::EthSpec>,
     ) -> Result<ObservationOutcome<AttesterSlashing<T::EthSpec>, T::EthSpec>, Error> {
         let wall_clock_state = self.wall_clock_state()?;
+
         Ok(self.observed_attester_slashings.lock().verify_and_observe(
             attester_slashing,
             &wall_clock_state,
@@ -2484,6 +2475,14 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             .fork_choice_write_lock()
             .on_attester_slashing(attester_slashing.as_inner());
 
+        if let Some(event_handler) = self.event_handler.as_ref() {
+            if event_handler.has_attester_slashing_subscribers() {
+                event_handler.register(EventKind::AttesterSlashing(Box::new(
+                    attester_slashing.clone().into_inner(),
+                )));
+            }
+        }
+
         // Add to the op pool (if we have the ability to propose blocks).
         if self.eth1_chain.is_some() {
             self.op_pool.insert_attester_slashing(attester_slashing)
@@ -2540,7 +2539,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     /// Check if the current slot is greater than or equal to the Capella fork epoch.
     pub fn current_slot_is_post_capella(&self) -> Result<bool, Error> {
         let current_fork = self.spec.fork_name_at_slot::<T::EthSpec>(self.slot()?);
-        if let ForkName::Base | ForkName::Altair | ForkName::Merge = current_fork {
+        if let ForkName::Base | ForkName::Altair | ForkName::Bellatrix = current_fork {
             Ok(false)
         } else {
             Ok(true)
@@ -2775,6 +2774,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                         signature_verified_block.block_root(),
                         signature_verified_block,
                         notify_execution_layer,
+                        BlockImportSource::RangeSync,
                         || Ok(()),
                     )
                     .await
@@ -2898,8 +2898,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             }
         }
 
-        self.data_availability_checker
-            .notify_gossip_blob(block_root, &blob);
         let r = self.check_gossip_blob_availability_and_import(blob).await;
         self.remove_notified(&block_root, r)
     }
@@ -2932,8 +2930,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             }
         }
 
-        self.data_availability_checker
-            .notify_rpc_blobs(block_root, &blobs);
         let r = self
             .check_rpc_blob_availability_and_import(slot, block_root, blobs)
             .await;
@@ -2950,25 +2946,32 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         let has_missing_components =
             matches!(r, Ok(AvailabilityProcessingStatus::MissingComponents(_, _)));
         if !has_missing_components {
-            self.data_availability_checker.remove_notified(block_root);
+            self.reqresp_pre_import_cache.write().remove(block_root);
         }
         r
     }
 
     /// Wraps `process_block` in logic to cache the block's commitments in the processing cache
-    /// and evict if the block was imported or erred.
+    /// and evict if the block was imported or errored.
     pub async fn process_block_with_early_caching<B: IntoExecutionPendingBlock<T>>(
         self: &Arc<Self>,
         block_root: Hash256,
         unverified_block: B,
+        block_source: BlockImportSource,
         notify_execution_layer: NotifyExecutionLayer,
     ) -> Result<AvailabilityProcessingStatus, BlockError<T::EthSpec>> {
-        self.data_availability_checker
-            .notify_block(block_root, unverified_block.block_cloned());
+        self.reqresp_pre_import_cache
+            .write()
+            .insert(block_root, unverified_block.block_cloned());
+
         let r = self
-            .process_block(block_root, unverified_block, notify_execution_layer, || {
-                Ok(())
-            })
+            .process_block(
+                block_root,
+                unverified_block,
+                notify_execution_layer,
+                block_source,
+                || Ok(()),
+            )
             .await;
         self.remove_notified(&block_root, r)
     }
@@ -2991,6 +2994,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         block_root: Hash256,
         unverified_block: B,
         notify_execution_layer: NotifyExecutionLayer,
+        block_source: BlockImportSource,
         publish_fn: impl FnOnce() -> Result<(), BlockError<T::EthSpec>> + Send + 'static,
     ) -> Result<AvailabilityProcessingStatus, BlockError<T::EthSpec>> {
         // Start the Prometheus timer.
@@ -2999,22 +3003,20 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         // Increment the Prometheus counter for block processing requests.
         metrics::inc_counter(&metrics::BLOCK_PROCESSING_REQUESTS);
 
+        let block_slot = unverified_block.block().slot();
+
         // Set observed time if not already set. Usually this should be set by gossip or RPC,
         // but just in case we set it again here (useful for tests).
-        if let (Some(seen_timestamp), Some(current_slot)) =
-            (self.slot_clock.now_duration(), self.slot_clock.now())
-        {
+        if let Some(seen_timestamp) = self.slot_clock.now_duration() {
             self.block_times_cache.write().set_time_observed(
                 block_root,
-                current_slot,
+                block_slot,
                 seen_timestamp,
                 None,
                 None,
             );
         }
 
-        let block_slot = unverified_block.block().slot();
-
         // A small closure to group the verification and import errors.
         let chain = self.clone();
         let import_block = async move {
@@ -3025,6 +3027,15 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             )?;
             publish_fn()?;
             let executed_block = chain.into_executed_block(execution_pending).await?;
+            // Record the time it took to ask the execution layer.
+            if let Some(seen_timestamp) = self.slot_clock.now_duration() {
+                self.block_times_cache.write().set_execution_time(
+                    block_root,
+                    block_slot,
+                    seen_timestamp,
+                )
+            }
+
             match executed_block {
                 ExecutedBlock::Available(block) => {
                     self.import_available_block(Box::new(block)).await
@@ -3044,6 +3055,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                     "Beacon block imported";
                     "block_root" => ?block_root,
                     "block_slot" => block_slot,
+                    "source" => %block_source,
                 );
 
                 // Increment the Prometheus counter for block processing successes.
@@ -3091,8 +3103,8 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         }
     }
 
-    /// Accepts a fully-verified block and awaits on it's payload verification handle to
-    /// get a fully `ExecutedBlock`
+    /// Accepts a fully-verified block and awaits on its payload verification handle to
+    /// get a fully `ExecutedBlock`.
     ///
     /// An error is returned if the verification handle couldn't be awaited.
     pub async fn into_executed_block(
@@ -3225,10 +3237,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     ) -> Result<AvailabilityProcessingStatus, BlockError<T::EthSpec>> {
         match availability {
             Availability::Available(block) => {
-                // This is the time since start of the slot where all the components of the block have become available
-                let delay =
-                    get_slot_delay_ms(timestamp_now(), block.block.slot(), &self.slot_clock);
-                metrics::observe_duration(&metrics::BLOCK_AVAILABILITY_DELAY, delay);
                 // Block is fully available, import into fork choice
                 self.import_available_block(block).await
             }
@@ -3257,6 +3265,15 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             consensus_context,
         } = import_data;
 
+        // Record the time at which this block's blobs became available.
+        if let Some(blobs_available) = block.blobs_available_timestamp() {
+            self.block_times_cache.write().set_time_blob_observed(
+                block_root,
+                block.slot(),
+                blobs_available,
+            );
+        }
+
         // import
         let chain = self.clone();
         let block_root = self
@@ -3397,6 +3414,14 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                                 "Early attester cache insert failed";
                                 "error" => ?e
                             );
+                        } else {
+                            let attestable_timestamp =
+                                self.slot_clock.now_duration().unwrap_or_default();
+                            self.block_times_cache.write().set_time_attestable(
+                                block_root,
+                                signed_block.slot(),
+                                attestable_timestamp,
+                            )
                         }
                     } else {
                         warn!(
@@ -3542,29 +3567,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 });
         }
 
-        self.snapshot_cache
-            .try_write_for(BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT)
-            .ok_or(Error::SnapshotCacheLockTimeout)
-            .map(|mut snapshot_cache| {
-                snapshot_cache.insert(
-                    BeaconSnapshot {
-                        beacon_state: state,
-                        beacon_block: signed_block.clone(),
-                        beacon_block_root: block_root,
-                    },
-                    None,
-                    &self.spec,
-                )
-            })
-            .unwrap_or_else(|e| {
-                error!(
-                    self.log,
-                    "Failed to insert snapshot";
-                    "error" => ?e,
-                    "task" => "process block"
-                );
-            });
-
         self.head_tracker
             .register_block(block_root, parent_root, slot);
 
@@ -3886,25 +3888,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             );
         }
 
-        // Do not store metrics if the block was > 4 slots old, this helps prevent noise during
-        // sync.
-        if block_delay_total < self.slot_clock.slot_duration() * 4 {
-            // Observe the delay between when we observed the block and when we imported it.
-            let block_delays = self.block_times_cache.read().get_block_delays(
-                block_root,
-                self.slot_clock
-                    .start_of(current_slot)
-                    .unwrap_or_else(|| Duration::from_secs(0)),
-            );
-
-            metrics::observe_duration(
-                &metrics::BEACON_BLOCK_IMPORTED_OBSERVED_DELAY_TIME,
-                block_delays
-                    .imported
-                    .unwrap_or_else(|| Duration::from_secs(0)),
-            );
-        }
-
         if let Some(event_handler) = self.event_handler.as_ref() {
             if event_handler.has_block_subscribers() {
                 event_handler.register(EventKind::Block(SseBlock {
@@ -4145,22 +4128,22 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         self.wait_for_fork_choice_before_block_production(slot)?;
         drop(fork_choice_timer);
 
-        // Producing a block requires the tree hash cache, so clone a full state corresponding to
-        // the head from the snapshot cache. Unfortunately we can't move the snapshot out of the
-        // cache (which would be fast), because we need to re-process the block after it has been
-        // signed. If we miss the cache or we're producing a block that conflicts with the head,
-        // fall back to getting the head from `slot - 1`.
         let state_load_timer = metrics::start_timer(&metrics::BLOCK_PRODUCTION_STATE_LOAD_TIMES);
 
         // Atomically read some values from the head whilst avoiding holding cached head `Arc` any
         // longer than necessary.
-        let (head_slot, head_block_root) = {
+        let (head_slot, head_block_root, head_state_root) = {
             let head = self.canonical_head.cached_head();
-            (head.head_slot(), head.head_block_root())
+            (
+                head.head_slot(),
+                head.head_block_root(),
+                head.head_state_root(),
+            )
         };
         let (state, state_root_opt) = if head_slot < slot {
             // Attempt an aggressive re-org if configured and the conditions are right.
-            if let Some(re_org_state) = self.get_state_for_re_org(slot, head_slot, head_block_root)
+            if let Some((re_org_state, re_org_state_root)) =
+                self.get_state_for_re_org(slot, head_slot, head_block_root)
             {
                 info!(
                     self.log,
@@ -4168,37 +4151,16 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                     "slot" => slot,
                     "head_to_reorg" => %head_block_root,
                 );
-                (re_org_state.pre_state, re_org_state.state_root)
-            }
-            // Normal case: proposing a block atop the current head using the cache.
-            else if let Some((_, cached_state)) =
-                self.get_state_from_block_production_cache(head_block_root)
-            {
-                (cached_state.pre_state, cached_state.state_root)
-            }
-            // Fall back to a direct read of the snapshot cache.
-            else if let Some(pre_state) =
-                self.get_state_from_snapshot_cache_for_block_production(head_block_root)
-            {
-                warn!(
-                    self.log,
-                    "Block production cache miss";
-                    "message" => "falling back to snapshot cache clone",
-                    "slot" => slot
-                );
-                (pre_state.pre_state, pre_state.state_root)
+                (re_org_state, Some(re_org_state_root))
             } else {
-                warn!(
-                    self.log,
-                    "Block production cache miss";
-                    "message" => "this block is more likely to be orphaned",
-                    "slot" => slot,
-                );
-                let state = self
-                    .state_at_slot(slot - 1, StateSkipConfig::WithStateRoots)
-                    .map_err(|_| BlockProductionError::UnableToProduceAtSlot(slot))?;
-
-                (state, None)
+                // Fetch the head state advanced through to `slot`, which should be present in the
+                // state cache thanks to the state advance timer.
+                let (state_root, state) = self
+                    .store
+                    .get_advanced_hot_state(head_block_root, slot, head_state_root)
+                    .map_err(BlockProductionError::FailedToLoadState)?
+                    .ok_or(BlockProductionError::UnableToProduceAtSlot(slot))?;
+                (state, Some(state_root))
             }
         } else {
             warn!(
@@ -4219,40 +4181,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         Ok((state, state_root_opt))
     }
 
-    /// Get the state cached for block production *if* it matches `head_block_root`.
-    ///
-    /// This will clear the cache regardless of whether the block root matches, so only call this if
-    /// you think the `head_block_root` is likely to match!
-    fn get_state_from_block_production_cache(
-        &self,
-        head_block_root: Hash256,
-    ) -> Option<(Hash256, BlockProductionPreState<T::EthSpec>)> {
-        // Take care to drop the lock as quickly as possible.
-        let mut lock = self.block_production_state.lock();
-        let result = lock
-            .take()
-            .filter(|(cached_block_root, _)| *cached_block_root == head_block_root);
-        drop(lock);
-        result
-    }
-
-    /// Get a state for block production from the snapshot cache.
-    fn get_state_from_snapshot_cache_for_block_production(
-        &self,
-        head_block_root: Hash256,
-    ) -> Option<BlockProductionPreState<T::EthSpec>> {
-        if let Some(lock) = self
-            .snapshot_cache
-            .try_read_for(BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT)
-        {
-            let result = lock.get_state_for_block_production(head_block_root);
-            drop(lock);
-            result
-        } else {
-            None
-        }
-    }
-
     /// Fetch the beacon state to use for producing a block if a 1-slot proposer re-org is viable.
     ///
     /// This function will return `None` if proposer re-orgs are disabled.
@@ -4261,7 +4189,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         slot: Slot,
         head_slot: Slot,
         canonical_head: Hash256,
-    ) -> Option<BlockProductionPreState<T::EthSpec>> {
+    ) -> Option<(BeaconState<T::EthSpec>, Hash256)> {
         let re_org_head_threshold = self.config.re_org_head_threshold?;
         let re_org_parent_threshold = self.config.re_org_parent_threshold?;
 
@@ -4345,26 +4273,14 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         drop(proposer_head_timer);
         let re_org_parent_block = proposer_head.parent_node.root;
 
-        // Only attempt a re-org if we hit the block production cache or snapshot cache.
-        let pre_state = self
-            .get_state_from_block_production_cache(re_org_parent_block)
-            .map(|(_, state)| state)
+        let (state_root, state) = self
+            .store
+            .get_advanced_hot_state_from_cache(re_org_parent_block, slot)
             .or_else(|| {
                 warn!(
-                    self.log,
-                    "Block production cache miss";
-                    "message" => "falling back to snapshot cache during re-org",
-                    "slot" => slot,
-                    "block_root" => ?re_org_parent_block
-                );
-                self.get_state_from_snapshot_cache_for_block_production(re_org_parent_block)
-            })
-            .or_else(|| {
-                debug!(
                     self.log,
                     "Not attempting re-org";
-                    "reason" => "missed snapshot cache",
-                    "parent_block" => ?re_org_parent_block,
+                    "reason" => "no state in cache"
                 );
                 None
             })?;
@@ -4378,7 +4294,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             "threshold_weight" => proposer_head.re_org_head_weight_threshold
         );
 
-        Some(pre_state)
+        Some((state, state_root))
     }
 
     /// Get the proposer index and `prev_randao` value for a proposal at slot `proposal_slot`.
@@ -4506,34 +4422,15 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         let (unadvanced_state, unadvanced_state_root) =
             if cached_head.head_block_root() == parent_block_root {
                 (Cow::Borrowed(head_state), cached_head.head_state_root())
-            } else if let Some(snapshot) = self
-                .snapshot_cache
-                .try_read_for(BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT)
-                .ok_or(Error::SnapshotCacheLockTimeout)?
-                .get_cloned(parent_block_root, CloneConfig::none())
-            {
-                debug!(
-                    self.log,
-                    "Hit snapshot cache during withdrawals calculation";
-                    "slot" => proposal_slot,
-                    "parent_block_root" => ?parent_block_root,
-                );
-                let state_root = snapshot.beacon_state_root();
-                (Cow::Owned(snapshot.beacon_state), state_root)
             } else {
-                info!(
-                    self.log,
-                    "Missed snapshot cache during withdrawals calculation";
-                    "slot" => proposal_slot,
-                    "parent_block_root" => ?parent_block_root
-                );
                 let block = self
                     .get_blinded_block(&parent_block_root)?
                     .ok_or(Error::MissingBeaconBlock(parent_block_root))?;
-                let state = self
-                    .get_state(&block.state_root(), Some(block.slot()))?
+                let (state_root, state) = self
+                    .store
+                    .get_advanced_hot_state(parent_block_root, proposal_slot, block.state_root())?
                     .ok_or(Error::MissingBeaconState(block.state_root()))?;
-                (Cow::Owned(state), block.state_root())
+                (Cow::Owned(state), state_root)
             };
 
         // Parent state epoch is the same as the proposal, we don't need to advance because the
@@ -4778,6 +4675,10 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         //
         // Perform the state advance and block-packing functions.
         let chain = self.clone();
+        let graffiti = self
+            .graffiti_calculator
+            .get_graffiti(validator_graffiti)
+            .await;
         let mut partial_beacon_block = self
             .task_executor
             .spawn_blocking_handle(
@@ -4787,7 +4688,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                         state_root_opt,
                         produce_at_slot,
                         randao_reveal,
-                        validator_graffiti,
+                        graffiti,
                         builder_boost_factor,
                         block_production_version,
                     )
@@ -4885,7 +4786,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         state_root_opt: Option<Hash256>,
         produce_at_slot: Slot,
         randao_reveal: Signature,
-        validator_graffiti: Option<Graffiti>,
+        graffiti: Graffiti,
         builder_boost_factor: Option<u64>,
         block_production_version: BlockProductionVersion,
     ) -> Result<PartialBeaconBlock<T::EthSpec>, BlockProductionError> {
@@ -4910,6 +4811,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         drop(slot_timer);
 
         state.build_committee_cache(RelativeEpoch::Current, &self.spec)?;
+        state.apply_pending_mutations()?;
 
         let parent_root = if state.slot() > 0 {
             *state
@@ -4941,7 +4843,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         // allows it to run concurrently with things like attestation packing.
         let prepare_payload_handle = match &state {
             BeaconState::Base(_) | BeaconState::Altair(_) => None,
-            BeaconState::Merge(_)
+            BeaconState::Bellatrix(_)
             | BeaconState::Capella(_)
             | BeaconState::Deneb(_)
             | BeaconState::Electra(_) => {
@@ -4990,12 +4892,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         }
         drop(unagg_import_timer);
 
-        // Override the beacon node's graffiti with graffiti from the validator, if present.
-        let graffiti = match validator_graffiti {
-            Some(graffiti) => graffiti,
-            None => self.graffiti,
-        };
-
         let attestation_packing_timer =
             metrics::start_timer(&metrics::BLOCK_PRODUCTION_ATTESTATION_TIMES);
 
@@ -5207,17 +5103,17 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 None,
                 Uint256::zero(),
             ),
-            BeaconState::Merge(_) => {
+            BeaconState::Bellatrix(_) => {
                 let block_proposal_contents =
                     block_contents.ok_or(BlockProductionError::MissingExecutionPayload)?;
                 let execution_payload_value = block_proposal_contents.block_value().to_owned();
                 (
-                    BeaconBlock::Merge(BeaconBlockMerge {
+                    BeaconBlock::Bellatrix(BeaconBlockBellatrix {
                         slot,
                         proposer_index,
                         parent_root,
                         state_root: Hash256::zero(),
-                        body: BeaconBlockBodyMerge {
+                        body: BeaconBlockBodyBellatrix {
                             randao_reveal,
                             eth1_data,
                             graffiti,
@@ -5383,7 +5279,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             &mut state,
             &block,
             signature_strategy,
-            StateProcessingStrategy::Accurate,
             VerifyBlockRoot::True,
             &mut ctxt,
             &self.spec,
@@ -5666,7 +5561,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         } else {
             let prepare_slot_fork = self.spec.fork_name_at_slot::<T::EthSpec>(prepare_slot);
             let withdrawals = match prepare_slot_fork {
-                ForkName::Base | ForkName::Altair | ForkName::Merge => None,
+                ForkName::Base | ForkName::Altair | ForkName::Bellatrix => None,
                 ForkName::Capella | ForkName::Deneb | ForkName::Electra => {
                     let chain = self.clone();
                     self.spawn_blocking_handle(
@@ -5681,7 +5576,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             };
 
             let parent_beacon_block_root = match prepare_slot_fork {
-                ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => None,
+                ForkName::Base | ForkName::Altair | ForkName::Bellatrix | ForkName::Capella => None,
                 ForkName::Deneb | ForkName::Electra => {
                     Some(pre_payload_attributes.parent_beacon_block_root)
                 }
@@ -6308,6 +6203,17 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 "head_block_root" => head_block_root.to_string(),
             );
 
+            // If the block's state will be so far ahead of `shuffling_epoch` that even its
+            // previous epoch committee cache will be too new, then error. Callers of this function
+            // shouldn't be requesting such old shufflings for this `head_block_root`.
+            let head_block_epoch = head_block.slot.epoch(T::EthSpec::slots_per_epoch());
+            if head_block_epoch > shuffling_epoch + 1 {
+                return Err(Error::InvalidStateForShuffling {
+                    state_epoch: head_block_epoch,
+                    shuffling_epoch,
+                });
+            }
+
             let state_read_timer =
                 metrics::start_timer(&metrics::ATTESTATION_PROCESSING_STATE_READ_TIMES);
 
@@ -6318,71 +6224,52 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             // to copy the head is liable to race-conditions.
             let head_state_opt = self.with_head(|head| {
                 if head.beacon_block_root == head_block_root {
-                    Ok(Some((
-                        head.beacon_state
-                            .clone_with(CloneConfig::committee_caches_only()),
-                        head.beacon_state_root(),
-                    )))
+                    Ok(Some((head.beacon_state.clone(), head.beacon_state_root())))
                 } else {
                     Ok::<_, Error>(None)
                 }
             })?;
 
+            // Compute the `target_slot` to advance the block's state to.
+            //
+            // Since there's a one-epoch look-ahead on the attester shuffling, it suffices to
+            // only advance into the first slot of the epoch prior to `shuffling_epoch`.
+            //
+            // If the `head_block` is already ahead of that slot, then we should load the state
+            // at that slot, as we've determined above that the `shuffling_epoch` cache will
+            // not be too far in the past.
+            let target_slot = std::cmp::max(
+                shuffling_epoch
+                    .saturating_sub(1_u64)
+                    .start_slot(T::EthSpec::slots_per_epoch()),
+                head_block.slot,
+            );
+
             // If the head state is useful for this request, use it. Otherwise, read a state from
-            // disk.
+            // disk that is advanced as close as possible to `target_slot`.
             let (mut state, state_root) = if let Some((state, state_root)) = head_state_opt {
                 (state, state_root)
             } else {
-                let block_state_root = head_block.state_root;
-                let max_slot = shuffling_epoch.start_slot(T::EthSpec::slots_per_epoch());
                 let (state_root, state) = self
                     .store
-                    .get_inconsistent_state_for_attestation_verification_only(
-                        &head_block_root,
-                        max_slot,
-                        block_state_root,
-                    )?
-                    .ok_or(Error::MissingBeaconState(block_state_root))?;
+                    .get_advanced_hot_state(head_block_root, target_slot, head_block.state_root)?
+                    .ok_or(Error::MissingBeaconState(head_block.state_root))?;
                 (state, state_root)
             };
 
-            /*
-             * IMPORTANT
-             *
-             * Since it's possible that
-             * `Store::get_inconsistent_state_for_attestation_verification_only` was used to obtain
-             * the state, we cannot rely upon the following fields:
-             *
-             * - `state.state_roots`
-             * - `state.block_roots`
-             *
-             * These fields should not be used for the rest of this function.
-             */
-
             metrics::stop_timer(state_read_timer);
             let state_skip_timer =
                 metrics::start_timer(&metrics::ATTESTATION_PROCESSING_STATE_SKIP_TIMES);
 
-            // If the state is in an earlier epoch, advance it. If it's from a later epoch, reject
-            // it.
+            // If the state is still in an earlier epoch, advance it to the `target_slot` so
+            // that its next epoch committee cache matches the `shuffling_epoch`.
             if state.current_epoch() + 1 < shuffling_epoch {
-                // Since there's a one-epoch look-ahead on the attester shuffling, it suffices to
-                // only advance into the slot prior to the `shuffling_epoch`.
-                let target_slot = shuffling_epoch
-                    .saturating_sub(1_u64)
-                    .start_slot(T::EthSpec::slots_per_epoch());
-
-                // Advance the state into the required slot, using the "partial" method since the state
-                // roots are not relevant for the shuffling.
+                // Advance the state into the required slot, using the "partial" method since the
+                // state roots are not relevant for the shuffling.
                 partial_state_advance(&mut state, Some(state_root), target_slot, &self.spec)?;
-            } else if state.current_epoch() > shuffling_epoch {
-                return Err(Error::InvalidStateForShuffling {
-                    state_epoch: state.current_epoch(),
-                    shuffling_epoch,
-                });
             }
-
             metrics::stop_timer(state_skip_timer);
+
             let committee_building_timer =
                 metrics::start_timer(&metrics::ATTESTATION_PROCESSING_COMMITTEE_BUILDING_TIMES);
 
@@ -6391,8 +6278,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
 
             state.build_committee_cache(relative_epoch, &self.spec)?;
 
-            let committee_cache = state.take_committee_cache(relative_epoch)?;
-            let committee_cache = Arc::new(committee_cache);
+            let committee_cache = state.committee_cache(relative_epoch)?.clone();
             let shuffling_decision_block = shuffling_id.shuffling_decision_block;
 
             self.shuffling_cache
@@ -6412,29 +6298,27 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     ///
     /// This could be a very expensive operation and should only be done in testing/analysis
     /// activities.
+    ///
+    /// This dump function previously used a backwards iterator but has been swapped to a forwards
+    /// iterator as it allows for MUCH better caching and rebasing. Memory usage of some tests went
+    /// from 5GB per test to 90MB.
     #[allow(clippy::type_complexity)]
     pub fn chain_dump(
         &self,
     ) -> Result<Vec<BeaconSnapshot<T::EthSpec, BlindedPayload<T::EthSpec>>>, Error> {
         let mut dump = vec![];
 
-        let mut last_slot = {
-            let head = self.canonical_head.cached_head();
-            BeaconSnapshot {
-                beacon_block: Arc::new(head.snapshot.beacon_block.clone_as_blinded()),
-                beacon_block_root: head.snapshot.beacon_block_root,
-                beacon_state: head.snapshot.beacon_state.clone(),
-            }
-        };
-
-        dump.push(last_slot.clone());
+        let mut prev_block_root = None;
+        let mut prev_beacon_state = None;
 
-        loop {
-            let beacon_block_root = last_slot.beacon_block.parent_root();
+        for res in self.forwards_iter_block_roots(Slot::new(0))? {
+            let (beacon_block_root, _) = res?;
 
-            if beacon_block_root == Hash256::zero() {
-                break; // Genesis has been reached.
+            // Do not include snapshots at skipped slots.
+            if Some(beacon_block_root) == prev_block_root {
+                continue;
             }
+            prev_block_root = Some(beacon_block_root);
 
             let beacon_block = self
                 .store
@@ -6443,25 +6327,31 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                     Error::DBInconsistent(format!("Missing block {}", beacon_block_root))
                 })?;
             let beacon_state_root = beacon_block.state_root();
-            let beacon_state = self
+
+            let mut beacon_state = self
                 .store
                 .get_state(&beacon_state_root, Some(beacon_block.slot()))?
                 .ok_or_else(|| {
                     Error::DBInconsistent(format!("Missing state {:?}", beacon_state_root))
                 })?;
 
-            let slot = BeaconSnapshot {
+            // This beacon state might come from the freezer DB, which means it could have pending
+            // updates or lots of untethered memory. We rebase it on the previous state in order to
+            // address this.
+            beacon_state.apply_pending_mutations()?;
+            if let Some(prev) = prev_beacon_state {
+                beacon_state.rebase_on(&prev, &self.spec)?;
+            }
+            beacon_state.build_caches(&self.spec)?;
+            prev_beacon_state = Some(beacon_state.clone());
+
+            let snapshot = BeaconSnapshot {
                 beacon_block: Arc::new(beacon_block),
                 beacon_block_root,
                 beacon_state,
             };
-
-            dump.push(slot.clone());
-            last_slot = slot;
+            dump.push(snapshot);
         }
-
-        dump.reverse();
-
         Ok(dump)
     }
 
@@ -6696,6 +6586,10 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         self.data_availability_checker.data_availability_boundary()
     }
 
+    pub fn logger(&self) -> &Logger {
+        &self.log
+    }
+
     /// Gets the `LightClientBootstrap` object for a requested block root.
     ///
     /// Returns `None` when the state or block is not found in the database.
@@ -6725,7 +6619,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
 
         match fork_name {
             ForkName::Altair
-            | ForkName::Merge
+            | ForkName::Bellatrix
             | ForkName::Capella
             | ForkName::Deneb
             | ForkName::Electra => {
diff --git a/beacon_node/beacon_chain/src/beacon_proposer_cache.rs b/beacon_node/beacon_chain/src/beacon_proposer_cache.rs
index ca390712b13..d10bbfbbc5f 100644
--- a/beacon_node/beacon_chain/src/beacon_proposer_cache.rs
+++ b/beacon_node/beacon_chain/src/beacon_proposer_cache.rs
@@ -17,8 +17,7 @@ use std::cmp::Ordering;
 use std::num::NonZeroUsize;
 use types::non_zero_usize::new_non_zero_usize;
 use types::{
-    BeaconState, BeaconStateError, ChainSpec, CloneConfig, Epoch, EthSpec, Fork, Hash256, Slot,
-    Unsigned,
+    BeaconState, BeaconStateError, ChainSpec, Epoch, EthSpec, Fork, Hash256, Slot, Unsigned,
 };
 
 /// The number of sets of proposer indices that should be cached.
@@ -145,10 +144,7 @@ pub fn compute_proposer_duties_from_head<T: BeaconChainTypes>(
     let (mut state, head_state_root, head_block_root) = {
         let head = chain.canonical_head.cached_head();
         // Take a copy of the head state.
-        let head_state = head
-            .snapshot
-            .beacon_state
-            .clone_with(CloneConfig::committee_caches_only());
+        let head_state = head.snapshot.beacon_state.clone();
         let head_state_root = head.head_state_root();
         let head_block_root = head.head_block_root();
         (head_state, head_state_root, head_block_root)
diff --git a/beacon_node/beacon_chain/src/beacon_snapshot.rs b/beacon_node/beacon_chain/src/beacon_snapshot.rs
index afb13247766..e9fde48ac67 100644
--- a/beacon_node/beacon_chain/src/beacon_snapshot.rs
+++ b/beacon_node/beacon_chain/src/beacon_snapshot.rs
@@ -1,8 +1,8 @@
 use serde::Serialize;
 use std::sync::Arc;
 use types::{
-    beacon_state::CloneConfig, AbstractExecPayload, BeaconState, EthSpec, FullPayload, Hash256,
-    SignedBeaconBlock,
+    AbstractExecPayload, BeaconState, EthSpec, FullPayload, Hash256, SignedBeaconBlock,
+    SignedBlindedBeaconBlock,
 };
 
 /// Represents some block and its associated state. Generally, this will be used for tracking the
@@ -14,6 +14,19 @@ pub struct BeaconSnapshot<E: EthSpec, Payload: AbstractExecPayload<E> = FullPayl
     pub beacon_state: BeaconState<E>,
 }
 
+/// This snapshot is to be used for verifying a child of `self.beacon_block`.
+#[derive(Debug)]
+pub struct PreProcessingSnapshot<T: EthSpec> {
+    /// This state is equivalent to the `self.beacon_block.state_root()` state that has been
+    /// advanced forward one slot using `per_slot_processing`. This state is "primed and ready" for
+    /// the application of another block.
+    pub pre_state: BeaconState<T>,
+    /// This value is only set to `Some` if the `pre_state` was *not* advanced forward.
+    pub beacon_state_root: Option<Hash256>,
+    pub beacon_block: SignedBlindedBeaconBlock<T>,
+    pub beacon_block_root: Hash256,
+}
+
 impl<E: EthSpec, Payload: AbstractExecPayload<E>> BeaconSnapshot<E, Payload> {
     /// Create a new checkpoint.
     pub fn new(
@@ -48,12 +61,4 @@ impl<E: EthSpec, Payload: AbstractExecPayload<E>> BeaconSnapshot<E, Payload> {
         self.beacon_block_root = beacon_block_root;
         self.beacon_state = beacon_state;
     }
-
-    pub fn clone_with(&self, clone_config: CloneConfig) -> Self {
-        Self {
-            beacon_block: self.beacon_block.clone(),
-            beacon_block_root: self.beacon_block_root,
-            beacon_state: self.beacon_state.clone_with(clone_config),
-        }
-    }
 }
diff --git a/beacon_node/beacon_chain/src/merge_readiness.rs b/beacon_node/beacon_chain/src/bellatrix_readiness.rs
similarity index 91%
rename from beacon_node/beacon_chain/src/merge_readiness.rs
rename to beacon_node/beacon_chain/src/bellatrix_readiness.rs
index 52a5ea912e0..bf9e8481261 100644
--- a/beacon_node/beacon_chain/src/merge_readiness.rs
+++ b/beacon_node/beacon_chain/src/bellatrix_readiness.rs
@@ -11,7 +11,7 @@ use types::*;
 
 /// The time before the Bellatrix fork when we will start issuing warnings about preparation.
 pub const SECONDS_IN_A_WEEK: u64 = 604800;
-pub const MERGE_READINESS_PREPARATION_SECONDS: u64 = SECONDS_IN_A_WEEK * 2;
+pub const BELLATRIX_READINESS_PREPARATION_SECONDS: u64 = SECONDS_IN_A_WEEK * 2;
 
 #[derive(Default, Debug, Serialize, Deserialize)]
 pub struct MergeConfig {
@@ -81,7 +81,7 @@ impl MergeConfig {
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 #[serde(tag = "type")]
-pub enum MergeReadiness {
+pub enum BellatrixReadiness {
     /// The node is ready, as far as we can tell.
     Ready {
         config: MergeConfig,
@@ -94,29 +94,29 @@ pub enum MergeReadiness {
     NoExecutionEndpoint,
 }
 
-impl fmt::Display for MergeReadiness {
+impl fmt::Display for BellatrixReadiness {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            MergeReadiness::Ready {
+            BellatrixReadiness::Ready {
                 config: params,
                 current_difficulty,
             } => {
                 write!(
                     f,
-                    "This node appears ready for the merge. \
+                    "This node appears ready for Bellatrix \
                         Params: {}, current_difficulty: {:?}",
                     params, current_difficulty
                 )
             }
-            MergeReadiness::NotSynced => write!(
+            BellatrixReadiness::NotSynced => write!(
                 f,
                 "The execution endpoint is connected and configured, \
                     however it is not yet synced"
             ),
-            MergeReadiness::NoExecutionEndpoint => write!(
+            BellatrixReadiness::NoExecutionEndpoint => write!(
                 f,
                 "The --execution-endpoint flag is not specified, this is a \
-                    requirement for the merge"
+                    requirement for Bellatrix"
             ),
         }
     }
@@ -143,12 +143,12 @@ pub enum GenesisExecutionPayloadStatus {
 
 impl<T: BeaconChainTypes> BeaconChain<T> {
     /// Returns `true` if user has an EL configured, or if the Bellatrix fork has occurred or will
-    /// occur within `MERGE_READINESS_PREPARATION_SECONDS`.
+    /// occur within `BELLATRIX_READINESS_PREPARATION_SECONDS`.
     pub fn is_time_to_prepare_for_bellatrix(&self, current_slot: Slot) -> bool {
         if let Some(bellatrix_epoch) = self.spec.bellatrix_fork_epoch {
             let bellatrix_slot = bellatrix_epoch.start_slot(T::EthSpec::slots_per_epoch());
-            let merge_readiness_preparation_slots =
-                MERGE_READINESS_PREPARATION_SECONDS / self.spec.seconds_per_slot;
+            let bellatrix_readiness_preparation_slots =
+                BELLATRIX_READINESS_PREPARATION_SECONDS / self.spec.seconds_per_slot;
 
             if self.execution_layer.is_some() {
                 // The user has already configured an execution layer, start checking for readiness
@@ -156,7 +156,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 true
             } else {
                 // Return `true` if Bellatrix has happened or is within the preparation time.
-                current_slot + merge_readiness_preparation_slots > bellatrix_slot
+                current_slot + bellatrix_readiness_preparation_slots > bellatrix_slot
             }
         } else {
             // The Bellatrix fork epoch has not been defined yet, no need to prepare.
@@ -164,22 +164,22 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         }
     }
 
-    /// Attempts to connect to the EL and confirm that it is ready for the merge.
-    pub async fn check_merge_readiness(&self, current_slot: Slot) -> MergeReadiness {
+    /// Attempts to connect to the EL and confirm that it is ready for Bellatrix.
+    pub async fn check_bellatrix_readiness(&self, current_slot: Slot) -> BellatrixReadiness {
         if let Some(el) = self.execution_layer.as_ref() {
             if !el.is_synced_for_notifier(current_slot).await {
                 // The EL is not synced.
-                return MergeReadiness::NotSynced;
+                return BellatrixReadiness::NotSynced;
             }
             let params = MergeConfig::from_chainspec(&self.spec);
             let current_difficulty = el.get_current_difficulty().await.ok();
-            MergeReadiness::Ready {
+            BellatrixReadiness::Ready {
                 config: params,
                 current_difficulty,
             }
         } else {
             // There is no EL configured.
-            MergeReadiness::NoExecutionEndpoint
+            BellatrixReadiness::NoExecutionEndpoint
         }
     }
 
diff --git a/beacon_node/beacon_chain/src/blob_verification.rs b/beacon_node/beacon_chain/src/blob_verification.rs
index a69f2b74524..fdf8ee2b971 100644
--- a/beacon_node/beacon_chain/src/blob_verification.rs
+++ b/beacon_node/beacon_chain/src/blob_verification.rs
@@ -2,7 +2,7 @@ use derivative::Derivative;
 use slot_clock::SlotClock;
 use std::sync::Arc;
 
-use crate::beacon_chain::{BeaconChain, BeaconChainTypes, BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT};
+use crate::beacon_chain::{BeaconChain, BeaconChainTypes};
 use crate::block_verification::{
     cheap_state_advance_to_obtain_committees, get_validator_pubkey_cache, process_block_slash_info,
     BlockSlashInfo,
@@ -11,14 +11,13 @@ use crate::kzg_utils::{validate_blob, validate_blobs};
 use crate::{metrics, BeaconChainError};
 use kzg::{Error as KzgError, Kzg, KzgCommitment};
 use merkle_proof::MerkleTreeError;
-use slog::{debug, warn};
+use slog::debug;
 use ssz_derive::{Decode, Encode};
 use ssz_types::VariableList;
+use std::time::Duration;
 use tree_hash::TreeHash;
 use types::blob_sidecar::BlobIdentifier;
-use types::{
-    BeaconStateError, BlobSidecar, CloneConfig, EthSpec, Hash256, SignedBeaconBlockHeader, Slot,
-};
+use types::{BeaconStateError, BlobSidecar, EthSpec, Hash256, SignedBeaconBlockHeader, Slot};
 
 /// An error occurred while validating a gossip blob.
 #[derive(Debug)]
@@ -214,7 +213,10 @@ impl<T: BeaconChainTypes> GossipVerifiedBlob<T> {
     pub fn __assumed_valid(blob: Arc<BlobSidecar<T::EthSpec>>) -> Self {
         Self {
             block_root: blob.block_root(),
-            blob: KzgVerifiedBlob { blob },
+            blob: KzgVerifiedBlob {
+                blob,
+                seen_timestamp: Duration::from_secs(0),
+            },
         }
     }
     pub fn id(&self) -> BlobIdentifier {
@@ -260,6 +262,8 @@ impl<T: BeaconChainTypes> GossipVerifiedBlob<T> {
 #[ssz(struct_behaviour = "transparent")]
 pub struct KzgVerifiedBlob<E: EthSpec> {
     blob: Arc<BlobSidecar<E>>,
+    #[ssz(skip_serializing, skip_deserializing)]
+    seen_timestamp: Duration,
 }
 
 impl<E: EthSpec> PartialOrd for KzgVerifiedBlob<E> {
@@ -275,8 +279,12 @@ impl<E: EthSpec> Ord for KzgVerifiedBlob<E> {
 }
 
 impl<E: EthSpec> KzgVerifiedBlob<E> {
-    pub fn new(blob: Arc<BlobSidecar<E>>, kzg: &Kzg) -> Result<Self, KzgError> {
-        verify_kzg_for_blob(blob, kzg)
+    pub fn new(
+        blob: Arc<BlobSidecar<E>>,
+        kzg: &Kzg,
+        seen_timestamp: Duration,
+    ) -> Result<Self, KzgError> {
+        verify_kzg_for_blob(blob, kzg, seen_timestamp)
     }
     pub fn to_blob(self) -> Arc<BlobSidecar<E>> {
         self.blob
@@ -284,6 +292,9 @@ impl<E: EthSpec> KzgVerifiedBlob<E> {
     pub fn as_blob(&self) -> &BlobSidecar<E> {
         &self.blob
     }
+    pub fn get_commitment(&self) -> &KzgCommitment {
+        &self.blob.kzg_commitment
+    }
     /// This is cheap as we're calling clone on an Arc
     pub fn clone_blob(&self) -> Arc<BlobSidecar<E>> {
         self.blob.clone()
@@ -291,12 +302,18 @@ impl<E: EthSpec> KzgVerifiedBlob<E> {
     pub fn blob_index(&self) -> u64 {
         self.blob.index
     }
+    pub fn seen_timestamp(&self) -> Duration {
+        self.seen_timestamp
+    }
     /// Construct a `KzgVerifiedBlob` that is assumed to be valid.
     ///
     /// This should ONLY be used for testing.
     #[cfg(test)]
     pub fn __assumed_valid(blob: Arc<BlobSidecar<E>>) -> Self {
-        Self { blob }
+        Self {
+            blob,
+            seen_timestamp: Duration::from_secs(0),
+        }
     }
 }
 
@@ -306,9 +323,13 @@ impl<E: EthSpec> KzgVerifiedBlob<E> {
 pub fn verify_kzg_for_blob<E: EthSpec>(
     blob: Arc<BlobSidecar<E>>,
     kzg: &Kzg,
+    seen_timestamp: Duration,
 ) -> Result<KzgVerifiedBlob<E>, KzgError> {
     validate_blob::<E>(kzg, &blob.blob, blob.kzg_commitment, blob.kzg_proof)?;
-    Ok(KzgVerifiedBlob { blob })
+    Ok(KzgVerifiedBlob {
+        blob,
+        seen_timestamp,
+    })
 }
 
 pub struct KzgVerifiedBlobList<E: EthSpec> {
@@ -319,13 +340,17 @@ impl<E: EthSpec> KzgVerifiedBlobList<E> {
     pub fn new<I: IntoIterator<Item = Arc<BlobSidecar<E>>>>(
         blob_list: I,
         kzg: &Kzg,
+        seen_timestamp: Duration,
     ) -> Result<Self, KzgError> {
         let blobs = blob_list.into_iter().collect::<Vec<_>>();
         verify_kzg_for_blob_list(blobs.iter(), kzg)?;
         Ok(Self {
             verified_blobs: blobs
                 .into_iter()
-                .map(|blob| KzgVerifiedBlob { blob })
+                .map(|blob| KzgVerifiedBlob {
+                    blob,
+                    seen_timestamp,
+                })
                 .collect(),
         })
     }
@@ -371,6 +396,8 @@ pub fn validate_blob_sidecar_for_gossip<T: BeaconChainTypes>(
     let blob_epoch = blob_slot.epoch(T::EthSpec::slots_per_epoch());
     let signed_block_header = &blob_sidecar.signed_block_header;
 
+    let seen_timestamp = chain.slot_clock.now_duration().unwrap_or_default();
+
     // This condition is not possible if we have received the blob from the network
     // since we only subscribe to `MaxBlobsPerBlock` subnets over gossip network.
     // We include this check only for completeness.
@@ -485,98 +512,43 @@ pub fn validate_blob_sidecar_for_gossip<T: BeaconChainTypes>(
             "block_root" => %block_root,
             "index" => %blob_index,
         );
-        if let Some(mut snapshot) = chain
-            .snapshot_cache
-            .try_read_for(BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT)
-            .and_then(|snapshot_cache| {
-                snapshot_cache.get_cloned(block_parent_root, CloneConfig::committee_caches_only())
-            })
-        {
-            if snapshot.beacon_state.slot() == blob_slot {
-                debug!(
-                    chain.log,
-                    "Cloning snapshot cache state for blob verification";
-                    "block_root" => %block_root,
-                    "index" => %blob_index,
-                );
-                (
-                    snapshot
-                        .beacon_state
-                        .get_beacon_proposer_index(blob_slot, &chain.spec)?,
-                    snapshot.beacon_state.fork(),
-                )
-            } else {
-                debug!(
-                    chain.log,
-                    "Cloning and advancing snapshot cache state for blob verification";
-                    "block_root" => %block_root,
-                    "index" => %blob_index,
-                );
-                let state =
-                    cheap_state_advance_to_obtain_committees::<_, GossipBlobError<T::EthSpec>>(
-                        &mut snapshot.beacon_state,
-                        Some(snapshot.beacon_block_root),
-                        blob_slot,
-                        &chain.spec,
-                    )?;
-                (
-                    state.get_beacon_proposer_index(blob_slot, &chain.spec)?,
-                    state.fork(),
-                )
-            }
-        }
-        // Need to advance the state to get the proposer index
-        else {
-            warn!(
-                chain.log,
-                "Snapshot cache miss for blob verification";
-                "block_root" => %block_root,
-                "index" => %blob_index,
-            );
-
-            let parent_block = chain
-                .get_blinded_block(&block_parent_root)
-                .map_err(GossipBlobError::BeaconChainError)?
-                .ok_or_else(|| {
-                    GossipBlobError::from(BeaconChainError::MissingBeaconBlock(block_parent_root))
-                })?;
-
-            let mut parent_state = chain
-                .get_state(&parent_block.state_root(), Some(parent_block.slot()))?
-                .ok_or_else(|| {
-                    BeaconChainError::DBInconsistent(format!(
-                        "Missing state {:?}",
-                        parent_block.state_root()
-                    ))
-                })?;
-            let state = cheap_state_advance_to_obtain_committees::<_, GossipBlobError<T::EthSpec>>(
-                &mut parent_state,
-                Some(parent_block.state_root()),
-                blob_slot,
-                &chain.spec,
-            )?;
-
-            let proposers = state.get_beacon_proposer_indices(&chain.spec)?;
-            let proposer_index = *proposers
-                .get(blob_slot.as_usize() % T::EthSpec::slots_per_epoch() as usize)
-                .ok_or_else(|| BeaconChainError::NoProposerForSlot(blob_slot))?;
-
-            let fork = state.fork();
-            // Prime the proposer shuffling cache with the newly-learned value.
-            chain.beacon_proposer_cache.lock().insert(
-                blob_epoch,
-                proposer_shuffling_root,
-                proposers,
-                fork,
-            )?;
-            (proposer_index, fork)
-        }
+        let (parent_state_root, mut parent_state) = chain
+            .store
+            .get_advanced_hot_state(block_parent_root, blob_slot, parent_block.state_root)
+            .map_err(|e| GossipBlobError::BeaconChainError(e.into()))?
+            .ok_or_else(|| {
+                BeaconChainError::DBInconsistent(format!(
+                    "Missing state for parent block {block_parent_root:?}",
+                ))
+            })?;
+
+        let state = cheap_state_advance_to_obtain_committees::<_, GossipBlobError<T::EthSpec>>(
+            &mut parent_state,
+            Some(parent_state_root),
+            blob_slot,
+            &chain.spec,
+        )?;
+
+        let proposers = state.get_beacon_proposer_indices(&chain.spec)?;
+        let proposer_index = *proposers
+            .get(blob_slot.as_usize() % T::EthSpec::slots_per_epoch() as usize)
+            .ok_or_else(|| BeaconChainError::NoProposerForSlot(blob_slot))?;
+
+        // Prime the proposer shuffling cache with the newly-learned value.
+        chain.beacon_proposer_cache.lock().insert(
+            blob_epoch,
+            proposer_shuffling_root,
+            proposers,
+            state.fork(),
+        )?;
+        (proposer_index, state.fork())
     };
 
     // Signature verify the signed block header.
     let signature_is_valid = {
         let pubkey_cache =
             get_validator_pubkey_cache(chain).map_err(|_| GossipBlobError::PubkeyCacheTimeout)?;
+
         let pubkey = pubkey_cache
             .get(proposer_index)
             .ok_or_else(|| GossipBlobError::UnknownValidator(proposer_index as u64))?;
@@ -599,6 +571,14 @@ pub fn validate_blob_sidecar_for_gossip<T: BeaconChainTypes>(
         });
     }
 
+    // Kzg verification for gossip blob sidecar
+    let kzg = chain
+        .kzg
+        .as_ref()
+        .ok_or(GossipBlobError::KzgNotInitialized)?;
+    let kzg_verified_blob = KzgVerifiedBlob::new(blob_sidecar.clone(), kzg, seen_timestamp)
+        .map_err(GossipBlobError::KzgError)?;
+
     chain
         .observed_slashable
         .write()
@@ -633,14 +613,6 @@ pub fn validate_blob_sidecar_for_gossip<T: BeaconChainTypes>(
         });
     }
 
-    // Kzg verification for gossip blob sidecar
-    let kzg = chain
-        .kzg
-        .as_ref()
-        .ok_or(GossipBlobError::KzgNotInitialized)?;
-    let kzg_verified_blob =
-        KzgVerifiedBlob::new(blob_sidecar, kzg).map_err(GossipBlobError::KzgError)?;
-
     Ok(GossipVerifiedBlob {
         block_root,
         blob: kzg_verified_blob,
diff --git a/beacon_node/beacon_chain/src/block_times_cache.rs b/beacon_node/beacon_chain/src/block_times_cache.rs
index c5293bcb0ee..db547a1186c 100644
--- a/beacon_node/beacon_chain/src/block_times_cache.rs
+++ b/beacon_node/beacon_chain/src/block_times_cache.rs
@@ -18,6 +18,9 @@ type BlockRoot = Hash256;
 #[derive(Clone, Default)]
 pub struct Timestamps {
     pub observed: Option<Duration>,
+    pub all_blobs_observed: Option<Duration>,
+    pub execution_time: Option<Duration>,
+    pub attestable: Option<Duration>,
     pub imported: Option<Duration>,
     pub set_as_head: Option<Duration>,
 }
@@ -25,8 +28,25 @@ pub struct Timestamps {
 // Helps arrange delay data so it is more relevant to metrics.
 #[derive(Debug, Default)]
 pub struct BlockDelays {
+    /// Time after start of slot we saw the block.
     pub observed: Option<Duration>,
+    /// The time after the start of the slot we saw all blobs.
+    pub all_blobs_observed: Option<Duration>,
+    /// The time it took to get verification from the EL for the block.
+    pub execution_time: Option<Duration>,
+    /// The delay from the start of the slot before the block became available
+    ///
+    /// Equal to max(`observed + execution_time`, `all_blobs_observed`).
+    pub available: Option<Duration>,
+    /// Time after `available`.
+    pub attestable: Option<Duration>,
+    /// Time
+    /// ALSO time after `available`.
+    ///
+    /// We need to use `available` again rather than `attestable` to handle the case where the block
+    /// does not get added to the early-attester cache.
     pub imported: Option<Duration>,
+    /// Time after `imported`.
     pub set_as_head: Option<Duration>,
 }
 
@@ -35,14 +55,34 @@ impl BlockDelays {
         let observed = times
             .observed
             .and_then(|observed_time| observed_time.checked_sub(slot_start_time));
+        let all_blobs_observed = times
+            .all_blobs_observed
+            .and_then(|all_blobs_observed| all_blobs_observed.checked_sub(slot_start_time));
+        let execution_time = times
+            .execution_time
+            .and_then(|execution_time| execution_time.checked_sub(times.observed?));
+        // Duration since UNIX epoch at which block became available.
+        let available_time = times.execution_time.map(|execution_time| {
+            std::cmp::max(execution_time, times.all_blobs_observed.unwrap_or_default())
+        });
+        // Duration from the start of the slot until the block became available.
+        let available_delay =
+            available_time.and_then(|available_time| available_time.checked_sub(slot_start_time));
+        let attestable = times
+            .attestable
+            .and_then(|attestable_time| attestable_time.checked_sub(slot_start_time));
         let imported = times
             .imported
-            .and_then(|imported_time| imported_time.checked_sub(times.observed?));
+            .and_then(|imported_time| imported_time.checked_sub(available_time?));
         let set_as_head = times
             .set_as_head
             .and_then(|set_as_head_time| set_as_head_time.checked_sub(times.imported?));
         BlockDelays {
             observed,
+            all_blobs_observed,
+            execution_time,
+            available: available_delay,
+            attestable,
             imported,
             set_as_head,
         }
@@ -109,6 +149,53 @@ impl BlockTimesCache {
         }
     }
 
+    pub fn set_time_blob_observed(
+        &mut self,
+        block_root: BlockRoot,
+        slot: Slot,
+        timestamp: Duration,
+    ) {
+        let block_times = self
+            .cache
+            .entry(block_root)
+            .or_insert_with(|| BlockTimesCacheValue::new(slot));
+        if block_times
+            .timestamps
+            .all_blobs_observed
+            .map_or(true, |prev| timestamp > prev)
+        {
+            block_times.timestamps.all_blobs_observed = Some(timestamp);
+        }
+    }
+
+    pub fn set_execution_time(&mut self, block_root: BlockRoot, slot: Slot, timestamp: Duration) {
+        let block_times = self
+            .cache
+            .entry(block_root)
+            .or_insert_with(|| BlockTimesCacheValue::new(slot));
+        if block_times
+            .timestamps
+            .execution_time
+            .map_or(true, |prev| timestamp < prev)
+        {
+            block_times.timestamps.execution_time = Some(timestamp);
+        }
+    }
+
+    pub fn set_time_attestable(&mut self, block_root: BlockRoot, slot: Slot, timestamp: Duration) {
+        let block_times = self
+            .cache
+            .entry(block_root)
+            .or_insert_with(|| BlockTimesCacheValue::new(slot));
+        if block_times
+            .timestamps
+            .attestable
+            .map_or(true, |prev| timestamp < prev)
+        {
+            block_times.timestamps.attestable = Some(timestamp);
+        }
+    }
+
     pub fn set_time_imported(&mut self, block_root: BlockRoot, slot: Slot, timestamp: Duration) {
         let block_times = self
             .cache
diff --git a/beacon_node/beacon_chain/src/block_verification.rs b/beacon_node/beacon_chain/src/block_verification.rs
index 3cd8a7f259b..866dde5a763 100644
--- a/beacon_node/beacon_chain/src/block_verification.rs
+++ b/beacon_node/beacon_chain/src/block_verification.rs
@@ -48,6 +48,7 @@
 // returned alongside.
 #![allow(clippy::result_large_err)]
 
+use crate::beacon_snapshot::PreProcessingSnapshot;
 use crate::blob_verification::{GossipBlobError, GossipVerifiedBlob};
 use crate::block_verification_types::{
     AsBlock, BlockContentsError, BlockImportData, GossipVerifiedBlockContents, RpcBlock,
@@ -59,14 +60,10 @@ use crate::execution_payload::{
     AllowOptimisticImport, NotifyExecutionLayer, PayloadNotifier,
 };
 use crate::observed_block_producers::SeenBlock;
-use crate::snapshot_cache::PreProcessingSnapshot;
 use crate::validator_monitor::HISTORIC_EPOCHS as VALIDATOR_MONITOR_HISTORIC_EPOCHS;
 use crate::validator_pubkey_cache::ValidatorPubkeyCache;
 use crate::{
-    beacon_chain::{
-        BeaconForkChoice, ForkChoiceError, BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT,
-        VALIDATOR_PUBKEY_CACHE_LOCK_TIMEOUT,
-    },
+    beacon_chain::{BeaconForkChoice, ForkChoiceError, VALIDATOR_PUBKEY_CACHE_LOCK_TIMEOUT},
     metrics, BeaconChain, BeaconChainError, BeaconChainTypes,
 };
 use derivative::Derivative;
@@ -86,22 +83,21 @@ use state_processing::{
     block_signature_verifier::{BlockSignatureVerifier, Error as BlockSignatureVerifierError},
     per_block_processing, per_slot_processing,
     state_advance::partial_state_advance,
-    BlockProcessingError, BlockSignatureStrategy, ConsensusContext, SlotProcessingError,
-    StateProcessingStrategy, VerifyBlockRoot,
+    AllCaches, BlockProcessingError, BlockSignatureStrategy, ConsensusContext, SlotProcessingError,
+    VerifyBlockRoot,
 };
 use std::borrow::Cow;
 use std::fmt::Debug;
 use std::fs;
 use std::io::Write;
 use std::sync::Arc;
-use std::time::Duration;
 use store::{Error as DBError, HotStateSummary, KeyValueStore, StoreOp};
 use task_executor::JoinHandle;
 use tree_hash::TreeHash;
 use types::{
-    BeaconBlockRef, BeaconState, BeaconStateError, ChainSpec, CloneConfig, Epoch, EthSpec,
-    ExecutionBlockHash, Hash256, InconsistentFork, PublicKey, PublicKeyBytes, RelativeEpoch,
-    SignedBeaconBlock, SignedBeaconBlockHeader, Slot,
+    BeaconBlockRef, BeaconState, BeaconStateError, ChainSpec, Epoch, EthSpec, ExecutionBlockHash,
+    Hash256, InconsistentFork, PublicKey, PublicKeyBytes, RelativeEpoch, SignedBeaconBlock,
+    SignedBeaconBlockHeader, Slot,
 };
 use types::{BlobSidecar, ExecPayload};
 
@@ -578,7 +574,7 @@ pub fn signature_verify_chain_segment<T: BeaconChainTypes>(
     }
 
     let (first_root, first_block) = chain_segment.remove(0);
-    let (mut parent, first_block) = load_parent(first_root, first_block, chain)?;
+    let (mut parent, first_block) = load_parent(first_block, chain)?;
     let slot = first_block.slot();
     chain_segment.insert(0, (first_root, first_block));
 
@@ -666,8 +662,7 @@ type PayloadVerificationHandle<E> =
 /// - Parent is known
 /// - Signatures
 /// - State root check
-/// - Per block processing
-/// - Blobs sidecar has been validated if present
+/// - Block processing
 ///
 /// Note: a `ExecutionPendingBlock` is not _forever_ valid to be imported, it may later become invalid
 /// due to finality or some other event. A `ExecutionPendingBlock` should be imported into the
@@ -894,7 +889,7 @@ impl<T: BeaconChainTypes> GossipVerifiedBlock<T> {
         } else {
             // The proposer index was *not* cached and we must load the parent in order to determine
             // the proposer index.
-            let (mut parent, block) = load_parent(block_root, block, chain)?;
+            let (mut parent, block) = load_parent(block, chain)?;
 
             debug!(
                 chain.log,
@@ -1043,7 +1038,7 @@ impl<T: BeaconChainTypes> SignatureVerifiedBlock<T> {
         // Check the anchor slot before loading the parent, to avoid spurious lookups.
         check_block_against_anchor_slot(block.message(), chain)?;
 
-        let (mut parent, block) = load_parent(block_root, block, chain)?;
+        let (mut parent, block) = load_parent(block, chain)?;
 
         let state = cheap_state_advance_to_obtain_committees::<_, BlockError<T::EthSpec>>(
             &mut parent.pre_state,
@@ -1093,7 +1088,7 @@ impl<T: BeaconChainTypes> SignatureVerifiedBlock<T> {
         let (mut parent, block) = if let Some(parent) = from.parent {
             (parent, from.block)
         } else {
-            load_parent(from.block_root, from.block, chain)?
+            load_parent(from.block, chain)?
         };
 
         let state = cheap_state_advance_to_obtain_committees::<_, BlockError<T::EthSpec>>(
@@ -1155,7 +1150,7 @@ impl<T: BeaconChainTypes> IntoExecutionPendingBlock<T> for SignatureVerifiedBloc
         let (parent, block) = if let Some(parent) = self.parent {
             (parent, self.block)
         } else {
-            load_parent(self.block_root, self.block, chain)
+            load_parent(self.block, chain)
                 .map_err(|e| BlockSlashInfo::SignatureValid(header.clone(), e))?
         };
 
@@ -1387,8 +1382,18 @@ impl<T: BeaconChainTypes> ExecutionPendingBlock<T> {
         let catchup_timer = metrics::start_timer(&metrics::BLOCK_PROCESSING_CATCHUP_STATE);
 
         // Stage a batch of operations to be completed atomically if this block is imported
-        // successfully.
-        let mut confirmed_state_roots = vec![];
+        // successfully. We include the state root of the pre-state, which may be an advanced state
+        // that was stored in the DB with a `temporary` flag.
+        let mut state = parent.pre_state;
+
+        let mut confirmed_state_roots = if state.slot() > parent.beacon_block.slot() {
+            // Advanced pre-state. Delete its temporary flag.
+            let pre_state_root = state.update_tree_hash_cache()?;
+            vec![pre_state_root]
+        } else {
+            // Pre state is parent state. It is already stored in the DB without temporary status.
+            vec![]
+        };
 
         // The block must have a higher slot than its parent.
         if block.slot() <= parent.beacon_block.slot() {
@@ -1398,14 +1403,6 @@ impl<T: BeaconChainTypes> ExecutionPendingBlock<T> {
             });
         }
 
-        let mut summaries = vec![];
-
-        // Transition the parent state to the block slot.
-        //
-        // It is important to note that we're using a "pre-state" here, one that has potentially
-        // been advanced one slot forward from `parent.beacon_block.slot`.
-        let mut state = parent.pre_state;
-
         // Perform a sanity check on the pre-state.
         let parent_slot = parent.beacon_block.slot();
         if state.slot() < parent_slot || state.slot() > block.slot() {
@@ -1424,6 +1421,12 @@ impl<T: BeaconChainTypes> ExecutionPendingBlock<T> {
             eth1_deposit_index: state.eth1_deposit_index(),
         };
 
+        // Transition the parent state to the block slot.
+        //
+        // It is important to note that we're using a "pre-state" here, one that has potentially
+        // been advanced one slot forward from `parent.beacon_block.slot`.
+        let mut summaries = vec![];
+
         let distance = block.slot().as_u64().saturating_sub(state.slot().as_u64());
         for _ in 0..distance {
             let state_root = if parent.beacon_block.slot() == state.slot() {
@@ -1523,8 +1526,7 @@ impl<T: BeaconChainTypes> ExecutionPendingBlock<T> {
 
         let committee_timer = metrics::start_timer(&metrics::BLOCK_PROCESSING_COMMITTEE);
 
-        state.build_committee_cache(RelativeEpoch::Previous, &chain.spec)?;
-        state.build_committee_cache(RelativeEpoch::Current, &chain.spec)?;
+        state.build_all_committee_caches(&chain.spec)?;
 
         metrics::stop_timer(committee_timer);
 
@@ -1565,7 +1567,6 @@ impl<T: BeaconChainTypes> ExecutionPendingBlock<T> {
             block.as_block(),
             // Signatures were verified earlier in this function.
             BlockSignatureStrategy::NoVerification,
-            StateProcessingStrategy::Accurate,
             VerifyBlockRoot::True,
             &mut consensus_context,
             &chain.spec,
@@ -1840,12 +1841,9 @@ fn verify_parent_block_is_known<T: BeaconChainTypes>(
 /// whilst attempting the operation.
 #[allow(clippy::type_complexity)]
 fn load_parent<T: BeaconChainTypes, B: AsBlock<T::EthSpec>>(
-    block_root: Hash256,
     block: B,
     chain: &BeaconChain<T>,
 ) -> Result<(PreProcessingSnapshot<T::EthSpec>, B), BlockError<T::EthSpec>> {
-    let spec = &chain.spec;
-
     // Reject any block if its parent is not known to fork choice.
     //
     // A block that is not in fork choice is either:
@@ -1864,45 +1862,10 @@ fn load_parent<T: BeaconChainTypes, B: AsBlock<T::EthSpec>>(
         return Err(BlockError::ParentUnknown(block.into_rpc_block()));
     }
 
-    let block_delay = chain
-        .block_times_cache
-        .read()
-        .get_block_delays(
-            block_root,
-            chain
-                .slot_clock
-                .start_of(block.slot())
-                .unwrap_or_else(|| Duration::from_secs(0)),
-        )
-        .observed;
-
     let db_read_timer = metrics::start_timer(&metrics::BLOCK_PROCESSING_DB_READ);
 
-    let result = if let Some((snapshot, cloned)) = chain
-        .snapshot_cache
-        .try_write_for(BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT)
-        .and_then(|mut snapshot_cache| {
-            snapshot_cache.get_state_for_block_processing(
-                block.parent_root(),
-                block.slot(),
-                block_delay,
-                spec,
-            )
-        }) {
-        if cloned {
-            metrics::inc_counter(&metrics::BLOCK_PROCESSING_SNAPSHOT_CACHE_CLONES);
-            debug!(
-                chain.log,
-                "Cloned snapshot for late block/skipped slot";
-                "slot" => %block.slot(),
-                "parent_slot" => %snapshot.beacon_block.slot(),
-                "parent_root" => ?block.parent_root(),
-                "block_delay" => ?block_delay,
-            );
-        }
-        Ok((snapshot, block))
-    } else {
-        // Load the blocks parent block from the database, returning invalid if that block is not
+    let result = {
+        // Load the block's parent block from the database, returning invalid if that block is not
         // found.
         //
         // We don't return a DBInconsistent error here since it's possible for a block to
@@ -1926,7 +1889,7 @@ fn load_parent<T: BeaconChainTypes, B: AsBlock<T::EthSpec>>(
         // Retrieve any state that is advanced through to at most `block.slot()`: this is
         // particularly important if `block` descends from the finalized/split block, but at a slot
         // prior to the finalized slot (which is invalid and inaccessible in our DB schema).
-        let (parent_state_root, parent_state) = chain
+        let (parent_state_root, state) = chain
             .store
             .get_advanced_hot_state(root, block.slot(), parent_block.state_root())?
             .ok_or_else(|| {
@@ -1935,22 +1898,46 @@ fn load_parent<T: BeaconChainTypes, B: AsBlock<T::EthSpec>>(
                 )
             })?;
 
-        metrics::inc_counter(&metrics::BLOCK_PROCESSING_SNAPSHOT_CACHE_MISSES);
-        debug!(
-            chain.log,
-            "Missed snapshot cache";
-            "slot" => block.slot(),
-            "parent_slot" => parent_block.slot(),
-            "parent_root" => ?block.parent_root(),
-            "block_delay" => ?block_delay,
-        );
+        if !state.all_caches_built() {
+            debug!(
+                chain.log,
+                "Parent state lacks built caches";
+                "block_slot" => block.slot(),
+                "state_slot" => state.slot(),
+            );
+        }
+
+        if block.slot() != state.slot() {
+            debug!(
+                chain.log,
+                "Parent state is not advanced";
+                "block_slot" => block.slot(),
+                "state_slot" => state.slot(),
+            );
+        }
+
+        let beacon_state_root = if state.slot() == parent_block.slot() {
+            // Sanity check.
+            if parent_state_root != parent_block.state_root() {
+                return Err(BeaconChainError::DBInconsistent(format!(
+                    "Parent state at slot {} has the wrong state root: {:?} != {:?}",
+                    state.slot(),
+                    parent_state_root,
+                    parent_block.state_root()
+                ))
+                .into());
+            }
+            Some(parent_block.state_root())
+        } else {
+            None
+        };
 
         Ok((
             PreProcessingSnapshot {
                 beacon_block: parent_block,
                 beacon_block_root: root,
-                pre_state: parent_state,
-                beacon_state_root: Some(parent_state_root),
+                pre_state: state,
+                beacon_state_root,
             },
             block,
         ))
@@ -2031,7 +2018,7 @@ pub fn cheap_state_advance_to_obtain_committees<'a, E: EthSpec, Err: BlockBlobEr
     } else if state.slot() > block_slot {
         Err(Err::not_later_than_parent_error(block_slot, state.slot()))
     } else {
-        let mut state = state.clone_with(CloneConfig::committee_caches_only());
+        let mut state = state.clone();
         let target_slot = block_epoch.start_slot(E::slots_per_epoch());
 
         // Advance the state into the same epoch as the block. Use the "partial" method since state
diff --git a/beacon_node/beacon_chain/src/block_verification_types.rs b/beacon_node/beacon_chain/src/block_verification_types.rs
index fb0e0c965f1..70f1e99ef74 100644
--- a/beacon_node/beacon_chain/src/block_verification_types.rs
+++ b/beacon_node/beacon_chain/src/block_verification_types.rs
@@ -96,13 +96,18 @@ impl<E: EthSpec> RpcBlock<E> {
     }
 
     /// Constructs a new `BlockAndBlobs` variant after making consistency
-    /// checks between the provided blocks and blobs.
+    /// checks between the provided blocks and blobs. This struct makes no
+    /// guarantees about whether blobs should be present, only that they are
+    /// consistent with the block. An empty list passed in for `blobs` is
+    /// viewed the same as `None` passed in.
     pub fn new(
         block_root: Option<Hash256>,
         block: Arc<SignedBeaconBlock<E>>,
         blobs: Option<BlobSidecarList<E>>,
     ) -> Result<Self, AvailabilityCheckError> {
         let block_root = block_root.unwrap_or_else(|| get_block_root(&block));
+        // Treat empty blob lists as if they are missing.
+        let blobs = blobs.filter(|b| !b.is_empty());
 
         if let (Some(blobs), Ok(block_commitments)) = (
             blobs.as_ref(),
@@ -309,6 +314,26 @@ pub struct BlockImportData<E: EthSpec> {
     pub consensus_context: ConsensusContext<E>,
 }
 
+impl<E: EthSpec> BlockImportData<E> {
+    pub fn __new_for_test(
+        block_root: Hash256,
+        state: BeaconState<E>,
+        parent_block: SignedBeaconBlock<E, BlindedPayload<E>>,
+    ) -> Self {
+        Self {
+            block_root,
+            state,
+            parent_block,
+            parent_eth1_finalization_data: Eth1FinalizationData {
+                eth1_data: <_>::default(),
+                eth1_deposit_index: 0,
+            },
+            confirmed_state_roots: vec![],
+            consensus_context: ConsensusContext::new(Slot::new(0)),
+        }
+    }
+}
+
 pub type GossipVerifiedBlockContents<E> =
     (GossipVerifiedBlock<E>, Option<GossipVerifiedBlobList<E>>);
 
diff --git a/beacon_node/beacon_chain/src/builder.rs b/beacon_node/beacon_chain/src/builder.rs
index c1ebeb68bba..90461b8f03e 100644
--- a/beacon_node/beacon_chain/src/builder.rs
+++ b/beacon_node/beacon_chain/src/builder.rs
@@ -7,12 +7,12 @@ use crate::eth1_chain::{CachingEth1Backend, SszEth1};
 use crate::eth1_finalization_cache::Eth1FinalizationCache;
 use crate::fork_choice_signal::ForkChoiceSignalTx;
 use crate::fork_revert::{reset_fork_choice_to_finalization, revert_to_fork_boundary};
+use crate::graffiti_calculator::{GraffitiCalculator, GraffitiOrigin};
 use crate::head_tracker::HeadTracker;
 use crate::light_client_server_cache::LightClientServerCache;
 use crate::migrate::{BackgroundMigrator, MigratorConfig};
 use crate::persisted_beacon_chain::PersistedBeaconChain;
 use crate::shuffling_cache::{BlockShufflingIds, ShufflingCache};
-use crate::snapshot_cache::SnapshotCache;
 use crate::timeout_rw_lock::TimeoutRwLock;
 use crate::validator_monitor::{ValidatorMonitor, ValidatorMonitorConfig};
 use crate::validator_pubkey_cache::ValidatorPubkeyCache;
@@ -25,22 +25,22 @@ use eth1::Config as Eth1Config;
 use execution_layer::ExecutionLayer;
 use fork_choice::{ForkChoice, ResetPayloadStatuses};
 use futures::channel::mpsc::Sender;
-use kzg::{Kzg, TrustedSetup};
+use kzg::Kzg;
 use operation_pool::{OperationPool, PersistedOperationPool};
 use parking_lot::{Mutex, RwLock};
 use proto_array::{DisallowedReOrgOffsets, ReOrgThreshold};
 use slasher::Slasher;
 use slog::{crit, debug, error, info, o, Logger};
 use slot_clock::{SlotClock, TestingSlotClock};
-use state_processing::per_slot_processing;
+use state_processing::{per_slot_processing, AllCaches};
 use std::marker::PhantomData;
 use std::sync::Arc;
 use std::time::Duration;
 use store::{Error as StoreError, HotColdDB, ItemStore, KeyValueStoreOp};
 use task_executor::{ShutdownReason, TaskExecutor};
 use types::{
-    BeaconBlock, BeaconState, BlobSidecarList, ChainSpec, Checkpoint, Epoch, EthSpec, Graffiti,
-    Hash256, Signature, SignedBeaconBlock, Slot,
+    BeaconBlock, BeaconState, BlobSidecarList, ChainSpec, Checkpoint, Epoch, EthSpec, Hash256,
+    Signature, SignedBeaconBlock, Slot,
 };
 
 /// An empty struct used to "witness" all the `BeaconChainTypes` traits. It has no user-facing
@@ -96,12 +96,12 @@ pub struct BeaconChainBuilder<T: BeaconChainTypes> {
     spec: ChainSpec,
     chain_config: ChainConfig,
     log: Option<Logger>,
-    graffiti: Graffiti,
+    beacon_graffiti: GraffitiOrigin,
     slasher: Option<Arc<Slasher<T::EthSpec>>>,
     // Pending I/O batch that is constructed during building and should be executed atomically
     // alongside `PersistedBeaconChain` storage when `BeaconChainBuilder::build` is called.
     pending_io_batch: Vec<KeyValueStoreOp>,
-    trusted_setup: Option<TrustedSetup>,
+    kzg: Option<Arc<Kzg>>,
     task_executor: Option<TaskExecutor>,
     validator_monitor_config: Option<ValidatorMonitorConfig>,
 }
@@ -139,10 +139,10 @@ where
             spec: E::default_spec(),
             chain_config: ChainConfig::default(),
             log: None,
-            graffiti: Graffiti::default(),
+            beacon_graffiti: GraffitiOrigin::default(),
             slasher: None,
             pending_io_batch: vec![],
-            trusted_setup: None,
+            kzg: None,
             task_executor: None,
             validator_monitor_config: None,
         }
@@ -462,7 +462,7 @@ where
         // Prime all caches before storing the state in the database and computing the tree hash
         // root.
         weak_subj_state
-            .build_caches(&self.spec)
+            .build_all_caches(&self.spec)
             .map_err(|e| format!("Error building caches on checkpoint state: {e:?}"))?;
         let weak_subj_state_root = weak_subj_state
             .update_tree_hash_cache()
@@ -537,6 +537,13 @@ where
 
         // Write the state, block and blobs non-atomically, it doesn't matter if they're forgotten
         // about on a crash restart.
+        store
+            .update_finalized_state(
+                weak_subj_state_root,
+                weak_subj_block_root,
+                weak_subj_state.clone(),
+            )
+            .map_err(|e| format!("Failed to set checkpoint state as finalized state: {:?}", e))?;
         store
             .put_state(&weak_subj_state_root, &weak_subj_state)
             .map_err(|e| format!("Failed to store weak subjectivity state: {e:?}"))?;
@@ -649,9 +656,9 @@ where
         self
     }
 
-    /// Sets the `graffiti` field.
-    pub fn graffiti(mut self, graffiti: Graffiti) -> Self {
-        self.graffiti = graffiti;
+    /// Sets the `beacon_graffiti` field.
+    pub fn beacon_graffiti(mut self, beacon_graffiti: GraffitiOrigin) -> Self {
+        self.beacon_graffiti = beacon_graffiti;
         self
     }
 
@@ -669,8 +676,8 @@ where
         self
     }
 
-    pub fn trusted_setup(mut self, trusted_setup: TrustedSetup) -> Self {
-        self.trusted_setup = Some(trusted_setup);
+    pub fn kzg(mut self, kzg: Option<Arc<Kzg>>) -> Self {
+        self.kzg = kzg;
         self
     }
 
@@ -701,8 +708,8 @@ where
             .ok_or("Cannot build without a genesis state root")?;
         let validator_monitor_config = self.validator_monitor_config.unwrap_or_default();
         let head_tracker = Arc::new(self.head_tracker.unwrap_or_default());
-
         let beacon_proposer_cache: Arc<Mutex<BeaconProposerCache>> = <_>::default();
+
         let mut validator_monitor = ValidatorMonitor::new(
             validator_monitor_config,
             beacon_proposer_cache.clone(),
@@ -718,15 +725,6 @@ where
             slot_clock.now().ok_or("Unable to read slot")?
         };
 
-        let kzg = if let Some(trusted_setup) = self.trusted_setup {
-            let kzg = Kzg::new_from_trusted_setup(trusted_setup)
-                .map_err(|e| format!("Failed to load trusted setup: {:?}", e))?;
-            let kzg_arc = Arc::new(kzg);
-            Some(kzg_arc)
-        } else {
-            None
-        };
-
         let initial_head_block_root = fork_choice
             .get_head(current_slot, &self.spec)
             .map_err(|e| format!("Unable to get fork choice head: {:?}", e))?;
@@ -860,10 +858,8 @@ where
 
         let genesis_validators_root = head_snapshot.beacon_state.genesis_validators_root();
         let genesis_time = head_snapshot.beacon_state.genesis_time();
-        let head_for_snapshot_cache = head_snapshot.clone();
         let canonical_head = CanonicalHead::new(fork_choice, Arc::new(head_snapshot));
         let shuffling_cache_size = self.chain_config.shuffling_cache_size;
-        let snapshot_cache_size = self.chain_config.snapshot_cache_size;
 
         // Calculate the weak subjectivity point in which to backfill blocks to.
         let genesis_backfill_slot = if self.chain_config.genesis_backfill {
@@ -929,7 +925,7 @@ where
             observed_attester_slashings: <_>::default(),
             observed_bls_to_execution_changes: <_>::default(),
             eth1_chain: self.eth1_chain,
-            execution_layer: self.execution_layer,
+            execution_layer: self.execution_layer.clone(),
             genesis_validators_root,
             genesis_time,
             canonical_head,
@@ -939,10 +935,6 @@ where
             fork_choice_signal_rx,
             event_handler: self.event_handler,
             head_tracker,
-            snapshot_cache: TimeoutRwLock::new(SnapshotCache::new(
-                snapshot_cache_size,
-                head_for_snapshot_cache,
-            )),
             shuffling_cache: TimeoutRwLock::new(ShufflingCache::new(
                 shuffling_cache_size,
                 head_shuffling_ids,
@@ -955,22 +947,27 @@ where
             validator_pubkey_cache: TimeoutRwLock::new(validator_pubkey_cache),
             attester_cache: <_>::default(),
             early_attester_cache: <_>::default(),
+            reqresp_pre_import_cache: <_>::default(),
             light_client_server_cache: LightClientServerCache::new(),
             light_client_server_tx: self.light_client_server_tx,
             shutdown_sender: self
                 .shutdown_sender
                 .ok_or("Cannot build without a shutdown sender.")?,
             log: log.clone(),
-            graffiti: self.graffiti,
+            graffiti_calculator: GraffitiCalculator::new(
+                self.beacon_graffiti,
+                self.execution_layer,
+                slot_clock.slot_duration() * E::slots_per_epoch() as u32,
+                log.clone(),
+            ),
             slasher: self.slasher.clone(),
             validator_monitor: RwLock::new(validator_monitor),
             genesis_backfill_slot,
             data_availability_checker: Arc::new(
-                DataAvailabilityChecker::new(slot_clock, kzg.clone(), store, &log, self.spec)
+                DataAvailabilityChecker::new(slot_clock, self.kzg.clone(), store, &log, self.spec)
                     .map_err(|e| format!("Error initializing DataAvailabiltyChecker: {:?}", e))?,
             ),
-            kzg,
-            block_production_state: Arc::new(Mutex::new(None)),
+            kzg: self.kzg.clone(),
         };
 
         let head = beacon_chain.head_snapshot();
diff --git a/beacon_node/beacon_chain/src/canonical_head.rs b/beacon_node/beacon_chain/src/canonical_head.rs
index ced4eda05cf..a84cfab298d 100644
--- a/beacon_node/beacon_chain/src/canonical_head.rs
+++ b/beacon_node/beacon_chain/src/canonical_head.rs
@@ -35,10 +35,7 @@ use crate::beacon_chain::ATTESTATION_CACHE_LOCK_TIMEOUT;
 use crate::persisted_fork_choice::PersistedForkChoice;
 use crate::shuffling_cache::BlockShufflingIds;
 use crate::{
-    beacon_chain::{
-        BeaconForkChoice, BeaconStore, OverrideForkchoiceUpdate,
-        BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT, FORK_CHOICE_DB_KEY,
-    },
+    beacon_chain::{BeaconForkChoice, BeaconStore, OverrideForkchoiceUpdate, FORK_CHOICE_DB_KEY},
     block_times_cache::BlockTimesCache,
     events::ServerSentEventHandler,
     metrics,
@@ -54,6 +51,7 @@ use itertools::process_results;
 use parking_lot::{Mutex, RwLock, RwLockReadGuard, RwLockWriteGuard};
 use slog::{crit, debug, error, warn, Logger};
 use slot_clock::SlotClock;
+use state_processing::AllCaches;
 use std::sync::Arc;
 use std::time::Duration;
 use store::{iter::StateRootsIterator, KeyValueStoreOp, StoreItem};
@@ -466,9 +464,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     pub fn head_beacon_state_cloned(&self) -> BeaconState<T::EthSpec> {
         // Don't clone whilst holding the read-lock, take an Arc-clone to reduce lock contention.
         let snapshot: Arc<_> = self.head_snapshot();
-        snapshot
-            .beacon_state
-            .clone_with(CloneConfig::committee_caches_only())
+        snapshot.beacon_state.clone()
     }
 
     /// Execute the fork choice algorithm and enthrone the result as the canonical head.
@@ -652,48 +648,31 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         let new_cached_head = if new_view.head_block_root != old_view.head_block_root {
             metrics::inc_counter(&metrics::FORK_CHOICE_CHANGED_HEAD);
 
-            // Try and obtain the snapshot for `beacon_block_root` from the snapshot cache, falling
-            // back to a database read if that fails.
-            let new_snapshot = self
-                .snapshot_cache
-                .try_read_for(BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT)
-                .and_then(|snapshot_cache| {
-                    snapshot_cache.get_cloned(
+            let mut new_snapshot = {
+                let beacon_block = self
+                    .store
+                    .get_full_block(&new_view.head_block_root)?
+                    .ok_or(Error::MissingBeaconBlock(new_view.head_block_root))?;
+
+                let (_, beacon_state) = self
+                    .store
+                    .get_advanced_hot_state(
                         new_view.head_block_root,
-                        CloneConfig::committee_caches_only(),
-                    )
-                })
-                .map::<Result<_, Error>, _>(Ok)
-                .unwrap_or_else(|| {
-                    let beacon_block = self
-                        .store
-                        .get_full_block(&new_view.head_block_root)?
-                        .ok_or(Error::MissingBeaconBlock(new_view.head_block_root))?;
-
-                    let (_, beacon_state) = self
-                        .store
-                        .get_advanced_hot_state(
-                            new_view.head_block_root,
-                            current_slot,
-                            beacon_block.state_root(),
-                        )?
-                        .ok_or(Error::MissingBeaconState(beacon_block.state_root()))?;
-
-                    Ok(BeaconSnapshot {
-                        beacon_block: Arc::new(beacon_block),
-                        beacon_block_root: new_view.head_block_root,
-                        beacon_state,
-                    })
-                })
-                .and_then(|mut snapshot| {
-                    // Regardless of where we got the state from, attempt to build the committee
-                    // caches.
-                    snapshot
-                        .beacon_state
-                        .build_all_committee_caches(&self.spec)
-                        .map_err(Into::into)
-                        .map(|()| snapshot)
-                })?;
+                        current_slot,
+                        beacon_block.state_root(),
+                    )?
+                    .ok_or(Error::MissingBeaconState(beacon_block.state_root()))?;
+
+                BeaconSnapshot {
+                    beacon_block: Arc::new(beacon_block),
+                    beacon_block_root: new_view.head_block_root,
+                    beacon_state,
+                }
+            };
+
+            // Regardless of where we got the state from, attempt to build all the
+            // caches except the tree hash cache.
+            new_snapshot.beacon_state.build_all_caches(&self.spec)?;
 
             let new_cached_head = CachedHead {
                 snapshot: Arc::new(new_snapshot),
@@ -834,25 +813,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             .beacon_state
             .attester_shuffling_decision_root(self.genesis_block_root, RelativeEpoch::Current);
 
-        // Update the snapshot cache with the latest head value.
-        //
-        // This *could* be done inside `recompute_head`, however updating the head on the snapshot
-        // cache is not critical so we avoid placing it on a critical path. Note that this function
-        // will not return an error if the update fails, it will just log an error.
-        self.snapshot_cache
-            .try_write_for(BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT)
-            .map(|mut snapshot_cache| {
-                snapshot_cache.update_head(new_snapshot.beacon_block_root);
-            })
-            .unwrap_or_else(|| {
-                error!(
-                    self.log,
-                    "Failed to obtain cache write lock";
-                    "lock" => "snapshot_cache",
-                    "task" => "update head"
-                );
-            });
-
         match BlockShufflingIds::try_from_head(
             new_snapshot.beacon_block_root,
             &new_snapshot.beacon_state,
@@ -998,26 +958,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 .start_slot(T::EthSpec::slots_per_epoch()),
         );
 
-        self.snapshot_cache
-            .try_write_for(BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT)
-            .map(|mut snapshot_cache| {
-                snapshot_cache.prune(new_view.finalized_checkpoint.epoch);
-                debug!(
-                    self.log,
-                    "Snapshot cache pruned";
-                    "new_len" => snapshot_cache.len(),
-                    "remaining_roots" => ?snapshot_cache.beacon_block_roots(),
-                );
-            })
-            .unwrap_or_else(|| {
-                error!(
-                    self.log,
-                    "Failed to obtain cache write lock";
-                    "lock" => "snapshot_cache",
-                    "task" => "prune"
-                );
-            });
-
         self.attester_cache
             .prune_below(new_view.finalized_checkpoint.epoch);
 
@@ -1405,13 +1345,6 @@ fn observe_head_block_delays<E: EthSpec, S: SlotClock>(
     // Do not store metrics if the block was > 4 slots old, this helps prevent noise during
     // sync.
     if !block_from_sync {
-        // Observe the total block delay. This is the delay between the time the slot started
-        // and when the block was set as head.
-        metrics::observe_duration(
-            &metrics::BEACON_BLOCK_HEAD_SLOT_START_DELAY_TIME,
-            block_delay_total,
-        );
-
         // Observe the delay between when we imported the block and when we set the block as
         // head.
         let block_delays = block_times_cache.get_block_delays(
@@ -1421,34 +1354,120 @@ fn observe_head_block_delays<E: EthSpec, S: SlotClock>(
                 .unwrap_or_else(|| Duration::from_secs(0)),
         );
 
-        metrics::observe_duration(
-            &metrics::BEACON_BLOCK_OBSERVED_SLOT_START_DELAY_TIME,
+        // Update all the metrics
+
+        // Convention here is to use "Time" to indicate the duration of the event and "Delay"
+        // to indicate the time since the start of the slot.
+        //
+        // Observe the total block delay. This is the delay between the time the slot started
+        // and when the block was set as head.
+        metrics::set_gauge(
+            &metrics::BEACON_BLOCK_DELAY_TOTAL,
+            block_delay_total.as_millis() as i64,
+        );
+
+        // The time at which the beacon block was first observed to be processed
+        metrics::set_gauge(
+            &metrics::BEACON_BLOCK_DELAY_OBSERVED_SLOT_START,
             block_delays
                 .observed
-                .unwrap_or_else(|| Duration::from_secs(0)),
+                .unwrap_or_else(|| Duration::from_secs(0))
+                .as_millis() as i64,
         );
 
-        metrics::observe_duration(
-            &metrics::BEACON_BLOCK_HEAD_IMPORTED_DELAY_TIME,
+        // The time from the start of the slot when all blobs have been observed. Technically this
+        // is the time we last saw a blob related to this block/slot.
+        metrics::set_gauge(
+            &metrics::BEACON_BLOB_DELAY_ALL_OBSERVED_SLOT_START,
+            block_delays
+                .all_blobs_observed
+                .unwrap_or_else(|| Duration::from_secs(0))
+                .as_millis() as i64,
+        );
+
+        // The time it took to check the validity with the EL
+        metrics::set_gauge(
+            &metrics::BEACON_BLOCK_DELAY_EXECUTION_TIME,
+            block_delays
+                .execution_time
+                .unwrap_or_else(|| Duration::from_secs(0))
+                .as_millis() as i64,
+        );
+
+        // The time the block became available after the start of the slot. Available here means
+        // that all the blobs have arrived and the block has been verified by the execution layer.
+        metrics::set_gauge(
+            &metrics::BEACON_BLOCK_DELAY_AVAILABLE_SLOT_START,
+            block_delays
+                .available
+                .unwrap_or_else(|| Duration::from_secs(0))
+                .as_millis() as i64,
+        );
+
+        // The time the block became attestable after the start of the slot.
+        metrics::set_gauge(
+            &metrics::BEACON_BLOCK_DELAY_ATTESTABLE_SLOT_START,
+            block_delays
+                .attestable
+                .unwrap_or_else(|| Duration::from_secs(0))
+                .as_millis() as i64,
+        );
+
+        // The time the block was imported since becoming available.
+        metrics::set_gauge(
+            &metrics::BEACON_BLOCK_DELAY_IMPORTED_TIME,
+            block_delays
+                .imported
+                .unwrap_or_else(|| Duration::from_secs(0))
+                .as_millis() as i64,
+        );
+
+        // The time the block was imported and setting it as head
+        metrics::set_gauge(
+            &metrics::BEACON_BLOCK_DELAY_HEAD_IMPORTED_TIME,
             block_delays
                 .set_as_head
-                .unwrap_or_else(|| Duration::from_secs(0)),
+                .unwrap_or_else(|| Duration::from_secs(0))
+                .as_millis() as i64,
         );
 
         // If the block was enshrined as head too late for attestations to be created for it,
         // log a debug warning and increment a metric.
+        let format_delay = |delay: &Option<Duration>| {
+            delay.map_or("unknown".to_string(), |d| format!("{}", d.as_millis()))
+        };
         if late_head {
-            metrics::inc_counter(&metrics::BEACON_BLOCK_HEAD_SLOT_START_DELAY_EXCEEDED_TOTAL);
+            metrics::inc_counter(&metrics::BEACON_BLOCK_DELAY_HEAD_SLOT_START_EXCEEDED_TOTAL);
             debug!(
                 log,
                 "Delayed head block";
                 "block_root" => ?head_block_root,
                 "proposer_index" => head_block_proposer_index,
                 "slot" => head_block_slot,
-                "block_delay" => ?block_delay_total,
-                "observed_delay" => ?block_delays.observed,
-                "imported_delay" => ?block_delays.imported,
-                "set_as_head_delay" => ?block_delays.set_as_head,
+                "total_delay_ms" => block_delay_total.as_millis(),
+                "observed_delay_ms" => format_delay(&block_delays.observed),
+                "blob_delay_ms" => format_delay(&block_delays.all_blobs_observed),
+                "execution_time_ms" => format_delay(&block_delays.execution_time),
+                "available_delay_ms" => format_delay(&block_delays.available),
+                "attestable_delay_ms" => format_delay(&block_delays.attestable),
+                "imported_time_ms" => format_delay(&block_delays.imported),
+                "set_as_head_time_ms" => format_delay(&block_delays.set_as_head),
+            );
+        } else {
+            debug!(
+                log,
+                "On-time head block";
+                "block_root" => ?head_block_root,
+                "proposer_index" => head_block_proposer_index,
+                "slot" => head_block_slot,
+                "total_delay_ms" => block_delay_total.as_millis(),
+                "observed_delay_ms" => format_delay(&block_delays.observed),
+                "blob_delay_ms" => format_delay(&block_delays.all_blobs_observed),
+                "execution_time_ms" => format_delay(&block_delays.execution_time),
+                "available_delay_ms" => format_delay(&block_delays.available),
+                "attestable_delay_ms" => format_delay(&block_delays.attestable),
+                "imported_time_ms" => format_delay(&block_delays.imported),
+                "set_as_head_time_ms" => format_delay(&block_delays.set_as_head),
             );
         }
     }
diff --git a/beacon_node/beacon_chain/src/capella_readiness.rs b/beacon_node/beacon_chain/src/capella_readiness.rs
index cde71d462d7..88af7db0aaa 100644
--- a/beacon_node/beacon_chain/src/capella_readiness.rs
+++ b/beacon_node/beacon_chain/src/capella_readiness.rs
@@ -10,7 +10,7 @@ use std::time::Duration;
 use types::*;
 
 /// The time before the Capella fork when we will start issuing warnings about preparation.
-use super::merge_readiness::SECONDS_IN_A_WEEK;
+use super::bellatrix_readiness::SECONDS_IN_A_WEEK;
 pub const CAPELLA_READINESS_PREPARATION_SECONDS: u64 = SECONDS_IN_A_WEEK * 2;
 pub const ENGINE_CAPABILITIES_REFRESH_INTERVAL: u64 = 300;
 
diff --git a/beacon_node/beacon_chain/src/chain_config.rs b/beacon_node/beacon_chain/src/chain_config.rs
index 0772aff6710..255b8f00497 100644
--- a/beacon_node/beacon_chain/src/chain_config.rs
+++ b/beacon_node/beacon_chain/src/chain_config.rs
@@ -75,8 +75,6 @@ pub struct ChainConfig {
     pub optimistic_finalized_sync: bool,
     /// The size of the shuffling cache,
     pub shuffling_cache_size: usize,
-    /// The size of the snapshot cache.
-    pub snapshot_cache_size: usize,
     /// If using a weak-subjectivity sync, whether we should download blocks all the way back to
     /// genesis.
     pub genesis_backfill: bool,
@@ -116,7 +114,6 @@ impl Default for ChainConfig {
             // This value isn't actually read except in tests.
             optimistic_finalized_sync: true,
             shuffling_cache_size: crate::shuffling_cache::DEFAULT_CACHE_SIZE,
-            snapshot_cache_size: crate::snapshot_cache::DEFAULT_SNAPSHOT_CACHE_SIZE,
             genesis_backfill: false,
             always_prepare_payload: false,
             epochs_per_migration: crate::migrate::DEFAULT_EPOCHS_PER_MIGRATION,
diff --git a/beacon_node/beacon_chain/src/data_availability_checker.rs b/beacon_node/beacon_chain/src/data_availability_checker.rs
index a4cb4177268..a981d31e554 100644
--- a/beacon_node/beacon_chain/src/data_availability_checker.rs
+++ b/beacon_node/beacon_chain/src/data_availability_checker.rs
@@ -2,34 +2,22 @@ use crate::blob_verification::{verify_kzg_for_blob_list, GossipVerifiedBlob, Kzg
 use crate::block_verification_types::{
     AvailabilityPendingExecutedBlock, AvailableExecutedBlock, RpcBlock,
 };
-pub use crate::data_availability_checker::availability_view::{
-    AvailabilityView, GetCommitment, GetCommitments,
-};
-pub use crate::data_availability_checker::child_components::ChildComponents;
 use crate::data_availability_checker::overflow_lru_cache::OverflowLRUCache;
-use crate::data_availability_checker::processing_cache::ProcessingCache;
 use crate::{BeaconChain, BeaconChainTypes, BeaconStore};
 use kzg::Kzg;
-use parking_lot::RwLock;
-pub use processing_cache::ProcessingComponents;
-use slasher::test_utils::E;
 use slog::{debug, error, Logger};
 use slot_clock::SlotClock;
-use ssz_types::FixedVector;
 use std::fmt;
 use std::fmt::Debug;
 use std::num::NonZeroUsize;
 use std::sync::Arc;
+use std::time::Duration;
 use task_executor::TaskExecutor;
-use types::beacon_block_body::KzgCommitmentOpts;
 use types::blob_sidecar::{BlobIdentifier, BlobSidecar, FixedBlobSidecarList};
 use types::{BlobSidecarList, ChainSpec, Epoch, EthSpec, Hash256, SignedBeaconBlock};
 
-mod availability_view;
-mod child_components;
 mod error;
 mod overflow_lru_cache;
-mod processing_cache;
 mod state_lru_cache;
 
 pub use error::{Error as AvailabilityCheckError, ErrorCategory as AvailabilityCheckErrorCategory};
@@ -50,7 +38,6 @@ pub const STATE_LRU_CAPACITY: usize = STATE_LRU_CAPACITY_NON_ZERO.get();
 /// `DataAvailabilityChecker` is responsible for KZG verification of block components as well as
 /// checking whether a "availability check" is required at all.
 pub struct DataAvailabilityChecker<T: BeaconChainTypes> {
-    processing_cache: RwLock<ProcessingCache<T::EthSpec>>,
     availability_cache: Arc<OverflowLRUCache<T>>,
     slot_clock: T::SlotClock,
     kzg: Option<Arc<Kzg>>,
@@ -89,7 +76,6 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
     ) -> Result<Self, AvailabilityCheckError> {
         let overflow_cache = OverflowLRUCache::new(OVERFLOW_LRU_CAPACITY, store, spec.clone())?;
         Ok(Self {
-            processing_cache: <_>::default(),
             availability_cache: Arc::new(overflow_cache),
             slot_clock,
             log: log.clone(),
@@ -98,61 +84,34 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
         })
     }
 
-    /// Checks if the given block root is cached.
-    pub fn has_block(&self, block_root: &Hash256) -> bool {
-        self.processing_cache.read().has_block(block_root)
+    /// Checks if the block root is currenlty in the availability cache awaiting import because
+    /// of missing components.
+    pub fn has_execution_valid_block(&self, block_root: &Hash256) -> bool {
+        self.availability_cache
+            .has_execution_valid_block(block_root)
     }
 
-    /// Get the processing info for a block.
-    pub fn get_processing_components(
-        &self,
-        block_root: Hash256,
-    ) -> Option<ProcessingComponents<T::EthSpec>> {
-        self.processing_cache.read().get(&block_root).cloned()
+    /// Return the required blobs `block_root` expects if the block is currenlty in the cache.
+    pub fn num_expected_blobs(&self, block_root: &Hash256) -> Option<usize> {
+        self.availability_cache
+            .peek_pending_components(block_root, |components| {
+                components.and_then(|components| components.num_expected_blobs())
+            })
     }
 
-    /// If there's no block, all possible ids will be returned that don't exist in the given blobs.
-    /// If there no blobs, all possible ids will be returned.
-    pub fn get_missing_blob_ids<V>(
-        &self,
-        block_root: Hash256,
-        block: &Option<Arc<SignedBeaconBlock<T::EthSpec>>>,
-        blobs: &FixedVector<Option<V>, <T::EthSpec as EthSpec>::MaxBlobsPerBlock>,
-    ) -> MissingBlobs {
-        let Some(current_slot) = self.slot_clock.now_or_genesis() else {
-            error!(
-                self.log,
-                "Failed to read slot clock when checking for missing blob ids"
-            );
-            return MissingBlobs::BlobsNotRequired;
-        };
-
-        let current_epoch = current_slot.epoch(T::EthSpec::slots_per_epoch());
-
-        if self.da_check_required_for_epoch(current_epoch) {
-            match block {
-                Some(cached_block) => {
-                    let block_commitments = cached_block.get_commitments();
-                    let blob_ids = blobs
+    /// Return the set of imported blob indexes for `block_root`. Returns None if there is no block
+    /// component for `block_root`.
+    pub fn imported_blob_indexes(&self, block_root: &Hash256) -> Option<Vec<u64>> {
+        self.availability_cache
+            .peek_pending_components(block_root, |components| {
+                components.map(|components| {
+                    components
+                        .get_cached_blobs()
                         .iter()
-                        .take(block_commitments.len())
-                        .enumerate()
-                        .filter_map(|(index, blob_commitment_opt)| {
-                            blob_commitment_opt.is_none().then_some(BlobIdentifier {
-                                block_root,
-                                index: index as u64,
-                            })
-                        })
-                        .collect();
-                    MissingBlobs::KnownMissing(blob_ids)
-                }
-                None => {
-                    MissingBlobs::PossibleMissing(BlobIdentifier::get_all_blob_ids::<E>(block_root))
-                }
-            }
-        } else {
-            MissingBlobs::BlobsNotRequired
-        }
+                        .filter_map(|blob| blob.as_ref().map(|blob| blob.blob_index()))
+                        .collect::<Vec<_>>()
+                })
+            })
     }
 
     /// Get a blob from the availability cache.
@@ -163,14 +122,6 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
         self.availability_cache.peek_blob(blob_id)
     }
 
-    /// Get a block from the availability cache. Includes any blocks we are currently processing.
-    pub fn get_block(&self, block_root: &Hash256) -> Option<Arc<SignedBeaconBlock<T::EthSpec>>> {
-        self.processing_cache
-            .read()
-            .get(block_root)
-            .and_then(|cached| cached.block.clone())
-    }
-
     /// Put a list of blobs received via RPC into the availability cache. This performs KZG
     /// verification on the blobs in the list.
     pub fn put_rpc_blobs(
@@ -182,8 +133,14 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
             return Err(AvailabilityCheckError::KzgNotInitialized);
         };
 
-        let verified_blobs = KzgVerifiedBlobList::new(Vec::from(blobs).into_iter().flatten(), kzg)
-            .map_err(AvailabilityCheckError::Kzg)?;
+        let seen_timestamp = self
+            .slot_clock
+            .now_duration()
+            .ok_or(AvailabilityCheckError::SlotClockError)?;
+
+        let verified_blobs =
+            KzgVerifiedBlobList::new(Vec::from(blobs).into_iter().flatten(), kzg, seen_timestamp)
+                .map_err(AvailabilityCheckError::Kzg)?;
 
         self.availability_cache
             .put_kzg_verified_blobs(block_root, verified_blobs)
@@ -231,6 +188,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
                         block_root,
                         block,
                         blobs: None,
+                        blobs_available_timestamp: None,
                     }))
                 }
             }
@@ -250,6 +208,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
                     block_root,
                     block,
                     blobs: verified_blobs,
+                    blobs_available_timestamp: None,
                 }))
             }
         }
@@ -295,6 +254,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
                             block_root,
                             block,
                             blobs: None,
+                            blobs_available_timestamp: None,
                         }))
                     }
                 }
@@ -309,6 +269,7 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
                         block_root,
                         block,
                         blobs: verified_blobs,
+                        blobs_available_timestamp: None,
                     }))
                 }
             }
@@ -323,52 +284,6 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
         block.num_expected_blobs() > 0 && self.da_check_required_for_epoch(block.epoch())
     }
 
-    /// Adds a block to the processing cache. This block's commitments are unverified but caching
-    /// them here is useful to avoid duplicate downloads of blocks, as well as understanding
-    /// our blob download requirements. We will also serve this over RPC.
-    pub fn notify_block(&self, block_root: Hash256, block: Arc<SignedBeaconBlock<T::EthSpec>>) {
-        self.processing_cache
-            .write()
-            .entry(block_root)
-            .or_default()
-            .merge_block(block);
-    }
-
-    /// Add a single blob commitment to the processing cache. This commitment is unverified but caching
-    /// them here is useful to avoid duplicate downloads of blobs, as well as understanding
-    /// our block and blob download requirements.
-    pub fn notify_gossip_blob(&self, block_root: Hash256, blob: &GossipVerifiedBlob<T>) {
-        let index = blob.index();
-        let commitment = blob.kzg_commitment();
-        self.processing_cache
-            .write()
-            .entry(block_root)
-            .or_default()
-            .merge_single_blob(index as usize, commitment);
-    }
-
-    /// Adds blob commitments to the processing cache. These commitments are unverified but caching
-    /// them here is useful to avoid duplicate downloads of blobs, as well as understanding
-    /// our block and blob download requirements.
-    pub fn notify_rpc_blobs(&self, block_root: Hash256, blobs: &FixedBlobSidecarList<T::EthSpec>) {
-        let mut commitments = KzgCommitmentOpts::<T::EthSpec>::default();
-        for blob in blobs.iter().flatten() {
-            if let Some(commitment) = commitments.get_mut(blob.index as usize) {
-                *commitment = Some(blob.kzg_commitment);
-            }
-        }
-        self.processing_cache
-            .write()
-            .entry(block_root)
-            .or_default()
-            .merge_blobs(commitments);
-    }
-
-    /// Clears the block and all blobs from the processing cache for a give root if they exist.
-    pub fn remove_notified(&self, block_root: &Hash256) {
-        self.processing_cache.write().remove(block_root)
-    }
-
     /// The epoch at which we require a data availability check in block processing.
     /// `None` if the `Deneb` fork is disabled.
     pub fn data_availability_boundary(&self) -> Option<Epoch> {
@@ -392,6 +307,18 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
             .map_or(false, |da_epoch| block_epoch >= da_epoch)
     }
 
+    pub fn da_check_required_for_current_epoch(&self) -> bool {
+        let Some(current_slot) = self.slot_clock.now_or_genesis() else {
+            error!(
+                self.log,
+                "Failed to read slot clock when checking for missing blob ids"
+            );
+            return false;
+        };
+
+        self.da_check_required_for_epoch(current_slot.epoch(T::EthSpec::slots_per_epoch()))
+    }
+
     /// Returns `true` if the current epoch is greater than or equal to the `Deneb` epoch.
     pub fn is_deneb(&self) -> bool {
         self.slot_clock.now().map_or(false, |slot| {
@@ -410,7 +337,6 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
     /// Collects metrics from the data availability checker.
     pub fn metrics(&self) -> DataAvailabilityCheckerMetrics {
         DataAvailabilityCheckerMetrics {
-            processing_cache_size: self.processing_cache.read().len(),
             num_store_entries: self.availability_cache.num_store_entries(),
             state_cache_size: self.availability_cache.state_cache_size(),
             block_cache_size: self.availability_cache.block_cache_size(),
@@ -420,7 +346,6 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
 
 /// Helper struct to group data availability checker metrics.
 pub struct DataAvailabilityCheckerMetrics {
-    pub processing_cache_size: usize,
     pub num_store_entries: usize,
     pub state_cache_size: usize,
     pub block_cache_size: usize,
@@ -516,6 +441,8 @@ pub struct AvailableBlock<E: EthSpec> {
     block_root: Hash256,
     block: Arc<SignedBeaconBlock<E>>,
     blobs: Option<BlobSidecarList<E>>,
+    /// Timestamp at which this block first became available (UNIX timestamp, time since 1970).
+    blobs_available_timestamp: Option<Duration>,
 }
 
 impl<E: EthSpec> AvailableBlock<E> {
@@ -528,6 +455,7 @@ impl<E: EthSpec> AvailableBlock<E> {
             block_root,
             block,
             blobs,
+            blobs_available_timestamp: None,
         }
     }
 
@@ -542,6 +470,10 @@ impl<E: EthSpec> AvailableBlock<E> {
         self.blobs.as_ref()
     }
 
+    pub fn blobs_available_timestamp(&self) -> Option<Duration> {
+        self.blobs_available_timestamp
+    }
+
     pub fn deconstruct(
         self,
     ) -> (
@@ -553,6 +485,7 @@ impl<E: EthSpec> AvailableBlock<E> {
             block_root,
             block,
             blobs,
+            blobs_available_timestamp: _,
         } = self;
         (block_root, block, blobs)
     }
@@ -579,61 +512,3 @@ impl<E: EthSpec> MaybeAvailableBlock<E> {
         }
     }
 }
-
-#[derive(Debug, Clone)]
-pub enum MissingBlobs {
-    /// We know for certain these blobs are missing.
-    KnownMissing(Vec<BlobIdentifier>),
-    /// We think these blobs might be missing.
-    PossibleMissing(Vec<BlobIdentifier>),
-    /// Blobs are not required.
-    BlobsNotRequired,
-}
-
-impl MissingBlobs {
-    pub fn new_without_block(block_root: Hash256, is_deneb: bool) -> Self {
-        if is_deneb {
-            MissingBlobs::PossibleMissing(BlobIdentifier::get_all_blob_ids::<E>(block_root))
-        } else {
-            MissingBlobs::BlobsNotRequired
-        }
-    }
-    pub fn is_empty(&self) -> bool {
-        match self {
-            MissingBlobs::KnownMissing(v) => v.is_empty(),
-            MissingBlobs::PossibleMissing(v) => v.is_empty(),
-            MissingBlobs::BlobsNotRequired => true,
-        }
-    }
-    pub fn contains(&self, blob_id: &BlobIdentifier) -> bool {
-        match self {
-            MissingBlobs::KnownMissing(v) => v.contains(blob_id),
-            MissingBlobs::PossibleMissing(v) => v.contains(blob_id),
-            MissingBlobs::BlobsNotRequired => false,
-        }
-    }
-    pub fn remove(&mut self, blob_id: &BlobIdentifier) {
-        match self {
-            MissingBlobs::KnownMissing(v) => v.retain(|id| id != blob_id),
-            MissingBlobs::PossibleMissing(v) => v.retain(|id| id != blob_id),
-            MissingBlobs::BlobsNotRequired => {}
-        }
-    }
-    pub fn indices(&self) -> Vec<u64> {
-        match self {
-            MissingBlobs::KnownMissing(v) => v.iter().map(|id| id.index).collect(),
-            MissingBlobs::PossibleMissing(v) => v.iter().map(|id| id.index).collect(),
-            MissingBlobs::BlobsNotRequired => vec![],
-        }
-    }
-}
-
-impl Into<Vec<BlobIdentifier>> for MissingBlobs {
-    fn into(self) -> Vec<BlobIdentifier> {
-        match self {
-            MissingBlobs::KnownMissing(v) => v,
-            MissingBlobs::PossibleMissing(v) => v,
-            MissingBlobs::BlobsNotRequired => vec![],
-        }
-    }
-}
diff --git a/beacon_node/beacon_chain/src/data_availability_checker/availability_view.rs b/beacon_node/beacon_chain/src/data_availability_checker/availability_view.rs
deleted file mode 100644
index 7b305cf959d..00000000000
--- a/beacon_node/beacon_chain/src/data_availability_checker/availability_view.rs
+++ /dev/null
@@ -1,507 +0,0 @@
-use super::state_lru_cache::DietAvailabilityPendingExecutedBlock;
-use crate::blob_verification::KzgVerifiedBlob;
-use crate::block_verification_types::AsBlock;
-use crate::data_availability_checker::overflow_lru_cache::PendingComponents;
-use crate::data_availability_checker::ProcessingComponents;
-use kzg::KzgCommitment;
-use ssz_types::FixedVector;
-use std::sync::Arc;
-use types::beacon_block_body::KzgCommitments;
-use types::{BlobSidecar, EthSpec, SignedBeaconBlock};
-
-/// Defines an interface for managing data availability with two key invariants:
-///
-/// 1. If we haven't seen a block yet, we will insert the first blob for a given (block_root, index)
-///    but we won't insert subsequent blobs for the same (block_root, index) if they have a different
-///    commitment.
-/// 2. On block insertion, any non-matching blob commitments are evicted.
-///
-/// Types implementing this trait can be used for validating and managing availability
-/// of blocks and blobs in a cache-like data structure.
-pub trait AvailabilityView<E: EthSpec> {
-    /// The type representing a block in the implementation.
-    type BlockType: GetCommitments<E>;
-
-    /// The type representing a blob in the implementation. Must implement `Clone`.
-    type BlobType: Clone + GetCommitment<E>;
-
-    /// Returns an immutable reference to the cached block.
-    fn get_cached_block(&self) -> &Option<Self::BlockType>;
-
-    /// Returns an immutable reference to the fixed vector of cached blobs.
-    fn get_cached_blobs(&self) -> &FixedVector<Option<Self::BlobType>, E::MaxBlobsPerBlock>;
-
-    /// Returns a mutable reference to the cached block.
-    fn get_cached_block_mut(&mut self) -> &mut Option<Self::BlockType>;
-
-    /// Returns a mutable reference to the fixed vector of cached blobs.
-    fn get_cached_blobs_mut(
-        &mut self,
-    ) -> &mut FixedVector<Option<Self::BlobType>, E::MaxBlobsPerBlock>;
-
-    /// Checks if a block exists in the cache.
-    ///
-    /// Returns:
-    /// - `true` if a block exists.
-    /// - `false` otherwise.
-    fn block_exists(&self) -> bool {
-        self.get_cached_block().is_some()
-    }
-
-    /// Checks if a blob exists at the given index in the cache.
-    ///
-    /// Returns:
-    /// - `true` if a blob exists at the given index.
-    /// - `false` otherwise.
-    fn blob_exists(&self, blob_index: usize) -> bool {
-        self.get_cached_blobs()
-            .get(blob_index)
-            .map(|b| b.is_some())
-            .unwrap_or(false)
-    }
-
-    /// Returns the number of blobs that are expected to be present. Returns `None` if we don't have a
-    /// block.
-    ///
-    /// This corresponds to the number of commitments that are present in a block.
-    fn num_expected_blobs(&self) -> Option<usize> {
-        self.get_cached_block()
-            .as_ref()
-            .map(|b| b.get_commitments().len())
-    }
-
-    /// Returns the number of blobs that have been received and are stored in the cache.
-    fn num_received_blobs(&self) -> usize {
-        self.get_cached_blobs().iter().flatten().count()
-    }
-
-    /// Inserts a block into the cache.
-    fn insert_block(&mut self, block: Self::BlockType) {
-        *self.get_cached_block_mut() = Some(block)
-    }
-
-    /// Inserts a blob at a specific index in the cache.
-    ///
-    /// Existing blob at the index will be replaced.
-    fn insert_blob_at_index(&mut self, blob_index: usize, blob: Self::BlobType) {
-        if let Some(b) = self.get_cached_blobs_mut().get_mut(blob_index) {
-            *b = Some(blob);
-        }
-    }
-
-    /// Merges a given set of blobs into the cache.
-    ///
-    /// Blobs are only inserted if:
-    /// 1. The blob entry at the index is empty and no block exists.
-    /// 2. The block exists and its commitment matches the blob's commitment.
-    fn merge_blobs(&mut self, blobs: FixedVector<Option<Self::BlobType>, E::MaxBlobsPerBlock>) {
-        for (index, blob) in blobs.iter().cloned().enumerate() {
-            let Some(blob) = blob else { continue };
-            self.merge_single_blob(index, blob);
-        }
-    }
-
-    /// Merges a single blob into the cache.
-    ///
-    /// Blobs are only inserted if:
-    /// 1. The blob entry at the index is empty and no block exists, or
-    /// 2. The block exists and its commitment matches the blob's commitment.
-    fn merge_single_blob(&mut self, index: usize, blob: Self::BlobType) {
-        if let Some(cached_block) = self.get_cached_block() {
-            let block_commitment_opt = cached_block.get_commitments().get(index).copied();
-            if let Some(block_commitment) = block_commitment_opt {
-                if block_commitment == *blob.get_commitment() {
-                    self.insert_blob_at_index(index, blob)
-                }
-            }
-        } else if !self.blob_exists(index) {
-            self.insert_blob_at_index(index, blob)
-        }
-    }
-
-    /// Inserts a new block and revalidates the existing blobs against it.
-    ///
-    /// Blobs that don't match the new block's commitments are evicted.
-    fn merge_block(&mut self, block: Self::BlockType) {
-        self.insert_block(block);
-        let reinsert = std::mem::take(self.get_cached_blobs_mut());
-        self.merge_blobs(reinsert);
-    }
-
-    /// Checks if the block and all of its expected blobs are available in the cache.
-    ///
-    /// Returns `true` if both the block exists and the number of received blobs matches the number
-    /// of expected blobs.
-    fn is_available(&self) -> bool {
-        if let Some(num_expected_blobs) = self.num_expected_blobs() {
-            num_expected_blobs == self.num_received_blobs()
-        } else {
-            false
-        }
-    }
-}
-
-/// Implements the `AvailabilityView` trait for a given struct.
-///
-/// - `$struct_name`: The name of the struct for which to implement `AvailabilityView`.
-/// - `$block_type`: The type to use for `BlockType` in the `AvailabilityView` trait.
-/// - `$blob_type`: The type to use for `BlobType` in the `AvailabilityView` trait.
-/// - `$block_field`: The field name in the struct that holds the cached block.
-/// - `$blob_field`: The field name in the struct that holds the cached blobs.
-#[macro_export]
-macro_rules! impl_availability_view {
-    ($struct_name:ident, $block_type:ty, $blob_type:ty, $block_field:ident, $blob_field:ident) => {
-        impl<E: EthSpec> AvailabilityView<E> for $struct_name<E> {
-            type BlockType = $block_type;
-            type BlobType = $blob_type;
-
-            fn get_cached_block(&self) -> &Option<Self::BlockType> {
-                &self.$block_field
-            }
-
-            fn get_cached_blobs(
-                &self,
-            ) -> &FixedVector<Option<Self::BlobType>, E::MaxBlobsPerBlock> {
-                &self.$blob_field
-            }
-
-            fn get_cached_block_mut(&mut self) -> &mut Option<Self::BlockType> {
-                &mut self.$block_field
-            }
-
-            fn get_cached_blobs_mut(
-                &mut self,
-            ) -> &mut FixedVector<Option<Self::BlobType>, E::MaxBlobsPerBlock> {
-                &mut self.$blob_field
-            }
-        }
-    };
-}
-
-impl_availability_view!(
-    ProcessingComponents,
-    Arc<SignedBeaconBlock<E>>,
-    KzgCommitment,
-    block,
-    blob_commitments
-);
-
-impl_availability_view!(
-    PendingComponents,
-    DietAvailabilityPendingExecutedBlock<E>,
-    KzgVerifiedBlob<E>,
-    executed_block,
-    verified_blobs
-);
-
-pub trait GetCommitments<E: EthSpec> {
-    fn get_commitments(&self) -> KzgCommitments<E>;
-}
-
-pub trait GetCommitment<E: EthSpec> {
-    fn get_commitment(&self) -> &KzgCommitment;
-}
-
-impl<E: EthSpec> GetCommitment<E> for KzgCommitment {
-    fn get_commitment(&self) -> &KzgCommitment {
-        self
-    }
-}
-
-// These implementations are required to implement `AvailabilityView` for `PendingComponents`.
-impl<E: EthSpec> GetCommitments<E> for DietAvailabilityPendingExecutedBlock<E> {
-    fn get_commitments(&self) -> KzgCommitments<E> {
-        self.as_block()
-            .message()
-            .body()
-            .blob_kzg_commitments()
-            .cloned()
-            .unwrap_or_default()
-    }
-}
-
-impl<E: EthSpec> GetCommitment<E> for KzgVerifiedBlob<E> {
-    fn get_commitment(&self) -> &KzgCommitment {
-        &self.as_blob().kzg_commitment
-    }
-}
-
-// These implementations are required to implement `AvailabilityView` for `ChildComponents`.
-impl<E: EthSpec> GetCommitments<E> for Arc<SignedBeaconBlock<E>> {
-    fn get_commitments(&self) -> KzgCommitments<E> {
-        self.message()
-            .body()
-            .blob_kzg_commitments()
-            .ok()
-            .cloned()
-            .unwrap_or_default()
-    }
-}
-impl<E: EthSpec> GetCommitment<E> for Arc<BlobSidecar<E>> {
-    fn get_commitment(&self) -> &KzgCommitment {
-        &self.kzg_commitment
-    }
-}
-
-#[cfg(test)]
-pub mod tests {
-    use super::*;
-    use crate::block_verification_types::BlockImportData;
-    use crate::eth1_finalization_cache::Eth1FinalizationData;
-    use crate::test_utils::{generate_rand_block_and_blobs, NumBlobs};
-    use crate::AvailabilityPendingExecutedBlock;
-    use crate::PayloadVerificationOutcome;
-    use fork_choice::PayloadVerificationStatus;
-    use rand::rngs::StdRng;
-    use rand::SeedableRng;
-    use state_processing::ConsensusContext;
-    use types::test_utils::TestRandom;
-    use types::{BeaconState, ChainSpec, ForkName, MainnetEthSpec, Slot};
-
-    type E = MainnetEthSpec;
-
-    type Setup<E> = (
-        SignedBeaconBlock<E>,
-        FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
-        FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
-    );
-
-    pub fn pre_setup() -> Setup<E> {
-        let mut rng = StdRng::seed_from_u64(0xDEADBEEF0BAD5EEDu64);
-        let (block, blobs_vec) =
-            generate_rand_block_and_blobs::<E>(ForkName::Deneb, NumBlobs::Random, &mut rng);
-        let mut blobs: FixedVector<_, <E as EthSpec>::MaxBlobsPerBlock> = FixedVector::default();
-
-        for blob in blobs_vec {
-            if let Some(b) = blobs.get_mut(blob.index as usize) {
-                *b = Some(Arc::new(blob));
-            }
-        }
-
-        let mut invalid_blobs: FixedVector<
-            Option<Arc<BlobSidecar<E>>>,
-            <E as EthSpec>::MaxBlobsPerBlock,
-        > = FixedVector::default();
-        for (index, blob) in blobs.iter().enumerate() {
-            if let Some(invalid_blob) = blob {
-                let mut blob_copy = invalid_blob.as_ref().clone();
-                blob_copy.kzg_commitment = KzgCommitment::random_for_test(&mut rng);
-                *invalid_blobs.get_mut(index).unwrap() = Some(Arc::new(blob_copy));
-            }
-        }
-
-        (block, blobs, invalid_blobs)
-    }
-
-    type ProcessingViewSetup<E> = (
-        Arc<SignedBeaconBlock<E>>,
-        FixedVector<Option<KzgCommitment>, <E as EthSpec>::MaxBlobsPerBlock>,
-        FixedVector<Option<KzgCommitment>, <E as EthSpec>::MaxBlobsPerBlock>,
-    );
-
-    pub fn setup_processing_components(
-        block: SignedBeaconBlock<E>,
-        valid_blobs: FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
-        invalid_blobs: FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
-    ) -> ProcessingViewSetup<E> {
-        let blobs = FixedVector::from(
-            valid_blobs
-                .iter()
-                .map(|blob_opt| blob_opt.as_ref().map(|blob| blob.kzg_commitment))
-                .collect::<Vec<_>>(),
-        );
-        let invalid_blobs = FixedVector::from(
-            invalid_blobs
-                .iter()
-                .map(|blob_opt| blob_opt.as_ref().map(|blob| blob.kzg_commitment))
-                .collect::<Vec<_>>(),
-        );
-        (Arc::new(block), blobs, invalid_blobs)
-    }
-
-    type PendingComponentsSetup<E> = (
-        DietAvailabilityPendingExecutedBlock<E>,
-        FixedVector<Option<KzgVerifiedBlob<E>>, <E as EthSpec>::MaxBlobsPerBlock>,
-        FixedVector<Option<KzgVerifiedBlob<E>>, <E as EthSpec>::MaxBlobsPerBlock>,
-    );
-
-    pub fn setup_pending_components(
-        block: SignedBeaconBlock<E>,
-        valid_blobs: FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
-        invalid_blobs: FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
-    ) -> PendingComponentsSetup<E> {
-        let blobs = FixedVector::from(
-            valid_blobs
-                .iter()
-                .map(|blob_opt| {
-                    blob_opt
-                        .as_ref()
-                        .map(|blob| KzgVerifiedBlob::__assumed_valid(blob.clone()))
-                })
-                .collect::<Vec<_>>(),
-        );
-        let invalid_blobs = FixedVector::from(
-            invalid_blobs
-                .iter()
-                .map(|blob_opt| {
-                    blob_opt
-                        .as_ref()
-                        .map(|blob| KzgVerifiedBlob::__assumed_valid(blob.clone()))
-                })
-                .collect::<Vec<_>>(),
-        );
-        let dummy_parent = block.clone_as_blinded();
-        let block = AvailabilityPendingExecutedBlock {
-            block: Arc::new(block),
-            import_data: BlockImportData {
-                block_root: Default::default(),
-                state: BeaconState::new(0, Default::default(), &ChainSpec::minimal()),
-                parent_block: dummy_parent,
-                parent_eth1_finalization_data: Eth1FinalizationData {
-                    eth1_data: Default::default(),
-                    eth1_deposit_index: 0,
-                },
-                confirmed_state_roots: vec![],
-                consensus_context: ConsensusContext::new(Slot::new(0)),
-            },
-            payload_verification_outcome: PayloadVerificationOutcome {
-                payload_verification_status: PayloadVerificationStatus::Verified,
-                is_valid_merge_transition_block: false,
-            },
-        };
-        (block.into(), blobs, invalid_blobs)
-    }
-
-    pub fn assert_cache_consistent<V: AvailabilityView<E>>(cache: V) {
-        if let Some(cached_block) = cache.get_cached_block() {
-            let cached_block_commitments = cached_block.get_commitments();
-            for index in 0..E::max_blobs_per_block() {
-                let block_commitment = cached_block_commitments.get(index).copied();
-                let blob_commitment_opt = cache.get_cached_blobs().get(index).unwrap();
-                let blob_commitment = blob_commitment_opt.as_ref().map(|b| *b.get_commitment());
-                assert_eq!(block_commitment, blob_commitment);
-            }
-        } else {
-            panic!("No cached block")
-        }
-    }
-
-    pub fn assert_empty_blob_cache<V: AvailabilityView<E>>(cache: V) {
-        for blob in cache.get_cached_blobs().iter() {
-            assert!(blob.is_none());
-        }
-    }
-
-    #[macro_export]
-    macro_rules! generate_tests {
-        ($module_name:ident, $type_name:ty, $block_field:ident, $blob_field:ident, $setup_fn:ident) => {
-            mod $module_name {
-                use super::*;
-                use types::Hash256;
-
-                #[test]
-                fn valid_block_invalid_blobs_valid_blobs() {
-                    let (block_commitments, blobs, random_blobs) = pre_setup();
-                    let (block_commitments, blobs, random_blobs) =
-                        $setup_fn(block_commitments, blobs, random_blobs);
-                    let block_root = Hash256::zero();
-                    let mut cache = <$type_name>::empty(block_root);
-                    cache.merge_block(block_commitments);
-                    cache.merge_blobs(random_blobs);
-                    cache.merge_blobs(blobs);
-
-                    assert_cache_consistent(cache);
-                }
-
-                #[test]
-                fn invalid_blobs_block_valid_blobs() {
-                    let (block_commitments, blobs, random_blobs) = pre_setup();
-                    let (block_commitments, blobs, random_blobs) =
-                        $setup_fn(block_commitments, blobs, random_blobs);
-                    let block_root = Hash256::zero();
-                    let mut cache = <$type_name>::empty(block_root);
-                    cache.merge_blobs(random_blobs);
-                    cache.merge_block(block_commitments);
-                    cache.merge_blobs(blobs);
-
-                    assert_cache_consistent(cache);
-                }
-
-                #[test]
-                fn invalid_blobs_valid_blobs_block() {
-                    let (block_commitments, blobs, random_blobs) = pre_setup();
-                    let (block_commitments, blobs, random_blobs) =
-                        $setup_fn(block_commitments, blobs, random_blobs);
-
-                    let block_root = Hash256::zero();
-                    let mut cache = <$type_name>::empty(block_root);
-                    cache.merge_blobs(random_blobs);
-                    cache.merge_blobs(blobs);
-                    cache.merge_block(block_commitments);
-
-                    assert_empty_blob_cache(cache);
-                }
-
-                #[test]
-                fn block_valid_blobs_invalid_blobs() {
-                    let (block_commitments, blobs, random_blobs) = pre_setup();
-                    let (block_commitments, blobs, random_blobs) =
-                        $setup_fn(block_commitments, blobs, random_blobs);
-
-                    let block_root = Hash256::zero();
-                    let mut cache = <$type_name>::empty(block_root);
-                    cache.merge_block(block_commitments);
-                    cache.merge_blobs(blobs);
-                    cache.merge_blobs(random_blobs);
-
-                    assert_cache_consistent(cache);
-                }
-
-                #[test]
-                fn valid_blobs_block_invalid_blobs() {
-                    let (block_commitments, blobs, random_blobs) = pre_setup();
-                    let (block_commitments, blobs, random_blobs) =
-                        $setup_fn(block_commitments, blobs, random_blobs);
-
-                    let block_root = Hash256::zero();
-                    let mut cache = <$type_name>::empty(block_root);
-                    cache.merge_blobs(blobs);
-                    cache.merge_block(block_commitments);
-                    cache.merge_blobs(random_blobs);
-
-                    assert_cache_consistent(cache);
-                }
-
-                #[test]
-                fn valid_blobs_invalid_blobs_block() {
-                    let (block_commitments, blobs, random_blobs) = pre_setup();
-                    let (block_commitments, blobs, random_blobs) =
-                        $setup_fn(block_commitments, blobs, random_blobs);
-
-                    let block_root = Hash256::zero();
-                    let mut cache = <$type_name>::empty(block_root);
-                    cache.merge_blobs(blobs);
-                    cache.merge_blobs(random_blobs);
-                    cache.merge_block(block_commitments);
-
-                    assert_cache_consistent(cache);
-                }
-            }
-        };
-    }
-
-    generate_tests!(
-        processing_components_tests,
-        ProcessingComponents::<E>,
-        kzg_commitments,
-        processing_blobs,
-        setup_processing_components
-    );
-    generate_tests!(
-        pending_components_tests,
-        PendingComponents<E>,
-        executed_block,
-        verified_blobs,
-        setup_pending_components
-    );
-}
diff --git a/beacon_node/beacon_chain/src/data_availability_checker/child_components.rs b/beacon_node/beacon_chain/src/data_availability_checker/child_components.rs
deleted file mode 100644
index 184dfc45001..00000000000
--- a/beacon_node/beacon_chain/src/data_availability_checker/child_components.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use crate::block_verification_types::RpcBlock;
-use bls::Hash256;
-use std::sync::Arc;
-use types::blob_sidecar::FixedBlobSidecarList;
-use types::{BlobSidecar, EthSpec, SignedBeaconBlock};
-
-/// For requests triggered by an `UnknownBlockParent` or `UnknownBlobParent`, this struct
-/// is used to cache components as they are sent to the network service. We can't use the
-/// data availability cache currently because any blocks or blobs without parents
-/// won't pass validation and therefore won't make it into the cache.
-pub struct ChildComponents<E: EthSpec> {
-    pub block_root: Hash256,
-    pub downloaded_block: Option<Arc<SignedBeaconBlock<E>>>,
-    pub downloaded_blobs: FixedBlobSidecarList<E>,
-}
-
-impl<E: EthSpec> From<RpcBlock<E>> for ChildComponents<E> {
-    fn from(value: RpcBlock<E>) -> Self {
-        let (block_root, block, blobs) = value.deconstruct();
-        let fixed_blobs = blobs.map(|blobs| {
-            FixedBlobSidecarList::from(blobs.into_iter().map(Some).collect::<Vec<_>>())
-        });
-        Self::new(block_root, Some(block), fixed_blobs)
-    }
-}
-
-impl<E: EthSpec> ChildComponents<E> {
-    pub fn empty(block_root: Hash256) -> Self {
-        Self {
-            block_root,
-            downloaded_block: None,
-            downloaded_blobs: <_>::default(),
-        }
-    }
-    pub fn new(
-        block_root: Hash256,
-        block: Option<Arc<SignedBeaconBlock<E>>>,
-        blobs: Option<FixedBlobSidecarList<E>>,
-    ) -> Self {
-        let mut cache = Self::empty(block_root);
-        if let Some(block) = block {
-            cache.merge_block(block);
-        }
-        if let Some(blobs) = blobs {
-            cache.merge_blobs(blobs);
-        }
-        cache
-    }
-
-    pub fn merge_block(&mut self, block: Arc<SignedBeaconBlock<E>>) {
-        self.downloaded_block = Some(block);
-    }
-
-    pub fn merge_blob(&mut self, blob: Arc<BlobSidecar<E>>) {
-        if let Some(blob_ref) = self.downloaded_blobs.get_mut(blob.index as usize) {
-            *blob_ref = Some(blob);
-        }
-    }
-
-    pub fn merge_blobs(&mut self, blobs: FixedBlobSidecarList<E>) {
-        for blob in blobs.iter().flatten() {
-            self.merge_blob(blob.clone());
-        }
-    }
-
-    pub fn clear_blobs(&mut self) {
-        self.downloaded_blobs = FixedBlobSidecarList::default();
-    }
-}
diff --git a/beacon_node/beacon_chain/src/data_availability_checker/error.rs b/beacon_node/beacon_chain/src/data_availability_checker/error.rs
index 0804fe3b9ab..d22f6b2cc9f 100644
--- a/beacon_node/beacon_chain/src/data_availability_checker/error.rs
+++ b/beacon_node/beacon_chain/src/data_availability_checker/error.rs
@@ -19,8 +19,10 @@ pub enum Error {
     ParentStateMissing(Hash256),
     BlockReplayError(state_processing::BlockReplayError),
     RebuildingStateCaches(BeaconStateError),
+    SlotClockError,
 }
 
+#[derive(PartialEq, Eq)]
 pub enum ErrorCategory {
     /// Internal Errors (not caused by peers)
     Internal,
@@ -39,7 +41,8 @@ impl Error {
             | Error::Unexpected
             | Error::ParentStateMissing(_)
             | Error::BlockReplayError(_)
-            | Error::RebuildingStateCaches(_) => ErrorCategory::Internal,
+            | Error::RebuildingStateCaches(_)
+            | Error::SlotClockError => ErrorCategory::Internal,
             Error::Kzg(_)
             | Error::BlobIndexInvalid(_)
             | Error::KzgCommitmentMismatch { .. }
diff --git a/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs b/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs
index 50e07987fdf..2e3c4aac558 100644
--- a/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs
+++ b/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs
@@ -33,7 +33,6 @@ use crate::blob_verification::KzgVerifiedBlob;
 use crate::block_verification_types::{
     AvailabilityPendingExecutedBlock, AvailableBlock, AvailableExecutedBlock,
 };
-use crate::data_availability_checker::availability_view::AvailabilityView;
 use crate::data_availability_checker::{Availability, AvailabilityCheckError};
 use crate::store::{DBColumn, KeyValueStore};
 use crate::BeaconChainTypes;
@@ -59,6 +58,126 @@ pub struct PendingComponents<E: EthSpec> {
 }
 
 impl<E: EthSpec> PendingComponents<E> {
+    /// Returns an immutable reference to the cached block.
+    pub fn get_cached_block(&self) -> &Option<DietAvailabilityPendingExecutedBlock<E>> {
+        &self.executed_block
+    }
+
+    /// Returns an immutable reference to the fixed vector of cached blobs.
+    pub fn get_cached_blobs(
+        &self,
+    ) -> &FixedVector<Option<KzgVerifiedBlob<E>>, E::MaxBlobsPerBlock> {
+        &self.verified_blobs
+    }
+
+    /// Returns a mutable reference to the cached block.
+    pub fn get_cached_block_mut(&mut self) -> &mut Option<DietAvailabilityPendingExecutedBlock<E>> {
+        &mut self.executed_block
+    }
+
+    /// Returns a mutable reference to the fixed vector of cached blobs.
+    pub fn get_cached_blobs_mut(
+        &mut self,
+    ) -> &mut FixedVector<Option<KzgVerifiedBlob<E>>, E::MaxBlobsPerBlock> {
+        &mut self.verified_blobs
+    }
+
+    /// Checks if a blob exists at the given index in the cache.
+    ///
+    /// Returns:
+    /// - `true` if a blob exists at the given index.
+    /// - `false` otherwise.
+    pub fn blob_exists(&self, blob_index: usize) -> bool {
+        self.get_cached_blobs()
+            .get(blob_index)
+            .map(|b| b.is_some())
+            .unwrap_or(false)
+    }
+
+    /// Returns the number of blobs that are expected to be present. Returns `None` if we don't have a
+    /// block.
+    ///
+    /// This corresponds to the number of commitments that are present in a block.
+    pub fn num_expected_blobs(&self) -> Option<usize> {
+        self.get_cached_block()
+            .as_ref()
+            .map(|b| b.get_commitments().len())
+    }
+
+    /// Returns the number of blobs that have been received and are stored in the cache.
+    pub fn num_received_blobs(&self) -> usize {
+        self.get_cached_blobs().iter().flatten().count()
+    }
+
+    /// Inserts a block into the cache.
+    pub fn insert_block(&mut self, block: DietAvailabilityPendingExecutedBlock<E>) {
+        *self.get_cached_block_mut() = Some(block)
+    }
+
+    /// Inserts a blob at a specific index in the cache.
+    ///
+    /// Existing blob at the index will be replaced.
+    pub fn insert_blob_at_index(&mut self, blob_index: usize, blob: KzgVerifiedBlob<E>) {
+        if let Some(b) = self.get_cached_blobs_mut().get_mut(blob_index) {
+            *b = Some(blob);
+        }
+    }
+
+    /// Merges a given set of blobs into the cache.
+    ///
+    /// Blobs are only inserted if:
+    /// 1. The blob entry at the index is empty and no block exists.
+    /// 2. The block exists and its commitment matches the blob's commitment.
+    pub fn merge_blobs(
+        &mut self,
+        blobs: FixedVector<Option<KzgVerifiedBlob<E>>, E::MaxBlobsPerBlock>,
+    ) {
+        for (index, blob) in blobs.iter().cloned().enumerate() {
+            let Some(blob) = blob else { continue };
+            self.merge_single_blob(index, blob);
+        }
+    }
+
+    /// Merges a single blob into the cache.
+    ///
+    /// Blobs are only inserted if:
+    /// 1. The blob entry at the index is empty and no block exists, or
+    /// 2. The block exists and its commitment matches the blob's commitment.
+    pub fn merge_single_blob(&mut self, index: usize, blob: KzgVerifiedBlob<E>) {
+        if let Some(cached_block) = self.get_cached_block() {
+            let block_commitment_opt = cached_block.get_commitments().get(index).copied();
+            if let Some(block_commitment) = block_commitment_opt {
+                if block_commitment == *blob.get_commitment() {
+                    self.insert_blob_at_index(index, blob)
+                }
+            }
+        } else if !self.blob_exists(index) {
+            self.insert_blob_at_index(index, blob)
+        }
+    }
+
+    /// Inserts a new block and revalidates the existing blobs against it.
+    ///
+    /// Blobs that don't match the new block's commitments are evicted.
+    pub fn merge_block(&mut self, block: DietAvailabilityPendingExecutedBlock<E>) {
+        self.insert_block(block);
+        let reinsert = std::mem::take(self.get_cached_blobs_mut());
+        self.merge_blobs(reinsert);
+    }
+
+    /// Checks if the block and all of its expected blobs are available in the cache.
+    ///
+    /// Returns `true` if both the block exists and the number of received blobs matches the number
+    /// of expected blobs.
+    pub fn is_available(&self) -> bool {
+        if let Some(num_expected_blobs) = self.num_expected_blobs() {
+            num_expected_blobs == self.num_received_blobs()
+        } else {
+            false
+        }
+    }
+
+    /// Returns an empty `PendingComponents` object with the given block root.
     pub fn empty(block_root: Hash256) -> Self {
         Self {
             block_root,
@@ -85,6 +204,12 @@ impl<E: EthSpec> PendingComponents<E> {
             executed_block,
         } = self;
 
+        let blobs_available_timestamp = verified_blobs
+            .iter()
+            .flatten()
+            .map(|blob| blob.seen_timestamp())
+            .max();
+
         let Some(diet_executed_block) = executed_block else {
             return Err(AvailabilityCheckError::Unexpected);
         };
@@ -112,12 +237,14 @@ impl<E: EthSpec> PendingComponents<E> {
             block_root,
             block,
             blobs: Some(verified_blobs),
+            blobs_available_timestamp,
         };
         Ok(Availability::Available(Box::new(
             AvailableExecutedBlock::new(available_block, import_data, payload_verification_outcome),
         )))
     }
 
+    /// Returns the epoch of the block if it is cached, otherwise returns the epoch of the first blob.
     pub fn epoch(&self) -> Option<Epoch> {
         self.executed_block
             .as_ref()
@@ -322,6 +449,13 @@ impl<T: BeaconChainTypes> Critical<T> {
         }
     }
 
+    pub fn peek_pending_components(
+        &self,
+        block_root: &Hash256,
+    ) -> Option<&PendingComponents<T::EthSpec>> {
+        self.in_memory.peek(block_root)
+    }
+
     /// Puts the pending components in the LRU cache. If the cache
     /// is at capacity, the LRU entry is written to the store first
     pub fn put_pending_components(
@@ -409,6 +543,15 @@ impl<T: BeaconChainTypes> OverflowLRUCache<T> {
         })
     }
 
+    /// Returns true if the block root is known, without altering the LRU ordering
+    pub fn has_execution_valid_block(&self, block_root: &Hash256) -> bool {
+        if let Some(pending_components) = self.critical.read().peek_pending_components(block_root) {
+            pending_components.executed_block.is_some()
+        } else {
+            false
+        }
+    }
+
     /// Fetch a blob from the cache without affecting the LRU ordering
     pub fn peek_blob(
         &self,
@@ -425,6 +568,14 @@ impl<T: BeaconChainTypes> OverflowLRUCache<T> {
         }
     }
 
+    pub fn peek_pending_components<R, F: FnOnce(Option<&PendingComponents<T::EthSpec>>) -> R>(
+        &self,
+        block_root: &Hash256,
+        f: F,
+    ) -> R {
+        f(self.critical.read().peek_pending_components(block_root))
+    }
+
     pub fn put_kzg_verified_blobs<I: IntoIterator<Item = KzgVerifiedBlob<T::EthSpec>>>(
         &self,
         block_root: Hash256,
@@ -837,17 +988,17 @@ mod test {
 
         // go to bellatrix slot
         harness.extend_to_slot(bellatrix_fork_slot).await;
-        let merge_head = &harness.chain.head_snapshot().beacon_block;
-        assert!(merge_head.as_merge().is_ok());
-        assert_eq!(merge_head.slot(), bellatrix_fork_slot);
+        let bellatrix_head = &harness.chain.head_snapshot().beacon_block;
+        assert!(bellatrix_head.as_bellatrix().is_ok());
+        assert_eq!(bellatrix_head.slot(), bellatrix_fork_slot);
         assert!(
-            merge_head
+            bellatrix_head
                 .message()
                 .body()
                 .execution_payload()
                 .unwrap()
                 .is_default_with_empty_roots(),
-            "Merge head is default payload"
+            "Bellatrix head is default payload"
         );
         // Trigger the terminal PoW block.
         harness
@@ -907,7 +1058,7 @@ mod test {
         let chain = &harness.chain;
         let log = chain.log.clone();
         let head = chain.head_snapshot();
-        let parent_state = head.beacon_state.clone_with_only_committee_caches();
+        let parent_state = head.beacon_state.clone();
 
         let target_slot = chain.slot().expect("should get slot") + 1;
         let parent_root = head.beacon_block_root;
@@ -1678,3 +1829,215 @@ mod test {
         );
     }
 }
+
+#[cfg(test)]
+mod pending_components_tests {
+    use super::*;
+    use crate::block_verification_types::BlockImportData;
+    use crate::eth1_finalization_cache::Eth1FinalizationData;
+    use crate::test_utils::{generate_rand_block_and_blobs, NumBlobs};
+    use crate::PayloadVerificationOutcome;
+    use fork_choice::PayloadVerificationStatus;
+    use kzg::KzgCommitment;
+    use rand::rngs::StdRng;
+    use rand::SeedableRng;
+    use state_processing::ConsensusContext;
+    use types::test_utils::TestRandom;
+    use types::{BeaconState, ForkName, MainnetEthSpec, SignedBeaconBlock, Slot};
+
+    type E = MainnetEthSpec;
+
+    type Setup<E> = (
+        SignedBeaconBlock<E>,
+        FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
+        FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
+    );
+
+    pub fn pre_setup() -> Setup<E> {
+        let mut rng = StdRng::seed_from_u64(0xDEADBEEF0BAD5EEDu64);
+        let (block, blobs_vec) =
+            generate_rand_block_and_blobs::<E>(ForkName::Deneb, NumBlobs::Random, &mut rng);
+        let mut blobs: FixedVector<_, <E as EthSpec>::MaxBlobsPerBlock> = FixedVector::default();
+
+        for blob in blobs_vec {
+            if let Some(b) = blobs.get_mut(blob.index as usize) {
+                *b = Some(Arc::new(blob));
+            }
+        }
+
+        let mut invalid_blobs: FixedVector<
+            Option<Arc<BlobSidecar<E>>>,
+            <E as EthSpec>::MaxBlobsPerBlock,
+        > = FixedVector::default();
+        for (index, blob) in blobs.iter().enumerate() {
+            if let Some(invalid_blob) = blob {
+                let mut blob_copy = invalid_blob.as_ref().clone();
+                blob_copy.kzg_commitment = KzgCommitment::random_for_test(&mut rng);
+                *invalid_blobs.get_mut(index).unwrap() = Some(Arc::new(blob_copy));
+            }
+        }
+
+        (block, blobs, invalid_blobs)
+    }
+
+    type PendingComponentsSetup<E> = (
+        DietAvailabilityPendingExecutedBlock<E>,
+        FixedVector<Option<KzgVerifiedBlob<E>>, <E as EthSpec>::MaxBlobsPerBlock>,
+        FixedVector<Option<KzgVerifiedBlob<E>>, <E as EthSpec>::MaxBlobsPerBlock>,
+    );
+
+    pub fn setup_pending_components(
+        block: SignedBeaconBlock<E>,
+        valid_blobs: FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
+        invalid_blobs: FixedVector<Option<Arc<BlobSidecar<E>>>, <E as EthSpec>::MaxBlobsPerBlock>,
+    ) -> PendingComponentsSetup<E> {
+        let blobs = FixedVector::from(
+            valid_blobs
+                .iter()
+                .map(|blob_opt| {
+                    blob_opt
+                        .as_ref()
+                        .map(|blob| KzgVerifiedBlob::__assumed_valid(blob.clone()))
+                })
+                .collect::<Vec<_>>(),
+        );
+        let invalid_blobs = FixedVector::from(
+            invalid_blobs
+                .iter()
+                .map(|blob_opt| {
+                    blob_opt
+                        .as_ref()
+                        .map(|blob| KzgVerifiedBlob::__assumed_valid(blob.clone()))
+                })
+                .collect::<Vec<_>>(),
+        );
+        let dummy_parent = block.clone_as_blinded();
+        let block = AvailabilityPendingExecutedBlock {
+            block: Arc::new(block),
+            import_data: BlockImportData {
+                block_root: Default::default(),
+                state: BeaconState::new(0, Default::default(), &ChainSpec::minimal()),
+                parent_block: dummy_parent,
+                parent_eth1_finalization_data: Eth1FinalizationData {
+                    eth1_data: Default::default(),
+                    eth1_deposit_index: 0,
+                },
+                confirmed_state_roots: vec![],
+                consensus_context: ConsensusContext::new(Slot::new(0)),
+            },
+            payload_verification_outcome: PayloadVerificationOutcome {
+                payload_verification_status: PayloadVerificationStatus::Verified,
+                is_valid_merge_transition_block: false,
+            },
+        };
+        (block.into(), blobs, invalid_blobs)
+    }
+
+    pub fn assert_cache_consistent(cache: PendingComponents<E>) {
+        if let Some(cached_block) = cache.get_cached_block() {
+            let cached_block_commitments = cached_block.get_commitments();
+            for index in 0..E::max_blobs_per_block() {
+                let block_commitment = cached_block_commitments.get(index).copied();
+                let blob_commitment_opt = cache.get_cached_blobs().get(index).unwrap();
+                let blob_commitment = blob_commitment_opt.as_ref().map(|b| *b.get_commitment());
+                assert_eq!(block_commitment, blob_commitment);
+            }
+        } else {
+            panic!("No cached block")
+        }
+    }
+
+    pub fn assert_empty_blob_cache(cache: PendingComponents<E>) {
+        for blob in cache.get_cached_blobs().iter() {
+            assert!(blob.is_none());
+        }
+    }
+
+    #[test]
+    fn valid_block_invalid_blobs_valid_blobs() {
+        let (block_commitments, blobs, random_blobs) = pre_setup();
+        let (block_commitments, blobs, random_blobs) =
+            setup_pending_components(block_commitments, blobs, random_blobs);
+        let block_root = Hash256::zero();
+        let mut cache = <PendingComponents<E>>::empty(block_root);
+        cache.merge_block(block_commitments);
+        cache.merge_blobs(random_blobs);
+        cache.merge_blobs(blobs);
+
+        assert_cache_consistent(cache);
+    }
+
+    #[test]
+    fn invalid_blobs_block_valid_blobs() {
+        let (block_commitments, blobs, random_blobs) = pre_setup();
+        let (block_commitments, blobs, random_blobs) =
+            setup_pending_components(block_commitments, blobs, random_blobs);
+        let block_root = Hash256::zero();
+        let mut cache = <PendingComponents<E>>::empty(block_root);
+        cache.merge_blobs(random_blobs);
+        cache.merge_block(block_commitments);
+        cache.merge_blobs(blobs);
+
+        assert_cache_consistent(cache);
+    }
+
+    #[test]
+    fn invalid_blobs_valid_blobs_block() {
+        let (block_commitments, blobs, random_blobs) = pre_setup();
+        let (block_commitments, blobs, random_blobs) =
+            setup_pending_components(block_commitments, blobs, random_blobs);
+
+        let block_root = Hash256::zero();
+        let mut cache = <PendingComponents<E>>::empty(block_root);
+        cache.merge_blobs(random_blobs);
+        cache.merge_blobs(blobs);
+        cache.merge_block(block_commitments);
+
+        assert_empty_blob_cache(cache);
+    }
+
+    #[test]
+    fn block_valid_blobs_invalid_blobs() {
+        let (block_commitments, blobs, random_blobs) = pre_setup();
+        let (block_commitments, blobs, random_blobs) =
+            setup_pending_components(block_commitments, blobs, random_blobs);
+
+        let block_root = Hash256::zero();
+        let mut cache = <PendingComponents<E>>::empty(block_root);
+        cache.merge_block(block_commitments);
+        cache.merge_blobs(blobs);
+        cache.merge_blobs(random_blobs);
+
+        assert_cache_consistent(cache);
+    }
+
+    #[test]
+    fn valid_blobs_block_invalid_blobs() {
+        let (block_commitments, blobs, random_blobs) = pre_setup();
+        let (block_commitments, blobs, random_blobs) =
+            setup_pending_components(block_commitments, blobs, random_blobs);
+
+        let block_root = Hash256::zero();
+        let mut cache = <PendingComponents<E>>::empty(block_root);
+        cache.merge_blobs(blobs);
+        cache.merge_block(block_commitments);
+        cache.merge_blobs(random_blobs);
+
+        assert_cache_consistent(cache);
+    }
+
+    #[test]
+    fn valid_blobs_invalid_blobs_block() {
+        let (block_commitments, blobs, random_blobs) = pre_setup();
+        let (block_commitments, blobs, random_blobs) =
+            setup_pending_components(block_commitments, blobs, random_blobs);
+
+        let block_root = Hash256::zero();
+        let mut cache = <PendingComponents<E>>::empty(block_root);
+        cache.merge_blobs(blobs);
+        cache.merge_blobs(random_blobs);
+        cache.merge_block(block_commitments);
+
+        assert_cache_consistent(cache);
+    }
+}
diff --git a/beacon_node/beacon_chain/src/data_availability_checker/processing_cache.rs b/beacon_node/beacon_chain/src/data_availability_checker/processing_cache.rs
deleted file mode 100644
index e09b3083be5..00000000000
--- a/beacon_node/beacon_chain/src/data_availability_checker/processing_cache.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-use crate::data_availability_checker::AvailabilityView;
-use std::collections::hash_map::Entry;
-use std::collections::HashMap;
-use std::sync::Arc;
-use types::beacon_block_body::KzgCommitmentOpts;
-use types::{EthSpec, Hash256, SignedBeaconBlock};
-
-/// This cache is used only for gossip blocks/blobs and single block/blob lookups, to give req/resp
-/// a view of what we have and what we require. This cache serves a slightly different purpose than
-/// gossip caches because it allows us to process duplicate blobs that are valid in gossip.
-/// See `AvailabilityView`'s trait definition.
-#[derive(Default)]
-pub struct ProcessingCache<E: EthSpec> {
-    processing_cache: HashMap<Hash256, ProcessingComponents<E>>,
-}
-
-impl<E: EthSpec> ProcessingCache<E> {
-    pub fn get(&self, block_root: &Hash256) -> Option<&ProcessingComponents<E>> {
-        self.processing_cache.get(block_root)
-    }
-    pub fn entry(&mut self, block_root: Hash256) -> Entry<'_, Hash256, ProcessingComponents<E>> {
-        self.processing_cache.entry(block_root)
-    }
-    pub fn remove(&mut self, block_root: &Hash256) {
-        self.processing_cache.remove(block_root);
-    }
-    pub fn has_block(&self, block_root: &Hash256) -> bool {
-        self.processing_cache
-            .get(block_root)
-            .map_or(false, |b| b.block_exists())
-    }
-    pub fn len(&self) -> usize {
-        self.processing_cache.len()
-    }
-}
-
-#[derive(Default, Debug, Clone)]
-pub struct ProcessingComponents<E: EthSpec> {
-    /// Blobs required for a block can only be known if we have seen the block. So `Some` here
-    /// means we've seen it, a `None` means we haven't. The `kzg_commitments` value helps us figure
-    /// out whether incoming blobs actually match the block.
-    pub block: Option<Arc<SignedBeaconBlock<E>>>,
-    /// `KzgCommitments` for blobs are always known, even if we haven't seen the block. See
-    /// `AvailabilityView`'s trait definition for more details.
-    pub blob_commitments: KzgCommitmentOpts<E>,
-}
-
-impl<E: EthSpec> ProcessingComponents<E> {
-    pub fn new() -> Self {
-        Self::default()
-    }
-}
-
-// Not safe for use outside of tests as this always required a slot.
-#[cfg(test)]
-impl<E: EthSpec> ProcessingComponents<E> {
-    pub fn empty(_block_root: Hash256) -> Self {
-        Self {
-            block: None,
-            blob_commitments: KzgCommitmentOpts::<E>::default(),
-        }
-    }
-}
diff --git a/beacon_node/beacon_chain/src/data_availability_checker/state_lru_cache.rs b/beacon_node/beacon_chain/src/data_availability_checker/state_lru_cache.rs
index 35c114db542..f8a243bd9e8 100644
--- a/beacon_node/beacon_chain/src/data_availability_checker/state_lru_cache.rs
+++ b/beacon_node/beacon_chain/src/data_availability_checker/state_lru_cache.rs
@@ -8,8 +8,10 @@ use crate::{
 use lru::LruCache;
 use parking_lot::RwLock;
 use ssz_derive::{Decode, Encode};
-use state_processing::{BlockReplayer, ConsensusContext, StateProcessingStrategy};
+use state_processing::BlockReplayer;
 use std::sync::Arc;
+use store::OnDiskConsensusContext;
+use types::beacon_block_body::KzgCommitments;
 use types::{ssz_tagged_signed_beacon_block, ssz_tagged_signed_beacon_block_arc};
 use types::{BeaconState, BlindedPayload, ChainSpec, Epoch, EthSpec, Hash256, SignedBeaconBlock};
 
@@ -25,7 +27,7 @@ pub struct DietAvailabilityPendingExecutedBlock<E: EthSpec> {
     parent_block: SignedBeaconBlock<E, BlindedPayload<E>>,
     parent_eth1_finalization_data: Eth1FinalizationData,
     confirmed_state_roots: Vec<Hash256>,
-    consensus_context: ConsensusContext<E>,
+    consensus_context: OnDiskConsensusContext<E>,
     payload_verification_outcome: PayloadVerificationOutcome,
 }
 
@@ -42,6 +44,15 @@ impl<E: EthSpec> DietAvailabilityPendingExecutedBlock<E> {
             .blob_kzg_commitments()
             .map_or(0, |commitments| commitments.len())
     }
+
+    pub fn get_commitments(&self) -> KzgCommitments<E> {
+        self.as_block()
+            .message()
+            .body()
+            .blob_kzg_commitments()
+            .cloned()
+            .unwrap_or_default()
+    }
 }
 
 /// This LRU cache holds BeaconStates used for block import. If the cache overflows,
@@ -84,7 +95,9 @@ impl<T: BeaconChainTypes> StateLRUCache<T> {
             parent_block: executed_block.import_data.parent_block,
             parent_eth1_finalization_data: executed_block.import_data.parent_eth1_finalization_data,
             confirmed_state_roots: executed_block.import_data.confirmed_state_roots,
-            consensus_context: executed_block.import_data.consensus_context,
+            consensus_context: OnDiskConsensusContext::from_consensus_context(
+                executed_block.import_data.consensus_context,
+            ),
             payload_verification_outcome: executed_block.payload_verification_outcome,
         }
     }
@@ -109,7 +122,9 @@ impl<T: BeaconChainTypes> StateLRUCache<T> {
                     parent_eth1_finalization_data: diet_executed_block
                         .parent_eth1_finalization_data,
                     confirmed_state_roots: diet_executed_block.confirmed_state_roots,
-                    consensus_context: diet_executed_block.consensus_context,
+                    consensus_context: diet_executed_block
+                        .consensus_context
+                        .into_consensus_context(),
                 },
                 payload_verification_outcome: diet_executed_block.payload_verification_outcome,
             })
@@ -135,7 +150,9 @@ impl<T: BeaconChainTypes> StateLRUCache<T> {
                 parent_block: diet_executed_block.parent_block,
                 parent_eth1_finalization_data: diet_executed_block.parent_eth1_finalization_data,
                 confirmed_state_roots: diet_executed_block.confirmed_state_roots,
-                consensus_context: diet_executed_block.consensus_context,
+                consensus_context: diet_executed_block
+                    .consensus_context
+                    .into_consensus_context(),
             },
             payload_verification_outcome: diet_executed_block.payload_verification_outcome,
         })
@@ -172,7 +189,6 @@ impl<T: BeaconChainTypes> StateLRUCache<T> {
         let block_replayer: BlockReplayer<'_, T::EthSpec, AvailabilityCheckError, _> =
             BlockReplayer::new(parent_state, &self.spec)
                 .no_signature_verification()
-                .state_processing_strategy(StateProcessingStrategy::Accurate)
                 .state_root_iter(state_roots.into_iter())
                 .minimal_block_root_verification();
 
@@ -222,7 +238,9 @@ impl<E: EthSpec> From<AvailabilityPendingExecutedBlock<E>>
             parent_block: value.import_data.parent_block,
             parent_eth1_finalization_data: value.import_data.parent_eth1_finalization_data,
             confirmed_state_roots: value.import_data.confirmed_state_roots,
-            consensus_context: value.import_data.consensus_context,
+            consensus_context: OnDiskConsensusContext::from_consensus_context(
+                value.import_data.consensus_context,
+            ),
             payload_verification_outcome: value.payload_verification_outcome,
         }
     }
diff --git a/beacon_node/beacon_chain/src/deneb_readiness.rs b/beacon_node/beacon_chain/src/deneb_readiness.rs
index 1ba6fe3ea6c..e11070a1f4f 100644
--- a/beacon_node/beacon_chain/src/deneb_readiness.rs
+++ b/beacon_node/beacon_chain/src/deneb_readiness.rs
@@ -10,7 +10,7 @@ use std::time::Duration;
 use types::*;
 
 /// The time before the Deneb fork when we will start issuing warnings about preparation.
-use super::merge_readiness::SECONDS_IN_A_WEEK;
+use super::bellatrix_readiness::SECONDS_IN_A_WEEK;
 pub const DENEB_READINESS_PREPARATION_SECONDS: u64 = SECONDS_IN_A_WEEK * 2;
 pub const ENGINE_CAPABILITIES_REFRESH_INTERVAL: u64 = 300;
 
diff --git a/beacon_node/beacon_chain/src/electra_readiness.rs b/beacon_node/beacon_chain/src/electra_readiness.rs
index 0e911bf37ec..42ee743fe6b 100644
--- a/beacon_node/beacon_chain/src/electra_readiness.rs
+++ b/beacon_node/beacon_chain/src/electra_readiness.rs
@@ -11,7 +11,7 @@ use std::time::Duration;
 use types::*;
 
 /// The time before the Electra fork when we will start issuing warnings about preparation.
-use super::merge_readiness::SECONDS_IN_A_WEEK;
+use super::bellatrix_readiness::SECONDS_IN_A_WEEK;
 pub const ELECTRA_READINESS_PREPARATION_SECONDS: u64 = SECONDS_IN_A_WEEK * 2;
 pub const ENGINE_CAPABILITIES_REFRESH_INTERVAL: u64 = 300;
 
diff --git a/beacon_node/beacon_chain/src/errors.rs b/beacon_node/beacon_chain/src/errors.rs
index 9c82e964cc0..340f1f9f797 100644
--- a/beacon_node/beacon_chain/src/errors.rs
+++ b/beacon_node/beacon_chain/src/errors.rs
@@ -31,6 +31,7 @@ use state_processing::{
 use std::time::Duration;
 use task_executor::ShutdownReason;
 use tokio::task::JoinError;
+use types::milhouse::Error as MilhouseError;
 use types::*;
 
 macro_rules! easy_from_to {
@@ -224,6 +225,7 @@ pub enum BeaconChainError {
     AvailabilityCheckError(AvailabilityCheckError),
     LightClientError(LightClientError),
     UnsupportedFork,
+    MilhouseError(MilhouseError),
 }
 
 easy_from_to!(SlotProcessingError, BeaconChainError);
@@ -253,6 +255,7 @@ easy_from_to!(InconsistentFork, BeaconChainError);
 easy_from_to!(AvailabilityCheckError, BeaconChainError);
 easy_from_to!(EpochCacheError, BeaconChainError);
 easy_from_to!(LightClientError, BeaconChainError);
+easy_from_to!(MilhouseError, BeaconChainError);
 
 #[derive(Debug)]
 pub enum BlockProductionError {
@@ -279,6 +282,7 @@ pub enum BlockProductionError {
     TerminalPoWBlockLookupFailed(execution_layer::Error),
     GetPayloadFailed(execution_layer::Error),
     FailedToReadFinalizedBlock(store::Error),
+    FailedToLoadState(store::Error),
     MissingFinalizedBlock(Hash256),
     BlockTooLarge(usize),
     ShuttingDown,
diff --git a/beacon_node/beacon_chain/src/eth1_chain.rs b/beacon_node/beacon_chain/src/eth1_chain.rs
index 3ec39f9d192..31297244e3e 100644
--- a/beacon_node/beacon_chain/src/eth1_chain.rs
+++ b/beacon_node/beacon_chain/src/eth1_chain.rs
@@ -1020,6 +1020,7 @@ mod test {
 
     mod collect_valid_votes {
         use super::*;
+        use types::List;
 
         fn get_eth1_data_vec(n: u64, block_number_offset: u64) -> Vec<(Eth1Data, BlockNumber)> {
             (0..n)
@@ -1067,12 +1068,14 @@ mod test {
 
             let votes_to_consider = get_eth1_data_vec(slots, 0);
 
-            *state.eth1_data_votes_mut() = votes_to_consider[0..slots as usize / 4]
-                .iter()
-                .map(|(eth1_data, _)| eth1_data)
-                .cloned()
-                .collect::<Vec<_>>()
-                .into();
+            *state.eth1_data_votes_mut() = List::new(
+                votes_to_consider[0..slots as usize / 4]
+                    .iter()
+                    .map(|(eth1_data, _)| eth1_data)
+                    .cloned()
+                    .collect::<Vec<_>>(),
+            )
+            .unwrap();
 
             let votes =
                 collect_valid_votes(&state, &votes_to_consider.clone().into_iter().collect());
@@ -1096,12 +1099,14 @@ mod test {
                 .expect("should have some eth1 data")
                 .clone();
 
-            *state.eth1_data_votes_mut() = vec![duplicate_eth1_data.clone(); 4]
-                .iter()
-                .map(|(eth1_data, _)| eth1_data)
-                .cloned()
-                .collect::<Vec<_>>()
-                .into();
+            *state.eth1_data_votes_mut() = List::new(
+                vec![duplicate_eth1_data.clone(); 4]
+                    .iter()
+                    .map(|(eth1_data, _)| eth1_data)
+                    .cloned()
+                    .collect::<Vec<_>>(),
+            )
+            .unwrap();
 
             let votes = collect_valid_votes(&state, &votes_to_consider.into_iter().collect());
             assert_votes!(
diff --git a/beacon_node/beacon_chain/src/events.rs b/beacon_node/beacon_chain/src/events.rs
index 1fdcfdf8d07..8700675a66e 100644
--- a/beacon_node/beacon_chain/src/events.rs
+++ b/beacon_node/beacon_chain/src/events.rs
@@ -20,6 +20,8 @@ pub struct ServerSentEventHandler<E: EthSpec> {
     light_client_finality_update_tx: Sender<EventKind<E>>,
     light_client_optimistic_update_tx: Sender<EventKind<E>>,
     block_reward_tx: Sender<EventKind<E>>,
+    proposer_slashing_tx: Sender<EventKind<E>>,
+    attester_slashing_tx: Sender<EventKind<E>>,
     log: Logger,
 }
 
@@ -45,6 +47,8 @@ impl<E: EthSpec> ServerSentEventHandler<E> {
         let (light_client_finality_update_tx, _) = broadcast::channel(capacity);
         let (light_client_optimistic_update_tx, _) = broadcast::channel(capacity);
         let (block_reward_tx, _) = broadcast::channel(capacity);
+        let (proposer_slashing_tx, _) = broadcast::channel(capacity);
+        let (attester_slashing_tx, _) = broadcast::channel(capacity);
 
         Self {
             attestation_tx,
@@ -60,6 +64,8 @@ impl<E: EthSpec> ServerSentEventHandler<E> {
             light_client_finality_update_tx,
             light_client_optimistic_update_tx,
             block_reward_tx,
+            proposer_slashing_tx,
+            attester_slashing_tx,
             log,
         }
     }
@@ -126,6 +132,14 @@ impl<E: EthSpec> ServerSentEventHandler<E> {
                 .block_reward_tx
                 .send(kind)
                 .map(|count| log_count("block reward", count)),
+            EventKind::ProposerSlashing(_) => self
+                .proposer_slashing_tx
+                .send(kind)
+                .map(|count| log_count("proposer slashing", count)),
+            EventKind::AttesterSlashing(_) => self
+                .attester_slashing_tx
+                .send(kind)
+                .map(|count| log_count("attester slashing", count)),
         };
         if let Err(SendError(event)) = result {
             trace!(self.log, "No receivers registered to listen for event"; "event" => ?event);
@@ -184,6 +198,14 @@ impl<E: EthSpec> ServerSentEventHandler<E> {
         self.block_reward_tx.subscribe()
     }
 
+    pub fn subscribe_attester_slashing(&self) -> Receiver<EventKind<E>> {
+        self.attester_slashing_tx.subscribe()
+    }
+
+    pub fn subscribe_proposer_slashing(&self) -> Receiver<EventKind<E>> {
+        self.proposer_slashing_tx.subscribe()
+    }
+
     pub fn has_attestation_subscribers(&self) -> bool {
         self.attestation_tx.receiver_count() > 0
     }
@@ -227,4 +249,12 @@ impl<E: EthSpec> ServerSentEventHandler<E> {
     pub fn has_block_reward_subscribers(&self) -> bool {
         self.block_reward_tx.receiver_count() > 0
     }
+
+    pub fn has_proposer_slashing_subscribers(&self) -> bool {
+        self.proposer_slashing_tx.receiver_count() > 0
+    }
+
+    pub fn has_attester_slashing_subscribers(&self) -> bool {
+        self.attester_slashing_tx.receiver_count() > 0
+    }
 }
diff --git a/beacon_node/beacon_chain/src/execution_payload.rs b/beacon_node/beacon_chain/src/execution_payload.rs
index b3804f0d23a..cbffe363422 100644
--- a/beacon_node/beacon_chain/src/execution_payload.rs
+++ b/beacon_node/beacon_chain/src/execution_payload.rs
@@ -336,7 +336,7 @@ pub fn validate_execution_payload_for_gossip<T: BeaconChainTypes>(
     block: BeaconBlockRef<'_, T::EthSpec>,
     chain: &BeaconChain<T>,
 ) -> Result<(), BlockError<T::EthSpec>> {
-    // Only apply this validation if this is a merge beacon block.
+    // Only apply this validation if this is a Bellatrix beacon block.
     if let Ok(execution_payload) = block.body().execution_payload() {
         // This logic should match `is_execution_enabled`. We use only the execution block hash of
         // the parent here in order to avoid loading the parent state during gossip verification.
@@ -385,7 +385,7 @@ pub fn validate_execution_payload_for_gossip<T: BeaconChainTypes>(
 /// ## Errors
 ///
 /// Will return an error when using a pre-merge fork `state`. Ensure to only run this function
-/// after the merge fork.
+/// after the Bellatrix fork.
 ///
 /// ## Specification
 ///
@@ -415,13 +415,13 @@ pub fn get_execution_payload<T: BeaconChainTypes>(
         &BeaconState::Capella(_) | &BeaconState::Deneb(_) | &BeaconState::Electra(_) => {
             Some(get_expected_withdrawals(state, spec)?.into())
         }
-        &BeaconState::Merge(_) => None,
+        &BeaconState::Bellatrix(_) => None,
         // These shouldn't happen but they're here to make the pattern irrefutable
         &BeaconState::Base(_) | &BeaconState::Altair(_) => None,
     };
     let parent_beacon_block_root = match state {
         BeaconState::Deneb(_) | BeaconState::Electra(_) => Some(parent_block_root),
-        BeaconState::Merge(_) | BeaconState::Capella(_) => None,
+        BeaconState::Bellatrix(_) | BeaconState::Capella(_) => None,
         // These shouldn't happen but they're here to make the pattern irrefutable
         BeaconState::Base(_) | BeaconState::Altair(_) => None,
     };
@@ -457,12 +457,12 @@ pub fn get_execution_payload<T: BeaconChainTypes>(
 
 /// Prepares an execution payload for inclusion in a block.
 ///
-/// Will return `Ok(None)` if the merge fork has occurred, but a terminal block has not been found.
+/// Will return `Ok(None)` if the Bellatrix fork has occurred, but a terminal block has not been found.
 ///
 /// ## Errors
 ///
-/// Will return an error when using a pre-merge fork `state`. Ensure to only run this function
-/// after the merge fork.
+/// Will return an error when using a pre-Bellatrix fork `state`. Ensure to only run this function
+/// after the Bellatrix fork.
 ///
 /// ## Specification
 ///
diff --git a/beacon_node/beacon_chain/src/fork_revert.rs b/beacon_node/beacon_chain/src/fork_revert.rs
index 084ae95e096..8d1c29f46f6 100644
--- a/beacon_node/beacon_chain/src/fork_revert.rs
+++ b/beacon_node/beacon_chain/src/fork_revert.rs
@@ -5,7 +5,7 @@ use slog::{info, warn, Logger};
 use state_processing::state_advance::complete_state_advance;
 use state_processing::{
     per_block_processing, per_block_processing::BlockSignatureStrategy, ConsensusContext,
-    StateProcessingStrategy, VerifyBlockRoot,
+    VerifyBlockRoot,
 };
 use std::sync::Arc;
 use std::time::Duration;
@@ -175,7 +175,6 @@ pub fn reset_fork_choice_to_finalization<E: EthSpec, Hot: ItemStore<E>, Cold: It
             &mut state,
             &block,
             BlockSignatureStrategy::NoVerification,
-            StateProcessingStrategy::Accurate,
             VerifyBlockRoot::True,
             &mut ctxt,
             spec,
diff --git a/beacon_node/beacon_chain/src/graffiti_calculator.rs b/beacon_node/beacon_chain/src/graffiti_calculator.rs
new file mode 100644
index 00000000000..599c99dc2da
--- /dev/null
+++ b/beacon_node/beacon_chain/src/graffiti_calculator.rs
@@ -0,0 +1,377 @@
+use crate::BeaconChain;
+use crate::BeaconChainTypes;
+use execution_layer::{http::ENGINE_GET_CLIENT_VERSION_V1, CommitPrefix, ExecutionLayer};
+use serde::{Deserialize, Serialize};
+use slog::{crit, debug, error, warn, Logger};
+use slot_clock::SlotClock;
+use std::{fmt::Debug, time::Duration};
+use task_executor::TaskExecutor;
+use types::{EthSpec, Graffiti, GRAFFITI_BYTES_LEN};
+
+const ENGINE_VERSION_AGE_LIMIT_EPOCH_MULTIPLE: u32 = 6; // 6 epochs
+const ENGINE_VERSION_CACHE_REFRESH_EPOCH_MULTIPLE: u32 = 2; // 2 epochs
+const ENGINE_VERSION_CACHE_PRELOAD_STARTUP_DELAY: Duration = Duration::from_secs(60);
+
+/// Represents the source and content of graffiti for block production, excluding
+/// inputs from the validator client and execution engine. Graffiti is categorized
+/// as either user-specified or calculated to facilitate decisions on graffiti
+/// selection.
+#[derive(Clone, Copy, Serialize, Deserialize)]
+pub enum GraffitiOrigin {
+    UserSpecified(Graffiti),
+    Calculated(Graffiti),
+}
+
+impl GraffitiOrigin {
+    pub fn graffiti(&self) -> Graffiti {
+        match self {
+            GraffitiOrigin::UserSpecified(graffiti) => *graffiti,
+            GraffitiOrigin::Calculated(graffiti) => *graffiti,
+        }
+    }
+}
+
+impl Default for GraffitiOrigin {
+    fn default() -> Self {
+        let version_bytes = lighthouse_version::VERSION.as_bytes();
+        let trimmed_len = std::cmp::min(version_bytes.len(), GRAFFITI_BYTES_LEN);
+        let mut bytes = [0u8; GRAFFITI_BYTES_LEN];
+        bytes[..trimmed_len].copy_from_slice(&version_bytes[..trimmed_len]);
+        Self::Calculated(Graffiti::from(bytes))
+    }
+}
+
+impl Debug for GraffitiOrigin {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        self.graffiti().fmt(f)
+    }
+}
+
+pub struct GraffitiCalculator<T: BeaconChainTypes> {
+    pub beacon_graffiti: GraffitiOrigin,
+    execution_layer: Option<ExecutionLayer<T::EthSpec>>,
+    pub epoch_duration: Duration,
+    log: Logger,
+}
+
+impl<T: BeaconChainTypes> GraffitiCalculator<T> {
+    pub fn new(
+        beacon_graffiti: GraffitiOrigin,
+        execution_layer: Option<ExecutionLayer<T::EthSpec>>,
+        epoch_duration: Duration,
+        log: Logger,
+    ) -> Self {
+        Self {
+            beacon_graffiti,
+            execution_layer,
+            epoch_duration,
+            log,
+        }
+    }
+
+    /// Returns the appropriate graffiti to use for block production, prioritizing
+    /// sources in the following order:
+    /// 1. Graffiti specified by the validator client.
+    /// 2. Graffiti specified by the user via beacon node CLI options.
+    /// 3. The EL & CL client version string, applicable when the EL supports version specification.
+    /// 4. The default lighthouse version string, used if the EL lacks version specification support.
+    pub async fn get_graffiti(&self, validator_graffiti: Option<Graffiti>) -> Graffiti {
+        if let Some(graffiti) = validator_graffiti {
+            return graffiti;
+        }
+
+        match self.beacon_graffiti {
+            GraffitiOrigin::UserSpecified(graffiti) => graffiti,
+            GraffitiOrigin::Calculated(default_graffiti) => {
+                let Some(execution_layer) = self.execution_layer.as_ref() else {
+                    // Return default graffiti if there is no execution layer. This
+                    // shouldn't occur if we're actually producing blocks.
+                    crit!(self.log, "No execution layer available for graffiti calculation during block production!");
+                    return default_graffiti;
+                };
+
+                // The engine version cache refresh service ensures this will almost always retrieve this data from the
+                // cache instead of making a request to the execution engine. A cache miss would only occur if lighthouse
+                // has recently started or the EL recently went offline.
+                let engine_versions = match execution_layer
+                    .get_engine_version(Some(
+                        self.epoch_duration * ENGINE_VERSION_AGE_LIMIT_EPOCH_MULTIPLE,
+                    ))
+                    .await
+                {
+                    Ok(engine_versions) => engine_versions,
+                    Err(el_error) => {
+                        warn!(self.log, "Failed to determine execution engine version for graffiti"; "error" => ?el_error);
+                        return default_graffiti;
+                    }
+                };
+
+                let Some(engine_version) = engine_versions.first() else {
+                    // Got an empty array which indicates the EL doesn't support the method
+                    debug!(
+                        self.log,
+                        "Using default lighthouse graffiti: EL does not support {} method",
+                        ENGINE_GET_CLIENT_VERSION_V1;
+                    );
+                    return default_graffiti;
+                };
+                if engine_versions.len() != 1 {
+                    // More than one version implies lighthouse is connected to
+                    // an EL multiplexer. We don't support modifying the graffiti
+                    // with these configurations.
+                    warn!(
+                        self.log,
+                        "Execution Engine multiplexer detected, using default graffiti"
+                    );
+                    return default_graffiti;
+                }
+
+                let lighthouse_commit_prefix = CommitPrefix::try_from(lighthouse_version::COMMIT_PREFIX.to_string())
+                    .unwrap_or_else(|error_message| {
+                        // This really shouldn't happen but we want to definitly log if it does
+                        crit!(self.log, "Failed to parse lighthouse commit prefix"; "error" => error_message);
+                        CommitPrefix("00000000".to_string())
+                    });
+
+                engine_version.calculate_graffiti(lighthouse_commit_prefix)
+            }
+        }
+    }
+}
+
+pub fn start_engine_version_cache_refresh_service<T: BeaconChainTypes>(
+    chain: &BeaconChain<T>,
+    executor: TaskExecutor,
+) {
+    let Some(el_ref) = chain.execution_layer.as_ref() else {
+        debug!(
+            chain.log,
+            "No execution layer configured, not starting engine version cache refresh service"
+        );
+        return;
+    };
+    if matches!(
+        chain.graffiti_calculator.beacon_graffiti,
+        GraffitiOrigin::UserSpecified(_)
+    ) {
+        debug!(
+            chain.log,
+            "Graffiti is user-specified, not starting engine version cache refresh service"
+        );
+        return;
+    }
+
+    let execution_layer = el_ref.clone();
+    let log = chain.log.clone();
+    let slot_clock = chain.slot_clock.clone();
+    let epoch_duration = chain.graffiti_calculator.epoch_duration;
+    executor.spawn(
+        async move {
+            engine_version_cache_refresh_service::<T>(
+                execution_layer,
+                slot_clock,
+                epoch_duration,
+                log,
+            )
+            .await
+        },
+        "engine_version_cache_refresh_service",
+    );
+}
+
+async fn engine_version_cache_refresh_service<T: BeaconChainTypes>(
+    execution_layer: ExecutionLayer<T::EthSpec>,
+    slot_clock: T::SlotClock,
+    epoch_duration: Duration,
+    log: Logger,
+) {
+    // Preload the engine version cache after a brief delay to allow for EL initialization.
+    // This initial priming ensures cache readiness before the service's regular update cycle begins.
+    tokio::time::sleep(ENGINE_VERSION_CACHE_PRELOAD_STARTUP_DELAY).await;
+    if let Err(e) = execution_layer.get_engine_version(None).await {
+        debug!(log, "Failed to preload engine version cache"; "error" => format!("{:?}", e));
+    }
+
+    // this service should run 3/8 of the way through the epoch
+    let epoch_delay = (epoch_duration * 3) / 8;
+    // the duration of 1 epoch less than the total duration between firing of this service
+    let partial_firing_delay =
+        epoch_duration * ENGINE_VERSION_CACHE_REFRESH_EPOCH_MULTIPLE.saturating_sub(1);
+    loop {
+        match slot_clock.duration_to_next_epoch(T::EthSpec::slots_per_epoch()) {
+            Some(duration_to_next_epoch) => {
+                let firing_delay = partial_firing_delay + duration_to_next_epoch + epoch_delay;
+                tokio::time::sleep(firing_delay).await;
+
+                debug!(
+                    log,
+                    "Engine version cache refresh service firing";
+                );
+
+                match execution_layer.get_engine_version(None).await {
+                    Err(e) => warn!(log, "Failed to populate engine version cache"; "error" => ?e),
+                    Ok(versions) => {
+                        if versions.is_empty() {
+                            // Empty array indicates the EL doesn't support the method
+                            debug!(
+                                log,
+                                "EL does not support {} method. Sleeping twice as long before retry",
+                                ENGINE_GET_CLIENT_VERSION_V1
+                            );
+                            tokio::time::sleep(
+                                epoch_duration * ENGINE_VERSION_CACHE_REFRESH_EPOCH_MULTIPLE,
+                            )
+                            .await;
+                        }
+                    }
+                }
+            }
+            None => {
+                error!(log, "Failed to read slot clock");
+                // If we can't read the slot clock, just wait another slot.
+                tokio::time::sleep(slot_clock.slot_duration()).await;
+            }
+        };
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::test_utils::{test_spec, BeaconChainHarness, EphemeralHarnessType};
+    use crate::ChainConfig;
+    use execution_layer::test_utils::{DEFAULT_CLIENT_VERSION, DEFAULT_ENGINE_CAPABILITIES};
+    use execution_layer::EngineCapabilities;
+    use lazy_static::lazy_static;
+    use slog::info;
+    use std::time::Duration;
+    use types::{ChainSpec, Graffiti, Keypair, MinimalEthSpec, GRAFFITI_BYTES_LEN};
+
+    const VALIDATOR_COUNT: usize = 48;
+    lazy_static! {
+        /// A cached set of keys.
+        static ref KEYPAIRS: Vec<Keypair> = types::test_utils::generate_deterministic_keypairs(VALIDATOR_COUNT);
+    }
+
+    fn get_harness(
+        validator_count: usize,
+        spec: ChainSpec,
+        chain_config: Option<ChainConfig>,
+    ) -> BeaconChainHarness<EphemeralHarnessType<MinimalEthSpec>> {
+        let harness = BeaconChainHarness::builder(MinimalEthSpec)
+            .spec(spec)
+            .chain_config(chain_config.unwrap_or_default())
+            .keypairs(KEYPAIRS[0..validator_count].to_vec())
+            .logger(logging::test_logger())
+            .fresh_ephemeral_store()
+            .mock_execution_layer()
+            .build();
+
+        harness.advance_slot();
+
+        harness
+    }
+
+    #[tokio::test]
+    async fn check_graffiti_without_el_version_support() {
+        let spec = test_spec::<MinimalEthSpec>();
+        let harness = get_harness(VALIDATOR_COUNT, spec, None);
+        // modify execution engine so it doesn't support engine_getClientVersionV1 method
+        let mock_execution_layer = harness.mock_execution_layer.as_ref().unwrap();
+        mock_execution_layer
+            .server
+            .set_engine_capabilities(EngineCapabilities {
+                get_client_version_v1: false,
+                ..DEFAULT_ENGINE_CAPABILITIES
+            });
+        // refresh capabilities cache
+        harness
+            .chain
+            .execution_layer
+            .as_ref()
+            .unwrap()
+            .get_engine_capabilities(Some(Duration::ZERO))
+            .await
+            .unwrap();
+
+        let version_bytes = std::cmp::min(
+            lighthouse_version::VERSION.as_bytes().len(),
+            GRAFFITI_BYTES_LEN,
+        );
+        // grab the slice of the graffiti that corresponds to the lighthouse version
+        let graffiti_slice =
+            &harness.chain.graffiti_calculator.get_graffiti(None).await.0[..version_bytes];
+
+        // convert graffiti bytes slice to ascii for easy debugging if this test should fail
+        let graffiti_str =
+            std::str::from_utf8(graffiti_slice).expect("bytes should convert nicely to ascii");
+
+        info!(harness.chain.log, "results"; "lighthouse_version" => lighthouse_version::VERSION, "graffiti_str" => graffiti_str);
+        println!("lighthouse_version: '{}'", lighthouse_version::VERSION);
+        println!("graffiti_str:       '{}'", graffiti_str);
+
+        assert!(lighthouse_version::VERSION.starts_with(graffiti_str));
+    }
+
+    #[tokio::test]
+    async fn check_graffiti_with_el_version_support() {
+        let spec = test_spec::<MinimalEthSpec>();
+        let harness = get_harness(VALIDATOR_COUNT, spec, None);
+
+        let found_graffiti_bytes = harness.chain.graffiti_calculator.get_graffiti(None).await.0;
+
+        let mock_commit = DEFAULT_CLIENT_VERSION.commit.clone();
+        let expected_graffiti_string = format!(
+            "{}{}{}{}",
+            DEFAULT_CLIENT_VERSION.code,
+            mock_commit
+                .strip_prefix("0x")
+                .unwrap_or(&mock_commit)
+                .get(0..4)
+                .expect("should get first 2 bytes in hex"),
+            "LH",
+            lighthouse_version::COMMIT_PREFIX
+                .get(0..4)
+                .expect("should get first 2 bytes in hex")
+        );
+
+        let expected_graffiti_prefix_bytes = expected_graffiti_string.as_bytes();
+        let expected_graffiti_prefix_len =
+            std::cmp::min(expected_graffiti_prefix_bytes.len(), GRAFFITI_BYTES_LEN);
+
+        let found_graffiti_string =
+            std::str::from_utf8(&found_graffiti_bytes[..expected_graffiti_prefix_len])
+                .expect("bytes should convert nicely to ascii");
+
+        info!(harness.chain.log, "results"; "expected_graffiti_string" => &expected_graffiti_string, "found_graffiti_string" => &found_graffiti_string);
+        println!("expected_graffiti_string: '{}'", expected_graffiti_string);
+        println!("found_graffiti_string:    '{}'", found_graffiti_string);
+
+        assert_eq!(expected_graffiti_string, found_graffiti_string);
+
+        let mut expected_graffiti_bytes = [0u8; GRAFFITI_BYTES_LEN];
+        expected_graffiti_bytes[..expected_graffiti_prefix_len]
+            .copy_from_slice(expected_graffiti_string.as_bytes());
+        assert_eq!(found_graffiti_bytes, expected_graffiti_bytes);
+    }
+
+    #[tokio::test]
+    async fn check_graffiti_with_validator_specified_value() {
+        let spec = test_spec::<MinimalEthSpec>();
+        let harness = get_harness(VALIDATOR_COUNT, spec, None);
+
+        let graffiti_str = "nice graffiti bro";
+        let mut graffiti_bytes = [0u8; GRAFFITI_BYTES_LEN];
+        graffiti_bytes[..graffiti_str.as_bytes().len()].copy_from_slice(graffiti_str.as_bytes());
+
+        let found_graffiti = harness
+            .chain
+            .graffiti_calculator
+            .get_graffiti(Some(Graffiti::from(graffiti_bytes)))
+            .await;
+
+        assert_eq!(
+            found_graffiti.to_string(),
+            "0x6e6963652067726166666974692062726f000000000000000000000000000000"
+        );
+    }
+}
diff --git a/beacon_node/beacon_chain/src/lib.rs b/beacon_node/beacon_chain/src/lib.rs
index 7721c9b00ff..221bb8b2922 100644
--- a/beacon_node/beacon_chain/src/lib.rs
+++ b/beacon_node/beacon_chain/src/lib.rs
@@ -8,6 +8,7 @@ mod beacon_chain;
 mod beacon_fork_choice_store;
 pub mod beacon_proposer_cache;
 mod beacon_snapshot;
+pub mod bellatrix_readiness;
 pub mod blob_verification;
 pub mod block_reward;
 mod block_times_cache;
@@ -28,13 +29,13 @@ pub mod events;
 pub mod execution_payload;
 pub mod fork_choice_signal;
 pub mod fork_revert;
+pub mod graffiti_calculator;
 mod head_tracker;
 pub mod historical_blocks;
 pub mod kzg_utils;
 pub mod light_client_finality_update_verification;
 pub mod light_client_optimistic_update_verification;
 mod light_client_server_cache;
-pub mod merge_readiness;
 pub mod metrics;
 pub mod migrate;
 mod naive_aggregation_pool;
@@ -51,7 +52,6 @@ mod pre_finalization_cache;
 pub mod proposer_prep_service;
 pub mod schema_change;
 pub mod shuffling_cache;
-pub mod snapshot_cache;
 pub mod state_advance_timer;
 pub mod sync_committee_rewards;
 pub mod sync_committee_verification;
@@ -86,7 +86,7 @@ pub use events::ServerSentEventHandler;
 pub use execution_layer::EngineState;
 pub use execution_payload::NotifyExecutionLayer;
 pub use fork_choice::{ExecutionStatus, ForkchoiceUpdateParameters};
-pub use kzg::TrustedSetup;
+pub use kzg::{Kzg, TrustedSetup};
 pub use metrics::scrape_for_metrics;
 pub use migrate::MigratorConfig;
 pub use parking_lot;
diff --git a/beacon_node/beacon_chain/src/metrics.rs b/beacon_node/beacon_chain/src/metrics.rs
index b40f46da221..3b2453c3112 100644
--- a/beacon_node/beacon_chain/src/metrics.rs
+++ b/beacon_node/beacon_chain/src/metrics.rs
@@ -4,12 +4,8 @@ use crate::{BeaconChain, BeaconChainError, BeaconChainTypes};
 use lazy_static::lazy_static;
 pub use lighthouse_metrics::*;
 use slot_clock::SlotClock;
-use std::time::Duration;
 use types::{BeaconState, Epoch, EthSpec, Hash256, Slot};
 
-/// The maximum time to wait for the snapshot cache lock during a metrics scrape.
-const SNAPSHOT_CACHE_TIMEOUT: Duration = Duration::from_millis(100);
-
 // Attestation simulator metrics
 pub const VALIDATOR_MONITOR_ATTESTATION_SIMULATOR_HEAD_ATTESTER_HIT_TOTAL: &str =
     "validator_monitor_attestation_simulator_head_attester_hit_total";
@@ -36,18 +32,11 @@ lazy_static! {
         "beacon_block_processing_successes_total",
         "Count of blocks processed without error"
     );
+    // Keeping the existing "snapshot_cache" metric name as it would break existing dashboards
     pub static ref BLOCK_PROCESSING_SNAPSHOT_CACHE_SIZE: Result<IntGauge> = try_create_int_gauge(
         "beacon_block_processing_snapshot_cache_size",
         "Count snapshots in the snapshot cache"
     );
-    pub static ref BLOCK_PROCESSING_SNAPSHOT_CACHE_MISSES: Result<IntCounter> = try_create_int_counter(
-        "beacon_block_processing_snapshot_cache_misses",
-        "Count of snapshot cache misses"
-    );
-    pub static ref BLOCK_PROCESSING_SNAPSHOT_CACHE_CLONES: Result<IntCounter> = try_create_int_counter(
-        "beacon_block_processing_snapshot_cache_clones",
-        "Count of snapshot cache clones"
-    );
     pub static ref BLOCK_PROCESSING_TIMES: Result<Histogram> =
         try_create_histogram("beacon_block_processing_seconds", "Full runtime of block processing");
     pub static ref BLOCK_PROCESSING_BLOCK_ROOT: Result<Histogram> = try_create_histogram(
@@ -304,6 +293,14 @@ lazy_static! {
         "Count of times the early attester cache returns an attestation"
     );
 
+    pub static ref BEACON_REQRESP_PRE_IMPORT_CACHE_SIZE: Result<IntGauge> = try_create_int_gauge(
+        "beacon_reqresp_pre_import_cache_size",
+        "Current count of items of the reqresp pre import cache"
+    );
+    pub static ref BEACON_REQRESP_PRE_IMPORT_CACHE_HITS: Result<IntCounter> = try_create_int_counter(
+        "beacon_reqresp_pre_import_cache_hits",
+        "Count of times the reqresp pre import cache returns an item"
+    );
 }
 
 // Second lazy-static block is used to account for macro recursion limit.
@@ -839,37 +836,55 @@ lazy_static! {
         "Number of attester slashings seen",
         &["src", "validator"]
     );
+}
+
+// Prevent recursion limit
+lazy_static! {
 
     /*
      * Block Delay Metrics
      */
-    pub static ref BEACON_BLOCK_OBSERVED_SLOT_START_DELAY_TIME: Result<Histogram> = try_create_histogram_with_buckets(
-        "beacon_block_observed_slot_start_delay_time",
-        "Duration between the start of the block's slot and the time the block was observed.",
-        // [0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50]
-        decimal_buckets(-1,2)
-    );
-    pub static ref BEACON_BLOCK_IMPORTED_OBSERVED_DELAY_TIME: Result<Histogram> = try_create_histogram_with_buckets(
-        "beacon_block_imported_observed_delay_time",
-        "Duration between the time the block was observed and the time when it was imported.",
-        // [0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1, 2, 5]
-        decimal_buckets(-2,0)
-    );
-    pub static ref BEACON_BLOCK_HEAD_IMPORTED_DELAY_TIME: Result<Histogram> = try_create_histogram_with_buckets(
-        "beacon_block_head_imported_delay_time",
-        "Duration between the time the block was imported and the time when it was set as head.",
-        // [0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1, 2, 5]
-        decimal_buckets(-2,-1)
-        );
-    pub static ref BEACON_BLOCK_HEAD_SLOT_START_DELAY_TIME: Result<Histogram> = try_create_histogram_with_buckets(
-        "beacon_block_head_slot_start_delay_time",
+    pub static ref BEACON_BLOCK_DELAY_TOTAL: Result<IntGauge> = try_create_int_gauge(
+        "beacon_block_delay_total",
         "Duration between the start of the block's slot and the time when it was set as head.",
-        // [0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50]
-        decimal_buckets(-1,2)
     );
-    pub static ref BEACON_BLOCK_HEAD_SLOT_START_DELAY_EXCEEDED_TOTAL: Result<IntCounter> = try_create_int_counter(
-        "beacon_block_head_slot_start_delay_exceeded_total",
-        "Triggered when the duration between the start of the block's slot and the current time \
+
+    pub static ref BEACON_BLOCK_DELAY_OBSERVED_SLOT_START: Result<IntGauge> = try_create_int_gauge(
+        "beacon_block_delay_observed_slot_start",
+        "Duration between the start of the block's slot and the time the block was observed.",
+    );
+
+    pub static ref BEACON_BLOB_DELAY_ALL_OBSERVED_SLOT_START: Result<IntGauge> = try_create_int_gauge(
+        "beacon_blob_delay_all_observed_slot_start",
+        "Duration between the start of the block's slot and the time the block was observed.",
+    );
+
+    pub static ref BEACON_BLOCK_DELAY_EXECUTION_TIME: Result<IntGauge> = try_create_int_gauge(
+        "beacon_block_delay_execution_time",
+        "The duration in verifying the block with the execution layer.",
+    );
+
+    pub static ref BEACON_BLOCK_DELAY_AVAILABLE_SLOT_START: Result<IntGauge> = try_create_int_gauge(
+        "beacon_block_delay_available_slot_start",
+        "Duration between the time that block became available and the start of the slot.",
+    );
+    pub static ref BEACON_BLOCK_DELAY_ATTESTABLE_SLOT_START: Result<IntGauge> = try_create_int_gauge(
+        "beacon_block_delay_attestable_slot_start",
+        "Duration between the time that block became attestable and the start of the slot.",
+    );
+
+    pub static ref BEACON_BLOCK_DELAY_IMPORTED_TIME: Result<IntGauge> = try_create_int_gauge(
+        "beacon_block_delay_imported_time",
+        "Duration between the time the block became available and the time when it was imported.",
+    );
+
+    pub static ref BEACON_BLOCK_DELAY_HEAD_IMPORTED_TIME: Result<IntGauge> = try_create_int_gauge(
+        "beacon_block_delay_head_imported_time",
+        "Duration between the time that block was imported and the time when it was set as head.",
+    );
+    pub static ref BEACON_BLOCK_DELAY_HEAD_SLOT_START_EXCEEDED_TOTAL: Result<IntCounter> = try_create_int_counter(
+        "beacon_block_delay_head_slot_start_exceeded_total",
+        "A counter that is triggered when the duration between the start of the block's slot and the current time \
         will result in failed attestations.",
     );
 
@@ -1122,22 +1137,14 @@ lazy_static! {
     /*
     * Availability related metrics
     */
-    pub static ref BLOCK_AVAILABILITY_DELAY: Result<Histogram> = try_create_histogram_with_buckets(
+    pub static ref BLOCK_AVAILABILITY_DELAY: Result<IntGauge> = try_create_int_gauge(
         "block_availability_delay",
         "Duration between start of the slot and the time at which all components of the block are available.",
-        // Create a custom bucket list for greater granularity in block delay
-        Ok(vec![0.1, 0.2, 0.3,0.4,0.5,0.75,1.0,1.25,1.5,1.75,2.0,2.5,3.0,3.5,4.0,5.0,6.0,7.0,8.0,9.0,10.0,15.0,20.0])
     );
 
-
     /*
     * Data Availability cache metrics
     */
-    pub static ref DATA_AVAILABILITY_PROCESSING_CACHE_SIZE: Result<IntGauge> =
-        try_create_int_gauge(
-            "data_availability_processing_cache_size",
-            "Number of entries in the data availability processing cache."
-        );
     pub static ref DATA_AVAILABILITY_OVERFLOW_MEMORY_BLOCK_CACHE_SIZE: Result<IntGauge> =
         try_create_int_gauge(
             "data_availability_overflow_memory_block_cache_size",
@@ -1186,21 +1193,17 @@ pub fn scrape_for_metrics<T: BeaconChainTypes>(beacon_chain: &BeaconChain<T>) {
 
     let attestation_stats = beacon_chain.op_pool.attestation_stats();
 
-    if let Some(snapshot_cache) = beacon_chain
-        .snapshot_cache
-        .try_write_for(SNAPSHOT_CACHE_TIMEOUT)
-    {
-        set_gauge(
-            &BLOCK_PROCESSING_SNAPSHOT_CACHE_SIZE,
-            snapshot_cache.len() as i64,
-        )
-    }
+    set_gauge_by_usize(
+        &BLOCK_PROCESSING_SNAPSHOT_CACHE_SIZE,
+        beacon_chain.store.state_cache_len(),
+    );
 
-    let da_checker_metrics = beacon_chain.data_availability_checker.metrics();
     set_gauge_by_usize(
-        &DATA_AVAILABILITY_PROCESSING_CACHE_SIZE,
-        da_checker_metrics.processing_cache_size,
+        &BEACON_REQRESP_PRE_IMPORT_CACHE_SIZE,
+        beacon_chain.reqresp_pre_import_cache.read().len(),
     );
+
+    let da_checker_metrics = beacon_chain.data_availability_checker.metrics();
     set_gauge_by_usize(
         &DATA_AVAILABILITY_OVERFLOW_MEMORY_BLOCK_CACHE_SIZE,
         da_checker_metrics.block_cache_size,
diff --git a/beacon_node/beacon_chain/src/shuffling_cache.rs b/beacon_node/beacon_chain/src/shuffling_cache.rs
index b3de6f91c92..04d58882639 100644
--- a/beacon_node/beacon_chain/src/shuffling_cache.rs
+++ b/beacon_node/beacon_chain/src/shuffling_cache.rs
@@ -339,7 +339,7 @@ mod test {
             .clone();
         let committee_b = state.committee_cache(RelativeEpoch::Next).unwrap().clone();
         assert!(committee_a != committee_b);
-        (Arc::new(committee_a), Arc::new(committee_b))
+        (committee_a, committee_b)
     }
 
     /// Builds a deterministic but incoherent shuffling ID from a `u64`.
diff --git a/beacon_node/beacon_chain/src/snapshot_cache.rs b/beacon_node/beacon_chain/src/snapshot_cache.rs
deleted file mode 100644
index ac4e71d3d5a..00000000000
--- a/beacon_node/beacon_chain/src/snapshot_cache.rs
+++ /dev/null
@@ -1,521 +0,0 @@
-use crate::BeaconSnapshot;
-use itertools::process_results;
-use std::cmp;
-use std::sync::Arc;
-use std::time::Duration;
-use types::{
-    beacon_state::CloneConfig, BeaconState, BlindedPayload, ChainSpec, Epoch, EthSpec, Hash256,
-    SignedBeaconBlock, Slot,
-};
-
-/// The default size of the cache.
-pub const DEFAULT_SNAPSHOT_CACHE_SIZE: usize = 3;
-
-/// The minimum block delay to clone the state in the cache instead of removing it.
-/// This helps keep block processing fast during re-orgs from late blocks.
-fn minimum_block_delay_for_clone(seconds_per_slot: u64) -> Duration {
-    // If the block arrived at the attestation deadline or later, it might get re-orged.
-    Duration::from_secs(seconds_per_slot) / 3
-}
-
-/// This snapshot is to be used for verifying a child of `self.beacon_block`.
-#[derive(Debug)]
-pub struct PreProcessingSnapshot<E: EthSpec> {
-    /// This state is equivalent to the `self.beacon_block.state_root()` state that has been
-    /// advanced forward one slot using `per_slot_processing`. This state is "primed and ready" for
-    /// the application of another block.
-    pub pre_state: BeaconState<E>,
-    /// This value is only set to `Some` if the `pre_state` was *not* advanced forward.
-    pub beacon_state_root: Option<Hash256>,
-    pub beacon_block: SignedBeaconBlock<E, BlindedPayload<E>>,
-    pub beacon_block_root: Hash256,
-}
-
-impl<E: EthSpec> From<BeaconSnapshot<E>> for PreProcessingSnapshot<E> {
-    fn from(snapshot: BeaconSnapshot<E>) -> Self {
-        let beacon_state_root = Some(snapshot.beacon_state_root());
-        Self {
-            pre_state: snapshot.beacon_state,
-            beacon_state_root,
-            beacon_block: snapshot.beacon_block.clone_as_blinded(),
-            beacon_block_root: snapshot.beacon_block_root,
-        }
-    }
-}
-
-impl<E: EthSpec> CacheItem<E> {
-    pub fn new_without_pre_state(snapshot: BeaconSnapshot<E>) -> Self {
-        Self {
-            beacon_block: snapshot.beacon_block,
-            beacon_block_root: snapshot.beacon_block_root,
-            beacon_state: snapshot.beacon_state,
-            pre_state: None,
-        }
-    }
-
-    fn clone_to_snapshot_with(&self, clone_config: CloneConfig) -> BeaconSnapshot<E> {
-        BeaconSnapshot {
-            beacon_state: self.beacon_state.clone_with(clone_config),
-            beacon_block: self.beacon_block.clone(),
-            beacon_block_root: self.beacon_block_root,
-        }
-    }
-
-    pub fn into_pre_state(self) -> PreProcessingSnapshot<E> {
-        // Do not include the beacon state root if the state has been advanced.
-        let beacon_state_root =
-            Some(self.beacon_block.state_root()).filter(|_| self.pre_state.is_none());
-
-        PreProcessingSnapshot {
-            beacon_block: self.beacon_block.clone_as_blinded(),
-            beacon_block_root: self.beacon_block_root,
-            pre_state: self.pre_state.unwrap_or(self.beacon_state),
-            beacon_state_root,
-        }
-    }
-
-    pub fn clone_as_pre_state(&self) -> PreProcessingSnapshot<E> {
-        // Do not include the beacon state root if the state has been advanced.
-        let beacon_state_root =
-            Some(self.beacon_block.state_root()).filter(|_| self.pre_state.is_none());
-
-        PreProcessingSnapshot {
-            beacon_block: self.beacon_block.clone_as_blinded(),
-            beacon_block_root: self.beacon_block_root,
-            pre_state: self
-                .pre_state
-                .as_ref()
-                .map_or_else(|| self.beacon_state.clone(), |pre_state| pre_state.clone()),
-            beacon_state_root,
-        }
-    }
-}
-
-/// The information required for block production.
-pub struct BlockProductionPreState<E: EthSpec> {
-    /// This state may or may not have been advanced forward a single slot.
-    ///
-    /// See the documentation in the `crate::state_advance_timer` module for more information.
-    pub pre_state: BeaconState<E>,
-    /// This value will only be `Some` if `self.pre_state` was **not** advanced forward a single
-    /// slot.
-    ///
-    /// This value can be used to avoid tree-hashing the state during the first call to
-    /// `per_slot_processing`.
-    pub state_root: Option<Hash256>,
-}
-
-pub enum StateAdvance<E: EthSpec> {
-    /// The cache does not contain the supplied block root.
-    BlockNotFound,
-    /// The cache contains the supplied block root but the state has already been advanced.
-    AlreadyAdvanced,
-    /// The cache contains the supplied block root and the state has not yet been advanced.
-    State {
-        state: Box<BeaconState<E>>,
-        state_root: Hash256,
-        block_slot: Slot,
-    },
-}
-
-/// The item stored in the `SnapshotCache`.
-pub struct CacheItem<E: EthSpec> {
-    beacon_block: Arc<SignedBeaconBlock<E>>,
-    beacon_block_root: Hash256,
-    /// This state is equivalent to `self.beacon_block.state_root()`.
-    beacon_state: BeaconState<E>,
-    /// This state is equivalent to `self.beacon_state` that has had `per_slot_processing` applied
-    /// to it. This state assists in optimizing block processing.
-    pre_state: Option<BeaconState<E>>,
-}
-
-impl<E: EthSpec> Into<BeaconSnapshot<E>> for CacheItem<E> {
-    fn into(self) -> BeaconSnapshot<E> {
-        BeaconSnapshot {
-            beacon_state: self.beacon_state,
-            beacon_block: self.beacon_block,
-            beacon_block_root: self.beacon_block_root,
-        }
-    }
-}
-
-/// Provides a cache of `BeaconSnapshot` that is intended primarily for block processing.
-///
-/// ## Cache Queuing
-///
-/// The cache has a non-standard queue mechanism (specifically, it is not LRU).
-///
-/// The cache has a max number of elements (`max_len`). Until `max_len` is achieved, all snapshots
-/// are simply added to the queue. Once `max_len` is achieved, adding a new snapshot will cause an
-/// existing snapshot to be ejected. The ejected snapshot will:
-///
-/// - Never be the `head_block_root`.
-/// - Be the snapshot with the lowest `state.slot` (ties broken arbitrarily).
-pub struct SnapshotCache<E: EthSpec> {
-    max_len: usize,
-    head_block_root: Hash256,
-    snapshots: Vec<CacheItem<E>>,
-}
-
-impl<E: EthSpec> SnapshotCache<E> {
-    /// Instantiate a new cache which contains the `head` snapshot.
-    ///
-    /// Setting `max_len = 0` is equivalent to setting `max_len = 1`.
-    pub fn new(max_len: usize, head: BeaconSnapshot<E>) -> Self {
-        Self {
-            max_len: cmp::max(max_len, 1),
-            head_block_root: head.beacon_block_root,
-            snapshots: vec![CacheItem::new_without_pre_state(head)],
-        }
-    }
-
-    /// The block roots of all snapshots contained in `self`.
-    pub fn beacon_block_roots(&self) -> Vec<Hash256> {
-        self.snapshots.iter().map(|s| s.beacon_block_root).collect()
-    }
-
-    #[allow(clippy::len_without_is_empty)]
-    /// The number of snapshots contained in `self`.
-    pub fn len(&self) -> usize {
-        self.snapshots.len()
-    }
-
-    /// Insert a snapshot, potentially removing an existing snapshot if `self` is at capacity (see
-    /// struct-level documentation for more info).
-    pub fn insert(
-        &mut self,
-        snapshot: BeaconSnapshot<E>,
-        pre_state: Option<BeaconState<E>>,
-        spec: &ChainSpec,
-    ) {
-        let parent_root = snapshot.beacon_block.message().parent_root();
-        let item = CacheItem {
-            beacon_block: snapshot.beacon_block.clone(),
-            beacon_block_root: snapshot.beacon_block_root,
-            beacon_state: snapshot.beacon_state,
-            pre_state,
-        };
-
-        // Remove the grandparent of the block that was just inserted.
-        //
-        // Assuming it's unlikely to see re-orgs deeper than one block, this method helps keep the
-        // cache small by removing any states that already have more than one descendant.
-        //
-        // Remove the grandparent first to free up room in the cache.
-        let grandparent_result =
-            process_results(item.beacon_state.rev_iter_block_roots(spec), |iter| {
-                iter.map(|(_slot, root)| root)
-                    .find(|root| *root != item.beacon_block_root && *root != parent_root)
-            });
-        if let Ok(Some(grandparent_root)) = grandparent_result {
-            let head_block_root = self.head_block_root;
-            self.snapshots.retain(|snapshot| {
-                let root = snapshot.beacon_block_root;
-                root == head_block_root || root != grandparent_root
-            });
-        }
-
-        if self.snapshots.len() < self.max_len {
-            self.snapshots.push(item);
-        } else {
-            let insert_at = self
-                .snapshots
-                .iter()
-                .enumerate()
-                .filter_map(|(i, snapshot)| {
-                    if snapshot.beacon_block_root != self.head_block_root {
-                        Some((i, snapshot.beacon_state.slot()))
-                    } else {
-                        None
-                    }
-                })
-                .min_by_key(|(_i, slot)| *slot)
-                .map(|(i, _slot)| i);
-
-            if let Some(i) = insert_at {
-                self.snapshots[i] = item;
-            }
-        }
-    }
-
-    /// If available, returns a `CacheItem` that should be used for importing/processing a block.
-    /// The method will remove the block from `self`, carrying across any caches that may or may not
-    /// be built.
-    ///
-    /// In the event the block being processed was observed late, clone the cache instead of
-    /// moving it. This allows us to process the next block quickly in the case of a re-org.
-    /// Additionally, if the slot was skipped, clone the cache. This ensures blocks that are
-    /// later than 1 slot still have access to the cache and can be processed quickly.
-    pub fn get_state_for_block_processing(
-        &mut self,
-        block_root: Hash256,
-        block_slot: Slot,
-        block_delay: Option<Duration>,
-        spec: &ChainSpec,
-    ) -> Option<(PreProcessingSnapshot<E>, bool)> {
-        self.snapshots
-            .iter()
-            .position(|snapshot| snapshot.beacon_block_root == block_root)
-            .map(|i| {
-                if let Some(cache) = self.snapshots.get(i) {
-                    // Avoid cloning the block during sync (when the `block_delay` is `None`).
-                    if let Some(delay) = block_delay {
-                        if delay >= minimum_block_delay_for_clone(spec.seconds_per_slot)
-                            && delay <= Duration::from_secs(spec.seconds_per_slot) * 4
-                            || block_slot > cache.beacon_block.slot() + 1
-                        {
-                            return (cache.clone_as_pre_state(), true);
-                        }
-                    }
-                }
-                (self.snapshots.remove(i).into_pre_state(), false)
-            })
-    }
-
-    /// If available, obtains a clone of a `BeaconState` that should be used for block production.
-    /// The clone will use `CloneConfig:all()`, ensuring any tree-hash cache is cloned too.
-    ///
-    /// ## Note
-    ///
-    /// This method clones the `BeaconState` (instead of removing it) since we assume that any block
-    /// we produce will soon be pushed to the `BeaconChain` for importing/processing. Keeping a copy
-    /// of that `BeaconState` in `self` will greatly help with import times.
-    pub fn get_state_for_block_production(
-        &self,
-        block_root: Hash256,
-    ) -> Option<BlockProductionPreState<E>> {
-        self.snapshots
-            .iter()
-            .find(|snapshot| snapshot.beacon_block_root == block_root)
-            .map(|snapshot| {
-                if let Some(pre_state) = &snapshot.pre_state {
-                    BlockProductionPreState {
-                        pre_state: pre_state.clone_with(CloneConfig::all()),
-                        state_root: None,
-                    }
-                } else {
-                    BlockProductionPreState {
-                        pre_state: snapshot.beacon_state.clone_with(CloneConfig::all()),
-                        state_root: Some(snapshot.beacon_block.state_root()),
-                    }
-                }
-            })
-    }
-
-    /// If there is a snapshot with `block_root`, clone it and return the clone.
-    pub fn get_cloned(
-        &self,
-        block_root: Hash256,
-        clone_config: CloneConfig,
-    ) -> Option<BeaconSnapshot<E>> {
-        self.snapshots
-            .iter()
-            .find(|snapshot| snapshot.beacon_block_root == block_root)
-            .map(|snapshot| snapshot.clone_to_snapshot_with(clone_config))
-    }
-
-    pub fn get_for_state_advance(&mut self, block_root: Hash256) -> StateAdvance<E> {
-        if let Some(snapshot) = self
-            .snapshots
-            .iter_mut()
-            .find(|snapshot| snapshot.beacon_block_root == block_root)
-        {
-            if snapshot.pre_state.is_some() {
-                StateAdvance::AlreadyAdvanced
-            } else {
-                let cloned = snapshot
-                    .beacon_state
-                    .clone_with(CloneConfig::committee_caches_only());
-
-                StateAdvance::State {
-                    state: Box::new(std::mem::replace(&mut snapshot.beacon_state, cloned)),
-                    state_root: snapshot.beacon_block.state_root(),
-                    block_slot: snapshot.beacon_block.slot(),
-                }
-            }
-        } else {
-            StateAdvance::BlockNotFound
-        }
-    }
-
-    pub fn update_pre_state(&mut self, block_root: Hash256, state: BeaconState<E>) -> Option<()> {
-        self.snapshots
-            .iter_mut()
-            .find(|snapshot| snapshot.beacon_block_root == block_root)
-            .map(|snapshot| {
-                snapshot.pre_state = Some(state);
-            })
-    }
-
-    /// Removes all snapshots from the queue that are less than or equal to the finalized epoch.
-    pub fn prune(&mut self, finalized_epoch: Epoch) {
-        self.snapshots.retain(|snapshot| {
-            snapshot.beacon_state.slot() > finalized_epoch.start_slot(E::slots_per_epoch())
-        })
-    }
-
-    /// Inform the cache that the head of the beacon chain has changed.
-    ///
-    /// The snapshot that matches this `head_block_root` will never be ejected from the cache
-    /// during `Self::insert`.
-    pub fn update_head(&mut self, head_block_root: Hash256) {
-        self.head_block_root = head_block_root
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::test_utils::{BeaconChainHarness, EphemeralHarnessType};
-    use types::{test_utils::generate_deterministic_keypair, BeaconBlock, MainnetEthSpec};
-
-    fn get_harness() -> BeaconChainHarness<EphemeralHarnessType<MainnetEthSpec>> {
-        let harness = BeaconChainHarness::builder(MainnetEthSpec)
-            .default_spec()
-            .deterministic_keypairs(1)
-            .fresh_ephemeral_store()
-            .build();
-
-        harness.advance_slot();
-
-        harness
-    }
-
-    const CACHE_SIZE: usize = 4;
-
-    fn get_snapshot(i: u64) -> BeaconSnapshot<MainnetEthSpec> {
-        let spec = MainnetEthSpec::default_spec();
-
-        let beacon_state = get_harness().chain.head_beacon_state_cloned();
-
-        let signed_beacon_block = SignedBeaconBlock::from_block(
-            BeaconBlock::empty(&spec),
-            generate_deterministic_keypair(0)
-                .sk
-                .sign(Hash256::from_low_u64_be(42)),
-        );
-
-        BeaconSnapshot {
-            beacon_state,
-            beacon_block: Arc::new(signed_beacon_block),
-            beacon_block_root: Hash256::from_low_u64_be(i),
-        }
-    }
-
-    #[test]
-    fn insert_get_prune_update() {
-        let spec = MainnetEthSpec::default_spec();
-        let mut cache = SnapshotCache::new(CACHE_SIZE, get_snapshot(0));
-
-        // Insert a bunch of entries in the cache. It should look like this:
-        //
-        // Index    Root
-        // 0        0     <--head
-        // 1        1
-        // 2        2
-        // 3        3
-        for i in 1..CACHE_SIZE as u64 {
-            let mut snapshot = get_snapshot(i);
-
-            // Each snapshot should be one slot into an epoch, with each snapshot one epoch apart.
-            *snapshot.beacon_state.slot_mut() =
-                Slot::from(i * MainnetEthSpec::slots_per_epoch() + 1);
-
-            cache.insert(snapshot, None, &spec);
-
-            assert_eq!(
-                cache.snapshots.len(),
-                i as usize + 1,
-                "cache length should be as expected"
-            );
-            assert_eq!(cache.head_block_root, Hash256::from_low_u64_be(0));
-        }
-
-        // Insert a new value in the cache. Afterwards it should look like:
-        //
-        // Index    Root
-        // 0        0     <--head
-        // 1        42
-        // 2        2
-        // 3        3
-        assert_eq!(cache.snapshots.len(), CACHE_SIZE);
-        cache.insert(get_snapshot(42), None, &spec);
-        assert_eq!(cache.snapshots.len(), CACHE_SIZE);
-
-        assert!(
-            cache
-                .get_state_for_block_processing(
-                    Hash256::from_low_u64_be(1),
-                    Slot::new(0),
-                    None,
-                    &spec
-                )
-                .is_none(),
-            "the snapshot with the lowest slot should have been removed during the insert function"
-        );
-        assert!(cache
-            .get_cloned(Hash256::from_low_u64_be(1), CloneConfig::none())
-            .is_none());
-
-        assert_eq!(
-            cache
-                .get_cloned(Hash256::from_low_u64_be(0), CloneConfig::none())
-                .expect("the head should still be in the cache")
-                .beacon_block_root,
-            Hash256::from_low_u64_be(0),
-            "get_cloned should get the correct snapshot"
-        );
-        assert_eq!(
-            cache
-                .get_state_for_block_processing(
-                    Hash256::from_low_u64_be(0),
-                    Slot::new(0),
-                    None,
-                    &spec
-                )
-                .expect("the head should still be in the cache")
-                .0
-                .beacon_block_root,
-            Hash256::from_low_u64_be(0),
-            "get_state_for_block_processing should get the correct snapshot"
-        );
-
-        assert_eq!(
-            cache.snapshots.len(),
-            CACHE_SIZE - 1,
-            "get_state_for_block_processing should shorten the cache"
-        );
-
-        // Prune the cache. Afterwards it should look like:
-        //
-        // Index    Root
-        // 0        2
-        // 1        3
-        cache.prune(Epoch::new(2));
-
-        assert_eq!(cache.snapshots.len(), 2);
-
-        cache.update_head(Hash256::from_low_u64_be(2));
-
-        // Over-fill the cache so it needs to eject some old values on insert.
-        for i in 0..CACHE_SIZE as u64 {
-            cache.insert(get_snapshot(u64::max_value() - i), None, &spec);
-        }
-
-        // Ensure that the new head value was not removed from the cache.
-        assert_eq!(
-            cache
-                .get_state_for_block_processing(
-                    Hash256::from_low_u64_be(2),
-                    Slot::new(0),
-                    None,
-                    &spec
-                )
-                .expect("the new head should still be in the cache")
-                .0
-                .beacon_block_root,
-            Hash256::from_low_u64_be(2),
-            "get_state_for_block_processing should get the correct snapshot"
-        );
-    }
-}
diff --git a/beacon_node/beacon_chain/src/state_advance_timer.rs b/beacon_node/beacon_chain/src/state_advance_timer.rs
index 39d35f81113..1f928a16e42 100644
--- a/beacon_node/beacon_chain/src/state_advance_timer.rs
+++ b/beacon_node/beacon_chain/src/state_advance_timer.rs
@@ -15,9 +15,7 @@
 //! 2. There's a possibility that the head block is never built upon, causing wasted CPU cycles.
 use crate::validator_monitor::HISTORIC_EPOCHS as VALIDATOR_MONITOR_HISTORIC_EPOCHS;
 use crate::{
-    beacon_chain::{ATTESTATION_CACHE_LOCK_TIMEOUT, BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT},
-    chain_config::FORK_CHOICE_LOOKAHEAD_FACTOR,
-    snapshot_cache::StateAdvance,
+    beacon_chain::ATTESTATION_CACHE_LOCK_TIMEOUT, chain_config::FORK_CHOICE_LOOKAHEAD_FACTOR,
     BeaconChain, BeaconChainError, BeaconChainTypes,
 };
 use slog::{debug, error, warn, Logger};
@@ -27,9 +25,10 @@ use std::sync::{
     atomic::{AtomicBool, Ordering},
     Arc,
 };
+use store::KeyValueStore;
 use task_executor::TaskExecutor;
 use tokio::time::{sleep, sleep_until, Instant};
-use types::{AttestationShufflingId, EthSpec, Hash256, RelativeEpoch, Slot};
+use types::{AttestationShufflingId, BeaconStateError, EthSpec, Hash256, RelativeEpoch, Slot};
 
 /// If the head slot is more than `MAX_ADVANCE_DISTANCE` from the current slot, then don't perform
 /// the state advancement.
@@ -45,14 +44,13 @@ const MAX_ADVANCE_DISTANCE: u64 = 4;
 /// impact whilst having 8 epochs without a block is a comfortable grace period.
 const MAX_FORK_CHOICE_DISTANCE: u64 = 256;
 
-/// Drop any unused block production state cache after this many slots.
-const MAX_BLOCK_PRODUCTION_CACHE_DISTANCE: u64 = 4;
-
 #[derive(Debug)]
 enum Error {
     BeaconChain(BeaconChainError),
     // We don't use the inner value directly, but it's used in the Debug impl.
     HeadMissingFromSnapshotCache(#[allow(dead_code)] Hash256),
+    BeaconState(#[allow(dead_code)] BeaconStateError),
+    Store(#[allow(dead_code)] store::Error),
     MaxDistanceExceeded {
         current_slot: Slot,
         head_slot: Slot,
@@ -72,6 +70,18 @@ impl From<BeaconChainError> for Error {
     }
 }
 
+impl From<BeaconStateError> for Error {
+    fn from(e: BeaconStateError) -> Self {
+        Self::BeaconState(e)
+    }
+}
+
+impl From<store::Error> for Error {
+    fn from(e: store::Error) -> Self {
+        Self::Store(e)
+    }
+}
+
 /// Provides a simple thread-safe lock to be used for task co-ordination. Practically equivalent to
 /// `Mutex<()>`.
 #[derive(Clone)]
@@ -231,7 +241,7 @@ async fn state_advance_timer<T: BeaconChainTypes>(
 
                 // Prepare proposers so that the node can send payload attributes in the case where
                 // it decides to abandon a proposer boost re-org.
-                let proposer_head = beacon_chain
+                beacon_chain
                     .prepare_beacon_proposer(current_slot)
                     .await
                     .unwrap_or_else(|e| {
@@ -248,56 +258,6 @@ async fn state_advance_timer<T: BeaconChainTypes>(
                 // in `ForkChoiceSignalTx`.
                 beacon_chain.task_executor.clone().spawn_blocking(
                     move || {
-                        // If we're proposing, clone the head state preemptively so that it isn't on
-                        // the hot path of proposing. We can delete this once we have tree-states.
-                        if let Some(proposer_head) = proposer_head {
-                            let mut cache = beacon_chain.block_production_state.lock();
-
-                            // Avoid holding two states in memory. It's OK to hold the lock because
-                            // we always lock the block production cache before the snapshot cache
-                            // and we prefer for block production to wait for the block production
-                            // cache if a clone is in-progress.
-                            if cache
-                                .as_ref()
-                                .map_or(false, |(cached_head, _)| *cached_head != proposer_head)
-                            {
-                                drop(cache.take());
-                            }
-                            if let Some(proposer_state) = beacon_chain
-                                .snapshot_cache
-                                .try_read_for(BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT)
-                                .and_then(|snapshot_cache| {
-                                    snapshot_cache.get_state_for_block_production(proposer_head)
-                                })
-                            {
-                                *cache = Some((proposer_head, proposer_state));
-                                debug!(
-                                    log,
-                                    "Cloned state ready for block production";
-                                    "head_block_root" => ?proposer_head,
-                                    "slot" => next_slot
-                                );
-                            } else {
-                                warn!(
-                                    log,
-                                    "Block production state missing from snapshot cache";
-                                    "head_block_root" => ?proposer_head,
-                                    "slot" => next_slot
-                                );
-                            }
-                        } else {
-                            // If we aren't proposing, drop any old block production cache to save
-                            // memory.
-                            let mut cache = beacon_chain.block_production_state.lock();
-                            if let Some((_, state)) = &*cache {
-                                if state.pre_state.slot() + MAX_BLOCK_PRODUCTION_CACHE_DISTANCE
-                                    <= current_slot
-                                {
-                                    drop(cache.take());
-                                }
-                            }
-                        }
-
                         // Signal block proposal for the next slot (if it happens to be waiting).
                         if let Some(tx) = &beacon_chain.fork_choice_signal_tx {
                             if let Err(e) = tx.notify_fork_choice_complete(next_slot) {
@@ -318,9 +278,9 @@ async fn state_advance_timer<T: BeaconChainTypes>(
     }
 }
 
-/// Reads the `snapshot_cache` from the `beacon_chain` and attempts to take a clone of the
+/// Reads the `state_cache` from the `beacon_chain` and attempts to take a clone of the
 /// `BeaconState` of the head block. If it obtains this clone, the state will be advanced a single
-/// slot then placed back in the `snapshot_cache` to be used for block verification.
+/// slot then placed in the `state_cache` to be used for block verification.
 ///
 /// See the module-level documentation for rationale.
 fn advance_head<T: BeaconChainTypes>(
@@ -345,46 +305,42 @@ fn advance_head<T: BeaconChainTypes>(
         }
     }
 
-    let head_root = beacon_chain.head_beacon_block_root();
+    let (head_block_root, head_block_state_root) = {
+        let snapshot = beacon_chain.head_snapshot();
+        (snapshot.beacon_block_root, snapshot.beacon_state_root())
+    };
 
-    let (head_slot, head_state_root, mut state) = match beacon_chain
-        .snapshot_cache
-        .try_write_for(BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT)
-        .ok_or(BeaconChainError::SnapshotCacheLockTimeout)?
-        .get_for_state_advance(head_root)
-    {
-        StateAdvance::AlreadyAdvanced => {
+    let (head_state_root, mut state) = beacon_chain
+        .store
+        .get_advanced_hot_state(head_block_root, current_slot, head_block_state_root)?
+        .ok_or(Error::HeadMissingFromSnapshotCache(head_block_root))?;
+
+    // Protect against advancing a state more than a single slot.
+    //
+    // Advancing more than one slot without storing the intermediate state would corrupt the
+    // database. Future works might store temporary, intermediate states inside this function.
+    match state.slot().cmp(&state.latest_block_header().slot) {
+        std::cmp::Ordering::Equal => (),
+        std::cmp::Ordering::Greater => {
             return Err(Error::StateAlreadyAdvanced {
-                block_root: head_root,
-            })
+                block_root: head_block_root,
+            });
         }
-        StateAdvance::BlockNotFound => return Err(Error::HeadMissingFromSnapshotCache(head_root)),
-        StateAdvance::State {
-            state,
-            state_root,
-            block_slot,
-        } => (block_slot, state_root, *state),
-    };
+        std::cmp::Ordering::Less => {
+            return Err(Error::BadStateSlot {
+                _block_slot: state.latest_block_header().slot,
+                _state_slot: state.slot(),
+            });
+        }
+    }
 
     let initial_slot = state.slot();
     let initial_epoch = state.current_epoch();
 
-    let state_root = if state.slot() == head_slot {
-        Some(head_state_root)
-    } else {
-        // Protect against advancing a state more than a single slot.
-        //
-        // Advancing more than one slot without storing the intermediate state would corrupt the
-        // database. Future works might store temporary, intermediate states inside this function.
-        return Err(Error::BadStateSlot {
-            _block_slot: head_slot,
-            _state_slot: state.slot(),
-        });
-    };
-
     // Advance the state a single slot.
-    if let Some(summary) = per_slot_processing(&mut state, state_root, &beacon_chain.spec)
-        .map_err(BeaconChainError::from)?
+    if let Some(summary) =
+        per_slot_processing(&mut state, Some(head_state_root), &beacon_chain.spec)
+            .map_err(BeaconChainError::from)?
     {
         // Expose Prometheus metrics.
         if let Err(e) = summary.observe_metrics() {
@@ -418,7 +374,7 @@ fn advance_head<T: BeaconChainTypes>(
     debug!(
         log,
         "Advanced head state one slot";
-        "head_root" => ?head_root,
+        "head_block_root" => ?head_block_root,
         "state_slot" => state.slot(),
         "current_slot" => current_slot,
     );
@@ -437,14 +393,14 @@ fn advance_head<T: BeaconChainTypes>(
     if initial_epoch < state.current_epoch() {
         // Update the proposer cache.
         //
-        // We supply the `head_root` as the decision block since the prior `if` statement guarantees
+        // We supply the `head_block_root` as the decision block since the prior `if` statement guarantees
         // the head root is the latest block from the prior epoch.
         beacon_chain
             .beacon_proposer_cache
             .lock()
             .insert(
                 state.current_epoch(),
-                head_root,
+                head_block_root,
                 state
                     .get_beacon_proposer_indices(&beacon_chain.spec)
                     .map_err(BeaconChainError::from)?,
@@ -453,8 +409,9 @@ fn advance_head<T: BeaconChainTypes>(
             .map_err(BeaconChainError::from)?;
 
         // Update the attester cache.
-        let shuffling_id = AttestationShufflingId::new(head_root, &state, RelativeEpoch::Next)
-            .map_err(BeaconChainError::from)?;
+        let shuffling_id =
+            AttestationShufflingId::new(head_block_root, &state, RelativeEpoch::Next)
+                .map_err(BeaconChainError::from)?;
         let committee_cache = state
             .committee_cache(RelativeEpoch::Next)
             .map_err(BeaconChainError::from)?;
@@ -467,7 +424,7 @@ fn advance_head<T: BeaconChainTypes>(
         debug!(
             log,
             "Primed proposer and attester caches";
-            "head_root" => ?head_root,
+            "head_block_root" => ?head_block_root,
             "next_epoch_shuffling_root" => ?shuffling_id.shuffling_decision_block,
             "state_epoch" => state.current_epoch(),
             "current_epoch" => current_slot.epoch(T::EthSpec::slots_per_epoch()),
@@ -477,22 +434,13 @@ fn advance_head<T: BeaconChainTypes>(
     // Apply the state to the attester cache, if the cache deems it interesting.
     beacon_chain
         .attester_cache
-        .maybe_cache_state(&state, head_root, &beacon_chain.spec)
+        .maybe_cache_state(&state, head_block_root, &beacon_chain.spec)
         .map_err(BeaconChainError::from)?;
 
     let final_slot = state.slot();
 
-    // Insert the advanced state back into the snapshot cache.
-    beacon_chain
-        .snapshot_cache
-        .try_write_for(BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT)
-        .ok_or(BeaconChainError::SnapshotCacheLockTimeout)?
-        .update_pre_state(head_root, state)
-        .ok_or(Error::HeadMissingFromSnapshotCache(head_root))?;
-
     // If we have moved into the next slot whilst processing the state then this function is going
-    // to become ineffective and likely become a hindrance as we're stealing the tree hash cache
-    // from the snapshot cache (which may force the next block to rebuild a new one).
+    // to become ineffective.
     //
     // If this warning occurs very frequently on well-resourced machines then we should consider
     // starting it earlier in the slot. Otherwise, it's a good indication that the machine is too
@@ -503,7 +451,7 @@ fn advance_head<T: BeaconChainTypes>(
         warn!(
             log,
             "State advance too slow";
-            "head_root" => %head_root,
+            "head_block_root" => %head_block_root,
             "advanced_slot" => final_slot,
             "current_slot" => current_slot,
             "starting_slot" => starting_slot,
@@ -511,10 +459,25 @@ fn advance_head<T: BeaconChainTypes>(
         );
     }
 
+    // Write the advanced state to the database with a temporary flag that will be deleted when
+    // a block is imported on top of this state. We should delete this once we bring in the DB
+    // changes from tree-states that allow us to prune states without temporary flags.
+    let advanced_state_root = state.update_tree_hash_cache()?;
+    let txn_lock = beacon_chain.store.hot_db.begin_rw_transaction();
+    let state_already_exists = beacon_chain
+        .store
+        .load_hot_state_summary(&advanced_state_root)?
+        .is_some();
+    let temporary = !state_already_exists;
+    beacon_chain
+        .store
+        .put_state_possibly_temporary(&advanced_state_root, &state, temporary)?;
+    drop(txn_lock);
+
     debug!(
         log,
         "Completed state advance";
-        "head_root" => ?head_root,
+        "head_block_root" => ?head_block_root,
         "advanced_slot" => final_slot,
         "initial_slot" => initial_slot,
     );
diff --git a/beacon_node/beacon_chain/src/sync_committee_rewards.rs b/beacon_node/beacon_chain/src/sync_committee_rewards.rs
index 2221aa1d5eb..9b35cff9432 100644
--- a/beacon_node/beacon_chain/src/sync_committee_rewards.rs
+++ b/beacon_node/beacon_chain/src/sync_committee_rewards.rs
@@ -38,9 +38,26 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             })?;
 
         let mut balances = HashMap::<usize, u64>::new();
+        for &validator_index in &sync_committee_indices {
+            balances.insert(
+                validator_index,
+                *state
+                    .balances()
+                    .get(validator_index)
+                    .ok_or(BeaconChainError::SyncCommitteeRewardsSyncError)?,
+            );
+        }
+
+        let proposer_index = block.proposer_index() as usize;
+        balances.insert(
+            proposer_index,
+            *state
+                .balances()
+                .get(proposer_index)
+                .ok_or(BeaconChainError::SyncCommitteeRewardsSyncError)?,
+        );
 
         let mut total_proposer_rewards = 0;
-        let proposer_index = state.get_beacon_proposer_index(block.slot(), spec)?;
 
         // Apply rewards to participant balances. Keep track of proposer rewards
         for (validator_index, participant_bit) in sync_committee_indices
@@ -48,15 +65,15 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             .zip(sync_aggregate.sync_committee_bits.iter())
         {
             let participant_balance = balances
-                .entry(*validator_index)
-                .or_insert_with(|| state.balances()[*validator_index]);
+                .get_mut(validator_index)
+                .ok_or(BeaconChainError::SyncCommitteeRewardsSyncError)?;
 
             if participant_bit {
                 participant_balance.safe_add_assign(participant_reward_value)?;
 
                 balances
-                    .entry(proposer_index)
-                    .or_insert_with(|| state.balances()[proposer_index])
+                    .get_mut(&proposer_index)
+                    .ok_or(BeaconChainError::SyncCommitteeRewardsSyncError)?
                     .safe_add_assign(proposer_reward_per_bit)?;
 
                 total_proposer_rewards.safe_add_assign(proposer_reward_per_bit)?;
@@ -67,18 +84,17 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
 
         Ok(balances
             .iter()
-            .filter_map(|(i, new_balance)| {
-                let reward = if *i != proposer_index {
-                    *new_balance as i64 - state.balances()[*i] as i64
-                } else if sync_committee_indices.contains(i) {
-                    *new_balance as i64
-                        - state.balances()[*i] as i64
-                        - total_proposer_rewards as i64
+            .filter_map(|(&i, &new_balance)| {
+                let initial_balance = *state.balances().get(i)? as i64;
+                let reward = if i != proposer_index {
+                    new_balance as i64 - initial_balance
+                } else if sync_committee_indices.contains(&i) {
+                    new_balance as i64 - initial_balance - total_proposer_rewards as i64
                 } else {
                     return None;
                 };
                 Some(SyncCommitteeReward {
-                    validator_index: *i as u64,
+                    validator_index: i as u64,
                     reward,
                 })
             })
diff --git a/beacon_node/beacon_chain/src/test_utils.rs b/beacon_node/beacon_chain/src/test_utils.rs
index 0a494e1d8a4..dde6b750545 100644
--- a/beacon_node/beacon_chain/src/test_utils.rs
+++ b/beacon_node/beacon_chain/src/test_utils.rs
@@ -31,6 +31,7 @@ use futures::channel::mpsc::Receiver;
 pub use genesis::{interop_genesis_state_with_eth1, DEFAULT_ETH1_BLOCK_HASH};
 use int_to_bytes::int_to_bytes32;
 use kzg::{Kzg, TrustedSetup};
+use lazy_static::lazy_static;
 use merkle_proof::MerkleTree;
 use operation_pool::ReceivedPreCapella;
 use parking_lot::Mutex;
@@ -45,10 +46,7 @@ use slog_async::Async;
 use slog_term::{FullFormat, TermDecorator};
 use slot_clock::{SlotClock, TestingSlotClock};
 use state_processing::per_block_processing::compute_timestamp_at_slot;
-use state_processing::{
-    state_advance::{complete_state_advance, partial_state_advance},
-    StateProcessingStrategy,
-};
+use state_processing::state_advance::complete_state_advance;
 use std::borrow::Cow;
 use std::collections::{HashMap, HashSet};
 use std::fmt;
@@ -76,6 +74,16 @@ pub const FORK_NAME_ENV_VAR: &str = "FORK_NAME";
 // a different value.
 pub const DEFAULT_TARGET_AGGREGATORS: u64 = u64::MAX;
 
+lazy_static! {
+    pub static ref KZG: Arc<Kzg> = {
+        let trusted_setup: TrustedSetup = serde_json::from_reader(TRUSTED_SETUP_BYTES)
+            .map_err(|e| format!("Unable to read trusted setup file: {}", e))
+            .expect("should have trusted setup");
+        let kzg = Kzg::new_from_trusted_setup(trusted_setup).expect("should create kzg");
+        Arc::new(kzg)
+    };
+}
+
 pub type BaseHarnessType<E, THotStore, TColdStore> =
     Witness<TestingSlotClock, CachingEth1Backend<E>, E, THotStore, TColdStore>;
 
@@ -408,21 +416,17 @@ where
         self
     }
 
-    pub fn execution_layer_from_urls(mut self, urls: &[&str]) -> Self {
+    pub fn execution_layer_from_url(mut self, url: &str) -> Self {
         assert!(
             self.execution_layer.is_none(),
             "execution layer already defined"
         );
 
-        let urls: Vec<SensitiveUrl> = urls
-            .iter()
-            .map(|s| SensitiveUrl::parse(s))
-            .collect::<Result<_, _>>()
-            .unwrap();
+        let url = SensitiveUrl::parse(url).ok();
 
         let config = execution_layer::Config {
-            execution_endpoints: urls,
-            secret_files: vec![],
+            execution_endpoint: url,
+            secret_file: None,
             suggested_fee_recipient: Some(Address::repeat_byte(42)),
             ..Default::default()
         };
@@ -505,16 +509,14 @@ where
         let validator_keypairs = self
             .validator_keypairs
             .expect("cannot build without validator keypairs");
-        let trusted_setup: TrustedSetup = serde_json::from_reader(TRUSTED_SETUP_BYTES)
-            .map_err(|e| format!("Unable to read trusted setup file: {}", e))
-            .unwrap();
+        let kzg = spec.deneb_fork_epoch.map(|_| KZG.clone());
 
         let validator_monitor_config = self.validator_monitor_config.unwrap_or_default();
 
         let chain_config = self.chain_config.unwrap_or_default();
         let mut builder = BeaconChainBuilder::new(self.eth_spec_instance)
             .logger(log.clone())
-            .custom_spec(spec)
+            .custom_spec(spec.clone())
             .store(self.store.expect("cannot build without store"))
             .store_migrator_config(
                 MigratorConfig::default()
@@ -532,7 +534,7 @@ where
                 5,
             )))
             .validator_monitor_config(validator_monitor_config)
-            .trusted_setup(trusted_setup);
+            .kzg(kzg);
 
         builder = if let Some(mutator) = self.initial_mutator {
             mutator(builder)
@@ -587,10 +589,7 @@ pub fn mock_execution_layer_from_parts<E: EthSpec>(
         HARNESS_GENESIS_TIME + spec.seconds_per_slot * E::slots_per_epoch() * epoch.as_u64()
     });
 
-    let trusted_setup: TrustedSetup = serde_json::from_reader(TRUSTED_SETUP_BYTES)
-        .map_err(|e| format!("Unable to read trusted setup file: {}", e))
-        .expect("should have trusted setup");
-    let kzg = Kzg::new_from_trusted_setup(trusted_setup).expect("should create kzg");
+    let kzg_opt = spec.deneb_fork_epoch.map(|_| KZG.clone());
 
     MockExecutionLayer::new(
         task_executor,
@@ -600,7 +599,7 @@ pub fn mock_execution_layer_from_parts<E: EthSpec>(
         prague_time,
         Some(JwtKey::from_slice(&DEFAULT_JWT_SECRET).unwrap()),
         spec.clone(),
-        Some(kzg),
+        kzg_opt,
     )
 }
 
@@ -754,10 +753,7 @@ where
     pub fn get_current_state_and_root(&self) -> (BeaconState<E>, Hash256) {
         let head = self.chain.head_snapshot();
         let state_root = head.beacon_state_root();
-        (
-            head.beacon_state.clone_with_only_committee_caches(),
-            state_root,
-        )
+        (head.beacon_state.clone(), state_root)
     }
 
     pub fn head_slot(&self) -> Slot {
@@ -800,8 +796,9 @@ where
     pub fn get_hot_state(&self, state_hash: BeaconStateHash) -> Option<BeaconState<E>> {
         self.chain
             .store
-            .load_hot_state(&state_hash.into(), StateProcessingStrategy::Accurate)
+            .load_hot_state(&state_hash.into())
             .unwrap()
+            .map(|(state, _)| state)
     }
 
     pub fn get_cold_state(&self, state_hash: BeaconStateHash) -> Option<BeaconState<E>> {
@@ -883,7 +880,7 @@ where
         let block_contents: SignedBlockContentsTuple<E> = match *signed_block {
             SignedBeaconBlock::Base(_)
             | SignedBeaconBlock::Altair(_)
-            | SignedBeaconBlock::Merge(_)
+            | SignedBeaconBlock::Bellatrix(_)
             | SignedBeaconBlock::Capella(_) => (signed_block, None),
             SignedBeaconBlock::Deneb(_) | SignedBeaconBlock::Electra(_) => {
                 (signed_block, block_response.blob_items)
@@ -947,7 +944,7 @@ where
         let block_contents: SignedBlockContentsTuple<E> = match *signed_block {
             SignedBeaconBlock::Base(_)
             | SignedBeaconBlock::Altair(_)
-            | SignedBeaconBlock::Merge(_)
+            | SignedBeaconBlock::Bellatrix(_)
             | SignedBeaconBlock::Capella(_) => (signed_block, None),
             SignedBeaconBlock::Deneb(_) | SignedBeaconBlock::Electra(_) => {
                 (signed_block, block_response.blob_items)
@@ -1015,9 +1012,7 @@ where
             return Err(BeaconChainError::CannotAttestToFutureState);
         } else if state.current_epoch() < epoch {
             let mut_state = state.to_mut();
-            // Only perform a "partial" state advance since we do not require the state roots to be
-            // accurate.
-            partial_state_advance(
+            complete_state_advance(
                 mut_state,
                 Some(state_root),
                 epoch.start_slot(E::slots_per_epoch()),
@@ -1886,6 +1881,7 @@ where
                 block_root,
                 RpcBlock::new(Some(block_root), block, sidecars).unwrap(),
                 NotifyExecutionLayer::Yes,
+                BlockImportSource::RangeSync,
                 || Ok(()),
             )
             .await?
@@ -1912,6 +1908,7 @@ where
                 block_root,
                 RpcBlock::new(Some(block_root), block, sidecars).unwrap(),
                 NotifyExecutionLayer::Yes,
+                BlockImportSource::RangeSync,
                 || Ok(()),
             )
             .await?
@@ -2498,6 +2495,7 @@ pub fn build_log(level: slog::Level, enabled: bool) -> Logger {
 
 pub enum NumBlobs {
     Random,
+    Number(usize),
     None,
 }
 
@@ -2518,6 +2516,7 @@ pub fn generate_rand_block_and_blobs<E: EthSpec>(
             let payload: &mut FullPayloadDeneb<E> = &mut message.body.execution_payload;
             let num_blobs = match num_blobs {
                 NumBlobs::Random => rng.gen_range(1..=E::max_blobs_per_block()),
+                NumBlobs::Number(n) => n,
                 NumBlobs::None => 0,
             };
             let (bundle, transactions) =
@@ -2537,6 +2536,7 @@ pub fn generate_rand_block_and_blobs<E: EthSpec>(
             let payload: &mut FullPayloadElectra<E> = &mut message.body.execution_payload;
             let num_blobs = match num_blobs {
                 NumBlobs::Random => rng.gen_range(1..=E::max_blobs_per_block()),
+                NumBlobs::Number(n) => n,
                 NumBlobs::None => 0,
             };
             let (bundle, transactions) =
diff --git a/beacon_node/beacon_chain/src/validator_pubkey_cache.rs b/beacon_node/beacon_chain/src/validator_pubkey_cache.rs
index 2cf0c326158..e1b50706286 100644
--- a/beacon_node/beacon_chain/src/validator_pubkey_cache.rs
+++ b/beacon_node/beacon_chain/src/validator_pubkey_cache.rs
@@ -81,8 +81,9 @@ impl<T: BeaconChainTypes> ValidatorPubkeyCache<T> {
     ) -> Result<Vec<StoreOp<'static, T::EthSpec>>, BeaconChainError> {
         if state.validators().len() > self.pubkeys.len() {
             self.import(
-                state.validators()[self.pubkeys.len()..]
-                    .iter()
+                state
+                    .validators()
+                    .iter_from(self.pubkeys.len())?
                     .map(|v| v.pubkey),
             )
         } else {
diff --git a/beacon_node/beacon_chain/tests/attestation_verification.rs b/beacon_node/beacon_chain/tests/attestation_verification.rs
index 3432604cc93..1463d1c5c15 100644
--- a/beacon_node/beacon_chain/tests/attestation_verification.rs
+++ b/beacon_node/beacon_chain/tests/attestation_verification.rs
@@ -336,7 +336,7 @@ impl GossipTester {
 
     pub fn earliest_valid_attestation_slot(&self) -> Slot {
         let offset = match self.harness.spec.fork_name_at_epoch(self.epoch()) {
-            ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => {
+            ForkName::Base | ForkName::Altair | ForkName::Bellatrix | ForkName::Capella => {
                 // Subtract an additional slot since the harness will be exactly on the start of the
                 // slot and the propagation tolerance will allow an extra slot.
                 E::slots_per_epoch() + 1
@@ -1382,7 +1382,10 @@ async fn attestation_verification_use_head_state_fork() {
         .block_at_slot(pre_capella_slot, WhenSlotSkipped::Prev)
         .expect("should not error getting block at slot")
         .expect("should find block at slot");
-    assert_eq!(pre_capella_block.fork_name(&spec).unwrap(), ForkName::Merge);
+    assert_eq!(
+        pre_capella_block.fork_name(&spec).unwrap(),
+        ForkName::Bellatrix
+    );
 
     // Advance slot clock to Capella fork.
     harness.advance_slot();
@@ -1427,7 +1430,7 @@ async fn attestation_verification_use_head_state_fork() {
     // Scenario 2: other node forgot to update their node and signed attestations using bellatrix fork
     {
         let attesters = (VALIDATOR_COUNT / 2..VALIDATOR_COUNT).collect::<Vec<_>>();
-        let merge_fork = spec.fork_for_name(ForkName::Merge).unwrap();
+        let bellatrix_fork = spec.fork_for_name(ForkName::Bellatrix).unwrap();
         let committee_attestations = harness
             .make_unaggregated_attestations_with_opts(
                 attesters.as_slice(),
@@ -1436,7 +1439,7 @@ async fn attestation_verification_use_head_state_fork() {
                 pre_capella_block.canonical_root().into(),
                 first_capella_slot,
                 MakeAttestationOptions {
-                    fork: merge_fork,
+                    fork: bellatrix_fork,
                     limit: None,
                 },
             )
@@ -1483,7 +1486,10 @@ async fn aggregated_attestation_verification_use_head_state_fork() {
         .block_at_slot(pre_capella_slot, WhenSlotSkipped::Prev)
         .expect("should not error getting block at slot")
         .expect("should find block at slot");
-    assert_eq!(pre_capella_block.fork_name(&spec).unwrap(), ForkName::Merge);
+    assert_eq!(
+        pre_capella_block.fork_name(&spec).unwrap(),
+        ForkName::Bellatrix
+    );
 
     // Advance slot clock to Capella fork.
     harness.advance_slot();
@@ -1525,7 +1531,7 @@ async fn aggregated_attestation_verification_use_head_state_fork() {
     // Scenario 2: other node forgot to update their node and signed attestations using bellatrix fork
     {
         let attesters = (VALIDATOR_COUNT / 2..VALIDATOR_COUNT).collect::<Vec<_>>();
-        let merge_fork = spec.fork_for_name(ForkName::Merge).unwrap();
+        let bellatrix_fork = spec.fork_for_name(ForkName::Bellatrix).unwrap();
         let aggregates = harness
             .make_attestations_with_opts(
                 attesters.as_slice(),
@@ -1534,7 +1540,7 @@ async fn aggregated_attestation_verification_use_head_state_fork() {
                 pre_capella_block.canonical_root().into(),
                 first_capella_slot,
                 MakeAttestationOptions {
-                    fork: merge_fork,
+                    fork: bellatrix_fork,
                     limit: None,
                 },
             )
diff --git a/beacon_node/beacon_chain/tests/merge.rs b/beacon_node/beacon_chain/tests/bellatrix.rs
similarity index 81%
rename from beacon_node/beacon_chain/tests/merge.rs
rename to beacon_node/beacon_chain/tests/bellatrix.rs
index bff5c4523d1..027082c11c9 100644
--- a/beacon_node/beacon_chain/tests/merge.rs
+++ b/beacon_node/beacon_chain/tests/bellatrix.rs
@@ -71,9 +71,9 @@ async fn merge_with_terminal_block_hash_override() {
             .chain
             .head_snapshot()
             .beacon_block
-            .as_merge()
+            .as_bellatrix()
             .is_ok(),
-        "genesis block should be a merge block"
+        "genesis block should be a bellatrix block"
     );
 
     let mut execution_payloads = vec![];
@@ -93,11 +93,11 @@ async fn merge_with_terminal_block_hash_override() {
 }
 
 #[tokio::test]
-async fn base_altair_merge_with_terminal_block_after_fork() {
+async fn base_altair_bellatrix_with_terminal_block_after_fork() {
     let altair_fork_epoch = Epoch::new(4);
     let altair_fork_slot = altair_fork_epoch.start_slot(E::slots_per_epoch());
     let bellatrix_fork_epoch = Epoch::new(8);
-    let merge_fork_slot = bellatrix_fork_epoch.start_slot(E::slots_per_epoch());
+    let bellatrix_fork_slot = bellatrix_fork_epoch.start_slot(E::slots_per_epoch());
 
     let mut spec = E::default_spec();
     spec.altair_fork_epoch = Some(altair_fork_epoch);
@@ -130,41 +130,41 @@ async fn base_altair_merge_with_terminal_block_after_fork() {
     assert_eq!(altair_head.slot(), altair_fork_slot);
 
     /*
-     * Do the merge fork, without a terminal PoW block.
+     * Do the Bellatrix fork, without a terminal PoW block.
      */
 
-    harness.extend_to_slot(merge_fork_slot).await;
+    harness.extend_to_slot(bellatrix_fork_slot).await;
 
-    let merge_head = &harness.chain.head_snapshot().beacon_block;
-    assert!(merge_head.as_merge().is_ok());
-    assert_eq!(merge_head.slot(), merge_fork_slot);
+    let bellatrix_head = &harness.chain.head_snapshot().beacon_block;
+    assert!(bellatrix_head.as_bellatrix().is_ok());
+    assert_eq!(bellatrix_head.slot(), bellatrix_fork_slot);
     assert!(
-        merge_head
+        bellatrix_head
             .message()
             .body()
             .execution_payload()
             .unwrap()
             .is_default_with_empty_roots(),
-        "Merge head is default payload"
+        "Bellatrix head is default payload"
     );
 
     /*
-     * Next merge block shouldn't include an exec payload.
+     * Next Bellatrix block shouldn't include an exec payload.
      */
 
     harness.extend_slots(1).await;
 
-    let one_after_merge_head = &harness.chain.head_snapshot().beacon_block;
+    let one_after_bellatrix_head = &harness.chain.head_snapshot().beacon_block;
     assert!(
-        one_after_merge_head
+        one_after_bellatrix_head
             .message()
             .body()
             .execution_payload()
             .unwrap()
             .is_default_with_empty_roots(),
-        "One after merge head is default payload"
+        "One after bellatrix head is default payload"
     );
-    assert_eq!(one_after_merge_head.slot(), merge_fork_slot + 1);
+    assert_eq!(one_after_bellatrix_head.slot(), bellatrix_fork_slot + 1);
 
     /*
      * Trigger the terminal PoW block.
@@ -188,20 +188,20 @@ async fn base_altair_merge_with_terminal_block_after_fork() {
 
     harness.extend_slots(1).await;
 
-    let two_after_merge_head = &harness.chain.head_snapshot().beacon_block;
+    let two_after_bellatrix_head = &harness.chain.head_snapshot().beacon_block;
     assert!(
-        two_after_merge_head
+        two_after_bellatrix_head
             .message()
             .body()
             .execution_payload()
             .unwrap()
             .is_default_with_empty_roots(),
-        "Two after merge head is default payload"
+        "Two after bellatrix head is default payload"
     );
-    assert_eq!(two_after_merge_head.slot(), merge_fork_slot + 2);
+    assert_eq!(two_after_bellatrix_head.slot(), bellatrix_fork_slot + 2);
 
     /*
-     * Next merge block should include an exec payload.
+     * Next Bellatrix block should include an exec payload.
      */
     for _ in 0..4 {
         harness.extend_slots(1).await;
diff --git a/beacon_node/beacon_chain/tests/block_verification.rs b/beacon_node/beacon_chain/tests/block_verification.rs
index 4d37557f0d1..9c196b12e16 100644
--- a/beacon_node/beacon_chain/tests/block_verification.rs
+++ b/beacon_node/beacon_chain/tests/block_verification.rs
@@ -15,8 +15,7 @@ use slasher::{Config as SlasherConfig, Slasher};
 use state_processing::{
     common::get_indexed_attestation,
     per_block_processing::{per_block_processing, BlockSignatureStrategy},
-    per_slot_processing, BlockProcessingError, ConsensusContext, StateProcessingStrategy,
-    VerifyBlockRoot,
+    per_slot_processing, BlockProcessingError, ConsensusContext, VerifyBlockRoot,
 };
 use std::marker::PhantomData;
 use std::sync::Arc;
@@ -474,6 +473,7 @@ async fn assert_invalid_signature(
             )
             .unwrap(),
             NotifyExecutionLayer::Yes,
+            BlockImportSource::Lookup,
             || Ok(()),
         )
         .await;
@@ -542,6 +542,7 @@ async fn invalid_signature_gossip_block() {
                         signed_block.canonical_root(),
                         Arc::new(signed_block),
                         NotifyExecutionLayer::Yes,
+                        BlockImportSource::Lookup,
                         || Ok(()),
                     )
                     .await,
@@ -876,6 +877,7 @@ async fn block_gossip_verification() {
                 gossip_verified.block_root,
                 gossip_verified,
                 NotifyExecutionLayer::Yes,
+                BlockImportSource::Lookup,
                 || Ok(()),
             )
             .await
@@ -1166,6 +1168,7 @@ async fn verify_block_for_gossip_slashing_detection() {
             verified_block.block_root,
             verified_block,
             NotifyExecutionLayer::Yes,
+            BlockImportSource::Lookup,
             || Ok(()),
         )
         .await
@@ -1197,6 +1200,7 @@ async fn verify_block_for_gossip_doppelganger_detection() {
             verified_block.block_root,
             verified_block,
             NotifyExecutionLayer::Yes,
+            BlockImportSource::Lookup,
             || Ok(()),
         )
         .await
@@ -1309,7 +1313,6 @@ async fn add_base_block_to_altair_chain() {
                 &mut state,
                 &base_block,
                 BlockSignatureStrategy::NoVerification,
-                StateProcessingStrategy::Accurate,
                 VerifyBlockRoot::True,
                 &mut ctxt,
                 &harness.chain.spec,
@@ -1344,6 +1347,7 @@ async fn add_base_block_to_altair_chain() {
                 base_block.canonical_root(),
                 Arc::new(base_block.clone()),
                 NotifyExecutionLayer::Yes,
+                BlockImportSource::Lookup,
                 || Ok(()),
             )
             .await
@@ -1445,7 +1449,6 @@ async fn add_altair_block_to_base_chain() {
                 &mut state,
                 &altair_block,
                 BlockSignatureStrategy::NoVerification,
-                StateProcessingStrategy::Accurate,
                 VerifyBlockRoot::True,
                 &mut ctxt,
                 &harness.chain.spec,
@@ -1480,6 +1483,7 @@ async fn add_altair_block_to_base_chain() {
                 altair_block.canonical_root(),
                 Arc::new(altair_block.clone()),
                 NotifyExecutionLayer::Yes,
+                BlockImportSource::Lookup,
                 || Ok(()),
             )
             .await
diff --git a/beacon_node/beacon_chain/tests/capella.rs b/beacon_node/beacon_chain/tests/capella.rs
index dc40280f530..c8fd2637f0c 100644
--- a/beacon_node/beacon_chain/tests/capella.rs
+++ b/beacon_node/beacon_chain/tests/capella.rs
@@ -25,11 +25,11 @@ fn verify_execution_payload_chain<E: EthSpec>(chain: &[FullPayload<E>]) {
 }
 
 #[tokio::test]
-async fn base_altair_merge_capella() {
+async fn base_altair_bellatrix_capella() {
     let altair_fork_epoch = Epoch::new(4);
     let altair_fork_slot = altair_fork_epoch.start_slot(E::slots_per_epoch());
     let bellatrix_fork_epoch = Epoch::new(8);
-    let merge_fork_slot = bellatrix_fork_epoch.start_slot(E::slots_per_epoch());
+    let bellatrix_fork_slot = bellatrix_fork_epoch.start_slot(E::slots_per_epoch());
     let capella_fork_epoch = Epoch::new(12);
     let capella_fork_slot = capella_fork_epoch.start_slot(E::slots_per_epoch());
 
@@ -61,39 +61,39 @@ async fn base_altair_merge_capella() {
     assert_eq!(altair_head.slot(), altair_fork_slot);
 
     /*
-     * Do the merge fork, without a terminal PoW block.
+     * Do the Bellatrix fork, without a terminal PoW block.
      */
-    harness.extend_to_slot(merge_fork_slot).await;
+    harness.extend_to_slot(bellatrix_fork_slot).await;
 
-    let merge_head = &harness.chain.head_snapshot().beacon_block;
-    assert!(merge_head.as_merge().is_ok());
-    assert_eq!(merge_head.slot(), merge_fork_slot);
+    let bellatrix_head = &harness.chain.head_snapshot().beacon_block;
+    assert!(bellatrix_head.as_bellatrix().is_ok());
+    assert_eq!(bellatrix_head.slot(), bellatrix_fork_slot);
     assert!(
-        merge_head
+        bellatrix_head
             .message()
             .body()
             .execution_payload()
             .unwrap()
             .is_default_with_empty_roots(),
-        "Merge head is default payload"
+        "Bellatrix head is default payload"
     );
 
     /*
-     * Next merge block shouldn't include an exec payload.
+     * Next Bellatrix block shouldn't include an exec payload.
      */
     harness.extend_slots(1).await;
 
-    let one_after_merge_head = &harness.chain.head_snapshot().beacon_block;
+    let one_after_bellatrix_head = &harness.chain.head_snapshot().beacon_block;
     assert!(
-        one_after_merge_head
+        one_after_bellatrix_head
             .message()
             .body()
             .execution_payload()
             .unwrap()
             .is_default_with_empty_roots(),
-        "One after merge head is default payload"
+        "One after bellatrix head is default payload"
     );
-    assert_eq!(one_after_merge_head.slot(), merge_fork_slot + 1);
+    assert_eq!(one_after_bellatrix_head.slot(), bellatrix_fork_slot + 1);
 
     /*
      * Trigger the terminal PoW block.
@@ -114,23 +114,23 @@ async fn base_altair_merge_capella() {
         });
     harness.extend_slots(1).await;
 
-    let two_after_merge_head = &harness.chain.head_snapshot().beacon_block;
+    let two_after_bellatrix_head = &harness.chain.head_snapshot().beacon_block;
     assert!(
-        two_after_merge_head
+        two_after_bellatrix_head
             .message()
             .body()
             .execution_payload()
             .unwrap()
             .is_default_with_empty_roots(),
-        "Two after merge head is default payload"
+        "Two after bellatrix head is default payload"
     );
-    assert_eq!(two_after_merge_head.slot(), merge_fork_slot + 2);
+    assert_eq!(two_after_bellatrix_head.slot(), bellatrix_fork_slot + 2);
 
     /*
-     * Next merge block should include an exec payload.
+     * Next Bellatrix block should include an exec payload.
      */
     let mut execution_payloads = vec![];
-    for _ in (merge_fork_slot.as_u64() + 3)..capella_fork_slot.as_u64() {
+    for _ in (bellatrix_fork_slot.as_u64() + 3)..capella_fork_slot.as_u64() {
         harness.extend_slots(1).await;
         let block = &harness.chain.head_snapshot().beacon_block;
         let full_payload: FullPayload<E> =
diff --git a/beacon_node/beacon_chain/tests/main.rs b/beacon_node/beacon_chain/tests/main.rs
index e0564e1510b..942ce816846 100644
--- a/beacon_node/beacon_chain/tests/main.rs
+++ b/beacon_node/beacon_chain/tests/main.rs
@@ -1,9 +1,9 @@
 mod attestation_production;
 mod attestation_verification;
+mod bellatrix;
 mod block_verification;
 mod capella;
 mod events;
-mod merge;
 mod op_verification;
 mod payload_invalidation;
 mod rewards;
diff --git a/beacon_node/beacon_chain/tests/payload_invalidation.rs b/beacon_node/beacon_chain/tests/payload_invalidation.rs
index f1262596f70..0c36d21f2ec 100644
--- a/beacon_node/beacon_chain/tests/payload_invalidation.rs
+++ b/beacon_node/beacon_chain/tests/payload_invalidation.rs
@@ -223,7 +223,7 @@ impl InvalidPayloadRig {
         let mock_execution_layer = self.harness.mock_execution_layer.as_ref().unwrap();
 
         let head = self.harness.chain.head_snapshot();
-        let state = head.beacon_state.clone_with_only_committee_caches();
+        let state = head.beacon_state.clone();
         let slot = slot_override.unwrap_or(state.slot() + 1);
         let ((block, blobs), post_state) = self.harness.make_block(state, slot).await;
         let block_root = block.canonical_root();
@@ -702,6 +702,7 @@ async fn invalidates_all_descendants() {
             fork_block.canonical_root(),
             fork_block,
             NotifyExecutionLayer::Yes,
+            BlockImportSource::Lookup,
             || Ok(()),
         )
         .await
@@ -802,6 +803,7 @@ async fn switches_heads() {
             fork_block.canonical_root(),
             fork_block,
             NotifyExecutionLayer::Yes,
+            BlockImportSource::Lookup,
             || Ok(()),
         )
         .await
@@ -1061,7 +1063,7 @@ async fn invalid_parent() {
 
     // Ensure the block built atop an invalid payload is invalid for import.
     assert!(matches!(
-        rig.harness.chain.process_block(block.canonical_root(), block.clone(), NotifyExecutionLayer::Yes,
+        rig.harness.chain.process_block(block.canonical_root(), block.clone(), NotifyExecutionLayer::Yes, BlockImportSource::Lookup,
             || Ok(()),
         ).await,
         Err(BlockError::ParentExecutionPayloadInvalid { parent_root: invalid_root })
@@ -1352,6 +1354,7 @@ async fn build_optimistic_chain(
                 block.canonical_root(),
                 block,
                 NotifyExecutionLayer::Yes,
+                BlockImportSource::Lookup,
                 || Ok(()),
             )
             .await
@@ -1926,6 +1929,7 @@ async fn recover_from_invalid_head_by_importing_blocks() {
             fork_block.canonical_root(),
             fork_block.clone(),
             NotifyExecutionLayer::Yes,
+            BlockImportSource::Lookup,
             || Ok(()),
         )
         .await
@@ -2048,7 +2052,7 @@ async fn weights_after_resetting_optimistic_status() {
             .fork_choice_read_lock()
             .get_block_weight(&head.head_block_root())
             .unwrap(),
-        head.snapshot.beacon_state.validators()[0].effective_balance,
+        head.snapshot.beacon_state.validators().get(0).unwrap().effective_balance,
         "proposer boost should be removed from the head block and the vote of a single validator applied"
     );
 
diff --git a/beacon_node/beacon_chain/tests/rewards.rs b/beacon_node/beacon_chain/tests/rewards.rs
index a78463ef5d7..1c80525223a 100644
--- a/beacon_node/beacon_chain/tests/rewards.rs
+++ b/beacon_node/beacon_chain/tests/rewards.rs
@@ -105,8 +105,8 @@ async fn test_sync_committee_rewards() {
             .get_validator_index(&validator.pubkey)
             .unwrap()
             .unwrap();
-        let pre_state_balance = parent_state.balances()[validator_index];
-        let post_state_balance = state.balances()[validator_index];
+        let pre_state_balance = *parent_state.balances().get(validator_index).unwrap();
+        let post_state_balance = *state.balances().get(validator_index).unwrap();
         let sync_committee_reward = rewards.get(&(validator_index as u64)).unwrap_or(&0);
 
         if validator_index == proposer_index {
@@ -141,7 +141,7 @@ async fn test_verify_attestation_rewards_base() {
         )
         .await;
 
-    let initial_balances: Vec<u64> = harness.get_current_state().balances().clone().into();
+    let initial_balances: Vec<u64> = harness.get_current_state().balances().to_vec();
 
     // extend slots to beginning of epoch N + 2
     harness.extend_slots(E::slots_per_epoch() as usize).await;
@@ -163,7 +163,7 @@ async fn test_verify_attestation_rewards_base() {
     let expected_balances = apply_attestation_rewards(&initial_balances, total_rewards);
 
     // verify expected balances against actual balances
-    let balances: Vec<u64> = harness.get_current_state().balances().clone().into();
+    let balances: Vec<u64> = harness.get_current_state().balances().to_vec();
     assert_eq!(expected_balances, balances);
 }
 
@@ -185,7 +185,7 @@ async fn test_verify_attestation_rewards_base_inactivity_leak() {
             AttestationStrategy::SomeValidators(half_validators.clone()),
         )
         .await;
-    let initial_balances: Vec<u64> = harness.get_current_state().balances().clone().into();
+    let initial_balances: Vec<u64> = harness.get_current_state().balances().to_vec();
 
     // extend slots to beginning of epoch N + 2
     harness.advance_slot();
@@ -215,7 +215,7 @@ async fn test_verify_attestation_rewards_base_inactivity_leak() {
     let expected_balances = apply_attestation_rewards(&initial_balances, total_rewards);
 
     // verify expected balances against actual balances
-    let balances: Vec<u64> = harness.get_current_state().balances().clone().into();
+    let balances: Vec<u64> = harness.get_current_state().balances().to_vec();
     assert_eq!(expected_balances, balances);
 }
 
@@ -241,7 +241,7 @@ async fn test_verify_attestation_rewards_base_inactivity_leak_justification_epoc
     // advance to create first justification epoch and get initial balances
     harness.extend_slots(E::slots_per_epoch() as usize).await;
     target_epoch += 1;
-    let initial_balances: Vec<u64> = harness.get_current_state().balances().clone().into();
+    let initial_balances: Vec<u64> = harness.get_current_state().balances().to_vec();
 
     //assert previous_justified_checkpoint matches 0 as we were in inactivity leak from beginning
     assert_eq!(
@@ -284,7 +284,7 @@ async fn test_verify_attestation_rewards_base_inactivity_leak_justification_epoc
     let expected_balances = apply_attestation_rewards(&initial_balances, total_rewards);
 
     // verify expected balances against actual balances
-    let balances: Vec<u64> = harness.get_current_state().balances().clone().into();
+    let balances: Vec<u64> = harness.get_current_state().balances().to_vec();
     assert_eq!(expected_balances, balances);
 }
 
@@ -298,7 +298,7 @@ async fn test_verify_attestation_rewards_altair() {
     harness
         .extend_slots((E::slots_per_epoch() * (target_epoch + 1)) as usize)
         .await;
-    let initial_balances: Vec<u64> = harness.get_current_state().balances().clone().into();
+    let initial_balances: Vec<u64> = harness.get_current_state().balances().to_vec();
 
     // advance until epoch N + 2 and build proposal rewards map
     let mut proposal_rewards_map: HashMap<u64, u64> = HashMap::new();
@@ -364,7 +364,7 @@ async fn test_verify_attestation_rewards_altair() {
         apply_sync_committee_rewards(&sync_committee_rewards_map, expected_balances);
 
     // verify expected balances against actual balances
-    let balances: Vec<u64> = harness.get_current_state().balances().clone().into();
+    let balances: Vec<u64> = harness.get_current_state().balances().to_vec();
 
     assert_eq!(expected_balances, balances);
 }
@@ -386,7 +386,7 @@ async fn test_verify_attestation_rewards_altair_inactivity_leak() {
             half_validators.clone(),
         )
         .await;
-    let initial_balances: Vec<u64> = harness.get_current_state().balances().clone().into();
+    let initial_balances: Vec<u64> = harness.get_current_state().balances().to_vec();
 
     // advance until epoch N + 2 and build proposal rewards map
     let mut proposal_rewards_map: HashMap<u64, u64> = HashMap::new();
@@ -458,7 +458,7 @@ async fn test_verify_attestation_rewards_altair_inactivity_leak() {
         apply_sync_committee_rewards(&sync_committee_rewards_map, expected_balances);
 
     // verify expected balances against actual balances
-    let balances: Vec<u64> = harness.get_current_state().balances().clone().into();
+    let balances: Vec<u64> = harness.get_current_state().balances().to_vec();
 
     assert_eq!(expected_balances, balances);
 }
@@ -492,7 +492,7 @@ async fn test_verify_attestation_rewards_altair_inactivity_leak_justification_ep
     // advance for first justification epoch and get balances
     harness.extend_slots(E::slots_per_epoch() as usize).await;
     target_epoch += 1;
-    let initial_balances: Vec<u64> = harness.get_current_state().balances().clone().into();
+    let initial_balances: Vec<u64> = harness.get_current_state().balances().to_vec();
 
     // advance until epoch N + 2 and build proposal rewards map
     let mut proposal_rewards_map: HashMap<u64, u64> = HashMap::new();
@@ -568,7 +568,7 @@ async fn test_verify_attestation_rewards_altair_inactivity_leak_justification_ep
         apply_sync_committee_rewards(&sync_committee_rewards_map, expected_balances);
 
     // verify expected balances against actual balances
-    let balances: Vec<u64> = harness.get_current_state().balances().clone().into();
+    let balances: Vec<u64> = harness.get_current_state().balances().to_vec();
     assert_eq!(expected_balances, balances);
 }
 
diff --git a/beacon_node/beacon_chain/tests/store_tests.rs b/beacon_node/beacon_chain/tests/store_tests.rs
index 66f4138afb4..5da92573f77 100644
--- a/beacon_node/beacon_chain/tests/store_tests.rs
+++ b/beacon_node/beacon_chain/tests/store_tests.rs
@@ -7,15 +7,13 @@ use beacon_chain::data_availability_checker::AvailableBlock;
 use beacon_chain::schema_change::migrate_schema;
 use beacon_chain::test_utils::{
     mock_execution_layer_from_parts, test_spec, AttestationStrategy, BeaconChainHarness,
-    BlockStrategy, DiskHarnessType,
+    BlockStrategy, DiskHarnessType, KZG,
 };
 use beacon_chain::{
     data_availability_checker::MaybeAvailableBlock, historical_blocks::HistoricalBlockError,
     migrate::MigratorConfig, BeaconChain, BeaconChainError, BeaconChainTypes, BeaconSnapshot,
     BlockError, ChainConfig, NotifyExecutionLayer, ServerSentEventHandler, WhenSlotSkipped,
 };
-use eth2_network_config::TRUSTED_SETUP_BYTES;
-use kzg::TrustedSetup;
 use lazy_static::lazy_static;
 use logging::test_logger;
 use maplit::hashset;
@@ -721,52 +719,6 @@ async fn forwards_iter_block_and_state_roots_until() {
     test_range(Slot::new(0), head_state.slot());
 }
 
-#[tokio::test]
-async fn block_replay_with_inaccurate_state_roots() {
-    let num_blocks_produced = E::slots_per_epoch() * 3 + 31;
-    let db_path = tempdir().unwrap();
-    let store = get_store(&db_path);
-    let harness = get_harness(store.clone(), LOW_VALIDATOR_COUNT);
-    let chain = &harness.chain;
-
-    harness
-        .extend_chain(
-            num_blocks_produced as usize,
-            BlockStrategy::OnCanonicalHead,
-            AttestationStrategy::AllValidators,
-        )
-        .await;
-
-    // Slot must not be 0 mod 32 or else no blocks will be replayed.
-    let (mut head_state, head_state_root) = harness.get_current_state_and_root();
-    let head_block_root = harness.head_block_root();
-    assert_ne!(head_state.slot() % 32, 0);
-
-    let (_, mut fast_head_state) = store
-        .get_inconsistent_state_for_attestation_verification_only(
-            &head_block_root,
-            head_state.slot(),
-            head_state_root,
-        )
-        .unwrap()
-        .unwrap();
-    assert_eq!(head_state.validators(), fast_head_state.validators());
-
-    head_state.build_all_committee_caches(&chain.spec).unwrap();
-    fast_head_state
-        .build_all_committee_caches(&chain.spec)
-        .unwrap();
-
-    assert_eq!(
-        head_state
-            .get_cached_active_validator_indices(RelativeEpoch::Current)
-            .unwrap(),
-        fast_head_state
-            .get_cached_active_validator_indices(RelativeEpoch::Current)
-            .unwrap()
-    );
-}
-
 #[tokio::test]
 async fn block_replayer_hooks() {
     let db_path = tempdir().unwrap();
@@ -797,7 +749,7 @@ async fn block_replayer_hooks() {
     let mut post_block_slots = vec![];
 
     let mut replay_state = BlockReplayer::<MinimalEthSpec>::new(state, &chain.spec)
-        .pre_slot_hook(Box::new(|state| {
+        .pre_slot_hook(Box::new(|_, state| {
             pre_slots.push(state.slot());
             Ok(())
         }))
@@ -836,6 +788,8 @@ async fn block_replayer_hooks() {
     assert_eq!(post_block_slots, block_slots);
 
     // States match.
+    end_state.apply_pending_mutations().unwrap();
+    replay_state.apply_pending_mutations().unwrap();
     end_state.drop_all_caches().unwrap();
     replay_state.drop_all_caches().unwrap();
     assert_eq!(end_state, replay_state);
@@ -1221,9 +1175,17 @@ fn check_shuffling_compatible(
                 |committee_cache, _| {
                     let state_cache = head_state.committee_cache(RelativeEpoch::Current).unwrap();
                     if current_epoch_shuffling_is_compatible {
-                        assert_eq!(committee_cache, state_cache, "block at slot {slot}");
+                        assert_eq!(
+                            committee_cache,
+                            state_cache.as_ref(),
+                            "block at slot {slot}"
+                        );
                     } else {
-                        assert_ne!(committee_cache, state_cache, "block at slot {slot}");
+                        assert_ne!(
+                            committee_cache,
+                            state_cache.as_ref(),
+                            "block at slot {slot}"
+                        );
                     }
                     Ok(())
                 },
@@ -1253,9 +1215,9 @@ fn check_shuffling_compatible(
                 |committee_cache, _| {
                     let state_cache = head_state.committee_cache(RelativeEpoch::Previous).unwrap();
                     if previous_epoch_shuffling_is_compatible {
-                        assert_eq!(committee_cache, state_cache);
+                        assert_eq!(committee_cache, state_cache.as_ref());
                     } else {
-                        assert_ne!(committee_cache, state_cache);
+                        assert_ne!(committee_cache, state_cache.as_ref());
                     }
                     Ok(())
                 },
@@ -2418,9 +2380,7 @@ async fn weak_subjectivity_sync_test(slots: Vec<Slot>, checkpoint_slot: Slot) {
     let store = get_store(&temp2);
     let spec = test_spec::<E>();
     let seconds_per_slot = spec.seconds_per_slot;
-    let trusted_setup: TrustedSetup = serde_json::from_reader(TRUSTED_SETUP_BYTES)
-        .map_err(|e| println!("Unable to read trusted setup file: {}", e))
-        .unwrap();
+    let kzg = spec.deneb_fork_epoch.map(|_| KZG.clone());
 
     let mock =
         mock_execution_layer_from_parts(&harness.spec, harness.runtime.task_executor.clone());
@@ -2457,7 +2417,7 @@ async fn weak_subjectivity_sync_test(slots: Vec<Slot>, checkpoint_slot: Slot) {
             1,
         )))
         .execution_layer(Some(mock.el))
-        .trusted_setup(trusted_setup)
+        .kzg(kzg)
         .build()
         .expect("should build");
 
@@ -2498,6 +2458,7 @@ async fn weak_subjectivity_sync_test(slots: Vec<Slot>, checkpoint_slot: Slot) {
                 full_block.canonical_root(),
                 RpcBlock::new(Some(block_root), Arc::new(full_block), Some(blobs)).unwrap(),
                 NotifyExecutionLayer::Yes,
+                BlockImportSource::Lookup,
                 || Ok(()),
             )
             .await
@@ -2716,6 +2677,7 @@ async fn process_blocks_and_attestations_for_unaligned_checkpoint() {
             invalid_fork_block.canonical_root(),
             invalid_fork_block.clone(),
             NotifyExecutionLayer::Yes,
+            BlockImportSource::Lookup,
             || Ok(()),
         )
         .await
@@ -2729,6 +2691,7 @@ async fn process_blocks_and_attestations_for_unaligned_checkpoint() {
             valid_fork_block.canonical_root(),
             valid_fork_block.clone(),
             NotifyExecutionLayer::Yes,
+            BlockImportSource::Lookup,
             || Ok(()),
         )
         .await
@@ -3609,16 +3572,16 @@ fn check_split_slot(harness: &TestHarness, store: Arc<HotColdDB<E, LevelDB<E>, L
 
 /// Check that all the states in a chain dump have the correct tree hash.
 fn check_chain_dump(harness: &TestHarness, expected_len: u64) {
-    let chain_dump = harness.chain.chain_dump().unwrap();
+    let mut chain_dump = harness.chain.chain_dump().unwrap();
     let split_slot = harness.chain.store.get_split_slot();
 
     assert_eq!(chain_dump.len() as u64, expected_len);
 
-    for checkpoint in &chain_dump {
+    for checkpoint in &mut chain_dump {
         // Check that the tree hash of the stored state is as expected
         assert_eq!(
             checkpoint.beacon_state_root(),
-            checkpoint.beacon_state.tree_hash_root(),
+            checkpoint.beacon_state.update_tree_hash_cache().unwrap(),
             "tree hash of stored state is incorrect"
         );
 
diff --git a/beacon_node/beacon_chain/tests/tests.rs b/beacon_node/beacon_chain/tests/tests.rs
index e27180a002c..2f496eecd71 100644
--- a/beacon_node/beacon_chain/tests/tests.rs
+++ b/beacon_node/beacon_chain/tests/tests.rs
@@ -12,7 +12,8 @@ use lazy_static::lazy_static;
 use operation_pool::PersistedOperationPool;
 use state_processing::{per_slot_processing, per_slot_processing::Error as SlotProcessingError};
 use types::{
-    BeaconState, BeaconStateError, EthSpec, Hash256, Keypair, MinimalEthSpec, RelativeEpoch, Slot,
+    BeaconState, BeaconStateError, BlockImportSource, EthSpec, Hash256, Keypair, MinimalEthSpec,
+    RelativeEpoch, Slot,
 };
 
 // Should ideally be divisible by 3.
@@ -686,6 +687,7 @@ async fn run_skip_slot_test(skip_slots: u64) {
             harness_a.chain.head_snapshot().beacon_block_root,
             harness_a.get_head_block(),
             NotifyExecutionLayer::Yes,
+            BlockImportSource::Lookup,
             || Ok(()),
         )
         .await
diff --git a/beacon_node/beacon_chain/tests/validator_monitor.rs b/beacon_node/beacon_chain/tests/validator_monitor.rs
index f595e5037e2..ea9ef73575f 100644
--- a/beacon_node/beacon_chain/tests/validator_monitor.rs
+++ b/beacon_node/beacon_chain/tests/validator_monitor.rs
@@ -211,7 +211,7 @@ async fn produces_missed_blocks() {
     // `validator_indexes[slot_in_epoch.as_usize()]` and add it below.
     let validator_index_to_monitor_altair = 2;
     // Same as above but for the merge upgrade
-    let validator_index_to_monitor_merge = 4;
+    let validator_index_to_monitor_bellatrix = 4;
     // Same as above but for the capella upgrade
     let validator_index_to_monitor_capella = 11;
     // Same as above but for the deneb upgrade
@@ -224,7 +224,7 @@ async fn produces_missed_blocks() {
         vec![
             validator_index_to_monitor,
             validator_index_to_monitor_altair,
-            validator_index_to_monitor_merge,
+            validator_index_to_monitor_bellatrix,
             validator_index_to_monitor_capella,
             validator_index_to_monitor_deneb,
             validator_index_to_monitor_electra,
diff --git a/beacon_node/beacon_processor/Cargo.toml b/beacon_node/beacon_processor/Cargo.toml
index 723b09b581c..6c49a28ec87 100644
--- a/beacon_node/beacon_processor/Cargo.toml
+++ b/beacon_node/beacon_processor/Cargo.toml
@@ -23,4 +23,7 @@ lazy_static = { workspace = true }
 lighthouse_metrics = { workspace = true }
 parking_lot = { workspace = true }
 num_cpus = { workspace = true }
-serde = { workspace = true }
\ No newline at end of file
+serde = { workspace = true }
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["test-util"] }
diff --git a/beacon_node/beacon_processor/src/lib.rs b/beacon_node/beacon_processor/src/lib.rs
index 9dd72845180..fee55b39adc 100644
--- a/beacon_node/beacon_processor/src/lib.rs
+++ b/beacon_node/beacon_processor/src/lib.rs
@@ -571,7 +571,7 @@ pub enum BlockingOrAsync {
 /// queuing specifics.
 pub enum Work<E: EthSpec> {
     GossipAttestation {
-        attestation: GossipAttestationPackage<E>,
+        attestation: Box<GossipAttestationPackage<E>>,
         process_individual: Box<dyn FnOnce(GossipAttestationPackage<E>) + Send + Sync>,
         process_batch: Box<dyn FnOnce(Vec<GossipAttestationPackage<E>>) + Send + Sync>,
     },
@@ -583,7 +583,7 @@ pub enum Work<E: EthSpec> {
         process_batch: Box<dyn FnOnce(Vec<GossipAttestationPackage<E>>) + Send + Sync>,
     },
     GossipAggregate {
-        aggregate: GossipAggregatePackage<E>,
+        aggregate: Box<GossipAggregatePackage<E>>,
         process_individual: Box<dyn FnOnce(GossipAggregatePackage<E>) + Send + Sync>,
         process_batch: Box<dyn FnOnce(Vec<GossipAggregatePackage<E>>) + Send + Sync>,
     },
@@ -624,8 +624,8 @@ pub enum Work<E: EthSpec> {
     ChainSegment(AsyncFn),
     ChainSegmentBackfill(AsyncFn),
     Status(BlockingFn),
-    BlocksByRangeRequest(BlockingFnWithManualSendOnIdle),
-    BlocksByRootsRequest(BlockingFnWithManualSendOnIdle),
+    BlocksByRangeRequest(AsyncFn),
+    BlocksByRootsRequest(AsyncFn),
     BlobsByRangeRequest(BlockingFn),
     BlobsByRootsRequest(BlockingFn),
     GossipBlsToExecutionChange(BlockingFn),
@@ -851,7 +851,7 @@ impl<E: EthSpec> BeaconProcessor<E> {
             ready_work_tx,
             work_reprocessing_rx,
             &self.executor,
-            slot_clock,
+            Arc::new(slot_clock),
             self.log.clone(),
             maximum_gossip_clock_disparity,
         )?;
@@ -1015,7 +1015,7 @@ impl<E: EthSpec> BeaconProcessor<E> {
                                                 process_individual: _,
                                                 process_batch,
                                             } => {
-                                                aggregates.push(aggregate);
+                                                aggregates.push(*aggregate);
                                                 if process_batch_opt.is_none() {
                                                     process_batch_opt = Some(process_batch);
                                                 }
@@ -1075,7 +1075,7 @@ impl<E: EthSpec> BeaconProcessor<E> {
                                                 process_individual: _,
                                                 process_batch,
                                             } => {
-                                                attestations.push(attestation);
+                                                attestations.push(*attestation);
                                                 if process_batch_opt.is_none() {
                                                     process_batch_opt = Some(process_batch);
                                                 }
@@ -1445,7 +1445,7 @@ impl<E: EthSpec> BeaconProcessor<E> {
                 process_individual,
                 process_batch: _,
             } => task_spawner.spawn_blocking(move || {
-                process_individual(attestation);
+                process_individual(*attestation);
             }),
             Work::GossipAttestationBatch {
                 attestations,
@@ -1458,7 +1458,7 @@ impl<E: EthSpec> BeaconProcessor<E> {
                 process_individual,
                 process_batch: _,
             } => task_spawner.spawn_blocking(move || {
-                process_individual(aggregate);
+                process_individual(*aggregate);
             }),
             Work::GossipAggregateBatch {
                 aggregates,
@@ -1493,7 +1493,7 @@ impl<E: EthSpec> BeaconProcessor<E> {
                 task_spawner.spawn_blocking(process_fn)
             }
             Work::BlocksByRangeRequest(work) | Work::BlocksByRootsRequest(work) => {
-                task_spawner.spawn_blocking_with_manual_send_idle(work)
+                task_spawner.spawn_async(work)
             }
             Work::ChainSegmentBackfill(process_fn) => task_spawner.spawn_async(process_fn),
             Work::ApiRequestP0(process_fn) | Work::ApiRequestP1(process_fn) => match process_fn {
@@ -1555,23 +1555,6 @@ impl TaskSpawner {
             WORKER_TASK_NAME,
         )
     }
-
-    /// Spawn a blocking task, passing the `SendOnDrop` into the task.
-    ///
-    /// ## Notes
-    ///
-    /// Users must ensure the `SendOnDrop` is dropped at the appropriate time!
-    pub fn spawn_blocking_with_manual_send_idle<F>(self, task: F)
-    where
-        F: FnOnce(SendOnDrop) + Send + 'static,
-    {
-        self.executor.spawn_blocking(
-            || {
-                task(self.send_idle_on_drop);
-            },
-            WORKER_TASK_NAME,
-        )
-    }
 }
 
 /// This struct will send a message on `self.tx` when it is dropped. An error will be logged on
diff --git a/beacon_node/beacon_processor/src/work_reprocessing_queue.rs b/beacon_node/beacon_processor/src/work_reprocessing_queue.rs
index c9be28444c8..496fa683d2c 100644
--- a/beacon_node/beacon_processor/src/work_reprocessing_queue.rs
+++ b/beacon_node/beacon_processor/src/work_reprocessing_queue.rs
@@ -22,6 +22,7 @@ use slot_clock::SlotClock;
 use std::collections::{HashMap, HashSet};
 use std::future::Future;
 use std::pin::Pin;
+use std::sync::Arc;
 use std::task::Context;
 use std::time::Duration;
 use strum::AsRefStr;
@@ -243,7 +244,7 @@ struct ReprocessQueue<S> {
     attestation_delay_debounce: TimeLatch,
     lc_update_delay_debounce: TimeLatch,
     next_backfill_batch_event: Option<Pin<Box<tokio::time::Sleep>>>,
-    slot_clock: Pin<Box<S>>,
+    slot_clock: Arc<S>,
 }
 
 pub type QueuedLightClientUpdateId = usize;
@@ -362,7 +363,7 @@ pub fn spawn_reprocess_scheduler<S: SlotClock + 'static>(
     ready_work_tx: Sender<ReadyWork>,
     work_reprocessing_rx: Receiver<ReprocessQueueMessage>,
     executor: &TaskExecutor,
-    slot_clock: S,
+    slot_clock: Arc<S>,
     log: Logger,
     maximum_gossip_clock_disparity: Duration,
 ) -> Result<(), String> {
@@ -370,34 +371,12 @@ pub fn spawn_reprocess_scheduler<S: SlotClock + 'static>(
     if ADDITIONAL_QUEUED_BLOCK_DELAY >= maximum_gossip_clock_disparity {
         return Err("The block delay and gossip disparity don't match.".to_string());
     }
-    let mut queue = ReprocessQueue {
-        work_reprocessing_rx,
-        ready_work_tx,
-        gossip_block_delay_queue: DelayQueue::new(),
-        rpc_block_delay_queue: DelayQueue::new(),
-        attestations_delay_queue: DelayQueue::new(),
-        lc_updates_delay_queue: DelayQueue::new(),
-        queued_gossip_block_roots: HashSet::new(),
-        queued_lc_updates: FnvHashMap::default(),
-        queued_aggregates: FnvHashMap::default(),
-        queued_unaggregates: FnvHashMap::default(),
-        awaiting_attestations_per_root: HashMap::new(),
-        awaiting_lc_updates_per_parent_root: HashMap::new(),
-        queued_backfill_batches: Vec::new(),
-        next_attestation: 0,
-        next_lc_update: 0,
-        early_block_debounce: TimeLatch::default(),
-        rpc_block_debounce: TimeLatch::default(),
-        attestation_delay_debounce: TimeLatch::default(),
-        lc_update_delay_debounce: TimeLatch::default(),
-        next_backfill_batch_event: None,
-        slot_clock: Box::pin(slot_clock.clone()),
-    };
+    let mut queue = ReprocessQueue::new(ready_work_tx, work_reprocessing_rx, slot_clock);
 
     executor.spawn(
         async move {
             while let Some(msg) = queue.next().await {
-                queue.handle_message(msg, &slot_clock, &log);
+                queue.handle_message(msg, &log);
             }
 
             debug!(
@@ -412,7 +391,37 @@ pub fn spawn_reprocess_scheduler<S: SlotClock + 'static>(
 }
 
 impl<S: SlotClock> ReprocessQueue<S> {
-    fn handle_message(&mut self, msg: InboundEvent, slot_clock: &S, log: &Logger) {
+    fn new(
+        ready_work_tx: Sender<ReadyWork>,
+        work_reprocessing_rx: Receiver<ReprocessQueueMessage>,
+        slot_clock: Arc<S>,
+    ) -> Self {
+        ReprocessQueue {
+            work_reprocessing_rx,
+            ready_work_tx,
+            gossip_block_delay_queue: DelayQueue::new(),
+            rpc_block_delay_queue: DelayQueue::new(),
+            attestations_delay_queue: DelayQueue::new(),
+            lc_updates_delay_queue: DelayQueue::new(),
+            queued_gossip_block_roots: HashSet::new(),
+            queued_lc_updates: FnvHashMap::default(),
+            queued_aggregates: FnvHashMap::default(),
+            queued_unaggregates: FnvHashMap::default(),
+            awaiting_attestations_per_root: HashMap::new(),
+            awaiting_lc_updates_per_parent_root: HashMap::new(),
+            queued_backfill_batches: Vec::new(),
+            next_attestation: 0,
+            next_lc_update: 0,
+            early_block_debounce: TimeLatch::default(),
+            rpc_block_debounce: TimeLatch::default(),
+            attestation_delay_debounce: TimeLatch::default(),
+            lc_update_delay_debounce: TimeLatch::default(),
+            next_backfill_batch_event: None,
+            slot_clock,
+        }
+    }
+
+    fn handle_message(&mut self, msg: InboundEvent, log: &Logger) {
         use ReprocessQueueMessage::*;
         match msg {
             // Some block has been indicated as "early" and should be processed when the
@@ -426,7 +435,7 @@ impl<S: SlotClock> ReprocessQueue<S> {
                     return;
                 }
 
-                if let Some(duration_till_slot) = slot_clock.duration_to_slot(block_slot) {
+                if let Some(duration_till_slot) = self.slot_clock.duration_to_slot(block_slot) {
                     // Check to ensure this won't over-fill the queue.
                     if self.queued_gossip_block_roots.len() >= MAXIMUM_QUEUED_BLOCKS {
                         if self.early_block_debounce.elapsed() {
@@ -459,7 +468,7 @@ impl<S: SlotClock> ReprocessQueue<S> {
                     // This logic is slightly awkward since `SlotClock::duration_to_slot`
                     // doesn't distinguish between a slot that has already arrived and an
                     // error reading the slot clock.
-                    if let Some(now) = slot_clock.now() {
+                    if let Some(now) = self.slot_clock.now() {
                         if block_slot <= now
                             && self
                                 .ready_work_tx
@@ -860,7 +869,8 @@ impl<S: SlotClock> ReprocessQueue<S> {
                 }
             }
             InboundEvent::ReadyBackfillSync(queued_backfill_batch) => {
-                let millis_from_slot_start = slot_clock
+                let millis_from_slot_start = self
+                    .slot_clock
                     .millis_from_current_slot_start()
                     .map_or("null".to_string(), |duration| {
                         duration.as_millis().to_string()
@@ -886,7 +896,12 @@ impl<S: SlotClock> ReprocessQueue<S> {
                             "Failed to send scheduled backfill work";
                             "info" => "sending work back to queue"
                         );
-                        self.queued_backfill_batches.insert(0, batch)
+                        self.queued_backfill_batches.insert(0, batch);
+
+                        // only recompute if there is no `next_backfill_batch_event` already scheduled
+                        if self.next_backfill_batch_event.is_none() {
+                            self.recompute_next_backfill_batch_event();
+                        }
                     }
                     // The message was not sent and we didn't get the correct
                     // return result. This is a logic error.
@@ -963,7 +978,11 @@ impl<S: SlotClock> ReprocessQueue<S> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use slot_clock::TestingSlotClock;
+    use logging::test_logger;
+    use slot_clock::{ManualSlotClock, TestingSlotClock};
+    use std::ops::Add;
+    use std::sync::Arc;
+    use task_executor::test_utils::TestRuntime;
 
     #[test]
     fn backfill_processing_schedule_calculation() {
@@ -1002,4 +1021,84 @@ mod tests {
             duration_to_next_slot + event_times[0]
         );
     }
+
+    // Regression test for issue #5504.
+    // See: https://github.com/sigp/lighthouse/issues/5504#issuecomment-2050930045
+    #[tokio::test]
+    async fn backfill_schedule_failed_should_reschedule() {
+        let runtime = TestRuntime::default();
+        let log = test_logger();
+        let (work_reprocessing_tx, work_reprocessing_rx) = mpsc::channel(1);
+        let (ready_work_tx, mut ready_work_rx) = mpsc::channel(1);
+        let slot_duration = 12;
+        let slot_clock = Arc::new(testing_slot_clock(slot_duration));
+
+        spawn_reprocess_scheduler(
+            ready_work_tx.clone(),
+            work_reprocessing_rx,
+            &runtime.task_executor,
+            slot_clock.clone(),
+            log,
+            Duration::from_millis(500),
+        )
+        .unwrap();
+
+        // Pause time so it only advances manually
+        tokio::time::pause();
+
+        // Send some random work to `ready_work_tx` to fill up the capacity first.
+        ready_work_tx
+            .try_send(ReadyWork::IgnoredRpcBlock(IgnoredRpcBlock {
+                process_fn: Box::new(|| {}),
+            }))
+            .unwrap();
+
+        // Now queue a backfill sync batch.
+        work_reprocessing_tx
+            .try_send(ReprocessQueueMessage::BackfillSync(QueuedBackfillBatch(
+                Box::pin(async {}),
+            )))
+            .unwrap();
+        tokio::task::yield_now().await;
+
+        // Advance the time by more than 1/2 the slot to trigger a scheduled backfill batch to be sent.
+        // This should fail as the `ready_work` channel is at capacity, and it should be rescheduled.
+        let duration_to_next_event =
+            ReprocessQueue::duration_until_next_backfill_batch_event(slot_clock.as_ref());
+        let one_ms = Duration::from_millis(1);
+        advance_time(&slot_clock, duration_to_next_event.add(one_ms)).await;
+
+        // Now drain the `ready_work` channel.
+        assert!(matches!(
+            ready_work_rx.try_recv(),
+            Ok(ReadyWork::IgnoredRpcBlock { .. })
+        ));
+        assert!(ready_work_rx.try_recv().is_err());
+
+        // Advance time again, and assert that the re-scheduled batch is successfully sent.
+        let duration_to_next_event =
+            ReprocessQueue::duration_until_next_backfill_batch_event(slot_clock.as_ref());
+        advance_time(&slot_clock, duration_to_next_event.add(one_ms)).await;
+        assert!(matches!(
+            ready_work_rx.try_recv(),
+            Ok(ReadyWork::BackfillSync { .. })
+        ));
+    }
+
+    /// Advances slot clock and test clock time by the same duration.
+    async fn advance_time(slot_clock: &ManualSlotClock, duration: Duration) {
+        slot_clock.advance_time(duration);
+        tokio::time::advance(duration).await;
+        // NOTE: The `tokio::time::advance` fn actually calls `yield_now()` after advancing the
+        // clock. Why do we need an extra `yield_now`?
+        tokio::task::yield_now().await;
+    }
+
+    fn testing_slot_clock(slot_duration: u64) -> ManualSlotClock {
+        TestingSlotClock::new(
+            Slot::new(0),
+            Duration::from_secs(0),
+            Duration::from_secs(slot_duration),
+        )
+    }
 }
diff --git a/beacon_node/client/Cargo.toml b/beacon_node/client/Cargo.toml
index 03cbcc9ff7f..16c4a947a66 100644
--- a/beacon_node/client/Cargo.toml
+++ b/beacon_node/client/Cargo.toml
@@ -46,3 +46,4 @@ execution_layer = { workspace = true }
 beacon_processor = { workspace = true }
 num_cpus = { workspace = true }
 ethereum_ssz = { workspace = true }
+tree_hash = { workspace = true }
diff --git a/beacon_node/client/src/builder.rs b/beacon_node/client/src/builder.rs
index 8ae4b9e2500..2af4e74c224 100644
--- a/beacon_node/client/src/builder.rs
+++ b/beacon_node/client/src/builder.rs
@@ -6,6 +6,7 @@ use crate::notifier::spawn_notifier;
 use crate::Client;
 use beacon_chain::attestation_simulator::start_attestation_simulator_service;
 use beacon_chain::data_availability_checker::start_availability_cache_maintenance_service;
+use beacon_chain::graffiti_calculator::start_engine_version_cache_refresh_service;
 use beacon_chain::otb_verification_service::start_otb_verification_service;
 use beacon_chain::proposer_prep_service::start_proposer_prep_service;
 use beacon_chain::schema_change::migrate_schema;
@@ -26,6 +27,7 @@ use eth2::{
     types::{BlockId, StateId},
     BeaconNodeHttpClient, Error as ApiError, Timeouts,
 };
+use execution_layer::test_utils::generate_genesis_header;
 use execution_layer::ExecutionLayer;
 use futures::channel::mpsc::Receiver;
 use genesis::{interop_genesis_state, Eth1GenesisService, DEFAULT_ETH1_BLOCK_HASH};
@@ -163,7 +165,7 @@ where
         let runtime_context = self.runtime_context.clone();
         let eth_spec_instance = self.eth_spec_instance.clone();
         let chain_config = config.chain.clone();
-        let graffiti = config.graffiti;
+        let beacon_graffiti = config.beacon_graffiti;
 
         let store = store.ok_or("beacon_chain_start_method requires a store")?;
         let runtime_context =
@@ -202,7 +204,7 @@ where
                 MigratorConfig::default().epochs_per_migration(chain_config.epochs_per_migration),
             )
             .chain_config(chain_config)
-            .graffiti(graffiti)
+            .beacon_graffiti(beacon_graffiti)
             .event_handler(event_handler)
             .execution_layer(execution_layer)
             .validator_monitor_config(config.validator_monitor.clone());
@@ -267,6 +269,21 @@ where
                 )?;
                 builder.genesis_state(genesis_state).map(|v| (v, None))?
             }
+            ClientGenesis::InteropMerge {
+                validator_count,
+                genesis_time,
+            } => {
+                let execution_payload_header = generate_genesis_header(&spec, true);
+                let keypairs = generate_deterministic_keypairs(validator_count);
+                let genesis_state = interop_genesis_state(
+                    &keypairs,
+                    genesis_time,
+                    Hash256::from_slice(DEFAULT_ETH1_BLOCK_HASH),
+                    execution_payload_header,
+                    &spec,
+                )?;
+                builder.genesis_state(genesis_state).map(|v| (v, None))?
+            }
             ClientGenesis::GenesisState => {
                 info!(
                     context.log(),
@@ -606,7 +623,12 @@ where
         };
 
         let beacon_chain_builder = if let Some(trusted_setup) = config.trusted_setup {
-            beacon_chain_builder.trusted_setup(trusted_setup)
+            let kzg = trusted_setup
+                .try_into()
+                .map(Arc::new)
+                .map(Some)
+                .map_err(|e| format!("Failed to load trusted setup: {:?}", e))?;
+            beacon_chain_builder.kzg(kzg)
         } else {
             beacon_chain_builder
         };
@@ -946,6 +968,10 @@ where
                 runtime_context.executor.clone(),
                 beacon_chain.clone(),
             );
+            start_engine_version_cache_refresh_service(
+                beacon_chain.as_ref(),
+                runtime_context.executor.clone(),
+            );
             start_attestation_simulator_service(
                 beacon_chain.task_executor.clone(),
                 beacon_chain.clone(),
diff --git a/beacon_node/client/src/config.rs b/beacon_node/client/src/config.rs
index 48ad77abc58..16000374b22 100644
--- a/beacon_node/client/src/config.rs
+++ b/beacon_node/client/src/config.rs
@@ -1,3 +1,4 @@
+use beacon_chain::graffiti_calculator::GraffitiOrigin;
 use beacon_chain::validator_monitor::ValidatorMonitorConfig;
 use beacon_chain::TrustedSetup;
 use beacon_processor::BeaconProcessorConfig;
@@ -9,7 +10,6 @@ use serde::{Deserialize, Serialize};
 use std::fs;
 use std::path::PathBuf;
 use std::time::Duration;
-use types::Graffiti;
 
 /// Default directory name for the freezer database under the top-level data dir.
 const DEFAULT_FREEZER_DB_DIR: &str = "freezer_db";
@@ -24,6 +24,11 @@ pub enum ClientGenesis {
         validator_count: usize,
         genesis_time: u64,
     },
+    // Creates a genesis state similar to the 2019 Canada specs, but starting post-Merge.
+    InteropMerge {
+        validator_count: usize,
+        genesis_time: u64,
+    },
     /// Reads the genesis state and other persisted data from the `Store`.
     FromStore,
     /// Connects to an eth1 node and waits until it can create the genesis state from the deposit
@@ -58,8 +63,8 @@ pub struct Config {
     /// This is the method used for the 2019 client interop in Canada.
     pub dummy_eth1_backend: bool,
     pub sync_eth1_chain: bool,
-    /// Graffiti to be inserted everytime we create a block.
-    pub graffiti: Graffiti,
+    /// Graffiti to be inserted everytime we create a block if the validator doesn't specify.
+    pub beacon_graffiti: GraffitiOrigin,
     pub validator_monitor: ValidatorMonitorConfig,
     #[serde(skip)]
     /// The `genesis` field is not serialized or deserialized by `serde` to ensure it is defined
@@ -99,7 +104,7 @@ impl Default for Config {
             eth1: <_>::default(),
             execution_layer: None,
             trusted_setup: None,
-            graffiti: Graffiti::default(),
+            beacon_graffiti: GraffitiOrigin::default(),
             http_api: <_>::default(),
             http_metrics: <_>::default(),
             monitoring_api: None,
diff --git a/beacon_node/client/src/notifier.rs b/beacon_node/client/src/notifier.rs
index 912babdae31..0a2f24748d0 100644
--- a/beacon_node/client/src/notifier.rs
+++ b/beacon_node/client/src/notifier.rs
@@ -1,9 +1,9 @@
 use crate::metrics;
 use beacon_chain::{
+    bellatrix_readiness::{BellatrixReadiness, GenesisExecutionPayloadStatus, MergeConfig},
     capella_readiness::CapellaReadiness,
     deneb_readiness::DenebReadiness,
     electra_readiness::ElectraReadiness,
-    merge_readiness::{GenesisExecutionPayloadStatus, MergeConfig, MergeReadiness},
     BeaconChain, BeaconChainTypes, ExecutionStatus,
 };
 use lighthouse_network::{types::SyncState, NetworkGlobals};
@@ -64,7 +64,7 @@ pub fn spawn_notifier<T: BeaconChainTypes>(
                         "wait_time" => estimated_time_pretty(Some(next_slot.as_secs() as f64)),
                     );
                     eth1_logging(&beacon_chain, &log);
-                    merge_readiness_logging(Slot::new(0), &beacon_chain, &log).await;
+                    bellatrix_readiness_logging(Slot::new(0), &beacon_chain, &log).await;
                     capella_readiness_logging(Slot::new(0), &beacon_chain, &log).await;
                     genesis_execution_payload_logging(&beacon_chain, &log).await;
                     sleep(slot_duration).await;
@@ -319,7 +319,7 @@ pub fn spawn_notifier<T: BeaconChainTypes>(
             }
 
             eth1_logging(&beacon_chain, &log);
-            merge_readiness_logging(current_slot, &beacon_chain, &log).await;
+            bellatrix_readiness_logging(current_slot, &beacon_chain, &log).await;
             capella_readiness_logging(current_slot, &beacon_chain, &log).await;
             deneb_readiness_logging(current_slot, &beacon_chain, &log).await;
             electra_readiness_logging(current_slot, &beacon_chain, &log).await;
@@ -334,7 +334,7 @@ pub fn spawn_notifier<T: BeaconChainTypes>(
 
 /// Provides some helpful logging to users to indicate if their node is ready for the Bellatrix
 /// fork and subsequent merge transition.
-async fn merge_readiness_logging<T: BeaconChainTypes>(
+async fn bellatrix_readiness_logging<T: BeaconChainTypes>(
     current_slot: Slot,
     beacon_chain: &BeaconChain<T>,
     log: &Logger,
@@ -372,8 +372,8 @@ async fn merge_readiness_logging<T: BeaconChainTypes>(
         return;
     }
 
-    match beacon_chain.check_merge_readiness(current_slot).await {
-        MergeReadiness::Ready {
+    match beacon_chain.check_bellatrix_readiness(current_slot).await {
+        BellatrixReadiness::Ready {
             config,
             current_difficulty,
         } => match config {
@@ -384,7 +384,7 @@ async fn merge_readiness_logging<T: BeaconChainTypes>(
             } => {
                 info!(
                     log,
-                    "Ready for the merge";
+                    "Ready for Bellatrix";
                     "terminal_total_difficulty" => %ttd,
                     "current_difficulty" => current_difficulty
                         .map(|d| d.to_string())
@@ -398,7 +398,7 @@ async fn merge_readiness_logging<T: BeaconChainTypes>(
             } => {
                 info!(
                     log,
-                    "Ready for the merge";
+                    "Ready for Bellatrix";
                     "info" => "you are using override parameters, please ensure that you \
                         understand these parameters and their implications.",
                     "terminal_block_hash" => ?terminal_block_hash,
@@ -411,14 +411,14 @@ async fn merge_readiness_logging<T: BeaconChainTypes>(
                 "config" => ?other
             ),
         },
-        readiness @ MergeReadiness::NotSynced => warn!(
+        readiness @ BellatrixReadiness::NotSynced => warn!(
             log,
-            "Not ready for merge";
+            "Not ready Bellatrix";
             "info" => %readiness,
         ),
-        readiness @ MergeReadiness::NoExecutionEndpoint => warn!(
+        readiness @ BellatrixReadiness::NoExecutionEndpoint => warn!(
             log,
-            "Not ready for merge";
+            "Not ready for Bellatrix";
             "info" => %readiness,
         ),
     }
@@ -434,11 +434,9 @@ async fn capella_readiness_logging<T: BeaconChainTypes>(
         .canonical_head
         .cached_head()
         .snapshot
-        .beacon_block
-        .message()
-        .body()
-        .execution_payload()
-        .map_or(false, |payload| payload.withdrawals_root().is_ok());
+        .beacon_state
+        .fork_name_unchecked()
+        >= ForkName::Capella;
 
     let has_execution_layer = beacon_chain.execution_layer.is_some();
 
@@ -496,11 +494,9 @@ async fn deneb_readiness_logging<T: BeaconChainTypes>(
         .canonical_head
         .cached_head()
         .snapshot
-        .beacon_block
-        .message()
-        .body()
-        .execution_payload()
-        .map_or(false, |payload| payload.blob_gas_used().is_ok());
+        .beacon_state
+        .fork_name_unchecked()
+        >= ForkName::Deneb;
 
     let has_execution_layer = beacon_chain.execution_layer.is_some();
 
@@ -549,17 +545,13 @@ async fn electra_readiness_logging<T: BeaconChainTypes>(
     beacon_chain: &BeaconChain<T>,
     log: &Logger,
 ) {
-    // TODO(electra): Once Electra has features, this code can be swapped back.
-    let electra_completed = false;
-    //let electra_completed = beacon_chain
-    //    .canonical_head
-    //    .cached_head()
-    //    .snapshot
-    //    .beacon_block
-    //    .message()
-    //    .body()
-    //    .execution_payload()
-    //    .map_or(false, |payload| payload.electra_placeholder().is_ok());
+    let electra_completed = beacon_chain
+        .canonical_head
+        .cached_head()
+        .snapshot
+        .beacon_state
+        .fork_name_unchecked()
+        >= ForkName::Electra;
 
     let has_execution_layer = beacon_chain.execution_layer.is_some();
 
diff --git a/beacon_node/execution_layer/Cargo.toml b/beacon_node/execution_layer/Cargo.toml
index ace8e24a8e4..28cd16e4ef9 100644
--- a/beacon_node/execution_layer/Cargo.toml
+++ b/beacon_node/execution_layer/Cargo.toml
@@ -52,3 +52,4 @@ arc-swap = "1.6.0"
 eth2_network_config = { workspace = true }
 alloy-rlp = "0.3"
 alloy-consensus = { git = "https://github.com/alloy-rs/alloy.git", rev = "974d488bab5e21e9f17452a39a4bfa56677367b2" }
+lighthouse_version = { workspace = true }
diff --git a/beacon_node/execution_layer/src/block_hash.rs b/beacon_node/execution_layer/src/block_hash.rs
index 1f8c29f6b25..0d0cfaf352c 100644
--- a/beacon_node/execution_layer/src/block_hash.rs
+++ b/beacon_node/execution_layer/src/block_hash.rs
@@ -146,7 +146,7 @@ mod test {
     }
 
     #[test]
-    fn test_rlp_encode_merge_block() {
+    fn test_rlp_encode_bellatrix_block() {
         let header = ExecutionBlockHeader {
             parent_hash: Hash256::from_str("927ca537f06c783a3a2635b8805eef1c8c2124f7444ad4a3389898dd832f2dbe").unwrap(),
             ommers_hash: Hash256::from_str("1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347").unwrap(),
diff --git a/beacon_node/execution_layer/src/engine_api.rs b/beacon_node/execution_layer/src/engine_api.rs
index a91f5d6a442..ce1e0fec5dd 100644
--- a/beacon_node/execution_layer/src/engine_api.rs
+++ b/beacon_node/execution_layer/src/engine_api.rs
@@ -1,9 +1,9 @@
 use crate::engines::ForkchoiceState;
 use crate::http::{
     ENGINE_FORKCHOICE_UPDATED_V1, ENGINE_FORKCHOICE_UPDATED_V2, ENGINE_FORKCHOICE_UPDATED_V3,
-    ENGINE_GET_PAYLOAD_BODIES_BY_HASH_V1, ENGINE_GET_PAYLOAD_BODIES_BY_RANGE_V1,
-    ENGINE_GET_PAYLOAD_V1, ENGINE_GET_PAYLOAD_V2, ENGINE_GET_PAYLOAD_V3, ENGINE_NEW_PAYLOAD_V1,
-    ENGINE_NEW_PAYLOAD_V2, ENGINE_NEW_PAYLOAD_V3,
+    ENGINE_GET_CLIENT_VERSION_V1, ENGINE_GET_PAYLOAD_BODIES_BY_HASH_V1,
+    ENGINE_GET_PAYLOAD_BODIES_BY_RANGE_V1, ENGINE_GET_PAYLOAD_V1, ENGINE_GET_PAYLOAD_V2,
+    ENGINE_GET_PAYLOAD_V3, ENGINE_NEW_PAYLOAD_V1, ENGINE_NEW_PAYLOAD_V2, ENGINE_NEW_PAYLOAD_V3,
 };
 use eth2::types::{
     BlobsBundle, SsePayloadAttributes, SsePayloadAttributesV1, SsePayloadAttributesV2,
@@ -24,11 +24,11 @@ pub use types::{
     ExecutionPayloadRef, FixedVector, ForkName, Hash256, Transactions, Uint256, VariableList,
     Withdrawal, Withdrawals,
 };
-
 use types::{
-    ExecutionPayloadCapella, ExecutionPayloadDeneb, ExecutionPayloadElectra, ExecutionPayloadMerge,
-    KzgProofs,
+    ExecutionPayloadBellatrix, ExecutionPayloadCapella, ExecutionPayloadDeneb,
+    ExecutionPayloadElectra, KzgProofs,
 };
+use types::{Graffiti, GRAFFITI_BYTES_LEN};
 
 pub mod auth;
 pub mod http;
@@ -36,8 +36,8 @@ pub mod json_structures;
 mod new_payload_request;
 
 pub use new_payload_request::{
-    NewPayloadRequest, NewPayloadRequestCapella, NewPayloadRequestDeneb, NewPayloadRequestElectra,
-    NewPayloadRequestMerge,
+    NewPayloadRequest, NewPayloadRequestBellatrix, NewPayloadRequestCapella,
+    NewPayloadRequestDeneb, NewPayloadRequestElectra,
 };
 
 pub const LATEST_TAG: &str = "latest";
@@ -61,13 +61,13 @@ pub enum Error {
     ParentHashEqualsBlockHash(ExecutionBlockHash),
     PayloadIdUnavailable,
     TransitionConfigurationMismatch,
-    PayloadConversionLogicFlaw,
     SszError(ssz_types::Error),
     DeserializeWithdrawals(ssz_types::Error),
     BuilderApi(builder_client::Error),
     IncorrectStateVariant,
     RequiredMethodUnsupported(&'static str),
     UnsupportedForkVariant(String),
+    InvalidClientVersion(String),
     RlpDecoderError(rlp::DecoderError),
 }
 
@@ -155,7 +155,7 @@ pub struct ExecutionBlock {
 
 /// Representation of an execution block with enough detail to reconstruct a payload.
 #[superstruct(
-    variants(Merge, Capella, Deneb, Electra),
+    variants(Bellatrix, Capella, Deneb, Electra),
     variant_attributes(
         derive(Clone, Debug, PartialEq, Serialize, Deserialize,),
         serde(bound = "E: EthSpec", rename_all = "camelCase"),
@@ -204,26 +204,28 @@ impl<E: EthSpec> TryFrom<ExecutionPayload<E>> for ExecutionBlockWithTransactions
 
     fn try_from(payload: ExecutionPayload<E>) -> Result<Self, Error> {
         let json_payload = match payload {
-            ExecutionPayload::Merge(block) => Self::Merge(ExecutionBlockWithTransactionsMerge {
-                parent_hash: block.parent_hash,
-                fee_recipient: block.fee_recipient,
-                state_root: block.state_root,
-                receipts_root: block.receipts_root,
-                logs_bloom: block.logs_bloom,
-                prev_randao: block.prev_randao,
-                block_number: block.block_number,
-                gas_limit: block.gas_limit,
-                gas_used: block.gas_used,
-                timestamp: block.timestamp,
-                extra_data: block.extra_data,
-                base_fee_per_gas: block.base_fee_per_gas,
-                block_hash: block.block_hash,
-                transactions: block
-                    .transactions
-                    .iter()
-                    .map(|tx| Transaction::decode(&Rlp::new(tx)))
-                    .collect::<Result<Vec<_>, _>>()?,
-            }),
+            ExecutionPayload::Bellatrix(block) => {
+                Self::Bellatrix(ExecutionBlockWithTransactionsBellatrix {
+                    parent_hash: block.parent_hash,
+                    fee_recipient: block.fee_recipient,
+                    state_root: block.state_root,
+                    receipts_root: block.receipts_root,
+                    logs_bloom: block.logs_bloom,
+                    prev_randao: block.prev_randao,
+                    block_number: block.block_number,
+                    gas_limit: block.gas_limit,
+                    gas_used: block.gas_used,
+                    timestamp: block.timestamp,
+                    extra_data: block.extra_data,
+                    base_fee_per_gas: block.base_fee_per_gas,
+                    block_hash: block.block_hash,
+                    transactions: block
+                        .transactions
+                        .iter()
+                        .map(|tx| Transaction::decode(&Rlp::new(tx)))
+                        .collect::<Result<Vec<_>, _>>()?,
+                })
+            }
             ExecutionPayload::Capella(block) => {
                 Self::Capella(ExecutionBlockWithTransactionsCapella {
                     parent_hash: block.parent_hash,
@@ -423,7 +425,7 @@ pub struct ProposeBlindedBlockResponse {
 }
 
 #[superstruct(
-    variants(Merge, Capella, Deneb, Electra),
+    variants(Bellatrix, Capella, Deneb, Electra),
     variant_attributes(derive(Clone, Debug, PartialEq),),
     map_into(ExecutionPayload),
     map_ref_into(ExecutionPayloadRef),
@@ -432,8 +434,11 @@ pub struct ProposeBlindedBlockResponse {
 )]
 #[derive(Clone, Debug, PartialEq)]
 pub struct GetPayloadResponse<E: EthSpec> {
-    #[superstruct(only(Merge), partial_getter(rename = "execution_payload_merge"))]
-    pub execution_payload: ExecutionPayloadMerge<E>,
+    #[superstruct(
+        only(Bellatrix),
+        partial_getter(rename = "execution_payload_bellatrix")
+    )]
+    pub execution_payload: ExecutionPayloadBellatrix<E>,
     #[superstruct(only(Capella), partial_getter(rename = "execution_payload_capella"))]
     pub execution_payload: ExecutionPayloadCapella<E>,
     #[superstruct(only(Deneb), partial_getter(rename = "execution_payload_deneb"))]
@@ -482,8 +487,8 @@ impl<E: EthSpec> From<GetPayloadResponse<E>>
 {
     fn from(response: GetPayloadResponse<E>) -> Self {
         match response {
-            GetPayloadResponse::Merge(inner) => (
-                ExecutionPayload::Merge(inner.execution_payload),
+            GetPayloadResponse::Bellatrix(inner) => (
+                ExecutionPayload::Bellatrix(inner.execution_payload),
                 inner.block_value,
                 None,
             ),
@@ -529,14 +534,14 @@ impl<E: EthSpec> ExecutionPayloadBodyV1<E> {
         header: ExecutionPayloadHeader<E>,
     ) -> Result<ExecutionPayload<E>, String> {
         match header {
-            ExecutionPayloadHeader::Merge(header) => {
+            ExecutionPayloadHeader::Bellatrix(header) => {
                 if self.withdrawals.is_some() {
                     return Err(format!(
                         "block {} is merge but payload body has withdrawals",
                         header.block_hash
                     ));
                 }
-                Ok(ExecutionPayload::Merge(ExecutionPayloadMerge {
+                Ok(ExecutionPayload::Bellatrix(ExecutionPayloadBellatrix {
                     parent_hash: header.parent_hash,
                     fee_recipient: header.fee_recipient,
                     state_root: header.state_root,
@@ -627,6 +632,9 @@ impl<E: EthSpec> ExecutionPayloadBodyV1<E> {
                         withdrawals,
                         blob_gas_used: header.blob_gas_used,
                         excess_blob_gas: header.excess_blob_gas,
+                        // TODO(electra)
+                        deposit_receipts: <_>::default(),
+                        withdrawal_requests: <_>::default(),
                     }))
                 } else {
                     Err(format!(
@@ -652,6 +660,7 @@ pub struct EngineCapabilities {
     pub get_payload_v1: bool,
     pub get_payload_v2: bool,
     pub get_payload_v3: bool,
+    pub get_client_version_v1: bool,
 }
 
 impl EngineCapabilities {
@@ -690,7 +699,141 @@ impl EngineCapabilities {
         if self.get_payload_v3 {
             response.push(ENGINE_GET_PAYLOAD_V3);
         }
+        if self.get_client_version_v1 {
+            response.push(ENGINE_GET_CLIENT_VERSION_V1);
+        }
 
         response
     }
 }
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum ClientCode {
+    Besu,
+    EtherumJS,
+    Erigon,
+    GoEthereum,
+    Grandine,
+    Lighthouse,
+    Lodestar,
+    Nethermind,
+    Nimbus,
+    Teku,
+    Prysm,
+    Reth,
+    Unknown(String),
+}
+
+impl std::fmt::Display for ClientCode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let s = match self {
+            ClientCode::Besu => "BU",
+            ClientCode::EtherumJS => "EJ",
+            ClientCode::Erigon => "EG",
+            ClientCode::GoEthereum => "GE",
+            ClientCode::Grandine => "GR",
+            ClientCode::Lighthouse => "LH",
+            ClientCode::Lodestar => "LS",
+            ClientCode::Nethermind => "NM",
+            ClientCode::Nimbus => "NB",
+            ClientCode::Teku => "TK",
+            ClientCode::Prysm => "PM",
+            ClientCode::Reth => "RH",
+            ClientCode::Unknown(code) => code,
+        };
+        write!(f, "{}", s)
+    }
+}
+
+impl TryFrom<String> for ClientCode {
+    type Error = String;
+
+    fn try_from(code: String) -> Result<Self, Self::Error> {
+        match code.as_str() {
+            "BU" => Ok(Self::Besu),
+            "EJ" => Ok(Self::EtherumJS),
+            "EG" => Ok(Self::Erigon),
+            "GE" => Ok(Self::GoEthereum),
+            "GR" => Ok(Self::Grandine),
+            "LH" => Ok(Self::Lighthouse),
+            "LS" => Ok(Self::Lodestar),
+            "NM" => Ok(Self::Nethermind),
+            "NB" => Ok(Self::Nimbus),
+            "TK" => Ok(Self::Teku),
+            "PM" => Ok(Self::Prysm),
+            "RH" => Ok(Self::Reth),
+            string => {
+                if string.len() == 2 {
+                    Ok(Self::Unknown(code))
+                } else {
+                    Err(format!("Invalid client code: {}", code))
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct CommitPrefix(pub String);
+
+impl TryFrom<String> for CommitPrefix {
+    type Error = String;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        // Check if the input starts with '0x' and strip it if it does
+        let commit_prefix = value.strip_prefix("0x").unwrap_or(&value);
+
+        // Ensure length is exactly 8 characters after '0x' removal
+        if commit_prefix.len() != 8 {
+            return Err(
+                "Input must be exactly 8 characters long (excluding any '0x' prefix)".to_string(),
+            );
+        }
+
+        // Ensure all characters are valid hex digits
+        if commit_prefix.chars().all(|c| c.is_ascii_hexdigit()) {
+            Ok(CommitPrefix(commit_prefix.to_lowercase()))
+        } else {
+            Err("Input must contain only hexadecimal characters".to_string())
+        }
+    }
+}
+
+impl std::fmt::Display for CommitPrefix {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ClientVersionV1 {
+    pub code: ClientCode,
+    pub name: String,
+    pub version: String,
+    pub commit: CommitPrefix,
+}
+
+impl ClientVersionV1 {
+    pub fn calculate_graffiti(&self, lighthouse_commit_prefix: CommitPrefix) -> Graffiti {
+        let graffiti_string = format!(
+            "{}{}LH{}",
+            self.code,
+            self.commit
+                .0
+                .get(..4)
+                .map_or_else(|| self.commit.0.as_str(), |s| s)
+                .to_lowercase(),
+            lighthouse_commit_prefix
+                .0
+                .get(..4)
+                .unwrap_or("0000")
+                .to_lowercase(),
+        );
+        let mut graffiti_bytes = [0u8; GRAFFITI_BYTES_LEN];
+        let bytes_to_copy = std::cmp::min(graffiti_string.len(), GRAFFITI_BYTES_LEN);
+        graffiti_bytes[..bytes_to_copy]
+            .copy_from_slice(&graffiti_string.as_bytes()[..bytes_to_copy]);
+
+        Graffiti::from(graffiti_bytes)
+    }
+}
diff --git a/beacon_node/execution_layer/src/engine_api/http.rs b/beacon_node/execution_layer/src/engine_api/http.rs
index ebd6ebeba2a..93705a16925 100644
--- a/beacon_node/execution_layer/src/engine_api/http.rs
+++ b/beacon_node/execution_layer/src/engine_api/http.rs
@@ -3,6 +3,8 @@
 use super::*;
 use crate::auth::Auth;
 use crate::json_structures::*;
+use lazy_static::lazy_static;
+use lighthouse_version::{COMMIT_PREFIX, VERSION};
 use reqwest::header::CONTENT_TYPE;
 use sensitive_url::SensitiveUrl;
 use serde::de::DeserializeOwned;
@@ -51,6 +53,9 @@ pub const ENGINE_GET_PAYLOAD_BODIES_TIMEOUT: Duration = Duration::from_secs(10);
 pub const ENGINE_EXCHANGE_CAPABILITIES: &str = "engine_exchangeCapabilities";
 pub const ENGINE_EXCHANGE_CAPABILITIES_TIMEOUT: Duration = Duration::from_secs(1);
 
+pub const ENGINE_GET_CLIENT_VERSION_V1: &str = "engine_getClientVersionV1";
+pub const ENGINE_GET_CLIENT_VERSION_TIMEOUT: Duration = Duration::from_secs(1);
+
 /// This error is returned during a `chainId` call by Geth.
 pub const EIP155_ERROR_STR: &str = "chain not synced beyond EIP-155 replay-protection fork block";
 /// This code is returned by all clients when a method is not supported
@@ -69,8 +74,22 @@ pub static LIGHTHOUSE_CAPABILITIES: &[&str] = &[
     ENGINE_FORKCHOICE_UPDATED_V3,
     ENGINE_GET_PAYLOAD_BODIES_BY_HASH_V1,
     ENGINE_GET_PAYLOAD_BODIES_BY_RANGE_V1,
+    ENGINE_GET_CLIENT_VERSION_V1,
 ];
 
+lazy_static! {
+    /// We opt to initialize the JsonClientVersionV1 rather than the ClientVersionV1
+    /// for two reasons:
+    /// 1. This saves the overhead of converting into Json for every engine call
+    /// 2. The Json version lacks error checking so we can avoid calling `unwrap()`
+    pub static ref LIGHTHOUSE_JSON_CLIENT_VERSION: JsonClientVersionV1 = JsonClientVersionV1 {
+        code: ClientCode::Lighthouse.to_string(),
+        name: "Lighthouse".to_string(),
+        version: VERSION.replace("Lighthouse/", ""),
+        commit: COMMIT_PREFIX.to_string(),
+    };
+}
+
 /// Contains methods to convert arbitrary bytes to an ETH2 deposit contract object.
 pub mod deposit_log {
     use ssz::Decode;
@@ -546,22 +565,21 @@ pub mod deposit_methods {
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct CapabilitiesCacheEntry {
-    engine_capabilities: EngineCapabilities,
-    fetch_time: Instant,
+pub struct CachedResponse<T: Clone> {
+    pub data: T,
+    pub fetch_time: Instant,
 }
 
-impl CapabilitiesCacheEntry {
-    pub fn new(engine_capabilities: EngineCapabilities) -> Self {
+impl<T: Clone> CachedResponse<T> {
+    pub fn new(data: T) -> Self {
         Self {
-            engine_capabilities,
+            data,
             fetch_time: Instant::now(),
         }
     }
 
-    pub fn engine_capabilities(&self) -> EngineCapabilities {
-        self.engine_capabilities
+    pub fn data(&self) -> T {
+        self.data.clone()
     }
 
     pub fn age(&self) -> Duration {
@@ -578,7 +596,8 @@ pub struct HttpJsonRpc {
     pub client: Client,
     pub url: SensitiveUrl,
     pub execution_timeout_multiplier: u32,
-    pub engine_capabilities_cache: Mutex<Option<CapabilitiesCacheEntry>>,
+    pub engine_capabilities_cache: Mutex<Option<CachedResponse<EngineCapabilities>>>,
+    pub engine_version_cache: Mutex<Option<CachedResponse<Vec<ClientVersionV1>>>>,
     auth: Option<Auth>,
 }
 
@@ -592,6 +611,7 @@ impl HttpJsonRpc {
             url,
             execution_timeout_multiplier: execution_timeout_multiplier.unwrap_or(1),
             engine_capabilities_cache: Mutex::new(None),
+            engine_version_cache: Mutex::new(None),
             auth: None,
         })
     }
@@ -606,6 +626,7 @@ impl HttpJsonRpc {
             url,
             execution_timeout_multiplier: execution_timeout_multiplier.unwrap_or(1),
             engine_capabilities_cache: Mutex::new(None),
+            engine_version_cache: Mutex::new(None),
             auth: Some(auth),
         })
     }
@@ -716,7 +737,7 @@ impl HttpJsonRpc {
     ) -> Result<Option<ExecutionBlockWithTransactions<E>>, Error> {
         let params = json!([block_hash, true]);
         Ok(Some(match fork {
-            ForkName::Merge => ExecutionBlockWithTransactions::Merge(
+            ForkName::Bellatrix => ExecutionBlockWithTransactions::Bellatrix(
                 self.rpc_request(
                     ETH_GET_BLOCK_BY_HASH,
                     params,
@@ -847,7 +868,7 @@ impl HttpJsonRpc {
             )
             .await?;
 
-        Ok(GetPayloadResponse::Merge(GetPayloadResponseMerge {
+        Ok(GetPayloadResponse::Bellatrix(GetPayloadResponseBellatrix {
             execution_payload: payload_v1.into(),
             // Set the V1 payload values from the EE to be zero. This simulates
             // the pre-block-value functionality of always choosing the builder
@@ -864,7 +885,7 @@ impl HttpJsonRpc {
         let params = json!([JsonPayloadIdRequest::from(payload_id)]);
 
         match fork_name {
-            ForkName::Merge => {
+            ForkName::Bellatrix => {
                 let response: JsonGetPayloadResponseV1<E> = self
                     .rpc_request(
                         ENGINE_GET_PAYLOAD_V2,
@@ -918,7 +939,7 @@ impl HttpJsonRpc {
                     .await?;
                 Ok(JsonGetPayloadResponse::V4(response).into())
             }
-            ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => Err(
+            ForkName::Base | ForkName::Altair | ForkName::Bellatrix | ForkName::Capella => Err(
                 Error::UnsupportedForkVariant(format!("called get_payload_v3 with {}", fork_name)),
             ),
         }
@@ -1056,6 +1077,7 @@ impl HttpJsonRpc {
             get_payload_v1: capabilities.contains(ENGINE_GET_PAYLOAD_V1),
             get_payload_v2: capabilities.contains(ENGINE_GET_PAYLOAD_V2),
             get_payload_v3: capabilities.contains(ENGINE_GET_PAYLOAD_V3),
+            get_client_version_v1: capabilities.contains(ENGINE_GET_CLIENT_VERSION_V1),
         })
     }
 
@@ -1078,15 +1100,78 @@ impl HttpJsonRpc {
     ) -> Result<EngineCapabilities, Error> {
         let mut lock = self.engine_capabilities_cache.lock().await;
 
-        if let Some(lock) = lock.as_ref().filter(|entry| !entry.older_than(age_limit)) {
-            Ok(lock.engine_capabilities())
+        if let Some(lock) = lock
+            .as_ref()
+            .filter(|cached_response| !cached_response.older_than(age_limit))
+        {
+            Ok(lock.data())
         } else {
             let engine_capabilities = self.exchange_capabilities().await?;
-            *lock = Some(CapabilitiesCacheEntry::new(engine_capabilities));
+            *lock = Some(CachedResponse::new(engine_capabilities));
             Ok(engine_capabilities)
         }
     }
 
+    /// This method fetches the response from the engine without checking
+    /// any caches or storing the result in the cache. It is better to use
+    /// `get_engine_version(Some(Duration::ZERO))` if you want to force
+    /// fetching from the EE as this will cache the result.
+    pub async fn get_client_version_v1(&self) -> Result<Vec<ClientVersionV1>, Error> {
+        let params = json!([*LIGHTHOUSE_JSON_CLIENT_VERSION]);
+
+        let response: Vec<JsonClientVersionV1> = self
+            .rpc_request(
+                ENGINE_GET_CLIENT_VERSION_V1,
+                params,
+                ENGINE_GET_CLIENT_VERSION_TIMEOUT * self.execution_timeout_multiplier,
+            )
+            .await?;
+
+        response
+            .into_iter()
+            .map(TryInto::try_into)
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(Error::InvalidClientVersion)
+    }
+
+    pub async fn clear_engine_version_cache(&self) {
+        *self.engine_version_cache.lock().await = None;
+    }
+
+    /// Returns the execution engine version resulting from a call to
+    /// engine_getClientVersionV1. If the version cache is not populated, or if it
+    /// is populated with a cached result of age >= `age_limit`, this method will
+    /// fetch the result from the execution engine and populate the cache before
+    /// returning it. Otherwise it will return the cached result from an earlier
+    /// call.
+    ///
+    /// Set `age_limit` to `None` to always return the cached result
+    /// Set `age_limit` to `Some(Duration::ZERO)` to force fetching from EE
+    pub async fn get_engine_version(
+        &self,
+        age_limit: Option<Duration>,
+    ) -> Result<Vec<ClientVersionV1>, Error> {
+        // check engine capabilities first (avoids holding two locks at once)
+        let engine_capabilities = self.get_engine_capabilities(None).await?;
+        if !engine_capabilities.get_client_version_v1 {
+            // We choose an empty vec to denote that this method is not
+            // supported instead of an error since this method is optional
+            // & we don't want to log a warning and concern the user
+            return Ok(vec![]);
+        }
+        let mut lock = self.engine_version_cache.lock().await;
+        if let Some(lock) = lock
+            .as_ref()
+            .filter(|cached_response| !cached_response.older_than(age_limit))
+        {
+            Ok(lock.data())
+        } else {
+            let engine_version = self.get_client_version_v1().await?;
+            *lock = Some(CachedResponse::new(engine_version.clone()));
+            Ok(engine_version)
+        }
+    }
+
     // automatically selects the latest version of
     // new_payload that the execution engine supports
     pub async fn new_payload<E: EthSpec>(
@@ -1095,7 +1180,7 @@ impl HttpJsonRpc {
     ) -> Result<PayloadStatusV1, Error> {
         let engine_capabilities = self.get_engine_capabilities(None).await?;
         match new_payload_request {
-            NewPayloadRequest::Merge(_) | NewPayloadRequest::Capella(_) => {
+            NewPayloadRequest::Bellatrix(_) | NewPayloadRequest::Capella(_) => {
                 if engine_capabilities.new_payload_v2 {
                     self.new_payload_v2(new_payload_request.into_execution_payload())
                         .await
@@ -1133,7 +1218,7 @@ impl HttpJsonRpc {
     ) -> Result<GetPayloadResponse<E>, Error> {
         let engine_capabilities = self.get_engine_capabilities(None).await?;
         match fork_name {
-            ForkName::Merge | ForkName::Capella => {
+            ForkName::Bellatrix | ForkName::Capella => {
                 if engine_capabilities.get_payload_v2 {
                     self.get_payload_v2(fork_name, payload_id).await
                 } else if engine_capabilities.new_payload_v1 {
@@ -1574,8 +1659,8 @@ mod test {
             .assert_request_equals(
                 |client| async move {
                     let _ = client
-                        .new_payload_v1::<MainnetEthSpec>(ExecutionPayload::Merge(
-                            ExecutionPayloadMerge {
+                        .new_payload_v1::<MainnetEthSpec>(ExecutionPayload::Bellatrix(
+                            ExecutionPayloadBellatrix {
                                 parent_hash: ExecutionBlockHash::repeat_byte(0),
                                 fee_recipient: Address::repeat_byte(1),
                                 state_root: Hash256::repeat_byte(1),
@@ -1621,8 +1706,8 @@ mod test {
         Tester::new(false)
             .assert_auth_failure(|client| async move {
                 client
-                    .new_payload_v1::<MainnetEthSpec>(ExecutionPayload::Merge(
-                        ExecutionPayloadMerge {
+                    .new_payload_v1::<MainnetEthSpec>(ExecutionPayload::Bellatrix(
+                        ExecutionPayloadBellatrix {
                             parent_hash: ExecutionBlockHash::repeat_byte(0),
                             fee_recipient: Address::repeat_byte(1),
                             state_root: Hash256::repeat_byte(1),
@@ -1832,7 +1917,7 @@ mod test {
                         .unwrap()
                         .into();
 
-                    let expected = ExecutionPayload::Merge(ExecutionPayloadMerge {
+                    let expected = ExecutionPayload::Bellatrix(ExecutionPayloadBellatrix {
                             parent_hash: ExecutionBlockHash::from_str("0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a").unwrap(),
                             fee_recipient: Address::from_str("0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b").unwrap(),
                             state_root: Hash256::from_str("0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45").unwrap(),
@@ -1857,7 +1942,7 @@ mod test {
                 // engine_newPayloadV1 REQUEST validation
                 |client| async move {
                     let _ = client
-                        .new_payload_v1::<MainnetEthSpec>(ExecutionPayload::Merge(ExecutionPayloadMerge{
+                        .new_payload_v1::<MainnetEthSpec>(ExecutionPayload::Bellatrix(ExecutionPayloadBellatrix{
                             parent_hash: ExecutionBlockHash::from_str("0x3b8fb240d288781d4aac94d3fd16809ee413bc99294a085798a589dae51ddd4a").unwrap(),
                             fee_recipient: Address::from_str("0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b").unwrap(),
                             state_root: Hash256::from_str("0xca3149fa9e37db08d1cd49c9061db1002ef1cd58db2210f2115c8c989b2bdf45").unwrap(),
@@ -1911,7 +1996,7 @@ mod test {
                 })],
                 |client| async move {
                     let response = client
-                        .new_payload_v1::<MainnetEthSpec>(ExecutionPayload::Merge(ExecutionPayloadMerge::default()))
+                        .new_payload_v1::<MainnetEthSpec>(ExecutionPayload::Bellatrix(ExecutionPayloadBellatrix::default()))
                         .await
                         .unwrap();
 
diff --git a/beacon_node/execution_layer/src/engine_api/json_structures.rs b/beacon_node/execution_layer/src/engine_api/json_structures.rs
index 9f2387ae314..50d3519e129 100644
--- a/beacon_node/execution_layer/src/engine_api/json_structures.rs
+++ b/beacon_node/execution_layer/src/engine_api/json_structures.rs
@@ -103,8 +103,8 @@ pub struct JsonExecutionPayload<E: EthSpec> {
     pub excess_blob_gas: u64,
 }
 
-impl<E: EthSpec> From<ExecutionPayloadMerge<E>> for JsonExecutionPayloadV1<E> {
-    fn from(payload: ExecutionPayloadMerge<E>) -> Self {
+impl<E: EthSpec> From<ExecutionPayloadBellatrix<E>> for JsonExecutionPayloadV1<E> {
+    fn from(payload: ExecutionPayloadBellatrix<E>) -> Self {
         JsonExecutionPayloadV1 {
             parent_hash: payload.parent_hash,
             fee_recipient: payload.fee_recipient,
@@ -210,7 +210,7 @@ impl<E: EthSpec> From<ExecutionPayloadElectra<E>> for JsonExecutionPayloadV4<E>
 impl<E: EthSpec> From<ExecutionPayload<E>> for JsonExecutionPayload<E> {
     fn from(execution_payload: ExecutionPayload<E>) -> Self {
         match execution_payload {
-            ExecutionPayload::Merge(payload) => JsonExecutionPayload::V1(payload.into()),
+            ExecutionPayload::Bellatrix(payload) => JsonExecutionPayload::V1(payload.into()),
             ExecutionPayload::Capella(payload) => JsonExecutionPayload::V2(payload.into()),
             ExecutionPayload::Deneb(payload) => JsonExecutionPayload::V3(payload.into()),
             ExecutionPayload::Electra(payload) => JsonExecutionPayload::V4(payload.into()),
@@ -218,9 +218,9 @@ impl<E: EthSpec> From<ExecutionPayload<E>> for JsonExecutionPayload<E> {
     }
 }
 
-impl<E: EthSpec> From<JsonExecutionPayloadV1<E>> for ExecutionPayloadMerge<E> {
+impl<E: EthSpec> From<JsonExecutionPayloadV1<E>> for ExecutionPayloadBellatrix<E> {
     fn from(payload: JsonExecutionPayloadV1<E>) -> Self {
-        ExecutionPayloadMerge {
+        ExecutionPayloadBellatrix {
             parent_hash: payload.parent_hash,
             fee_recipient: payload.fee_recipient,
             state_root: payload.state_root,
@@ -319,6 +319,9 @@ impl<E: EthSpec> From<JsonExecutionPayloadV4<E>> for ExecutionPayloadElectra<E>
                 .into(),
             blob_gas_used: payload.blob_gas_used,
             excess_blob_gas: payload.excess_blob_gas,
+            // TODO(electra)
+            deposit_receipts: Default::default(),
+            withdrawal_requests: Default::default(),
         }
     }
 }
@@ -326,7 +329,7 @@ impl<E: EthSpec> From<JsonExecutionPayloadV4<E>> for ExecutionPayloadElectra<E>
 impl<E: EthSpec> From<JsonExecutionPayload<E>> for ExecutionPayload<E> {
     fn from(json_execution_payload: JsonExecutionPayload<E>) -> Self {
         match json_execution_payload {
-            JsonExecutionPayload::V1(payload) => ExecutionPayload::Merge(payload.into()),
+            JsonExecutionPayload::V1(payload) => ExecutionPayload::Bellatrix(payload.into()),
             JsonExecutionPayload::V2(payload) => ExecutionPayload::Capella(payload.into()),
             JsonExecutionPayload::V3(payload) => ExecutionPayload::Deneb(payload.into()),
             JsonExecutionPayload::V4(payload) => ExecutionPayload::Electra(payload.into()),
@@ -366,7 +369,7 @@ impl<E: EthSpec> From<JsonGetPayloadResponse<E>> for GetPayloadResponse<E> {
     fn from(json_get_payload_response: JsonGetPayloadResponse<E>) -> Self {
         match json_get_payload_response {
             JsonGetPayloadResponse::V1(response) => {
-                GetPayloadResponse::Merge(GetPayloadResponseMerge {
+                GetPayloadResponse::Bellatrix(GetPayloadResponseBellatrix {
                     execution_payload: response.execution_payload.into(),
                     block_value: response.block_value,
                 })
@@ -747,3 +750,36 @@ pub mod serde_logs_bloom {
             .map_err(|e| serde::de::Error::custom(format!("invalid logs bloom: {:?}", e)))
     }
 }
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct JsonClientVersionV1 {
+    pub code: String,
+    pub name: String,
+    pub version: String,
+    pub commit: String,
+}
+
+impl From<ClientVersionV1> for JsonClientVersionV1 {
+    fn from(client_version: ClientVersionV1) -> Self {
+        Self {
+            code: client_version.code.to_string(),
+            name: client_version.name,
+            version: client_version.version,
+            commit: client_version.commit.to_string(),
+        }
+    }
+}
+
+impl TryFrom<JsonClientVersionV1> for ClientVersionV1 {
+    type Error = String;
+
+    fn try_from(json: JsonClientVersionV1) -> Result<Self, Self::Error> {
+        Ok(Self {
+            code: json.code.try_into()?,
+            name: json.name,
+            version: json.version,
+            commit: json.commit.try_into()?,
+        })
+    }
+}
diff --git a/beacon_node/execution_layer/src/engine_api/new_payload_request.rs b/beacon_node/execution_layer/src/engine_api/new_payload_request.rs
index 6b6df13b704..8d2e3d5ad06 100644
--- a/beacon_node/execution_layer/src/engine_api/new_payload_request.rs
+++ b/beacon_node/execution_layer/src/engine_api/new_payload_request.rs
@@ -8,11 +8,12 @@ use types::{
     ExecutionPayloadRef, Hash256, VersionedHash,
 };
 use types::{
-    ExecutionPayloadCapella, ExecutionPayloadDeneb, ExecutionPayloadElectra, ExecutionPayloadMerge,
+    ExecutionPayloadBellatrix, ExecutionPayloadCapella, ExecutionPayloadDeneb,
+    ExecutionPayloadElectra,
 };
 
 #[superstruct(
-    variants(Merge, Capella, Deneb, Electra),
+    variants(Bellatrix, Capella, Deneb, Electra),
     variant_attributes(derive(Clone, Debug, PartialEq),),
     map_into(ExecutionPayload),
     map_ref_into(ExecutionPayloadRef),
@@ -27,8 +28,11 @@ use types::{
 )]
 #[derive(Clone, Debug, PartialEq)]
 pub struct NewPayloadRequest<'block, E: EthSpec> {
-    #[superstruct(only(Merge), partial_getter(rename = "execution_payload_merge"))]
-    pub execution_payload: &'block ExecutionPayloadMerge<E>,
+    #[superstruct(
+        only(Bellatrix),
+        partial_getter(rename = "execution_payload_bellatrix")
+    )]
+    pub execution_payload: &'block ExecutionPayloadBellatrix<E>,
     #[superstruct(only(Capella), partial_getter(rename = "execution_payload_capella"))]
     pub execution_payload: &'block ExecutionPayloadCapella<E>,
     #[superstruct(only(Deneb), partial_getter(rename = "execution_payload_deneb"))]
@@ -44,7 +48,7 @@ pub struct NewPayloadRequest<'block, E: EthSpec> {
 impl<'block, E: EthSpec> NewPayloadRequest<'block, E> {
     pub fn parent_hash(&self) -> ExecutionBlockHash {
         match self {
-            Self::Merge(payload) => payload.execution_payload.parent_hash,
+            Self::Bellatrix(payload) => payload.execution_payload.parent_hash,
             Self::Capella(payload) => payload.execution_payload.parent_hash,
             Self::Deneb(payload) => payload.execution_payload.parent_hash,
             Self::Electra(payload) => payload.execution_payload.parent_hash,
@@ -53,7 +57,7 @@ impl<'block, E: EthSpec> NewPayloadRequest<'block, E> {
 
     pub fn block_hash(&self) -> ExecutionBlockHash {
         match self {
-            Self::Merge(payload) => payload.execution_payload.block_hash,
+            Self::Bellatrix(payload) => payload.execution_payload.block_hash,
             Self::Capella(payload) => payload.execution_payload.block_hash,
             Self::Deneb(payload) => payload.execution_payload.block_hash,
             Self::Electra(payload) => payload.execution_payload.block_hash,
@@ -62,7 +66,7 @@ impl<'block, E: EthSpec> NewPayloadRequest<'block, E> {
 
     pub fn block_number(&self) -> u64 {
         match self {
-            Self::Merge(payload) => payload.execution_payload.block_number,
+            Self::Bellatrix(payload) => payload.execution_payload.block_number,
             Self::Capella(payload) => payload.execution_payload.block_number,
             Self::Deneb(payload) => payload.execution_payload.block_number,
             Self::Electra(payload) => payload.execution_payload.block_number,
@@ -71,7 +75,7 @@ impl<'block, E: EthSpec> NewPayloadRequest<'block, E> {
 
     pub fn execution_payload_ref(&self) -> ExecutionPayloadRef<'block, E> {
         match self {
-            Self::Merge(request) => ExecutionPayloadRef::Merge(request.execution_payload),
+            Self::Bellatrix(request) => ExecutionPayloadRef::Bellatrix(request.execution_payload),
             Self::Capella(request) => ExecutionPayloadRef::Capella(request.execution_payload),
             Self::Deneb(request) => ExecutionPayloadRef::Deneb(request.execution_payload),
             Self::Electra(request) => ExecutionPayloadRef::Electra(request.execution_payload),
@@ -80,7 +84,9 @@ impl<'block, E: EthSpec> NewPayloadRequest<'block, E> {
 
     pub fn into_execution_payload(self) -> ExecutionPayload<E> {
         match self {
-            Self::Merge(request) => ExecutionPayload::Merge(request.execution_payload.clone()),
+            Self::Bellatrix(request) => {
+                ExecutionPayload::Bellatrix(request.execution_payload.clone())
+            }
             Self::Capella(request) => ExecutionPayload::Capella(request.execution_payload.clone()),
             Self::Deneb(request) => ExecutionPayload::Deneb(request.execution_payload.clone()),
             Self::Electra(request) => ExecutionPayload::Electra(request.execution_payload.clone()),
@@ -150,9 +156,11 @@ impl<'a, E: EthSpec> TryFrom<BeaconBlockRef<'a, E>> for NewPayloadRequest<'a, E>
             BeaconBlockRef::Base(_) | BeaconBlockRef::Altair(_) => {
                 Err(Self::Error::IncorrectStateVariant)
             }
-            BeaconBlockRef::Merge(block_ref) => Ok(Self::Merge(NewPayloadRequestMerge {
-                execution_payload: &block_ref.body.execution_payload.execution_payload,
-            })),
+            BeaconBlockRef::Bellatrix(block_ref) => {
+                Ok(Self::Bellatrix(NewPayloadRequestBellatrix {
+                    execution_payload: &block_ref.body.execution_payload.execution_payload,
+                }))
+            }
             BeaconBlockRef::Capella(block_ref) => Ok(Self::Capella(NewPayloadRequestCapella {
                 execution_payload: &block_ref.body.execution_payload.execution_payload,
             })),
@@ -185,9 +193,11 @@ impl<'a, E: EthSpec> TryFrom<ExecutionPayloadRef<'a, E>> for NewPayloadRequest<'
 
     fn try_from(payload: ExecutionPayloadRef<'a, E>) -> Result<Self, Self::Error> {
         match payload {
-            ExecutionPayloadRef::Merge(payload) => Ok(Self::Merge(NewPayloadRequestMerge {
-                execution_payload: payload,
-            })),
+            ExecutionPayloadRef::Bellatrix(payload) => {
+                Ok(Self::Bellatrix(NewPayloadRequestBellatrix {
+                    execution_payload: payload,
+                }))
+            }
             ExecutionPayloadRef::Capella(payload) => Ok(Self::Capella(NewPayloadRequestCapella {
                 execution_payload: payload,
             })),
diff --git a/beacon_node/execution_layer/src/engines.rs b/beacon_node/execution_layer/src/engines.rs
index bc8e4e31404..75d0b872cef 100644
--- a/beacon_node/execution_layer/src/engines.rs
+++ b/beacon_node/execution_layer/src/engines.rs
@@ -4,7 +4,7 @@ use crate::engine_api::{
     EngineCapabilities, Error as EngineApiError, ForkchoiceUpdatedResponse, PayloadAttributes,
     PayloadId,
 };
-use crate::HttpJsonRpc;
+use crate::{ClientVersionV1, HttpJsonRpc};
 use lru::LruCache;
 use slog::{debug, error, info, warn, Logger};
 use std::future::Future;
@@ -21,7 +21,7 @@ use types::ExecutionBlockHash;
 ///
 /// Since the size of each value is small (~800 bytes) a large number is used for safety.
 const PAYLOAD_ID_LRU_CACHE_SIZE: NonZeroUsize = new_non_zero_usize(512);
-const CACHED_ENGINE_CAPABILITIES_AGE_LIMIT: Duration = Duration::from_secs(900); // 15 minutes
+const CACHED_RESPONSE_AGE_LIMIT: Duration = Duration::from_secs(900); // 15 minutes
 
 /// Stores the remembered state of a engine.
 #[derive(Copy, Clone, PartialEq, Debug, Eq, Default)]
@@ -34,11 +34,11 @@ enum EngineStateInternal {
 }
 
 #[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
-enum CapabilitiesCacheAction {
+enum ResponseCacheAction {
     #[default]
     None,
-    Update,
-    Clear,
+    Update, // Update cached responses
+    Clear,  // Clear cached responses
 }
 
 /// A subset of the engine state to inform other services if the engine is online or offline.
@@ -266,12 +266,12 @@ impl Engine {
                     );
                 }
                 state.update(EngineStateInternal::Synced);
-                (**state, CapabilitiesCacheAction::Update)
+                (**state, ResponseCacheAction::Update)
             }
             Err(EngineApiError::IsSyncing) => {
                 let mut state = self.state.write().await;
                 state.update(EngineStateInternal::Syncing);
-                (**state, CapabilitiesCacheAction::Update)
+                (**state, ResponseCacheAction::Update)
             }
             Err(EngineApiError::Auth(err)) => {
                 error!(
@@ -282,7 +282,7 @@ impl Engine {
 
                 let mut state = self.state.write().await;
                 state.update(EngineStateInternal::AuthFailed);
-                (**state, CapabilitiesCacheAction::Clear)
+                (**state, ResponseCacheAction::Clear)
             }
             Err(e) => {
                 error!(
@@ -293,28 +293,37 @@ impl Engine {
 
                 let mut state = self.state.write().await;
                 state.update(EngineStateInternal::Offline);
-                // need to clear the engine capabilities cache if we detect the
-                // execution engine is offline as it is likely the engine is being
-                // updated to a newer version with new capabilities
-                (**state, CapabilitiesCacheAction::Clear)
+                // need to clear cached responses if we detect the execution engine
+                // is offline as it is likely the engine is being updated to a newer
+                // version which might also have new capabilities
+                (**state, ResponseCacheAction::Clear)
             }
         };
 
         // do this after dropping state lock guard to avoid holding two locks at once
         match cache_action {
-            CapabilitiesCacheAction::None => {}
-            CapabilitiesCacheAction::Update => {
+            ResponseCacheAction::None => {}
+            ResponseCacheAction::Update => {
                 if let Err(e) = self
-                    .get_engine_capabilities(Some(CACHED_ENGINE_CAPABILITIES_AGE_LIMIT))
+                    .get_engine_capabilities(Some(CACHED_RESPONSE_AGE_LIMIT))
                     .await
                 {
                     warn!(self.log,
                         "Error during exchange capabilities";
                         "error" => ?e,
                     )
+                } else {
+                    // no point in running this if there was an error fetching the capabilities
+                    // as it will just result in an error again
+                    let _ = self
+                        .get_engine_version(Some(CACHED_RESPONSE_AGE_LIMIT))
+                        .await;
                 }
             }
-            CapabilitiesCacheAction::Clear => self.api.clear_exchange_capabilties_cache().await,
+            ResponseCacheAction::Clear => {
+                self.api.clear_exchange_capabilties_cache().await;
+                self.api.clear_engine_version_cache().await;
+            }
         }
 
         debug!(
@@ -340,6 +349,22 @@ impl Engine {
         self.api.get_engine_capabilities(age_limit).await
     }
 
+    /// Returns the execution engine version resulting from a call to
+    /// engine_clientVersionV1. If the version cache is not populated, or if it
+    /// is populated with a cached result of age >= `age_limit`, this method will
+    /// fetch the result from the execution engine and populate the cache before
+    /// returning it. Otherwise it will return the cached result from an earlier
+    /// call.
+    ///
+    /// Set `age_limit` to `None` to always return the cached result
+    /// Set `age_limit` to `Some(Duration::ZERO)` to force fetching from EE
+    pub async fn get_engine_version(
+        &self,
+        age_limit: Option<Duration>,
+    ) -> Result<Vec<ClientVersionV1>, EngineApiError> {
+        self.api.get_engine_version(age_limit).await
+    }
+
     /// Run `func` on the node regardless of the node's current state.
     ///
     /// ## Note
diff --git a/beacon_node/execution_layer/src/lib.rs b/beacon_node/execution_layer/src/lib.rs
index 30930318eff..d441596edda 100644
--- a/beacon_node/execution_layer/src/lib.rs
+++ b/beacon_node/execution_layer/src/lib.rs
@@ -24,7 +24,7 @@ use payload_status::process_payload_status;
 pub use payload_status::PayloadStatus;
 use sensitive_url::SensitiveUrl;
 use serde::{Deserialize, Serialize};
-use slog::{crit, debug, error, info, trace, warn, Logger};
+use slog::{crit, debug, error, info, warn, Logger};
 use slot_clock::SlotClock;
 use std::collections::HashMap;
 use std::fmt;
@@ -50,8 +50,8 @@ use types::{
     AbstractExecPayload, BlobsList, ExecutionPayloadDeneb, KzgProofs, SignedBlindedBeaconBlock,
 };
 use types::{
-    BeaconStateError, BlindedPayload, ChainSpec, Epoch, ExecPayload, ExecutionPayloadCapella,
-    ExecutionPayloadElectra, ExecutionPayloadMerge, FullPayload, ProposerPreparationData,
+    BeaconStateError, BlindedPayload, ChainSpec, Epoch, ExecPayload, ExecutionPayloadBellatrix,
+    ExecutionPayloadCapella, ExecutionPayloadElectra, FullPayload, ProposerPreparationData,
     PublicKeyBytes, Signature, Slot,
 };
 
@@ -98,8 +98,8 @@ impl<E: EthSpec> TryFrom<BuilderBid<E>> for ProvenancedPayload<BlockProposalCont
 
     fn try_from(value: BuilderBid<E>) -> Result<Self, Error> {
         let block_proposal_contents = match value {
-            BuilderBid::Merge(builder_bid) => BlockProposalContents::Payload {
-                payload: ExecutionPayloadHeader::Merge(builder_bid.header).into(),
+            BuilderBid::Bellatrix(builder_bid) => BlockProposalContents::Payload {
+                payload: ExecutionPayloadHeader::Bellatrix(builder_bid.header).into(),
                 block_value: builder_bid.value,
             },
             BuilderBid::Capella(builder_bid) => BlockProposalContents::Payload {
@@ -165,6 +165,17 @@ impl From<ApiError> for Error {
     }
 }
 
+impl From<EngineError> for Error {
+    fn from(e: EngineError) -> Self {
+        match e {
+            // This removes an unnecessary layer of indirection.
+            // TODO (mark): consider refactoring these error enums
+            EngineError::Api { error } => Error::ApiError(error),
+            _ => Error::EngineError(Box::new(e)),
+        }
+    }
+}
+
 pub enum BlockProposalContentsType<E: EthSpec> {
     Full(BlockProposalContents<E, FullPayload<E>>),
     Blinded(BlockProposalContents<E, BlindedPayload<E>>),
@@ -355,14 +366,14 @@ struct Inner<E: EthSpec> {
 
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]
 pub struct Config {
-    /// Endpoint urls for EL nodes that are running the engine api.
-    pub execution_endpoints: Vec<SensitiveUrl>,
+    /// Endpoint url for EL nodes that are running the engine api.
+    pub execution_endpoint: Option<SensitiveUrl>,
     /// Endpoint urls for services providing the builder api.
     pub builder_url: Option<SensitiveUrl>,
     /// User agent to send with requests to the builder API.
     pub builder_user_agent: Option<String>,
-    /// JWT secrets for the above endpoints running the engine api.
-    pub secret_files: Vec<PathBuf>,
+    /// JWT secret for the above endpoint running the engine api.
+    pub secret_file: Option<PathBuf>,
     /// The default fee recipient to use on the beacon node if none if provided from
     /// the validator client during block preparation.
     pub suggested_fee_recipient: Option<Address>,
@@ -386,10 +397,10 @@ impl<E: EthSpec> ExecutionLayer<E> {
     /// Instantiate `Self` with an Execution engine specified in `Config`, using JSON-RPC via HTTP.
     pub fn from_config(config: Config, executor: TaskExecutor, log: Logger) -> Result<Self, Error> {
         let Config {
-            execution_endpoints: urls,
+            execution_endpoint: url,
             builder_url,
             builder_user_agent,
-            secret_files,
+            secret_file,
             suggested_fee_recipient,
             jwt_id,
             jwt_version,
@@ -397,16 +408,10 @@ impl<E: EthSpec> ExecutionLayer<E> {
             execution_timeout_multiplier,
         } = config;
 
-        if urls.len() > 1 {
-            warn!(log, "Only the first execution engine url will be used");
-        }
-        let execution_url = urls.into_iter().next().ok_or(Error::NoEngine)?;
+        let execution_url = url.ok_or(Error::NoEngine)?;
 
         // Use the default jwt secret path if not provided via cli.
-        let secret_file = secret_files
-            .into_iter()
-            .next()
-            .unwrap_or_else(|| default_datadir.join(DEFAULT_JWT_FILE));
+        let secret_file = secret_file.unwrap_or_else(|| default_datadir.join(DEFAULT_JWT_FILE));
 
         let jwt_key = if secret_file.exists() {
             // Read secret from file if it already exists
@@ -1337,15 +1342,11 @@ impl<E: EthSpec> ExecutionLayer<E> {
             &metrics::EXECUTION_LAYER_REQUEST_TIMES,
             &[metrics::NEW_PAYLOAD],
         );
+        let timer = std::time::Instant::now();
 
+        let block_number = new_payload_request.block_number();
         let block_hash = new_payload_request.block_hash();
-        trace!(
-            self.log(),
-            "Issuing engine_newPayload";
-            "parent_hash" => ?new_payload_request.parent_hash(),
-            "block_hash" => ?block_hash,
-            "block_number" => ?new_payload_request.block_number(),
-        );
+        let parent_hash = new_payload_request.parent_hash();
 
         let result = self
             .engine()
@@ -1353,9 +1354,19 @@ impl<E: EthSpec> ExecutionLayer<E> {
             .await;
 
         if let Ok(status) = &result {
+            let status_str = <&'static str>::from(status.status);
             metrics::inc_counter_vec(
                 &metrics::EXECUTION_LAYER_PAYLOAD_STATUS,
-                &["new_payload", status.status.into()],
+                &["new_payload", status_str],
+            );
+            debug!(
+                self.log(),
+                "Processed engine_newPayload";
+                "status" => status_str,
+                "parent_hash" => ?parent_hash,
+                "block_hash" => ?block_hash,
+                "block_number" => block_number,
+                "response_time_ms" => timer.elapsed().as_millis()
             );
         }
         *self.inner.last_new_payload_errored.write().await = result.is_err();
@@ -1526,8 +1537,26 @@ impl<E: EthSpec> ExecutionLayer<E> {
         self.engine()
             .request(|engine| engine.get_engine_capabilities(age_limit))
             .await
-            .map_err(Box::new)
-            .map_err(Error::EngineError)
+            .map_err(Into::into)
+    }
+
+    /// Returns the execution engine version resulting from a call to
+    /// engine_clientVersionV1. If the version cache is not populated, or if it
+    /// is populated with a cached result of age >= `age_limit`, this method will
+    /// fetch the result from the execution engine and populate the cache before
+    /// returning it. Otherwise it will return the cached result from an earlier
+    /// call.
+    ///
+    /// Set `age_limit` to `None` to always return the cached result
+    /// Set `age_limit` to `Some(Duration::ZERO)` to force fetching from EE
+    pub async fn get_engine_version(
+        &self,
+        age_limit: Option<Duration>,
+    ) -> Result<Vec<ClientVersionV1>, Error> {
+        self.engine()
+            .request(|engine| engine.get_engine_version(age_limit))
+            .await
+            .map_err(Into::into)
     }
 
     /// Used during block production to determine if the merge has been triggered.
@@ -1775,7 +1804,7 @@ impl<E: EthSpec> ExecutionLayer<E> {
         // Handle default payload body.
         if header.block_hash() == ExecutionBlockHash::zero() {
             let payload = match fork {
-                ForkName::Merge => ExecutionPayloadMerge::default().into(),
+                ForkName::Bellatrix => ExecutionPayloadBellatrix::default().into(),
                 ForkName::Capella => ExecutionPayloadCapella::default().into(),
                 ForkName::Deneb => ExecutionPayloadDeneb::default().into(),
                 ForkName::Electra => ExecutionPayloadElectra::default().into(),
@@ -1844,7 +1873,7 @@ impl<E: EthSpec> ExecutionLayer<E> {
 
         if hash == ExecutionBlockHash::zero() {
             return match fork {
-                ForkName::Merge => Ok(Some(ExecutionPayloadMerge::default().into())),
+                ForkName::Bellatrix => Ok(Some(ExecutionPayloadBellatrix::default().into())),
                 ForkName::Capella => Ok(Some(ExecutionPayloadCapella::default().into())),
                 ForkName::Deneb => Ok(Some(ExecutionPayloadDeneb::default().into())),
                 ForkName::Electra => Ok(Some(ExecutionPayloadElectra::default().into())),
@@ -1873,22 +1902,22 @@ impl<E: EthSpec> ExecutionLayer<E> {
         };
 
         let payload = match block {
-            ExecutionBlockWithTransactions::Merge(merge_block) => {
-                ExecutionPayload::Merge(ExecutionPayloadMerge {
-                    parent_hash: merge_block.parent_hash,
-                    fee_recipient: merge_block.fee_recipient,
-                    state_root: merge_block.state_root,
-                    receipts_root: merge_block.receipts_root,
-                    logs_bloom: merge_block.logs_bloom,
-                    prev_randao: merge_block.prev_randao,
-                    block_number: merge_block.block_number,
-                    gas_limit: merge_block.gas_limit,
-                    gas_used: merge_block.gas_used,
-                    timestamp: merge_block.timestamp,
-                    extra_data: merge_block.extra_data,
-                    base_fee_per_gas: merge_block.base_fee_per_gas,
-                    block_hash: merge_block.block_hash,
-                    transactions: convert_transactions(merge_block.transactions)?,
+            ExecutionBlockWithTransactions::Bellatrix(bellatrix_block) => {
+                ExecutionPayload::Bellatrix(ExecutionPayloadBellatrix {
+                    parent_hash: bellatrix_block.parent_hash,
+                    fee_recipient: bellatrix_block.fee_recipient,
+                    state_root: bellatrix_block.state_root,
+                    receipts_root: bellatrix_block.receipts_root,
+                    logs_bloom: bellatrix_block.logs_bloom,
+                    prev_randao: bellatrix_block.prev_randao,
+                    block_number: bellatrix_block.block_number,
+                    gas_limit: bellatrix_block.gas_limit,
+                    gas_used: bellatrix_block.gas_used,
+                    timestamp: bellatrix_block.timestamp,
+                    extra_data: bellatrix_block.extra_data,
+                    base_fee_per_gas: bellatrix_block.base_fee_per_gas,
+                    block_hash: bellatrix_block.block_hash,
+                    transactions: convert_transactions(bellatrix_block.transactions)?,
                 })
             }
             ExecutionBlockWithTransactions::Capella(capella_block) => {
@@ -1974,6 +2003,11 @@ impl<E: EthSpec> ExecutionLayer<E> {
                     withdrawals,
                     blob_gas_used: electra_block.blob_gas_used,
                     excess_blob_gas: electra_block.excess_blob_gas,
+                    // TODO(electra)
+                    // deposit_receipts: electra_block.deposit_receipts,
+                    // withdrawal_requests: electra_block.withdrawal_requests,
+                    deposit_receipts: <_>::default(),
+                    withdrawal_requests: <_>::default(),
                 })
             }
         };
diff --git a/beacon_node/execution_layer/src/test_utils/execution_block_generator.rs b/beacon_node/execution_layer/src/test_utils/execution_block_generator.rs
index 87484ced67c..e80c6b23705 100644
--- a/beacon_node/execution_layer/src/test_utils/execution_block_generator.rs
+++ b/beacon_node/execution_layer/src/test_utils/execution_block_generator.rs
@@ -21,9 +21,9 @@ use std::sync::Arc;
 use tree_hash::TreeHash;
 use tree_hash_derive::TreeHash;
 use types::{
-    Blob, ChainSpec, EthSpec, ExecutionBlockHash, ExecutionPayload, ExecutionPayloadCapella,
-    ExecutionPayloadDeneb, ExecutionPayloadElectra, ExecutionPayloadHeader, ExecutionPayloadMerge,
-    ForkName, Hash256, Transaction, Transactions, Uint256,
+    Blob, ChainSpec, EthSpec, ExecutionBlockHash, ExecutionPayload, ExecutionPayloadBellatrix,
+    ExecutionPayloadCapella, ExecutionPayloadDeneb, ExecutionPayloadElectra,
+    ExecutionPayloadHeader, ForkName, Hash256, Transaction, Transactions, Uint256,
 };
 
 use super::DEFAULT_TERMINAL_BLOCK;
@@ -91,7 +91,14 @@ impl<E: EthSpec> Block<E> {
     pub fn as_execution_block_with_tx(&self) -> Option<ExecutionBlockWithTransactions<E>> {
         match self {
             Block::PoS(payload) => Some(payload.clone().try_into().unwrap()),
-            Block::PoW(_) => None,
+            Block::PoW(block) => Some(
+                ExecutionPayload::Bellatrix(ExecutionPayloadBellatrix {
+                    block_hash: block.block_hash,
+                    ..Default::default()
+                })
+                .try_into()
+                .unwrap(),
+            ),
         }
     }
 }
@@ -155,7 +162,7 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
         shanghai_time: Option<u64>,
         cancun_time: Option<u64>,
         prague_time: Option<u64>,
-        kzg: Option<Kzg>,
+        kzg: Option<Arc<Kzg>>,
     ) -> Self {
         let mut gen = Self {
             head_block: <_>::default(),
@@ -172,7 +179,7 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
             cancun_time,
             prague_time,
             blobs_bundles: <_>::default(),
-            kzg: kzg.map(Arc::new),
+            kzg,
             rng: make_rng(),
         };
 
@@ -190,6 +197,19 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
             .map(|block| block.as_execution_block(self.terminal_total_difficulty))
     }
 
+    pub fn genesis_block(&self) -> Option<Block<E>> {
+        if let Some(genesis_block_hash) = self.block_hashes.get(&0) {
+            self.blocks.get(genesis_block_hash.first()?).cloned()
+        } else {
+            None
+        }
+    }
+
+    pub fn genesis_execution_block(&self) -> Option<ExecutionBlock> {
+        self.genesis_block()
+            .map(|block| block.as_execution_block(self.terminal_total_difficulty))
+    }
+
     pub fn block_by_number(&self, number: u64) -> Option<Block<E>> {
         // Get the latest canonical head block
         let mut latest_block = self.latest_block()?;
@@ -212,7 +232,7 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
                 Some(fork_time) if timestamp >= fork_time => ForkName::Deneb,
                 _ => match self.shanghai_time {
                     Some(fork_time) if timestamp >= fork_time => ForkName::Capella,
-                    _ => ForkName::Merge,
+                    _ => ForkName::Bellatrix,
                 },
             },
         }
@@ -502,13 +522,6 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
         let id = match payload_attributes {
             None => None,
             Some(attributes) => {
-                if !self.blocks.iter().any(|(_, block)| {
-                    block.block_hash() == self.terminal_block_hash
-                        || block.block_number() == self.terminal_block_number
-                }) {
-                    return Err("refusing to create payload id before terminal block".to_string());
-                }
-
                 let parent = self
                     .blocks
                     .get(&head_block_hash)
@@ -556,7 +569,7 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
         attributes: &PayloadAttributes,
     ) -> Result<ExecutionPayload<E>, String> {
         let mut execution_payload = match attributes {
-            PayloadAttributes::V1(pa) => ExecutionPayload::Merge(ExecutionPayloadMerge {
+            PayloadAttributes::V1(pa) => ExecutionPayload::Bellatrix(ExecutionPayloadBellatrix {
                 parent_hash: head_block_hash,
                 fee_recipient: pa.suggested_fee_recipient,
                 receipts_root: Hash256::repeat_byte(42),
@@ -573,7 +586,7 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
                 transactions: vec![].into(),
             }),
             PayloadAttributes::V2(pa) => match self.get_fork_at_timestamp(pa.timestamp) {
-                ForkName::Merge => ExecutionPayload::Merge(ExecutionPayloadMerge {
+                ForkName::Bellatrix => ExecutionPayload::Bellatrix(ExecutionPayloadBellatrix {
                     parent_hash: head_block_hash,
                     fee_recipient: pa.suggested_fee_recipient,
                     receipts_root: Hash256::repeat_byte(42),
@@ -646,13 +659,15 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
                     withdrawals: pa.withdrawals.clone().into(),
                     blob_gas_used: 0,
                     excess_blob_gas: 0,
+                    deposit_receipts: vec![].into(),
+                    withdrawal_requests: vec![].into(),
                 }),
                 _ => unreachable!(),
             },
         };
 
         match execution_payload.fork_name() {
-            ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => {}
+            ForkName::Base | ForkName::Altair | ForkName::Bellatrix | ForkName::Capella => {}
             ForkName::Deneb | ForkName::Electra => {
                 // get random number between 0 and Max Blobs
                 let mut rng = self.rng.lock();
@@ -766,30 +781,35 @@ pub fn generate_genesis_header<E: EthSpec>(
         generate_genesis_block(spec.terminal_total_difficulty, DEFAULT_TERMINAL_BLOCK)
             .ok()
             .map(|block| block.block_hash);
+    let empty_transactions_root = Transactions::<E>::empty().tree_hash_root();
     match genesis_fork {
         ForkName::Base | ForkName::Altair => None,
-        ForkName::Merge => {
+        ForkName::Bellatrix => {
             if post_transition_merge {
-                let mut header = ExecutionPayloadHeader::Merge(<_>::default());
+                let mut header = ExecutionPayloadHeader::Bellatrix(<_>::default());
                 *header.block_hash_mut() = genesis_block_hash.unwrap_or_default();
+                *header.transactions_root_mut() = empty_transactions_root;
                 Some(header)
             } else {
-                Some(ExecutionPayloadHeader::<E>::Merge(<_>::default()))
+                Some(ExecutionPayloadHeader::<E>::Bellatrix(<_>::default()))
             }
         }
         ForkName::Capella => {
             let mut header = ExecutionPayloadHeader::Capella(<_>::default());
             *header.block_hash_mut() = genesis_block_hash.unwrap_or_default();
+            *header.transactions_root_mut() = empty_transactions_root;
             Some(header)
         }
         ForkName::Deneb => {
             let mut header = ExecutionPayloadHeader::Deneb(<_>::default());
             *header.block_hash_mut() = genesis_block_hash.unwrap_or_default();
+            *header.transactions_root_mut() = empty_transactions_root;
             Some(header)
         }
         ForkName::Electra => {
             let mut header = ExecutionPayloadHeader::Electra(<_>::default());
             *header.block_hash_mut() = genesis_block_hash.unwrap_or_default();
+            *header.transactions_root_mut() = empty_transactions_root;
             Some(header)
         }
     }
diff --git a/beacon_node/execution_layer/src/test_utils/handle_rpc.rs b/beacon_node/execution_layer/src/test_utils/handle_rpc.rs
index 77d972ab88e..1dc8f0ab83e 100644
--- a/beacon_node/execution_layer/src/test_utils/handle_rpc.rs
+++ b/beacon_node/execution_layer/src/test_utils/handle_rpc.rs
@@ -1,7 +1,7 @@
 use super::Context;
 use crate::engine_api::{http::*, *};
 use crate::json_structures::*;
-use crate::test_utils::DEFAULT_MOCK_EL_PAYLOAD_VALUE_WEI;
+use crate::test_utils::{DEFAULT_CLIENT_VERSION, DEFAULT_MOCK_EL_PAYLOAD_VALUE_WEI};
 use serde::{de::DeserializeOwned, Deserialize};
 use serde_json::Value as JsonValue;
 use std::sync::Arc;
@@ -49,6 +49,12 @@ pub async fn handle_rpc<E: EthSpec>(
                         .latest_execution_block(),
                 )
                 .unwrap()),
+                "0x0" => Ok(serde_json::to_value(
+                    ctx.execution_block_generator
+                        .read()
+                        .genesis_execution_block(),
+                )
+                .unwrap()),
                 other => Err((
                     format!("The tag {} is not supported", other),
                     BAD_PARAMS_ERROR_CODE,
@@ -129,7 +135,7 @@ pub async fn handle_rpc<E: EthSpec>(
                 .get_fork_at_timestamp(*request.timestamp());
             // validate method called correctly according to fork time
             match fork {
-                ForkName::Merge => {
+                ForkName::Bellatrix => {
                     if matches!(request, JsonExecutionPayload::V2(_)) {
                         return Err((
                             format!(
@@ -389,7 +395,7 @@ pub async fn handle_rpc<E: EthSpec>(
                                     .read()
                                     .get_fork_at_timestamp(*pa.timestamp())
                                 {
-                                    ForkName::Merge => {
+                                    ForkName::Bellatrix => {
                                         get_param::<Option<JsonPayloadAttributesV1>>(params, 1)
                                             .map(|opt| opt.map(JsonPayloadAttributes::V1))
                                             .transpose()
@@ -421,7 +427,7 @@ pub async fn handle_rpc<E: EthSpec>(
                     .read()
                     .get_fork_at_timestamp(*pa.timestamp())
                 {
-                    ForkName::Merge => {
+                    ForkName::Bellatrix => {
                         if matches!(pa, JsonPayloadAttributes::V2(_)) {
                             return Err((
                                 format!(
@@ -522,6 +528,9 @@ pub async fn handle_rpc<E: EthSpec>(
             let engine_capabilities = ctx.engine_capabilities.read();
             Ok(serde_json::to_value(engine_capabilities.to_response()).unwrap())
         }
+        ENGINE_GET_CLIENT_VERSION_V1 => {
+            Ok(serde_json::to_value([DEFAULT_CLIENT_VERSION.clone()]).unwrap())
+        }
         ENGINE_GET_PAYLOAD_BODIES_BY_RANGE_V1 => {
             #[derive(Deserialize)]
             #[serde(transparent)]
diff --git a/beacon_node/execution_layer/src/test_utils/mock_builder.rs b/beacon_node/execution_layer/src/test_utils/mock_builder.rs
index b12e26a3d6c..c9ae1e60cdc 100644
--- a/beacon_node/execution_layer/src/test_utils/mock_builder.rs
+++ b/beacon_node/execution_layer/src/test_utils/mock_builder.rs
@@ -15,7 +15,7 @@ use task_executor::TaskExecutor;
 use tempfile::NamedTempFile;
 use tree_hash::TreeHash;
 use types::builder_bid::{
-    BuilderBid, BuilderBidCapella, BuilderBidDeneb, BuilderBidElectra, BuilderBidMerge,
+    BuilderBid, BuilderBidBellatrix, BuilderBidCapella, BuilderBidDeneb, BuilderBidElectra,
     SignedBuilderBid,
 };
 use types::{
@@ -77,7 +77,7 @@ pub trait BidStuff<E: EthSpec> {
 impl<E: EthSpec> BidStuff<E> for BuilderBid<E> {
     fn set_fee_recipient(&mut self, fee_recipient: Address) {
         match self.to_mut().header_mut() {
-            ExecutionPayloadHeaderRefMut::Merge(header) => {
+            ExecutionPayloadHeaderRefMut::Bellatrix(header) => {
                 header.fee_recipient = fee_recipient;
             }
             ExecutionPayloadHeaderRefMut::Capella(header) => {
@@ -94,7 +94,7 @@ impl<E: EthSpec> BidStuff<E> for BuilderBid<E> {
 
     fn set_gas_limit(&mut self, gas_limit: u64) {
         match self.to_mut().header_mut() {
-            ExecutionPayloadHeaderRefMut::Merge(header) => {
+            ExecutionPayloadHeaderRefMut::Bellatrix(header) => {
                 header.gas_limit = gas_limit;
             }
             ExecutionPayloadHeaderRefMut::Capella(header) => {
@@ -115,7 +115,7 @@ impl<E: EthSpec> BidStuff<E> for BuilderBid<E> {
 
     fn set_parent_hash(&mut self, parent_hash: Hash256) {
         match self.to_mut().header_mut() {
-            ExecutionPayloadHeaderRefMut::Merge(header) => {
+            ExecutionPayloadHeaderRefMut::Bellatrix(header) => {
                 header.parent_hash = ExecutionBlockHash::from_root(parent_hash);
             }
             ExecutionPayloadHeaderRefMut::Capella(header) => {
@@ -132,7 +132,7 @@ impl<E: EthSpec> BidStuff<E> for BuilderBid<E> {
 
     fn set_prev_randao(&mut self, prev_randao: Hash256) {
         match self.to_mut().header_mut() {
-            ExecutionPayloadHeaderRefMut::Merge(header) => {
+            ExecutionPayloadHeaderRefMut::Bellatrix(header) => {
                 header.prev_randao = prev_randao;
             }
             ExecutionPayloadHeaderRefMut::Capella(header) => {
@@ -149,7 +149,7 @@ impl<E: EthSpec> BidStuff<E> for BuilderBid<E> {
 
     fn set_block_number(&mut self, block_number: u64) {
         match self.to_mut().header_mut() {
-            ExecutionPayloadHeaderRefMut::Merge(header) => {
+            ExecutionPayloadHeaderRefMut::Bellatrix(header) => {
                 header.block_number = block_number;
             }
             ExecutionPayloadHeaderRefMut::Capella(header) => {
@@ -166,7 +166,7 @@ impl<E: EthSpec> BidStuff<E> for BuilderBid<E> {
 
     fn set_timestamp(&mut self, timestamp: u64) {
         match self.to_mut().header_mut() {
-            ExecutionPayloadHeaderRefMut::Merge(header) => {
+            ExecutionPayloadHeaderRefMut::Bellatrix(header) => {
                 header.timestamp = timestamp;
             }
             ExecutionPayloadHeaderRefMut::Capella(header) => {
@@ -183,7 +183,7 @@ impl<E: EthSpec> BidStuff<E> for BuilderBid<E> {
 
     fn set_withdrawals_root(&mut self, withdrawals_root: Hash256) {
         match self.to_mut().header_mut() {
-            ExecutionPayloadHeaderRefMut::Merge(_) => {
+            ExecutionPayloadHeaderRefMut::Bellatrix(_) => {
                 panic!("no withdrawals before capella")
             }
             ExecutionPayloadHeaderRefMut::Capella(header) => {
@@ -229,8 +229,8 @@ impl<E: EthSpec> MockBuilder<E> {
 
         // This EL should not talk to a builder
         let config = Config {
-            execution_endpoints: vec![mock_el_url],
-            secret_files: vec![path],
+            execution_endpoint: Some(mock_el_url),
+            secret_file: Some(path),
             suggested_fee_recipient: None,
             ..Default::default()
         };
@@ -336,7 +336,7 @@ pub fn serve<E: EthSpec>(
                         SignedBlindedBeaconBlock::Base(_) | types::SignedBeaconBlock::Altair(_) => {
                             return Err(reject("invalid fork"));
                         }
-                        SignedBlindedBeaconBlock::Merge(block) => {
+                        SignedBlindedBeaconBlock::Bellatrix(block) => {
                             block.message.body.execution_payload.tree_hash_root()
                         }
                         SignedBlindedBeaconBlock::Capella(block) => {
@@ -480,7 +480,7 @@ pub fn serve<E: EthSpec>(
                     .get_randao_mix(head_state.current_epoch())
                     .map_err(|_| reject("couldn't get prev randao"))?;
                 let expected_withdrawals = match fork {
-                    ForkName::Base | ForkName::Altair | ForkName::Merge => None,
+                    ForkName::Base | ForkName::Altair | ForkName::Bellatrix => None,
                     ForkName::Capella | ForkName::Deneb | ForkName::Electra => Some(
                         builder
                             .beacon_client
@@ -496,7 +496,7 @@ pub fn serve<E: EthSpec>(
                     // first to avoid polluting the execution block generator with invalid payload attributes
                     // NOTE: this was part of an effort to add payload attribute uniqueness checks,
                     // which was abandoned because it broke too many tests in subtle ways.
-                    ForkName::Merge | ForkName::Capella => PayloadAttributes::new(
+                    ForkName::Bellatrix | ForkName::Capella => PayloadAttributes::new(
                         timestamp,
                         *prev_randao,
                         fee_recipient,
@@ -577,9 +577,9 @@ pub fn serve<E: EthSpec>(
                                 value: Uint256::from(DEFAULT_BUILDER_PAYLOAD_VALUE_WEI),
                                 pubkey: builder.builder_sk.public_key().compress(),
                             }),
-                            ForkName::Merge => BuilderBid::Merge(BuilderBidMerge {
+                            ForkName::Bellatrix => BuilderBid::Bellatrix(BuilderBidBellatrix {
                                 header: payload
-                                    .as_merge()
+                                    .as_bellatrix()
                                     .map_err(|_| reject("incorrect payload variant"))?
                                     .into(),
                                 value: Uint256::from(DEFAULT_BUILDER_PAYLOAD_VALUE_WEI),
@@ -627,9 +627,9 @@ pub fn serve<E: EthSpec>(
                                 value: Uint256::from(DEFAULT_BUILDER_PAYLOAD_VALUE_WEI),
                                 pubkey: builder.builder_sk.public_key().compress(),
                             }),
-                            ForkName::Merge => BuilderBid::Merge(BuilderBidMerge {
+                            ForkName::Bellatrix => BuilderBid::Bellatrix(BuilderBidBellatrix {
                                 header: payload
-                                    .as_merge()
+                                    .as_bellatrix()
                                     .map_err(|_| reject("incorrect payload variant"))?
                                     .into(),
                                 value: Uint256::from(DEFAULT_BUILDER_PAYLOAD_VALUE_WEI),
diff --git a/beacon_node/execution_layer/src/test_utils/mock_execution_layer.rs b/beacon_node/execution_layer/src/test_utils/mock_execution_layer.rs
index fbd6744ea60..da9b2817f69 100644
--- a/beacon_node/execution_layer/src/test_utils/mock_execution_layer.rs
+++ b/beacon_node/execution_layer/src/test_utils/mock_execution_layer.rs
@@ -43,7 +43,7 @@ impl<E: EthSpec> MockExecutionLayer<E> {
         prague_time: Option<u64>,
         jwt_key: Option<JwtKey>,
         spec: ChainSpec,
-        kzg: Option<Kzg>,
+        kzg: Option<Arc<Kzg>>,
     ) -> Self {
         let handle = executor.handle().unwrap();
 
@@ -67,8 +67,8 @@ impl<E: EthSpec> MockExecutionLayer<E> {
         std::fs::write(&path, hex::encode(DEFAULT_JWT_SECRET)).unwrap();
 
         let config = Config {
-            execution_endpoints: vec![url],
-            secret_files: vec![path],
+            execution_endpoint: Some(url),
+            secret_file: Some(path),
             suggested_fee_recipient: Some(Address::repeat_byte(42)),
             ..Default::default()
         };
@@ -138,7 +138,7 @@ impl<E: EthSpec> MockExecutionLayer<E> {
                 &payload_attributes,
                 forkchoice_update_params,
                 builder_params,
-                ForkName::Merge,
+                ForkName::Bellatrix,
                 &self.spec,
                 None,
                 BlockProductionVersion::FullV2,
@@ -178,7 +178,7 @@ impl<E: EthSpec> MockExecutionLayer<E> {
                 &payload_attributes,
                 forkchoice_update_params,
                 builder_params,
-                ForkName::Merge,
+                ForkName::Bellatrix,
                 &self.spec,
                 None,
                 BlockProductionVersion::BlindedV2,
diff --git a/beacon_node/execution_layer/src/test_utils/mod.rs b/beacon_node/execution_layer/src/test_utils/mod.rs
index 29ef1bb08df..a6d47995af8 100644
--- a/beacon_node/execution_layer/src/test_utils/mod.rs
+++ b/beacon_node/execution_layer/src/test_utils/mod.rs
@@ -4,11 +4,13 @@ use crate::engine_api::auth::JwtKey;
 use crate::engine_api::{
     auth::Auth, http::JSONRPC_VERSION, ExecutionBlock, PayloadStatusV1, PayloadStatusV1Status,
 };
+use crate::json_structures::JsonClientVersionV1;
 use bytes::Bytes;
 use environment::null_logger;
 use execution_block_generator::PoWBlock;
 use handle_rpc::handle_rpc;
 use kzg::Kzg;
+use lazy_static::lazy_static;
 use parking_lot::{Mutex, RwLock, RwLockWriteGuard};
 use serde::{Deserialize, Serialize};
 use serde_json::json;
@@ -49,8 +51,18 @@ pub const DEFAULT_ENGINE_CAPABILITIES: EngineCapabilities = EngineCapabilities {
     get_payload_v1: true,
     get_payload_v2: true,
     get_payload_v3: true,
+    get_client_version_v1: true,
 };
 
+lazy_static! {
+    pub static ref DEFAULT_CLIENT_VERSION: JsonClientVersionV1 = JsonClientVersionV1 {
+        code: "MC".to_string(), // "mock client"
+        name: "Mock Execution Client".to_string(),
+        version: "0.1.0".to_string(),
+        commit: "0xabcdef01".to_string(),
+    };
+}
+
 mod execution_block_generator;
 mod handle_rpc;
 mod hook;
@@ -58,6 +70,7 @@ mod mock_builder;
 mod mock_execution_layer;
 
 /// Configuration for the MockExecutionLayer.
+#[derive(Clone)]
 pub struct MockExecutionConfig {
     pub server_config: Config,
     pub jwt_key: JwtKey,
@@ -109,7 +122,7 @@ impl<E: EthSpec> MockServer<E> {
     pub fn new_with_config(
         handle: &runtime::Handle,
         config: MockExecutionConfig,
-        kzg: Option<Kzg>,
+        kzg: Option<Arc<Kzg>>,
     ) -> Self {
         let MockExecutionConfig {
             jwt_key,
@@ -193,7 +206,7 @@ impl<E: EthSpec> MockServer<E> {
         shanghai_time: Option<u64>,
         cancun_time: Option<u64>,
         prague_time: Option<u64>,
-        kzg: Option<Kzg>,
+        kzg: Option<Arc<Kzg>>,
     ) -> Self {
         Self::new_with_config(
             handle,
diff --git a/beacon_node/genesis/src/eth1_genesis_service.rs b/beacon_node/genesis/src/eth1_genesis_service.rs
index fdba9f4741c..0ede74ba754 100644
--- a/beacon_node/genesis/src/eth1_genesis_service.rs
+++ b/beacon_node/genesis/src/eth1_genesis_service.rs
@@ -5,7 +5,7 @@ use eth1::{DepositLog, Eth1Block, Service as Eth1Service};
 use slog::{debug, error, info, trace, Logger};
 use state_processing::{
     eth2_genesis_time, initialize_beacon_state_from_eth1, is_valid_genesis_state,
-    per_block_processing::process_operations::process_deposit, process_activations,
+    per_block_processing::process_operations::apply_deposit, process_activations,
 };
 use std::sync::{
     atomic::{AtomicU64, AtomicUsize, Ordering},
@@ -433,7 +433,7 @@ impl Eth1GenesisService {
                 // is reached _prior_ to `MIN_ACTIVE_VALIDATOR_COUNT`. I suspect this won't be the
                 // case for mainnet, so we defer this optimization.
 
-                process_deposit(&mut state, &deposit, spec, PROOF_VERIFICATION)
+                apply_deposit(&mut state, &deposit, spec, PROOF_VERIFICATION)
                     .map_err(|e| format!("Error whilst processing deposit: {:?}", e))
             })?;
 
diff --git a/beacon_node/genesis/src/interop.rs b/beacon_node/genesis/src/interop.rs
index b4753e92f1f..4c78b8efd8f 100644
--- a/beacon_node/genesis/src/interop.rs
+++ b/beacon_node/genesis/src/interop.rs
@@ -178,13 +178,14 @@ mod test {
         }
 
         for v in state.validators() {
-            let creds = v.withdrawal_credentials.as_bytes();
+            let creds = v.withdrawal_credentials;
             assert_eq!(
-                creds[0], spec.bls_withdrawal_prefix_byte,
+                creds.as_bytes()[0],
+                spec.bls_withdrawal_prefix_byte,
                 "first byte of withdrawal creds should be bls prefix"
             );
             assert_eq!(
-                &creds[1..],
+                &creds.as_bytes()[1..],
                 &hash(&v.pubkey.as_ssz_bytes())[1..],
                 "rest of withdrawal creds should be pubkey hash"
             )
@@ -240,7 +241,8 @@ mod test {
         }
 
         for (index, v) in state.validators().iter().enumerate() {
-            let creds = v.withdrawal_credentials.as_bytes();
+            let withdrawal_credientials = v.withdrawal_credentials;
+            let creds = withdrawal_credientials.as_bytes();
             if index % 2 == 0 {
                 assert_eq!(
                     creds[0], spec.bls_withdrawal_prefix_byte,
diff --git a/beacon_node/http_api/src/attester_duties.rs b/beacon_node/http_api/src/attester_duties.rs
index f3242a2b374..6c7dc3348c1 100644
--- a/beacon_node/http_api/src/attester_duties.rs
+++ b/beacon_node/http_api/src/attester_duties.rs
@@ -5,9 +5,7 @@ use beacon_chain::{BeaconChain, BeaconChainError, BeaconChainTypes};
 use eth2::types::{self as api_types};
 use slot_clock::SlotClock;
 use state_processing::state_advance::partial_state_advance;
-use types::{
-    AttestationDuty, BeaconState, ChainSpec, CloneConfig, Epoch, EthSpec, Hash256, RelativeEpoch,
-};
+use types::{AttestationDuty, BeaconState, ChainSpec, Epoch, EthSpec, Hash256, RelativeEpoch};
 
 /// The struct that is returned to the requesting HTTP client.
 type ApiDuties = api_types::DutiesResponse<Vec<api_types::AttesterData>>;
@@ -90,8 +88,7 @@ fn compute_historic_attester_duties<T: BeaconChainTypes>(
         if head.beacon_state.current_epoch() <= request_epoch {
             Some((
                 head.beacon_state_root(),
-                head.beacon_state
-                    .clone_with(CloneConfig::committee_caches_only()),
+                head.beacon_state.clone(),
                 execution_status.is_optimistic_or_invalid(),
             ))
         } else {
diff --git a/beacon_node/http_api/src/block_packing_efficiency.rs b/beacon_node/http_api/src/block_packing_efficiency.rs
index d78f1f7c66e..f105fdf0a7d 100644
--- a/beacon_node/http_api/src/block_packing_efficiency.rs
+++ b/beacon_node/http_api/src/block_packing_efficiency.rs
@@ -279,7 +279,7 @@ pub fn get_block_packing_efficiency<T: BeaconChainTypes>(
     ));
 
     let pre_slot_hook =
-        |state: &mut BeaconState<T::EthSpec>| -> Result<(), PackingEfficiencyError> {
+        |_, state: &mut BeaconState<T::EthSpec>| -> Result<(), PackingEfficiencyError> {
             // Add attestations to `available_attestations`.
             handler.lock().add_attestations(state.slot())?;
             Ok(())
diff --git a/beacon_node/http_api/src/build_block_contents.rs b/beacon_node/http_api/src/build_block_contents.rs
index 7e3778b3fbb..05a6735b327 100644
--- a/beacon_node/http_api/src/build_block_contents.rs
+++ b/beacon_node/http_api/src/build_block_contents.rs
@@ -12,7 +12,7 @@ pub fn build_block_contents<E: EthSpec>(
             Ok(ProduceBlockV3Response::Blinded(block.block))
         }
         BeaconBlockResponseWrapper::Full(block) => match fork_name {
-            ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => Ok(
+            ForkName::Base | ForkName::Altair | ForkName::Bellatrix | ForkName::Capella => Ok(
                 ProduceBlockV3Response::Full(FullBlockContents::Block(block.block)),
             ),
             ForkName::Deneb | ForkName::Electra => {
diff --git a/beacon_node/http_api/src/builder_states.rs b/beacon_node/http_api/src/builder_states.rs
index 90203f2d60c..a540113ab43 100644
--- a/beacon_node/http_api/src/builder_states.rs
+++ b/beacon_node/http_api/src/builder_states.rs
@@ -53,7 +53,7 @@ fn get_next_withdrawals_sanity_checks<T: BeaconChainTypes>(
     }
 
     let fork = chain.spec.fork_name_at_slot::<T::EthSpec>(proposal_slot);
-    if let ForkName::Base | ForkName::Altair | ForkName::Merge = fork {
+    if let ForkName::Base | ForkName::Altair | ForkName::Bellatrix = fork {
         return Err(warp_utils::reject::custom_bad_request(
             "the specified state is a pre-capella state.".to_string(),
         ));
diff --git a/beacon_node/http_api/src/lib.rs b/beacon_node/http_api/src/lib.rs
index 9e6022dc954..024e268e2a5 100644
--- a/beacon_node/http_api/src/lib.rs
+++ b/beacon_node/http_api/src/lib.rs
@@ -61,7 +61,6 @@ use slog::{crit, debug, error, info, warn, Logger};
 use slot_clock::SlotClock;
 use ssz::Encode;
 pub use state_id::StateId;
-use std::borrow::Cow;
 use std::future::Future;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
 use std::path::PathBuf;
@@ -144,7 +143,6 @@ pub struct Config {
     pub listen_port: u16,
     pub allow_origin: Option<String>,
     pub tls_config: Option<TlsConfig>,
-    pub allow_sync_stalled: bool,
     pub spec_fork_name: Option<ForkName>,
     pub data_dir: PathBuf,
     pub sse_capacity_multiplier: usize,
@@ -162,7 +160,6 @@ impl Default for Config {
             listen_port: 5052,
             allow_origin: None,
             tls_config: None,
-            allow_sync_stalled: false,
             spec_fork_name: None,
             data_dir: PathBuf::from(DEFAULT_ROOT_DIR),
             sse_capacity_multiplier: 1,
@@ -321,7 +318,6 @@ pub fn serve<T: BeaconChainTypes>(
     shutdown: impl Future<Output = ()> + Send + Sync + 'static,
 ) -> Result<HttpServer, Error> {
     let config = ctx.config.clone();
-    let allow_sync_stalled = config.allow_sync_stalled;
     let log = ctx.log.clone();
 
     // Configure CORS.
@@ -482,10 +478,7 @@ pub fn serve<T: BeaconChainTypes>(
                         | SyncState::SyncTransition
                         | SyncState::BackFillSyncing { .. } => Ok(()),
                         SyncState::Synced => Ok(()),
-                        SyncState::Stalled if allow_sync_stalled => Ok(()),
-                        SyncState::Stalled => Err(warp_utils::reject::not_synced(
-                            "sync is stalled".to_string(),
-                        )),
+                        SyncState::Stalled => Ok(()),
                     }
                 },
             );
@@ -870,10 +863,10 @@ pub fn serve<T: BeaconChainTypes>(
                                     None
                                 };
 
-                                let committee_cache = if let Some(ref shuffling) =
+                                let committee_cache = if let Some(shuffling) =
                                     maybe_cached_shuffling
                                 {
-                                    Cow::Borrowed(&**shuffling)
+                                    shuffling
                                 } else {
                                     let possibly_built_cache =
                                         match RelativeEpoch::from_epoch(current_epoch, epoch) {
@@ -882,16 +875,13 @@ pub fn serve<T: BeaconChainTypes>(
                                                     relative_epoch,
                                                 ) =>
                                             {
-                                                state
-                                                    .committee_cache(relative_epoch)
-                                                    .map(Cow::Borrowed)
+                                                state.committee_cache(relative_epoch).cloned()
                                             }
                                             _ => CommitteeCache::initialized(
                                                 state,
                                                 epoch,
                                                 &chain.spec,
-                                            )
-                                            .map(Cow::Owned),
+                                            ),
                                         }
                                         .map_err(|e| {
                                             match e {
@@ -939,7 +929,7 @@ pub fn serve<T: BeaconChainTypes>(
                                             {
                                                 cache_write.insert_committee_cache(
                                                     shuffling_id,
-                                                    &*possibly_built_cache,
+                                                    &possibly_built_cache,
                                                 );
                                             }
                                         }
@@ -4306,7 +4296,7 @@ pub fn serve<T: BeaconChainTypes>(
             |task_spawner: TaskSpawner<T::EthSpec>, chain: Arc<BeaconChain<T>>| {
                 task_spawner.spawn_async_with_rejection(Priority::P1, async move {
                     let current_slot = chain.slot_clock.now_or_genesis().unwrap_or(Slot::new(0));
-                    let merge_readiness = chain.check_merge_readiness(current_slot).await;
+                    let merge_readiness = chain.check_bellatrix_readiness(current_slot).await;
                     Ok::<_, warp::reject::Rejection>(
                         warp::reply::json(&api_types::GenericResponse::from(merge_readiness))
                             .into_response(),
@@ -4368,6 +4358,12 @@ pub fn serve<T: BeaconChainTypes>(
                                 api_types::EventTopic::BlockReward => {
                                     event_handler.subscribe_block_reward()
                                 }
+                                api_types::EventTopic::AttesterSlashing => {
+                                    event_handler.subscribe_attester_slashing()
+                                }
+                                api_types::EventTopic::ProposerSlashing => {
+                                    event_handler.subscribe_proposer_slashing()
+                                }
                             };
 
                             receivers.push(
diff --git a/beacon_node/http_api/src/metrics.rs b/beacon_node/http_api/src/metrics.rs
index 26ee183c83f..3eada3a3d46 100644
--- a/beacon_node/http_api/src/metrics.rs
+++ b/beacon_node/http_api/src/metrics.rs
@@ -31,7 +31,13 @@ lazy_static::lazy_static! {
     );
     pub static ref HTTP_API_BLOCK_BROADCAST_DELAY_TIMES: Result<HistogramVec> = try_create_histogram_vec(
         "http_api_block_broadcast_delay_times",
-        "Time between start of the slot and when the block was broadcast",
+        "Time between start of the slot and when the block completed broadcast and processing",
+        &["provenance"]
+    );
+    pub static ref HTTP_API_BLOCK_GOSSIP_TIMES: Result<HistogramVec> = try_create_histogram_vec_with_buckets(
+        "http_api_block_gossip_times",
+        "Time between receiving the block on HTTP and publishing it on gossip",
+        decimal_buckets(-2, 2),
         &["provenance"]
     );
     pub static ref HTTP_API_BLOCK_PUBLISHED_LATE_TOTAL: Result<IntCounter> = try_create_int_counter(
diff --git a/beacon_node/http_api/src/produce_block.rs b/beacon_node/http_api/src/produce_block.rs
index 0da3bdc7aab..ed30da7362c 100644
--- a/beacon_node/http_api/src/produce_block.rs
+++ b/beacon_node/http_api/src/produce_block.rs
@@ -20,6 +20,10 @@ use warp::{
     Reply,
 };
 
+/// If default boost factor is provided in validator/blocks v3 request, we will skip the calculation
+/// to keep the precision.
+const DEFAULT_BOOST_FACTOR: u64 = 100;
+
 pub fn get_randao_verification(
     query: &api_types::ValidatorBlocksQuery,
     randao_reveal_infinity: bool,
@@ -52,6 +56,11 @@ pub async fn produce_block_v3<T: BeaconChainTypes>(
     })?;
 
     let randao_verification = get_randao_verification(&query, randao_reveal.is_infinity())?;
+    let builder_boost_factor = if query.builder_boost_factor == Some(DEFAULT_BOOST_FACTOR) {
+        None
+    } else {
+        query.builder_boost_factor
+    };
 
     let block_response_type = chain
         .produce_block_with_verification(
@@ -59,7 +68,7 @@ pub async fn produce_block_v3<T: BeaconChainTypes>(
             slot,
             query.graffiti,
             randao_verification,
-            query.builder_boost_factor,
+            builder_boost_factor,
             BlockProductionVersion::V3,
         )
         .await
diff --git a/beacon_node/http_api/src/proposer_duties.rs b/beacon_node/http_api/src/proposer_duties.rs
index c31dd9b1faa..ab8952976c8 100644
--- a/beacon_node/http_api/src/proposer_duties.rs
+++ b/beacon_node/http_api/src/proposer_duties.rs
@@ -10,7 +10,7 @@ use safe_arith::SafeArith;
 use slog::{debug, Logger};
 use slot_clock::SlotClock;
 use std::cmp::Ordering;
-use types::{CloneConfig, Epoch, EthSpec, Hash256, Slot};
+use types::{Epoch, EthSpec, Hash256, Slot};
 
 /// The struct that is returned to the requesting HTTP client.
 type ApiDuties = api_types::DutiesResponse<Vec<api_types::ProposerData>>;
@@ -192,8 +192,7 @@ fn compute_historic_proposer_duties<T: BeaconChainTypes>(
         if head.beacon_state.current_epoch() <= epoch {
             Some((
                 head.beacon_state_root(),
-                head.beacon_state
-                    .clone_with(CloneConfig::committee_caches_only()),
+                head.beacon_state.clone(),
                 execution_status.is_optimistic_or_invalid(),
             ))
         } else {
diff --git a/beacon_node/http_api/src/publish_blocks.rs b/beacon_node/http_api/src/publish_blocks.rs
index 52e77753ce4..10d000ef6f8 100644
--- a/beacon_node/http_api/src/publish_blocks.rs
+++ b/beacon_node/http_api/src/publish_blocks.rs
@@ -19,9 +19,9 @@ use std::time::Duration;
 use tokio::sync::mpsc::UnboundedSender;
 use tree_hash::TreeHash;
 use types::{
-    AbstractExecPayload, BeaconBlockRef, BlobSidecarList, EthSpec, ExecPayload, ExecutionBlockHash,
-    ForkName, FullPayload, FullPayloadMerge, Hash256, SignedBeaconBlock, SignedBlindedBeaconBlock,
-    VariableList,
+    AbstractExecPayload, BeaconBlockRef, BlobSidecarList, BlockImportSource, EthSpec, ExecPayload,
+    ExecutionBlockHash, ForkName, FullPayload, FullPayloadBellatrix, Hash256, SignedBeaconBlock,
+    SignedBlindedBeaconBlock, VariableList,
 };
 use warp::http::StatusCode;
 use warp::{reply::Response, Rejection, Reply};
@@ -60,6 +60,11 @@ pub async fn publish_block<T: BeaconChainTypes, B: IntoGossipVerifiedBlockConten
         ProvenancedBlock::Local(block_contents, _) => (block_contents, true),
         ProvenancedBlock::Builder(block_contents, _) => (block_contents, false),
     };
+    let provenance = if is_locally_built_block {
+        "local"
+    } else {
+        "builder"
+    };
     let block = block_contents.inner_block().clone();
     let delay = get_block_delay_ms(seen_timestamp, block.message(), &chain.slot_clock);
     debug!(log, "Signed block received in HTTP API"; "slot" => block.slot());
@@ -75,12 +80,23 @@ pub async fn publish_block<T: BeaconChainTypes, B: IntoGossipVerifiedBlockConten
             .checked_sub(seen_timestamp)
             .unwrap_or_else(|| Duration::from_secs(0));
 
-        info!(log, "Signed block published to network via HTTP API"; "slot" => block.slot(), "publish_delay" => ?publish_delay);
+        metrics::observe_timer_vec(
+            &metrics::HTTP_API_BLOCK_GOSSIP_TIMES,
+            &[provenance],
+            publish_delay,
+        );
+
+        info!(
+            log,
+            "Signed block published to network via HTTP API";
+            "slot" => block.slot(),
+            "publish_delay_ms" => publish_delay.as_millis()
+        );
 
         match block.as_ref() {
             SignedBeaconBlock::Base(_)
             | SignedBeaconBlock::Altair(_)
-            | SignedBeaconBlock::Merge(_)
+            | SignedBeaconBlock::Bellatrix(_)
             | SignedBeaconBlock::Capella(_) => {
                 crate::publish_pubsub_message(&sender, PubsubMessage::BeaconBlock(block))
                     .map_err(|_| BlockError::BeaconChainError(BeaconChainError::UnableToPublish))?;
@@ -214,6 +230,7 @@ pub async fn publish_block<T: BeaconChainTypes, B: IntoGossipVerifiedBlockConten
         block_root,
         gossip_verified_block,
         NotifyExecutionLayer::Yes,
+        BlockImportSource::HttpApi,
         publish_fn,
     ))
     .await
@@ -331,8 +348,8 @@ pub async fn reconstruct_block<T: BeaconChainTypes>(
             let fork_name = chain
                 .spec
                 .fork_name_at_epoch(block.slot().epoch(T::EthSpec::slots_per_epoch()));
-            if fork_name == ForkName::Merge {
-                let payload: FullPayload<T::EthSpec> = FullPayloadMerge::default().into();
+            if fork_name == ForkName::Bellatrix {
+                let payload: FullPayload<T::EthSpec> = FullPayloadBellatrix::default().into();
                 ProvenancedPayload::Local(FullPayloadContents::Payload(payload.into()))
             } else {
                 Err(warp_utils::reject::custom_server_error(
diff --git a/beacon_node/http_api/src/state_id.rs b/beacon_node/http_api/src/state_id.rs
index 1a76333e2d4..fdc99fa954e 100644
--- a/beacon_node/http_api/src/state_id.rs
+++ b/beacon_node/http_api/src/state_id.rs
@@ -178,10 +178,7 @@ impl StateId {
                     .head_and_execution_status()
                     .map_err(warp_utils::reject::beacon_chain_error)?;
                 return Ok((
-                    cached_head
-                        .snapshot
-                        .beacon_state
-                        .clone_with_only_committee_caches(),
+                    cached_head.snapshot.beacon_state.clone(),
                     execution_status.is_optimistic_or_invalid(),
                     false,
                 ));
diff --git a/beacon_node/http_api/tests/fork_tests.rs b/beacon_node/http_api/tests/fork_tests.rs
index 74b26475639..ad32ff1d579 100644
--- a/beacon_node/http_api/tests/fork_tests.rs
+++ b/beacon_node/http_api/tests/fork_tests.rs
@@ -128,17 +128,18 @@ async fn attestations_across_fork_with_skip_slots() {
     let all_validators = harness.get_all_validators();
 
     let fork_slot = fork_epoch.start_slot(E::slots_per_epoch());
-    let fork_state = harness
+    let mut fork_state = harness
         .chain
         .state_at_slot(fork_slot, StateSkipConfig::WithStateRoots)
         .unwrap();
+    let fork_state_root = fork_state.update_tree_hash_cache().unwrap();
 
     harness.set_current_slot(fork_slot);
 
     let attestations = harness.make_attestations(
         &all_validators,
         &fork_state,
-        fork_state.canonical_root(),
+        fork_state_root,
         (*fork_state.get_block_root(fork_slot - 1).unwrap()).into(),
         fork_slot,
     );
diff --git a/beacon_node/http_api/tests/tests.rs b/beacon_node/http_api/tests/tests.rs
index e4580e4ffdb..ace54714b26 100644
--- a/beacon_node/http_api/tests/tests.rs
+++ b/beacon_node/http_api/tests/tests.rs
@@ -806,7 +806,7 @@ impl ApiTester {
                 let state_opt = state_id.state(&self.chain).ok();
                 let validators: Vec<Validator> = match state_opt.as_ref() {
                     Some((state, _execution_optimistic, _finalized)) => {
-                        state.validators().clone().into()
+                        state.validators().clone().to_vec()
                     }
                     None => vec![],
                 };
@@ -822,7 +822,7 @@ impl ApiTester {
                         ValidatorId::PublicKey(
                             validators
                                 .get(i as usize)
-                                .map_or(PublicKeyBytes::empty(), |val| val.pubkey.clone()),
+                                .map_or(PublicKeyBytes::empty(), |val| val.pubkey),
                         )
                     })
                     .collect::<Vec<ValidatorId>>();
@@ -865,7 +865,7 @@ impl ApiTester {
                         if i < state.balances().len() as u64 {
                             validators.push(ValidatorBalanceData {
                                 index: i as u64,
-                                balance: state.balances()[i as usize],
+                                balance: *state.balances().get(i as usize).unwrap(),
                             });
                         }
                     }
@@ -892,7 +892,7 @@ impl ApiTester {
                         .ok()
                         .map(|(state, _execution_optimistic, _finalized)| state);
                     let validators: Vec<Validator> = match state_opt.as_ref() {
-                        Some(state) => state.validators().clone().into(),
+                        Some(state) => state.validators().to_vec(),
                         None => vec![],
                     };
                     let validator_index_ids = validator_indices
@@ -907,7 +907,7 @@ impl ApiTester {
                             ValidatorId::PublicKey(
                                 validators
                                     .get(i as usize)
-                                    .map_or(PublicKeyBytes::empty(), |val| val.pubkey.clone()),
+                                    .map_or(PublicKeyBytes::empty(), |val| val.pubkey),
                             )
                         })
                         .collect::<Vec<ValidatorId>>();
@@ -955,7 +955,7 @@ impl ApiTester {
                             if i >= state.validators().len() as u64 {
                                 continue;
                             }
-                            let validator = state.validators()[i as usize].clone();
+                            let validator = state.validators().get(i as usize).unwrap().clone();
                             let status = ValidatorStatus::from_validator(
                                 &validator,
                                 epoch,
@@ -967,7 +967,7 @@ impl ApiTester {
                             {
                                 validators.push(ValidatorData {
                                     index: i as u64,
-                                    balance: state.balances()[i as usize],
+                                    balance: *state.balances().get(i as usize).unwrap(),
                                     status,
                                     validator,
                                 });
@@ -995,13 +995,13 @@ impl ApiTester {
                 .ok()
                 .map(|(state, _execution_optimistic, _finalized)| state);
             let validators = match state_opt.as_ref() {
-                Some(state) => state.validators().clone().into(),
+                Some(state) => state.validators().to_vec(),
                 None => vec![],
             };
 
             for (i, validator) in validators.into_iter().enumerate() {
                 let validator_ids = &[
-                    ValidatorId::PublicKey(validator.pubkey.clone()),
+                    ValidatorId::PublicKey(validator.pubkey),
                     ValidatorId::Index(i as u64),
                 ];
 
@@ -1025,7 +1025,7 @@ impl ApiTester {
 
                         ValidatorData {
                             index: i as u64,
-                            balance: state.balances()[i],
+                            balance: *state.balances().get(i).unwrap(),
                             status: ValidatorStatus::from_validator(
                                 &validator,
                                 epoch,
@@ -2360,7 +2360,7 @@ impl ApiTester {
                         .unwrap()
                     {
                         let expected = AttesterData {
-                            pubkey: state.validators()[i as usize].pubkey.clone().into(),
+                            pubkey: state.validators().get(i as usize).unwrap().pubkey,
                             validator_index: i,
                             committees_at_slot: duty.committees_at_slot,
                             committee_index: duty.index,
@@ -2465,7 +2465,7 @@ impl ApiTester {
                     let index = state
                         .get_beacon_proposer_index(slot, &self.chain.spec)
                         .unwrap();
-                    let pubkey = state.validators()[index].pubkey.clone().into();
+                    let pubkey = state.validators().get(index).unwrap().pubkey;
 
                     ProposerData {
                         pubkey,
@@ -5214,6 +5214,8 @@ impl ApiTester {
             EventTopic::Block,
             EventTopic::Head,
             EventTopic::FinalizedCheckpoint,
+            EventTopic::AttesterSlashing,
+            EventTopic::ProposerSlashing,
         ];
         let mut events_future = self
             .client
@@ -5353,6 +5355,42 @@ impl ApiTester {
         .await;
         assert_eq!(reorg_event.as_slice(), &[expected_reorg]);
 
+        // Test attester slashing event
+        let mut attester_slashing_event_future = self
+            .client
+            .get_events::<E>(&[EventTopic::AttesterSlashing])
+            .await
+            .unwrap();
+
+        self.harness.add_attester_slashing(vec![1, 2, 3]).unwrap();
+
+        let attester_slashing_event = poll_events(
+            &mut attester_slashing_event_future,
+            1,
+            Duration::from_millis(10000),
+        )
+        .await;
+
+        assert!(attester_slashing_event.len() == 1);
+
+        // Test proposer slashing event
+        let mut proposer_slashing_event_future = self
+            .client
+            .get_events::<E>(&[EventTopic::ProposerSlashing])
+            .await
+            .unwrap();
+
+        self.harness.add_proposer_slashing(1).unwrap();
+
+        let proposer_slashing_event = poll_events(
+            &mut proposer_slashing_event_future,
+            1,
+            Duration::from_millis(10000),
+        )
+        .await;
+
+        assert!(proposer_slashing_event.len() == 1);
+
         self
     }
 
diff --git a/beacon_node/lighthouse_network/src/config.rs b/beacon_node/lighthouse_network/src/config.rs
index 85f8b1f848d..91c5b62d0b2 100644
--- a/beacon_node/lighthouse_network/src/config.rs
+++ b/beacon_node/lighthouse_network/src/config.rs
@@ -69,10 +69,6 @@ pub struct Config {
     /// Target number of connected peers.
     pub target_peers: usize,
 
-    /// Gossipsub configuration parameters.
-    #[serde(skip)]
-    pub gs_config: gossipsub::Config,
-
     /// Discv5 configuration parameters.
     #[serde(skip)]
     pub discv5_config: discv5::Config,
@@ -278,12 +274,6 @@ impl Default for Config {
             .join(DEFAULT_BEACON_NODE_DIR)
             .join(DEFAULT_NETWORK_DIR);
 
-        // Note: Using the default config here. Use `gossipsub_config` function for getting
-        // Lighthouse specific configuration for gossipsub.
-        let gs_config = gossipsub::ConfigBuilder::default()
-            .build()
-            .expect("valid gossipsub configuration");
-
         // Discv5 Unsolicited Packet Rate Limiter
         let filter_rate_limiter = Some(
             discv5::RateLimiterBuilder::new()
@@ -336,7 +326,6 @@ impl Default for Config {
             enr_quic6_port: None,
             enr_tcp6_port: None,
             target_peers: 100,
-            gs_config,
             discv5_config,
             boot_nodes_enr: vec![],
             boot_nodes_multiaddr: vec![],
@@ -449,7 +438,7 @@ pub fn gossipsub_config(
         let topic_bytes = message.topic.as_str().as_bytes();
         match fork_context.current_fork() {
             ForkName::Altair
-            | ForkName::Merge
+            | ForkName::Bellatrix
             | ForkName::Capella
             | ForkName::Deneb
             | ForkName::Electra => {
@@ -472,7 +461,7 @@ pub fn gossipsub_config(
         }
     }
     let message_domain_valid_snappy = gossipsub_config_params.message_domain_valid_snappy;
-    let is_merge_enabled = fork_context.fork_exists(ForkName::Merge);
+    let is_bellatrix_enabled = fork_context.fork_exists(ForkName::Bellatrix);
     let gossip_message_id = move |message: &gossipsub::Message| {
         gossipsub::MessageId::from(
             &Sha256::digest(
@@ -492,7 +481,7 @@ pub fn gossipsub_config(
 
     gossipsub::ConfigBuilder::default()
         .max_transmit_size(gossip_max_size(
-            is_merge_enabled,
+            is_bellatrix_enabled,
             gossipsub_config_params.gossip_max_size,
         ))
         .heartbeat_interval(load.heartbeat_interval)
diff --git a/beacon_node/lighthouse_network/src/discovery/mod.rs b/beacon_node/lighthouse_network/src/discovery/mod.rs
index 8cc2ea86c0c..5c937a1e0be 100644
--- a/beacon_node/lighthouse_network/src/discovery/mod.rs
+++ b/beacon_node/lighthouse_network/src/discovery/mod.rs
@@ -398,16 +398,32 @@ impl<E: EthSpec> Discovery<E> {
     /// automatically update the external address.
     ///
     /// If the external address needs to be modified, use `update_enr_udp_socket.
-    pub fn update_enr_tcp_port(&mut self, port: u16) -> Result<(), String> {
+    ///
+    /// This returns Ok(true) if the ENR was updated, otherwise Ok(false) if nothing was done.
+    pub fn update_enr_tcp_port(&mut self, port: u16, v6: bool) -> Result<bool, String> {
+        let enr_field = if v6 {
+            if self.discv5.external_enr().read().tcp6() == Some(port) {
+                // The field is already set to the same value, nothing to do
+                return Ok(false);
+            }
+            "tcp6"
+        } else {
+            if self.discv5.external_enr().read().tcp4() == Some(port) {
+                // The field is already set to the same value, nothing to do
+                return Ok(false);
+            }
+            "tcp"
+        };
+
         self.discv5
-            .enr_insert("tcp", &port)
+            .enr_insert(enr_field, &port)
             .map_err(|e| format!("{:?}", e))?;
 
         // replace the global version
         *self.network_globals.local_enr.write() = self.discv5.local_enr();
         // persist modified enr to disk
         enr::save_enr_to_disk(Path::new(&self.enr_dir), &self.local_enr(), &self.log);
-        Ok(())
+        Ok(true)
     }
 
     // TODO: Group these functions here once the ENR is shared across discv5 and lighthouse and
@@ -415,16 +431,35 @@ impl<E: EthSpec> Discovery<E> {
     // This currently doesn't support ipv6. All of these functions should be removed and
     // addressed properly in the following issue.
     // https://github.com/sigp/lighthouse/issues/4706
-    pub fn update_enr_quic_port(&mut self, port: u16) -> Result<(), String> {
+    pub fn update_enr_quic_port(&mut self, port: u16, v6: bool) -> Result<bool, String> {
+        let enr_field = if v6 {
+            if self.discv5.external_enr().read().quic6() == Some(port) {
+                // The field is already set to the same value, nothing to do
+                return Ok(false);
+            }
+            "quic6"
+        } else {
+            if self.discv5.external_enr().read().quic4() == Some(port) {
+                // The field is already set to the same value, nothing to do
+                return Ok(false);
+            }
+            "quic"
+        };
+        let current_field = self.discv5.external_enr().read().quic4();
+        if current_field == Some(port) {
+            // The current field is already set, no need to update.
+            return Ok(false);
+        }
+
         self.discv5
-            .enr_insert("quic", &port)
+            .enr_insert(enr_field, &port)
             .map_err(|e| format!("{:?}", e))?;
 
         // replace the global version
         *self.network_globals.local_enr.write() = self.discv5.local_enr();
         // persist modified enr to disk
         enr::save_enr_to_disk(Path::new(&self.enr_dir), &self.local_enr(), &self.log);
-        Ok(())
+        Ok(true)
     }
 
     /// Updates the local ENR UDP socket.
@@ -1057,7 +1092,7 @@ impl<E: EthSpec> NetworkBehaviour for Discovery<E> {
                                 return;
                             }
 
-                            self.update_enr_tcp_port(port)
+                            self.update_enr_tcp_port(port, false)
                         }
                         (Some(Protocol::Udp(port)), Some(Protocol::QuicV1)) => {
                             if !self.update_ports.quic4 {
@@ -1065,7 +1100,7 @@ impl<E: EthSpec> NetworkBehaviour for Discovery<E> {
                                 return;
                             }
 
-                            self.update_enr_quic_port(port)
+                            self.update_enr_quic_port(port, false)
                         }
                         _ => {
                             debug!(self.log, "Encountered unacceptable multiaddr for listening (unsupported transport)"; "addr" => ?addr);
@@ -1079,7 +1114,7 @@ impl<E: EthSpec> NetworkBehaviour for Discovery<E> {
                                 return;
                             }
 
-                            self.update_enr_tcp_port(port)
+                            self.update_enr_tcp_port(port, true)
                         }
                         (Some(Protocol::Udp(port)), Some(Protocol::QuicV1)) => {
                             if !self.update_ports.quic6 {
@@ -1087,7 +1122,7 @@ impl<E: EthSpec> NetworkBehaviour for Discovery<E> {
                                 return;
                             }
 
-                            self.update_enr_quic_port(port)
+                            self.update_enr_quic_port(port, true)
                         }
                         _ => {
                             debug!(self.log, "Encountered unacceptable multiaddr for listening (unsupported transport)"; "addr" => ?addr);
@@ -1103,9 +1138,10 @@ impl<E: EthSpec> NetworkBehaviour for Discovery<E> {
                 let local_enr: Enr = self.discv5.local_enr();
 
                 match attempt_enr_update {
-                    Ok(_) => {
+                    Ok(true) => {
                         info!(self.log, "Updated local ENR"; "enr" => local_enr.to_base64(), "seq" => local_enr.seq(), "id"=> %local_enr.node_id(), "ip4" => ?local_enr.ip4(), "udp4"=> ?local_enr.udp4(), "tcp4" => ?local_enr.tcp4(), "tcp6" => ?local_enr.tcp6(), "udp6" => ?local_enr.udp6())
                     }
+                    Ok(false) => {} // Nothing to do, ENR already configured
                     Err(e) => warn!(self.log, "Failed to update ENR"; "error" => ?e),
                 }
             }
diff --git a/beacon_node/lighthouse_network/src/peer_manager/peerdb.rs b/beacon_node/lighthouse_network/src/peer_manager/peerdb.rs
index 978f815d5bc..c3e77ae225e 100644
--- a/beacon_node/lighthouse_network/src/peer_manager/peerdb.rs
+++ b/beacon_node/lighthouse_network/src/peer_manager/peerdb.rs
@@ -1,3 +1,4 @@
+use crate::discovery::CombinedKey;
 use crate::{metrics, multiaddr::Multiaddr, types::Subnet, Enr, Gossipsub, PeerId};
 use peer_info::{ConnectionDirection, PeerConnectionStatus, PeerInfo};
 use rand::seq::SliceRandom;
@@ -671,6 +672,20 @@ impl<E: EthSpec> PeerDB<E> {
         );
     }
 
+    /// Updates the connection state. MUST ONLY BE USED IN TESTS.
+    pub fn __add_connected_peer_testing_only(&mut self, peer_id: &PeerId) -> Option<BanOperation> {
+        let enr_key = CombinedKey::generate_secp256k1();
+        let enr = Enr::builder().build(&enr_key).unwrap();
+        self.update_connection_state(
+            peer_id,
+            NewConnectionState::Connected {
+                enr: Some(enr),
+                seen_address: Multiaddr::empty(),
+                direction: ConnectionDirection::Outgoing,
+            },
+        )
+    }
+
     /// The connection state of the peer has been changed. Modify the peer in the db to ensure all
     /// variables are in sync with libp2p.
     /// Updating the state can lead to a `BanOperation` which needs to be processed via the peer
diff --git a/beacon_node/lighthouse_network/src/rpc/codec/base.rs b/beacon_node/lighthouse_network/src/rpc/codec/base.rs
index 287f0a3f5fd..42a31d3480a 100644
--- a/beacon_node/lighthouse_network/src/rpc/codec/base.rs
+++ b/beacon_node/lighthouse_network/src/rpc/codec/base.rs
@@ -184,13 +184,13 @@ mod tests {
     fn fork_context(fork_name: ForkName) -> ForkContext {
         let mut chain_spec = Spec::default_spec();
         let altair_fork_epoch = Epoch::new(1);
-        let merge_fork_epoch = Epoch::new(2);
+        let bellatrix_fork_epoch = Epoch::new(2);
         let capella_fork_epoch = Epoch::new(3);
         let deneb_fork_epoch = Epoch::new(4);
         let electra_fork_epoch = Epoch::new(5);
 
         chain_spec.altair_fork_epoch = Some(altair_fork_epoch);
-        chain_spec.bellatrix_fork_epoch = Some(merge_fork_epoch);
+        chain_spec.bellatrix_fork_epoch = Some(bellatrix_fork_epoch);
         chain_spec.capella_fork_epoch = Some(capella_fork_epoch);
         chain_spec.deneb_fork_epoch = Some(deneb_fork_epoch);
         chain_spec.electra_fork_epoch = Some(electra_fork_epoch);
@@ -198,7 +198,7 @@ mod tests {
         let current_slot = match fork_name {
             ForkName::Base => Slot::new(0),
             ForkName::Altair => altair_fork_epoch.start_slot(Spec::slots_per_epoch()),
-            ForkName::Merge => merge_fork_epoch.start_slot(Spec::slots_per_epoch()),
+            ForkName::Bellatrix => bellatrix_fork_epoch.start_slot(Spec::slots_per_epoch()),
             ForkName::Capella => capella_fork_epoch.start_slot(Spec::slots_per_epoch()),
             ForkName::Deneb => deneb_fork_epoch.start_slot(Spec::slots_per_epoch()),
             ForkName::Electra => electra_fork_epoch.start_slot(Spec::slots_per_epoch()),
diff --git a/beacon_node/lighthouse_network/src/rpc/codec/ssz_snappy.rs b/beacon_node/lighthouse_network/src/rpc/codec/ssz_snappy.rs
index 4cbb6582583..482d1d96b4a 100644
--- a/beacon_node/lighthouse_network/src/rpc/codec/ssz_snappy.rs
+++ b/beacon_node/lighthouse_network/src/rpc/codec/ssz_snappy.rs
@@ -18,8 +18,8 @@ use tokio_util::codec::{Decoder, Encoder};
 use types::{
     BlobSidecar, ChainSpec, EthSpec, ForkContext, ForkName, Hash256, LightClientBootstrap,
     LightClientFinalityUpdate, LightClientOptimisticUpdate, RuntimeVariableList, SignedBeaconBlock,
-    SignedBeaconBlockAltair, SignedBeaconBlockBase, SignedBeaconBlockCapella,
-    SignedBeaconBlockDeneb, SignedBeaconBlockElectra, SignedBeaconBlockMerge,
+    SignedBeaconBlockAltair, SignedBeaconBlockBase, SignedBeaconBlockBellatrix,
+    SignedBeaconBlockCapella, SignedBeaconBlockDeneb, SignedBeaconBlockElectra,
 };
 use unsigned_varint::codec::Uvi;
 
@@ -403,8 +403,8 @@ fn context_bytes<E: EthSpec>(
                         SignedBeaconBlock::Capella { .. } => {
                             fork_context.to_context_bytes(ForkName::Capella)
                         }
-                        SignedBeaconBlock::Merge { .. } => {
-                            fork_context.to_context_bytes(ForkName::Merge)
+                        SignedBeaconBlock::Bellatrix { .. } => {
+                            fork_context.to_context_bytes(ForkName::Bellatrix)
                         }
                         SignedBeaconBlock::Altair { .. } => {
                             fork_context.to_context_bytes(ForkName::Altair)
@@ -658,8 +658,10 @@ fn handle_rpc_response<E: EthSpec>(
             Some(ForkName::Base) => Ok(Some(RPCResponse::BlocksByRange(Arc::new(
                 SignedBeaconBlock::Base(SignedBeaconBlockBase::from_ssz_bytes(decoded_buffer)?),
             )))),
-            Some(ForkName::Merge) => Ok(Some(RPCResponse::BlocksByRange(Arc::new(
-                SignedBeaconBlock::Merge(SignedBeaconBlockMerge::from_ssz_bytes(decoded_buffer)?),
+            Some(ForkName::Bellatrix) => Ok(Some(RPCResponse::BlocksByRange(Arc::new(
+                SignedBeaconBlock::Bellatrix(SignedBeaconBlockBellatrix::from_ssz_bytes(
+                    decoded_buffer,
+                )?),
             )))),
             Some(ForkName::Capella) => Ok(Some(RPCResponse::BlocksByRange(Arc::new(
                 SignedBeaconBlock::Capella(SignedBeaconBlockCapella::from_ssz_bytes(
@@ -689,8 +691,10 @@ fn handle_rpc_response<E: EthSpec>(
             Some(ForkName::Base) => Ok(Some(RPCResponse::BlocksByRoot(Arc::new(
                 SignedBeaconBlock::Base(SignedBeaconBlockBase::from_ssz_bytes(decoded_buffer)?),
             )))),
-            Some(ForkName::Merge) => Ok(Some(RPCResponse::BlocksByRoot(Arc::new(
-                SignedBeaconBlock::Merge(SignedBeaconBlockMerge::from_ssz_bytes(decoded_buffer)?),
+            Some(ForkName::Bellatrix) => Ok(Some(RPCResponse::BlocksByRoot(Arc::new(
+                SignedBeaconBlock::Bellatrix(SignedBeaconBlockBellatrix::from_ssz_bytes(
+                    decoded_buffer,
+                )?),
             )))),
             Some(ForkName::Capella) => Ok(Some(RPCResponse::BlocksByRoot(Arc::new(
                 SignedBeaconBlock::Capella(SignedBeaconBlockCapella::from_ssz_bytes(
@@ -743,7 +747,7 @@ mod tests {
     use crate::types::{EnrAttestationBitfield, EnrSyncCommitteeBitfield};
     use types::{
         blob_sidecar::BlobIdentifier, BeaconBlock, BeaconBlockAltair, BeaconBlockBase,
-        BeaconBlockMerge, EmptyBlock, Epoch, FullPayload, Signature, Slot,
+        BeaconBlockBellatrix, EmptyBlock, Epoch, FullPayload, Signature, Slot,
     };
 
     type Spec = types::MainnetEthSpec;
@@ -751,13 +755,13 @@ mod tests {
     fn fork_context(fork_name: ForkName) -> ForkContext {
         let mut chain_spec = Spec::default_spec();
         let altair_fork_epoch = Epoch::new(1);
-        let merge_fork_epoch = Epoch::new(2);
+        let bellatrix_fork_epoch = Epoch::new(2);
         let capella_fork_epoch = Epoch::new(3);
         let deneb_fork_epoch = Epoch::new(4);
         let electra_fork_epoch = Epoch::new(5);
 
         chain_spec.altair_fork_epoch = Some(altair_fork_epoch);
-        chain_spec.bellatrix_fork_epoch = Some(merge_fork_epoch);
+        chain_spec.bellatrix_fork_epoch = Some(bellatrix_fork_epoch);
         chain_spec.capella_fork_epoch = Some(capella_fork_epoch);
         chain_spec.deneb_fork_epoch = Some(deneb_fork_epoch);
         chain_spec.electra_fork_epoch = Some(electra_fork_epoch);
@@ -765,7 +769,7 @@ mod tests {
         let current_slot = match fork_name {
             ForkName::Base => Slot::new(0),
             ForkName::Altair => altair_fork_epoch.start_slot(Spec::slots_per_epoch()),
-            ForkName::Merge => merge_fork_epoch.start_slot(Spec::slots_per_epoch()),
+            ForkName::Bellatrix => bellatrix_fork_epoch.start_slot(Spec::slots_per_epoch()),
             ForkName::Capella => capella_fork_epoch.start_slot(Spec::slots_per_epoch()),
             ForkName::Deneb => deneb_fork_epoch.start_slot(Spec::slots_per_epoch()),
             ForkName::Electra => electra_fork_epoch.start_slot(Spec::slots_per_epoch()),
@@ -790,32 +794,38 @@ mod tests {
         Arc::new(BlobSidecar::empty())
     }
 
-    /// Merge block with length < max_rpc_size.
-    fn merge_block_small(fork_context: &ForkContext, spec: &ChainSpec) -> SignedBeaconBlock<Spec> {
-        let mut block: BeaconBlockMerge<_, FullPayload<Spec>> =
-            BeaconBlockMerge::empty(&Spec::default_spec());
+    /// Bellatrix block with length < max_rpc_size.
+    fn bellatrix_block_small(
+        fork_context: &ForkContext,
+        spec: &ChainSpec,
+    ) -> SignedBeaconBlock<Spec> {
+        let mut block: BeaconBlockBellatrix<_, FullPayload<Spec>> =
+            BeaconBlockBellatrix::empty(&Spec::default_spec());
         let tx = VariableList::from(vec![0; 1024]);
         let txs = VariableList::from(std::iter::repeat(tx).take(5000).collect::<Vec<_>>());
 
         block.body.execution_payload.execution_payload.transactions = txs;
 
-        let block = BeaconBlock::Merge(block);
+        let block = BeaconBlock::Bellatrix(block);
         assert!(block.ssz_bytes_len() <= max_rpc_size(fork_context, spec.max_chunk_size as usize));
         SignedBeaconBlock::from_block(block, Signature::empty())
     }
 
-    /// Merge block with length > MAX_RPC_SIZE.
-    /// The max limit for a merge block is in the order of ~16GiB which wouldn't fit in memory.
-    /// Hence, we generate a merge block just greater than `MAX_RPC_SIZE` to test rejection on the rpc layer.
-    fn merge_block_large(fork_context: &ForkContext, spec: &ChainSpec) -> SignedBeaconBlock<Spec> {
-        let mut block: BeaconBlockMerge<_, FullPayload<Spec>> =
-            BeaconBlockMerge::empty(&Spec::default_spec());
+    /// Bellatrix block with length > MAX_RPC_SIZE.
+    /// The max limit for a Bellatrix block is in the order of ~16GiB which wouldn't fit in memory.
+    /// Hence, we generate a Bellatrix block just greater than `MAX_RPC_SIZE` to test rejection on the rpc layer.
+    fn bellatrix_block_large(
+        fork_context: &ForkContext,
+        spec: &ChainSpec,
+    ) -> SignedBeaconBlock<Spec> {
+        let mut block: BeaconBlockBellatrix<_, FullPayload<Spec>> =
+            BeaconBlockBellatrix::empty(&Spec::default_spec());
         let tx = VariableList::from(vec![0; 1024]);
         let txs = VariableList::from(std::iter::repeat(tx).take(100000).collect::<Vec<_>>());
 
         block.body.execution_payload.execution_payload.transactions = txs;
 
-        let block = BeaconBlock::Merge(block);
+        let block = BeaconBlock::Bellatrix(block);
         assert!(block.ssz_bytes_len() > max_rpc_size(fork_context, spec.max_chunk_size as usize));
         SignedBeaconBlock::from_block(block, Signature::empty())
     }
@@ -1172,25 +1182,27 @@ mod tests {
             Ok(Some(RPCResponse::BlocksByRange(Arc::new(altair_block()))))
         );
 
-        let merge_block_small = merge_block_small(&fork_context(ForkName::Merge), &chain_spec);
-        let merge_block_large = merge_block_large(&fork_context(ForkName::Merge), &chain_spec);
+        let bellatrix_block_small =
+            bellatrix_block_small(&fork_context(ForkName::Bellatrix), &chain_spec);
+        let bellatrix_block_large =
+            bellatrix_block_large(&fork_context(ForkName::Bellatrix), &chain_spec);
 
         assert_eq!(
             encode_then_decode_response(
                 SupportedProtocol::BlocksByRangeV2,
                 RPCCodedResponse::Success(RPCResponse::BlocksByRange(Arc::new(
-                    merge_block_small.clone()
+                    bellatrix_block_small.clone()
                 ))),
-                ForkName::Merge,
+                ForkName::Bellatrix,
                 &chain_spec,
             ),
             Ok(Some(RPCResponse::BlocksByRange(Arc::new(
-                merge_block_small.clone()
+                bellatrix_block_small.clone()
             ))))
         );
 
         let mut encoded =
-            encode_without_length_checks(merge_block_large.as_ssz_bytes(), ForkName::Merge)
+            encode_without_length_checks(bellatrix_block_large.as_ssz_bytes(), ForkName::Bellatrix)
                 .unwrap();
 
         assert!(
@@ -1198,7 +1210,7 @@ mod tests {
                 decode_response(
                     SupportedProtocol::BlocksByRangeV2,
                     &mut encoded,
-                    ForkName::Merge,
+                    ForkName::Bellatrix,
                     &chain_spec,
                 )
                 .unwrap_err(),
@@ -1248,16 +1260,18 @@ mod tests {
             encode_then_decode_response(
                 SupportedProtocol::BlocksByRootV2,
                 RPCCodedResponse::Success(RPCResponse::BlocksByRoot(Arc::new(
-                    merge_block_small.clone()
+                    bellatrix_block_small.clone()
                 ))),
-                ForkName::Merge,
+                ForkName::Bellatrix,
                 &chain_spec,
             ),
-            Ok(Some(RPCResponse::BlocksByRoot(Arc::new(merge_block_small))))
+            Ok(Some(RPCResponse::BlocksByRoot(Arc::new(
+                bellatrix_block_small
+            ))))
         );
 
         let mut encoded =
-            encode_without_length_checks(merge_block_large.as_ssz_bytes(), ForkName::Merge)
+            encode_without_length_checks(bellatrix_block_large.as_ssz_bytes(), ForkName::Bellatrix)
                 .unwrap();
 
         assert!(
@@ -1265,7 +1279,7 @@ mod tests {
                 decode_response(
                     SupportedProtocol::BlocksByRootV2,
                     &mut encoded,
-                    ForkName::Merge,
+                    ForkName::Bellatrix,
                     &chain_spec,
                 )
                 .unwrap_err(),
diff --git a/beacon_node/lighthouse_network/src/rpc/handler.rs b/beacon_node/lighthouse_network/src/rpc/handler.rs
index cb537f23590..daf95fb8c91 100644
--- a/beacon_node/lighthouse_network/src/rpc/handler.rs
+++ b/beacon_node/lighthouse_network/src/rpc/handler.rs
@@ -163,7 +163,7 @@ struct InboundInfo<E: EthSpec> {
     /// Protocol of the original request we received from the peer.
     protocol: Protocol,
     /// Responses that the peer is still expecting from us.
-    remaining_chunks: u64,
+    max_remaining_chunks: u64,
     /// Useful to timing how long each request took to process. Currently only used by
     /// BlocksByRange.
     request_start_time: Instant,
@@ -180,7 +180,7 @@ struct OutboundInfo<Id, E: EthSpec> {
     /// Info over the protocol this substream is handling.
     proto: Protocol,
     /// Number of chunks to be seen from the peer's response.
-    remaining_chunks: Option<u64>,
+    max_remaining_chunks: Option<u64>,
     /// `Id` as given by the application that sent the request.
     req_id: Id,
 }
@@ -352,6 +352,31 @@ where
         !matches!(self.state, HandlerState::Deactivated)
     }
 
+    // NOTE: This function gets polled to completion upon a connection close.
+    fn poll_close(&mut self, _: &mut Context<'_>) -> Poll<Option<Self::ToBehaviour>> {
+        // Inform the network behaviour of any failed requests
+
+        while let Some(substream_id) = self.outbound_substreams.keys().next().cloned() {
+            let outbound_info = self
+                .outbound_substreams
+                .remove(&substream_id)
+                .expect("The value must exist for a key");
+            // If the state of the connection is closing, we do not need to report this case to
+            // the behaviour, as the connection has just closed non-gracefully
+            if matches!(outbound_info.state, OutboundSubstreamState::Closing(_)) {
+                continue;
+            }
+
+            // Register this request as an RPC Error
+            return Poll::Ready(Some(HandlerEvent::Err(HandlerErr::Outbound {
+                error: RPCError::Disconnected,
+                proto: outbound_info.proto,
+                id: outbound_info.req_id,
+            })));
+        }
+        Poll::Ready(None)
+    }
+
     fn poll(
         &mut self,
         cx: &mut Context<'_>,
@@ -471,7 +496,7 @@ where
                         // Process one more message if one exists.
                         if let Some(message) = info.pending_items.pop_front() {
                             // If this is the last chunk, terminate the stream.
-                            let last_chunk = info.remaining_chunks <= 1;
+                            let last_chunk = info.max_remaining_chunks <= 1;
                             let fut =
                                 send_message_to_inbound_substream(substream, message, last_chunk)
                                     .boxed();
@@ -537,7 +562,8 @@ where
                             {
                                 // The substream is still active, decrement the remaining
                                 // chunks expected.
-                                info.remaining_chunks = info.remaining_chunks.saturating_sub(1);
+                                info.max_remaining_chunks =
+                                    info.max_remaining_chunks.saturating_sub(1);
 
                                 // If this substream has not ended, we reset the timer.
                                 // Each chunk is allowed RESPONSE_TIMEOUT to be sent.
@@ -552,7 +578,7 @@ where
                                     // Process one more message if one exists.
                                     if let Some(message) = info.pending_items.pop_front() {
                                         // If this is the last chunk, terminate the stream.
-                                        let last_chunk = info.remaining_chunks <= 1;
+                                        let last_chunk = info.max_remaining_chunks <= 1;
                                         let fut = send_message_to_inbound_substream(
                                             substream, message, last_chunk,
                                         )
@@ -664,15 +690,19 @@ where
                     request,
                 } => match substream.poll_next_unpin(cx) {
                     Poll::Ready(Some(Ok(response))) => {
-                        if request.expected_responses() > 1 && !response.close_after() {
+                        if request.expect_exactly_one_response() || response.close_after() {
+                            // either this is a single response request or this response closes the
+                            // stream
+                            entry.get_mut().state = OutboundSubstreamState::Closing(substream);
+                        } else {
                             let substream_entry = entry.get_mut();
                             let delay_key = &substream_entry.delay_key;
                             // chunks left after this one
-                            let remaining_chunks = substream_entry
-                                .remaining_chunks
+                            let max_remaining_chunks = substream_entry
+                                .max_remaining_chunks
                                 .map(|count| count.saturating_sub(1))
                                 .unwrap_or_else(|| 0);
-                            if remaining_chunks == 0 {
+                            if max_remaining_chunks == 0 {
                                 // this is the last expected message, close the stream as all expected chunks have been received
                                 substream_entry.state = OutboundSubstreamState::Closing(substream);
                             } else {
@@ -682,14 +712,10 @@ where
                                         substream,
                                         request,
                                     };
-                                substream_entry.remaining_chunks = Some(remaining_chunks);
+                                substream_entry.max_remaining_chunks = Some(max_remaining_chunks);
                                 self.outbound_substreams_delay
                                     .reset(delay_key, self.resp_timeout);
                             }
-                        } else {
-                            // either this is a single response request or this response closes the
-                            // stream
-                            entry.get_mut().state = OutboundSubstreamState::Closing(substream);
                         }
 
                         // Check what type of response we got and report it accordingly
@@ -725,7 +751,16 @@ where
                         self.outbound_substreams_delay.remove(delay_key);
                         entry.remove_entry();
                         // notify the application error
-                        if request.expected_responses() > 1 {
+                        if request.expect_exactly_one_response() {
+                            // return an error, stream should not have closed early.
+                            return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour(
+                                HandlerEvent::Err(HandlerErr::Outbound {
+                                    id: request_id,
+                                    proto: request.versioned_protocol().protocol(),
+                                    error: RPCError::IncompleteStream,
+                                }),
+                            ));
+                        } else {
                             // return an end of stream result
                             return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour(
                                 HandlerEvent::Ok(RPCReceived::EndOfStream(
@@ -734,16 +769,6 @@ where
                                 )),
                             ));
                         }
-
-                        // else we return an error, stream should not have closed early.
-                        let outbound_err = HandlerErr::Outbound {
-                            id: request_id,
-                            proto: request.versioned_protocol().protocol(),
-                            error: RPCError::IncompleteStream,
-                        };
-                        return Poll::Ready(ConnectionHandlerEvent::NotifyBehaviour(
-                            HandlerEvent::Err(outbound_err),
-                        ));
                     }
                     Poll::Pending => {
                         entry.get_mut().state =
@@ -880,10 +905,10 @@ where
         }
 
         let (req, substream) = substream;
-        let expected_responses = req.expected_responses();
+        let max_responses = req.max_responses();
 
         // store requests that expect responses
-        if expected_responses > 0 {
+        if max_responses > 0 {
             if self.inbound_substreams.len() < MAX_INBOUND_SUBSTREAMS {
                 // Store the stream and tag the output.
                 let delay_key = self
@@ -894,14 +919,13 @@ where
                     self.current_inbound_substream_id,
                     InboundInfo {
                         state: awaiting_stream,
-                        pending_items: VecDeque::with_capacity(std::cmp::min(
-                            expected_responses,
-                            128,
-                        ) as usize),
+                        pending_items: VecDeque::with_capacity(
+                            std::cmp::min(max_responses, 128) as usize
+                        ),
                         delay_key: Some(delay_key),
                         protocol: req.versioned_protocol().protocol(),
                         request_start_time: Instant::now(),
-                        remaining_chunks: expected_responses,
+                        max_remaining_chunks: max_responses,
                     },
                 );
             } else {
@@ -948,8 +972,14 @@ where
         }
 
         // add the stream to substreams if we expect a response, otherwise drop the stream.
-        let expected_responses = request.expected_responses();
-        if expected_responses > 0 {
+        let max_responses = request.max_responses();
+        if max_responses > 0 {
+            let max_remaining_chunks = if request.expect_exactly_one_response() {
+                // Currently enforced only for multiple responses
+                None
+            } else {
+                Some(max_responses)
+            };
             // new outbound request. Store the stream and tag the output.
             let delay_key = self
                 .outbound_substreams_delay
@@ -958,12 +988,6 @@ where
                 substream: Box::new(substream),
                 request,
             };
-            let expected_responses = if expected_responses > 1 {
-                // Currently enforced only for multiple responses
-                Some(expected_responses)
-            } else {
-                None
-            };
             if self
                 .outbound_substreams
                 .insert(
@@ -972,7 +996,7 @@ where
                         state: awaiting_stream,
                         delay_key,
                         proto,
-                        remaining_chunks: expected_responses,
+                        max_remaining_chunks,
                         req_id: id,
                     },
                 )
diff --git a/beacon_node/lighthouse_network/src/rpc/methods.rs b/beacon_node/lighthouse_network/src/rpc/methods.rs
index 67eea09ea77..1b0486ff771 100644
--- a/beacon_node/lighthouse_network/src/rpc/methods.rs
+++ b/beacon_node/lighthouse_network/src/rpc/methods.rs
@@ -483,27 +483,6 @@ impl<E: EthSpec> RPCCodedResponse<E> {
         RPCCodedResponse::Error(code, err)
     }
 
-    /// Specifies which response allows for multiple chunks for the stream handler.
-    pub fn multiple_responses(&self) -> bool {
-        match self {
-            RPCCodedResponse::Success(resp) => match resp {
-                RPCResponse::Status(_) => false,
-                RPCResponse::BlocksByRange(_) => true,
-                RPCResponse::BlocksByRoot(_) => true,
-                RPCResponse::BlobsByRange(_) => true,
-                RPCResponse::BlobsByRoot(_) => true,
-                RPCResponse::Pong(_) => false,
-                RPCResponse::MetaData(_) => false,
-                RPCResponse::LightClientBootstrap(_) => false,
-                RPCResponse::LightClientOptimisticUpdate(_) => false,
-                RPCResponse::LightClientFinalityUpdate(_) => false,
-            },
-            RPCCodedResponse::Error(_, _) => true,
-            // Stream terminations are part of responses that have chunks
-            RPCCodedResponse::StreamTermination(_) => true,
-        }
-    }
-
     /// Returns true if this response always terminates the stream.
     pub fn close_after(&self) -> bool {
         !matches!(self, RPCCodedResponse::Success(_))
diff --git a/beacon_node/lighthouse_network/src/rpc/outbound.rs b/beacon_node/lighthouse_network/src/rpc/outbound.rs
index 09ef6185957..8ea7b84bc95 100644
--- a/beacon_node/lighthouse_network/src/rpc/outbound.rs
+++ b/beacon_node/lighthouse_network/src/rpc/outbound.rs
@@ -91,8 +91,8 @@ impl<E: EthSpec> OutboundRequest<E> {
     }
     /* These functions are used in the handler for stream management */
 
-    /// Number of responses expected for this request.
-    pub fn expected_responses(&self) -> u64 {
+    /// Maximum number of responses expected for this request.
+    pub fn max_responses(&self) -> u64 {
         match self {
             OutboundRequest::Status(_) => 1,
             OutboundRequest::Goodbye(_) => 0,
@@ -105,6 +105,19 @@ impl<E: EthSpec> OutboundRequest<E> {
         }
     }
 
+    pub fn expect_exactly_one_response(&self) -> bool {
+        match self {
+            OutboundRequest::Status(_) => true,
+            OutboundRequest::Goodbye(_) => false,
+            OutboundRequest::BlocksByRange(_) => false,
+            OutboundRequest::BlocksByRoot(_) => false,
+            OutboundRequest::BlobsByRange(_) => false,
+            OutboundRequest::BlobsByRoot(_) => false,
+            OutboundRequest::Ping(_) => true,
+            OutboundRequest::MetaData(_) => true,
+        }
+    }
+
     /// Gives the corresponding `SupportedProtocol` to this request.
     pub fn versioned_protocol(&self) -> SupportedProtocol {
         match self {
diff --git a/beacon_node/lighthouse_network/src/rpc/protocol.rs b/beacon_node/lighthouse_network/src/rpc/protocol.rs
index 6ff72f658a8..12a7f09338e 100644
--- a/beacon_node/lighthouse_network/src/rpc/protocol.rs
+++ b/beacon_node/lighthouse_network/src/rpc/protocol.rs
@@ -17,8 +17,8 @@ use tokio_util::{
     compat::{Compat, FuturesAsyncReadCompatExt},
 };
 use types::{
-    BeaconBlock, BeaconBlockAltair, BeaconBlockBase, BeaconBlockCapella, BeaconBlockElectra,
-    BeaconBlockMerge, BlobSidecar, ChainSpec, EmptyBlock, EthSpec, ForkContext, ForkName,
+    BeaconBlock, BeaconBlockAltair, BeaconBlockBase, BeaconBlockBellatrix, BeaconBlockCapella,
+    BeaconBlockElectra, BlobSidecar, ChainSpec, EmptyBlock, EthSpec, ForkContext, ForkName,
     LightClientBootstrap, LightClientBootstrapAltair, LightClientFinalityUpdate,
     LightClientFinalityUpdateAltair, LightClientOptimisticUpdate,
     LightClientOptimisticUpdateAltair, MainnetEthSpec, Signature, SignedBeaconBlock,
@@ -53,8 +53,8 @@ lazy_static! {
     .as_ssz_bytes()
     .len();
 
-    pub static ref SIGNED_BEACON_BLOCK_MERGE_MIN: usize = SignedBeaconBlock::<MainnetEthSpec>::from_block(
-        BeaconBlock::Merge(BeaconBlockMerge::<MainnetEthSpec>::empty(&MainnetEthSpec::default_spec())),
+    pub static ref SIGNED_BEACON_BLOCK_BELLATRIX_MIN: usize = SignedBeaconBlock::<MainnetEthSpec>::from_block(
+        BeaconBlock::Bellatrix(BeaconBlockBellatrix::<MainnetEthSpec>::empty(&MainnetEthSpec::default_spec())),
         Signature::empty(),
     )
     .as_ssz_bytes()
@@ -74,14 +74,14 @@ lazy_static! {
     .as_ssz_bytes()
     .len();
 
-    /// The `BeaconBlockMerge` block has an `ExecutionPayload` field which has a max size ~16 GiB for future proofing.
+    /// The `BeaconBlockBellatrix` block has an `ExecutionPayload` field which has a max size ~16 GiB for future proofing.
     /// We calculate the value from its fields instead of constructing the block and checking the length.
     /// Note: This is only the theoretical upper bound. We further bound the max size we receive over the network
     /// with `max_chunk_size`.
-    pub static ref SIGNED_BEACON_BLOCK_MERGE_MAX: usize =
+    pub static ref SIGNED_BEACON_BLOCK_BELLATRIX_MAX: usize =
     // Size of a full altair block
     *SIGNED_BEACON_BLOCK_ALTAIR_MAX
-    + types::ExecutionPayload::<MainnetEthSpec>::max_execution_payload_merge_size() // adding max size of execution payload (~16gb)
+    + types::ExecutionPayload::<MainnetEthSpec>::max_execution_payload_bellatrix_size() // adding max size of execution payload (~16gb)
     + ssz::BYTES_PER_LENGTH_OFFSET; // Adding the additional ssz offset for the `ExecutionPayload` field
 
     pub static ref SIGNED_BEACON_BLOCK_CAPELLA_MAX: usize = *SIGNED_BEACON_BLOCK_CAPELLA_MAX_WITHOUT_PAYLOAD
@@ -134,7 +134,7 @@ const REQUEST_TIMEOUT: u64 = 15;
 pub fn max_rpc_size(fork_context: &ForkContext, max_chunk_size: usize) -> usize {
     match fork_context.current_fork() {
         ForkName::Altair | ForkName::Base => max_chunk_size / 10,
-        ForkName::Merge => max_chunk_size,
+        ForkName::Bellatrix => max_chunk_size,
         ForkName::Capella => max_chunk_size,
         ForkName::Deneb => max_chunk_size,
         ForkName::Electra => max_chunk_size,
@@ -154,20 +154,20 @@ pub fn rpc_block_limits_by_fork(current_fork: ForkName) -> RpcLimits {
             *SIGNED_BEACON_BLOCK_BASE_MIN, // Base block is smaller than altair blocks
             *SIGNED_BEACON_BLOCK_ALTAIR_MAX, // Altair block is larger than base blocks
         ),
-        ForkName::Merge => RpcLimits::new(
-            *SIGNED_BEACON_BLOCK_BASE_MIN, // Base block is smaller than altair and merge blocks
-            *SIGNED_BEACON_BLOCK_MERGE_MAX, // Merge block is larger than base and altair blocks
+        ForkName::Bellatrix => RpcLimits::new(
+            *SIGNED_BEACON_BLOCK_BASE_MIN, // Base block is smaller than altair and bellatrix blocks
+            *SIGNED_BEACON_BLOCK_BELLATRIX_MAX, // Bellatrix block is larger than base and altair blocks
         ),
         ForkName::Capella => RpcLimits::new(
-            *SIGNED_BEACON_BLOCK_BASE_MIN, // Base block is smaller than altair and merge blocks
+            *SIGNED_BEACON_BLOCK_BASE_MIN, // Base block is smaller than altair and bellatrix blocks
             *SIGNED_BEACON_BLOCK_CAPELLA_MAX, // Capella block is larger than base, altair and merge blocks
         ),
         ForkName::Deneb => RpcLimits::new(
-            *SIGNED_BEACON_BLOCK_BASE_MIN, // Base block is smaller than altair and merge blocks
+            *SIGNED_BEACON_BLOCK_BASE_MIN, // Base block is smaller than altair and bellatrix blocks
             *SIGNED_BEACON_BLOCK_DENEB_MAX, // Deneb block is larger than all prior fork blocks
         ),
         ForkName::Electra => RpcLimits::new(
-            *SIGNED_BEACON_BLOCK_BASE_MIN, // Base block is smaller than altair and merge blocks
+            *SIGNED_BEACON_BLOCK_BASE_MIN, // Base block is smaller than altair and bellatrix blocks
             *SIGNED_BEACON_BLOCK_ELECTRA_MAX, // Electra block is larger than Deneb block
         ),
     }
@@ -178,7 +178,9 @@ fn rpc_light_client_finality_update_limits_by_fork(current_fork: ForkName) -> Rp
 
     match &current_fork {
         ForkName::Base => RpcLimits::new(0, 0),
-        ForkName::Altair | ForkName::Merge => RpcLimits::new(altair_fixed_len, altair_fixed_len),
+        ForkName::Altair | ForkName::Bellatrix => {
+            RpcLimits::new(altair_fixed_len, altair_fixed_len)
+        }
         ForkName::Capella => {
             RpcLimits::new(altair_fixed_len, *LIGHT_CLIENT_FINALITY_UPDATE_CAPELLA_MAX)
         }
@@ -196,7 +198,9 @@ fn rpc_light_client_optimistic_update_limits_by_fork(current_fork: ForkName) ->
 
     match &current_fork {
         ForkName::Base => RpcLimits::new(0, 0),
-        ForkName::Altair | ForkName::Merge => RpcLimits::new(altair_fixed_len, altair_fixed_len),
+        ForkName::Altair | ForkName::Bellatrix => {
+            RpcLimits::new(altair_fixed_len, altair_fixed_len)
+        }
         ForkName::Capella => RpcLimits::new(
             altair_fixed_len,
             *LIGHT_CLIENT_OPTIMISTIC_UPDATE_CAPELLA_MAX,
@@ -216,7 +220,9 @@ fn rpc_light_client_bootstrap_limits_by_fork(current_fork: ForkName) -> RpcLimit
 
     match &current_fork {
         ForkName::Base => RpcLimits::new(0, 0),
-        ForkName::Altair | ForkName::Merge => RpcLimits::new(altair_fixed_len, altair_fixed_len),
+        ForkName::Altair | ForkName::Bellatrix => {
+            RpcLimits::new(altair_fixed_len, altair_fixed_len)
+        }
         ForkName::Capella => RpcLimits::new(altair_fixed_len, *LIGHT_CLIENT_BOOTSTRAP_CAPELLA_MAX),
         ForkName::Deneb => RpcLimits::new(altair_fixed_len, *LIGHT_CLIENT_BOOTSTRAP_DENEB_MAX),
         ForkName::Electra => RpcLimits::new(altair_fixed_len, *LIGHT_CLIENT_BOOTSTRAP_ELECTRA_MAX),
@@ -654,8 +660,8 @@ pub enum InboundRequest<E: EthSpec> {
 impl<E: EthSpec> InboundRequest<E> {
     /* These functions are used in the handler for stream management */
 
-    /// Number of responses expected for this request.
-    pub fn expected_responses(&self) -> u64 {
+    /// Maximum number of responses expected for this request.
+    pub fn max_responses(&self) -> u64 {
         match self {
             InboundRequest::Status(_) => 1,
             InboundRequest::Goodbye(_) => 0,
diff --git a/beacon_node/lighthouse_network/src/rpc/rate_limiter.rs b/beacon_node/lighthouse_network/src/rpc/rate_limiter.rs
index 801a4af54b3..b304eb546da 100644
--- a/beacon_node/lighthouse_network/src/rpc/rate_limiter.rs
+++ b/beacon_node/lighthouse_network/src/rpc/rate_limiter.rs
@@ -228,7 +228,7 @@ impl RPCRateLimiterBuilder {
 
 pub trait RateLimiterItem {
     fn protocol(&self) -> Protocol;
-    fn expected_responses(&self) -> u64;
+    fn max_responses(&self) -> u64;
 }
 
 impl<E: EthSpec> RateLimiterItem for super::InboundRequest<E> {
@@ -236,8 +236,8 @@ impl<E: EthSpec> RateLimiterItem for super::InboundRequest<E> {
         self.versioned_protocol().protocol()
     }
 
-    fn expected_responses(&self) -> u64 {
-        self.expected_responses()
+    fn max_responses(&self) -> u64 {
+        self.max_responses()
     }
 }
 
@@ -246,8 +246,8 @@ impl<E: EthSpec> RateLimiterItem for super::OutboundRequest<E> {
         self.versioned_protocol().protocol()
     }
 
-    fn expected_responses(&self) -> u64 {
-        self.expected_responses()
+    fn max_responses(&self) -> u64 {
+        self.max_responses()
     }
 }
 impl RPCRateLimiter {
@@ -299,7 +299,7 @@ impl RPCRateLimiter {
         request: &Item,
     ) -> Result<(), RateLimitedErr> {
         let time_since_start = self.init_time.elapsed();
-        let tokens = request.expected_responses().max(1);
+        let tokens = request.max_responses().max(1);
 
         let check =
             |limiter: &mut Limiter<PeerId>| limiter.allows(time_since_start, peer_id, tokens);
diff --git a/beacon_node/lighthouse_network/src/service/gossipsub_scoring_parameters.rs b/beacon_node/lighthouse_network/src/service/gossipsub_scoring_parameters.rs
index 0846a9f4aa6..c6a764bb0ef 100644
--- a/beacon_node/lighthouse_network/src/service/gossipsub_scoring_parameters.rs
+++ b/beacon_node/lighthouse_network/src/service/gossipsub_scoring_parameters.rs
@@ -1,9 +1,6 @@
 use crate::types::{GossipEncoding, GossipKind, GossipTopic};
 use crate::{error, TopicHash};
-use gossipsub::{
-    Config as GossipsubConfig, IdentTopic as Topic, PeerScoreParams, PeerScoreThresholds,
-    TopicScoreParams,
-};
+use gossipsub::{IdentTopic as Topic, PeerScoreParams, PeerScoreThresholds, TopicScoreParams};
 use std::cmp::max;
 use std::collections::HashMap;
 use std::marker::PhantomData;
@@ -54,7 +51,7 @@ pub struct PeerScoreSettings<E: EthSpec> {
 }
 
 impl<E: EthSpec> PeerScoreSettings<E> {
-    pub fn new(chain_spec: &ChainSpec, gs_config: &GossipsubConfig) -> PeerScoreSettings<E> {
+    pub fn new(chain_spec: &ChainSpec, mesh_n: usize) -> PeerScoreSettings<E> {
         let slot = Duration::from_secs(chain_spec.seconds_per_slot);
         let beacon_attestation_subnet_weight = 1.0 / chain_spec.attestation_subnet_count as f64;
         let max_positive_score = (MAX_IN_MESH_SCORE + MAX_FIRST_MESSAGE_DELIVERIES_SCORE)
@@ -72,7 +69,7 @@ impl<E: EthSpec> PeerScoreSettings<E> {
             max_positive_score,
             decay_interval: max(Duration::from_secs(1), slot),
             decay_to_zero: 0.01,
-            mesh_n: gs_config.mesh_n(),
+            mesh_n,
             max_committees_per_slot: chain_spec.max_committees_per_slot,
             target_committee_size: chain_spec.target_committee_size,
             target_aggregators_per_committee: chain_spec.target_aggregators_per_committee as usize,
diff --git a/beacon_node/lighthouse_network/src/service/mod.rs b/beacon_node/lighthouse_network/src/service/mod.rs
index 3dd1d9b50c9..8ed8658a4bb 100644
--- a/beacon_node/lighthouse_network/src/service/mod.rs
+++ b/beacon_node/lighthouse_network/src/service/mod.rs
@@ -140,7 +140,7 @@ impl<AppReqId: ReqId, E: EthSpec> Network<AppReqId, E> {
     ) -> error::Result<(Self, Arc<NetworkGlobals<E>>)> {
         let log = log.new(o!("service"=> "libp2p"));
 
-        let mut config = ctx.config.clone();
+        let config = ctx.config.clone();
         trace!(log, "Libp2p Service starting");
         // initialise the node's ID
         let local_keypair = utils::load_private_key(&config, &log);
@@ -180,7 +180,19 @@ impl<AppReqId: ReqId, E: EthSpec> Network<AppReqId, E> {
             .eth2()
             .expect("Local ENR must have a fork id");
 
-        let score_settings = PeerScoreSettings::new(ctx.chain_spec, &config.gs_config);
+        let gossipsub_config_params = GossipsubConfigParams {
+            message_domain_valid_snappy: ctx.chain_spec.message_domain_valid_snappy,
+            gossip_max_size: ctx.chain_spec.gossip_max_size as usize,
+        };
+        let gs_config = gossipsub_config(
+            config.network_load,
+            ctx.fork_context.clone(),
+            gossipsub_config_params,
+            ctx.chain_spec.seconds_per_slot,
+            E::slots_per_epoch(),
+        );
+
+        let score_settings = PeerScoreSettings::new(ctx.chain_spec, gs_config.mesh_n());
 
         let gossip_cache = {
             let slot_duration = std::time::Duration::from_secs(ctx.chain_spec.seconds_per_slot);
@@ -248,18 +260,6 @@ impl<AppReqId: ReqId, E: EthSpec> Network<AppReqId, E> {
                 max_subscriptions_per_request: max_topics * 2,
             };
 
-            let gossipsub_config_params = GossipsubConfigParams {
-                message_domain_valid_snappy: ctx.chain_spec.message_domain_valid_snappy,
-                gossip_max_size: ctx.chain_spec.gossip_max_size as usize,
-            };
-            config.gs_config = gossipsub_config(
-                config.network_load,
-                ctx.fork_context.clone(),
-                gossipsub_config_params,
-                ctx.chain_spec.seconds_per_slot,
-                E::slots_per_epoch(),
-            );
-
             // If metrics are enabled for libp2p build the configuration
             let gossipsub_metrics = ctx.libp2p_registry.as_mut().map(|registry| {
                 (
@@ -268,10 +268,10 @@ impl<AppReqId: ReqId, E: EthSpec> Network<AppReqId, E> {
                 )
             });
 
-            let snappy_transform = SnappyTransform::new(config.gs_config.max_transmit_size());
+            let snappy_transform = SnappyTransform::new(gs_config.max_transmit_size());
             let mut gossipsub = Gossipsub::new_with_subscription_filter_and_transform(
                 MessageAuthenticity::Anonymous,
-                config.gs_config.clone(),
+                gs_config.clone(),
                 gossipsub_metrics,
                 filter,
                 snappy_transform,
@@ -972,6 +972,12 @@ impl<AppReqId: ReqId, E: EthSpec> Network<AppReqId, E> {
             .goodbye_peer(peer_id, reason, source);
     }
 
+    /// Hard (ungraceful) disconnect for testing purposes only
+    /// Use goodbye_peer for disconnections, do not use this function.
+    pub fn __hard_disconnect_testing_only(&mut self, peer_id: PeerId) {
+        let _ = self.swarm.disconnect_peer_id(peer_id);
+    }
+
     /// Returns an iterator over all enr entries in the DHT.
     pub fn enr_entries(&self) -> Vec<Enr> {
         self.discovery().table_entries_enr()
@@ -1373,12 +1379,18 @@ impl<AppReqId: ReqId, E: EthSpec> Network<AppReqId, E> {
         let peer_id = event.peer_id;
 
         if !self.peer_manager().is_connected(&peer_id) {
-            debug!(
-                self.log,
-                "Ignoring rpc message of disconnecting peer";
-                event
-            );
-            return None;
+            // Sync expects a RPCError::Disconnected to drop associated lookups with this peer.
+            // Silencing this event breaks the API contract with RPC where every request ends with
+            // - A stream termination event, or
+            // - An RPCError event
+            if !matches!(event.event, HandlerEvent::Err(HandlerErr::Outbound { .. })) {
+                debug!(
+                    self.log,
+                    "Ignoring rpc message of disconnecting peer";
+                    event
+                );
+                return None;
+            }
         }
 
         let handler_id = event.conn_id;
@@ -1681,12 +1693,16 @@ impl<AppReqId: ReqId, E: EthSpec> Network<AppReqId, E> {
             libp2p::upnp::Event::NewExternalAddr(addr) => {
                 info!(self.log, "UPnP route established"; "addr" => %addr);
                 let mut iter = addr.iter();
-                // Skip Ip address.
-                iter.next();
+                let is_ip6 = {
+                    let addr = iter.next();
+                    matches!(addr, Some(MProtocol::Ip6(_)))
+                };
                 match iter.next() {
                     Some(multiaddr::Protocol::Udp(udp_port)) => match iter.next() {
                         Some(multiaddr::Protocol::QuicV1) => {
-                            if let Err(e) = self.discovery_mut().update_enr_quic_port(udp_port) {
+                            if let Err(e) =
+                                self.discovery_mut().update_enr_quic_port(udp_port, is_ip6)
+                            {
                                 warn!(self.log, "Failed to update ENR"; "error" => e);
                             }
                         }
@@ -1695,7 +1711,7 @@ impl<AppReqId: ReqId, E: EthSpec> Network<AppReqId, E> {
                         }
                     },
                     Some(multiaddr::Protocol::Tcp(tcp_port)) => {
-                        if let Err(e) = self.discovery_mut().update_enr_tcp_port(tcp_port) {
+                        if let Err(e) = self.discovery_mut().update_enr_tcp_port(tcp_port, is_ip6) {
                             warn!(self.log, "Failed to update ENR"; "error" => e);
                         }
                     }
diff --git a/beacon_node/lighthouse_network/src/types/pubsub.rs b/beacon_node/lighthouse_network/src/types/pubsub.rs
index a5cf03412d5..ed63ad014c9 100644
--- a/beacon_node/lighthouse_network/src/types/pubsub.rs
+++ b/beacon_node/lighthouse_network/src/types/pubsub.rs
@@ -10,8 +10,8 @@ use types::{
     Attestation, AttesterSlashing, BlobSidecar, EthSpec, ForkContext, ForkName,
     LightClientFinalityUpdate, LightClientOptimisticUpdate, ProposerSlashing,
     SignedAggregateAndProof, SignedBeaconBlock, SignedBeaconBlockAltair, SignedBeaconBlockBase,
-    SignedBeaconBlockCapella, SignedBeaconBlockDeneb, SignedBeaconBlockElectra,
-    SignedBeaconBlockMerge, SignedBlsToExecutionChange, SignedContributionAndProof,
+    SignedBeaconBlockBellatrix, SignedBeaconBlockCapella, SignedBeaconBlockDeneb,
+    SignedBeaconBlockElectra, SignedBlsToExecutionChange, SignedContributionAndProof,
     SignedVoluntaryExit, SubnetId, SyncCommitteeMessage, SyncSubnetId,
 };
 
@@ -179,8 +179,8 @@ impl<E: EthSpec> PubsubMessage<E> {
                                     SignedBeaconBlockAltair::from_ssz_bytes(data)
                                         .map_err(|e| format!("{:?}", e))?,
                                 ),
-                                Some(ForkName::Merge) => SignedBeaconBlock::<E>::Merge(
-                                    SignedBeaconBlockMerge::from_ssz_bytes(data)
+                                Some(ForkName::Bellatrix) => SignedBeaconBlock::<E>::Bellatrix(
+                                    SignedBeaconBlockBellatrix::from_ssz_bytes(data)
                                         .map_err(|e| format!("{:?}", e))?,
                                 ),
                                 Some(ForkName::Capella) => SignedBeaconBlock::<E>::Capella(
@@ -219,7 +219,7 @@ impl<E: EthSpec> PubsubMessage<E> {
                             Some(
                                 ForkName::Base
                                 | ForkName::Altair
-                                | ForkName::Merge
+                                | ForkName::Bellatrix
                                 | ForkName::Capella,
                             )
                             | None => Err(format!(
diff --git a/beacon_node/lighthouse_network/src/types/topics.rs b/beacon_node/lighthouse_network/src/types/topics.rs
index 7cbb5bac57f..c5f4b0c9ebb 100644
--- a/beacon_node/lighthouse_network/src/types/topics.rs
+++ b/beacon_node/lighthouse_network/src/types/topics.rs
@@ -47,7 +47,7 @@ pub fn fork_core_topics<E: EthSpec>(fork_name: &ForkName, spec: &ChainSpec) -> V
     match fork_name {
         ForkName::Base => BASE_CORE_TOPICS.to_vec(),
         ForkName::Altair => ALTAIR_CORE_TOPICS.to_vec(),
-        ForkName::Merge => vec![],
+        ForkName::Bellatrix => vec![],
         ForkName::Capella => CAPELLA_CORE_TOPICS.to_vec(),
         ForkName::Deneb => {
             // All of deneb blob topics are core topics
diff --git a/beacon_node/lighthouse_network/tests/common.rs b/beacon_node/lighthouse_network/tests/common.rs
index 9ca7eeb2308..32e3a034666 100644
--- a/beacon_node/lighthouse_network/tests/common.rs
+++ b/beacon_node/lighthouse_network/tests/common.rs
@@ -7,7 +7,6 @@ use lighthouse_network::{NetworkConfig, NetworkEvent};
 use slog::{debug, error, o, Drain};
 use std::sync::Arc;
 use std::sync::Weak;
-use std::time::Duration;
 use tokio::runtime::Runtime;
 use types::{
     ChainSpec, EnrForkId, Epoch, EthSpec, ForkContext, ForkName, Hash256, MinimalEthSpec, Slot,
@@ -22,13 +21,13 @@ use tempfile::Builder as TempBuilder;
 pub fn fork_context(fork_name: ForkName) -> ForkContext {
     let mut chain_spec = E::default_spec();
     let altair_fork_epoch = Epoch::new(1);
-    let merge_fork_epoch = Epoch::new(2);
+    let bellatrix_fork_epoch = Epoch::new(2);
     let capella_fork_epoch = Epoch::new(3);
     let deneb_fork_epoch = Epoch::new(4);
     let electra_fork_epoch = Epoch::new(5);
 
     chain_spec.altair_fork_epoch = Some(altair_fork_epoch);
-    chain_spec.bellatrix_fork_epoch = Some(merge_fork_epoch);
+    chain_spec.bellatrix_fork_epoch = Some(bellatrix_fork_epoch);
     chain_spec.capella_fork_epoch = Some(capella_fork_epoch);
     chain_spec.deneb_fork_epoch = Some(deneb_fork_epoch);
     chain_spec.electra_fork_epoch = Some(electra_fork_epoch);
@@ -36,7 +35,7 @@ pub fn fork_context(fork_name: ForkName) -> ForkContext {
     let current_slot = match fork_name {
         ForkName::Base => Slot::new(0),
         ForkName::Altair => altair_fork_epoch.start_slot(E::slots_per_epoch()),
-        ForkName::Merge => merge_fork_epoch.start_slot(E::slots_per_epoch()),
+        ForkName::Bellatrix => bellatrix_fork_epoch.start_slot(E::slots_per_epoch()),
         ForkName::Capella => capella_fork_epoch.start_slot(E::slots_per_epoch()),
         ForkName::Deneb => deneb_fork_epoch.start_slot(E::slots_per_epoch()),
         ForkName::Electra => electra_fork_epoch.start_slot(E::slots_per_epoch()),
@@ -93,12 +92,6 @@ pub fn build_config(mut boot_nodes: Vec<Enr>) -> NetworkConfig {
     config.enr_address = (Some(std::net::Ipv4Addr::LOCALHOST), None);
     config.boot_nodes_enr.append(&mut boot_nodes);
     config.network_dir = path.into_path();
-    // Reduce gossipsub heartbeat parameters
-    config.gs_config = gossipsub::ConfigBuilder::from(config.gs_config)
-        .heartbeat_initial_delay(Duration::from_millis(500))
-        .heartbeat_interval(Duration::from_millis(500))
-        .build()
-        .unwrap();
     config
 }
 
diff --git a/beacon_node/lighthouse_network/tests/rpc_tests.rs b/beacon_node/lighthouse_network/tests/rpc_tests.rs
index 5a21b462d43..e2b72f86732 100644
--- a/beacon_node/lighthouse_network/tests/rpc_tests.rs
+++ b/beacon_node/lighthouse_network/tests/rpc_tests.rs
@@ -3,7 +3,7 @@
 mod common;
 
 use common::Protocol;
-use lighthouse_network::rpc::methods::*;
+use lighthouse_network::rpc::{methods::*, RPCError};
 use lighthouse_network::{rpc::max_rpc_size, NetworkEvent, ReportSource, Request, Response};
 use slog::{debug, warn, Level};
 use ssz::Encode;
@@ -13,37 +13,37 @@ use std::time::Duration;
 use tokio::runtime::Runtime;
 use tokio::time::sleep;
 use types::{
-    BeaconBlock, BeaconBlockAltair, BeaconBlockBase, BeaconBlockMerge, BlobSidecar, ChainSpec,
+    BeaconBlock, BeaconBlockAltair, BeaconBlockBase, BeaconBlockBellatrix, BlobSidecar, ChainSpec,
     EmptyBlock, Epoch, EthSpec, ForkContext, ForkName, Hash256, MinimalEthSpec, Signature,
     SignedBeaconBlock, Slot,
 };
 
 type E = MinimalEthSpec;
 
-/// Merge block with length < max_rpc_size.
-fn merge_block_small(fork_context: &ForkContext, spec: &ChainSpec) -> BeaconBlock<E> {
-    let mut block = BeaconBlockMerge::<E>::empty(spec);
+/// Bellatrix block with length < max_rpc_size.
+fn bellatrix_block_small(fork_context: &ForkContext, spec: &ChainSpec) -> BeaconBlock<E> {
+    let mut block = BeaconBlockBellatrix::<E>::empty(spec);
     let tx = VariableList::from(vec![0; 1024]);
     let txs = VariableList::from(std::iter::repeat(tx).take(5000).collect::<Vec<_>>());
 
     block.body.execution_payload.execution_payload.transactions = txs;
 
-    let block = BeaconBlock::Merge(block);
+    let block = BeaconBlock::Bellatrix(block);
     assert!(block.ssz_bytes_len() <= max_rpc_size(fork_context, spec.max_chunk_size as usize));
     block
 }
 
-/// Merge block with length > MAX_RPC_SIZE.
-/// The max limit for a merge block is in the order of ~16GiB which wouldn't fit in memory.
-/// Hence, we generate a merge block just greater than `MAX_RPC_SIZE` to test rejection on the rpc layer.
-fn merge_block_large(fork_context: &ForkContext, spec: &ChainSpec) -> BeaconBlock<E> {
-    let mut block = BeaconBlockMerge::<E>::empty(spec);
+/// Bellatrix block with length > MAX_RPC_SIZE.
+/// The max limit for a bellatrix block is in the order of ~16GiB which wouldn't fit in memory.
+/// Hence, we generate a bellatrix block just greater than `MAX_RPC_SIZE` to test rejection on the rpc layer.
+fn bellatrix_block_large(fork_context: &ForkContext, spec: &ChainSpec) -> BeaconBlock<E> {
+    let mut block = BeaconBlockBellatrix::<E>::empty(spec);
     let tx = VariableList::from(vec![0; 1024]);
     let txs = VariableList::from(std::iter::repeat(tx).take(100000).collect::<Vec<_>>());
 
     block.body.execution_payload.execution_payload.transactions = txs;
 
-    let block = BeaconBlock::Merge(block);
+    let block = BeaconBlock::Bellatrix(block);
     assert!(block.ssz_bytes_len() > max_rpc_size(fork_context, spec.max_chunk_size as usize));
     block
 }
@@ -167,7 +167,7 @@ fn test_tcp_blocks_by_range_chunked_rpc() {
         let (mut sender, mut receiver) = common::build_node_pair(
             Arc::downgrade(&rt),
             &log,
-            ForkName::Merge,
+            ForkName::Bellatrix,
             &spec,
             Protocol::Tcp,
         )
@@ -187,9 +187,10 @@ fn test_tcp_blocks_by_range_chunked_rpc() {
         let signed_full_block = SignedBeaconBlock::from_block(full_block, Signature::empty());
         let rpc_response_altair = Response::BlocksByRange(Some(Arc::new(signed_full_block)));
 
-        let full_block = merge_block_small(&common::fork_context(ForkName::Merge), &spec);
+        let full_block = bellatrix_block_small(&common::fork_context(ForkName::Bellatrix), &spec);
         let signed_full_block = SignedBeaconBlock::from_block(full_block, Signature::empty());
-        let rpc_response_merge_small = Response::BlocksByRange(Some(Arc::new(signed_full_block)));
+        let rpc_response_bellatrix_small =
+            Response::BlocksByRange(Some(Arc::new(signed_full_block)));
 
         // keep count of the number of messages received
         let mut messages_received = 0;
@@ -216,7 +217,7 @@ fn test_tcp_blocks_by_range_chunked_rpc() {
                                 } else if messages_received < 4 {
                                     assert_eq!(response, rpc_response_altair.clone());
                                 } else {
-                                    assert_eq!(response, rpc_response_merge_small.clone());
+                                    assert_eq!(response, rpc_response_bellatrix_small.clone());
                                 }
                                 messages_received += 1;
                                 warn!(log, "Chunk received");
@@ -249,13 +250,13 @@ fn test_tcp_blocks_by_range_chunked_rpc() {
                             warn!(log, "Receiver got request");
                             for i in 0..messages_to_send {
                                 // Send first third of responses as base blocks,
-                                // second as altair and third as merge.
+                                // second as altair and third as bellatrix.
                                 let rpc_response = if i < 2 {
                                     rpc_response_base.clone()
                                 } else if i < 4 {
                                     rpc_response_altair.clone()
                                 } else {
-                                    rpc_response_merge_small.clone()
+                                    rpc_response_bellatrix_small.clone()
                                 };
                                 receiver.send_response(peer_id, id, rpc_response.clone());
                             }
@@ -368,7 +369,7 @@ fn test_blobs_by_range_chunked_rpc() {
                             warn!(log, "Receiver got request");
                             for _ in 0..messages_to_send {
                                 // Send first third of responses as base blocks,
-                                // second as altair and third as merge.
+                                // second as altair and third as bellatrix.
                                 receiver.send_response(peer_id, id, rpc_response.clone());
                             }
                             // send the stream termination
@@ -411,7 +412,7 @@ fn test_tcp_blocks_by_range_over_limit() {
         let (mut sender, mut receiver) = common::build_node_pair(
             Arc::downgrade(&rt),
             &log,
-            ForkName::Merge,
+            ForkName::Bellatrix,
             &spec,
             Protocol::Tcp,
         )
@@ -421,9 +422,10 @@ fn test_tcp_blocks_by_range_over_limit() {
         let rpc_request = Request::BlocksByRange(BlocksByRangeRequest::new(0, messages_to_send));
 
         // BlocksByRange Response
-        let full_block = merge_block_large(&common::fork_context(ForkName::Merge), &spec);
+        let full_block = bellatrix_block_large(&common::fork_context(ForkName::Bellatrix), &spec);
         let signed_full_block = SignedBeaconBlock::from_block(full_block, Signature::empty());
-        let rpc_response_merge_large = Response::BlocksByRange(Some(Arc::new(signed_full_block)));
+        let rpc_response_bellatrix_large =
+            Response::BlocksByRange(Some(Arc::new(signed_full_block)));
 
         let request_id = messages_to_send as usize;
         // build the sender future
@@ -458,7 +460,7 @@ fn test_tcp_blocks_by_range_over_limit() {
                             // send the response
                             warn!(log, "Receiver got request");
                             for _ in 0..messages_to_send {
-                                let rpc_response = rpc_response_merge_large.clone();
+                                let rpc_response = rpc_response_bellatrix_large.clone();
                                 receiver.send_response(peer_id, id, rpc_response.clone());
                             }
                             // send the stream termination
@@ -736,7 +738,7 @@ fn test_tcp_blocks_by_root_chunked_rpc() {
         let (mut sender, mut receiver) = common::build_node_pair(
             Arc::downgrade(&rt),
             &log,
-            ForkName::Merge,
+            ForkName::Bellatrix,
             &spec,
             Protocol::Tcp,
         )
@@ -764,9 +766,10 @@ fn test_tcp_blocks_by_root_chunked_rpc() {
         let signed_full_block = SignedBeaconBlock::from_block(full_block, Signature::empty());
         let rpc_response_altair = Response::BlocksByRoot(Some(Arc::new(signed_full_block)));
 
-        let full_block = merge_block_small(&common::fork_context(ForkName::Merge), &spec);
+        let full_block = bellatrix_block_small(&common::fork_context(ForkName::Bellatrix), &spec);
         let signed_full_block = SignedBeaconBlock::from_block(full_block, Signature::empty());
-        let rpc_response_merge_small = Response::BlocksByRoot(Some(Arc::new(signed_full_block)));
+        let rpc_response_bellatrix_small =
+            Response::BlocksByRoot(Some(Arc::new(signed_full_block)));
 
         // keep count of the number of messages received
         let mut messages_received = 0;
@@ -790,7 +793,7 @@ fn test_tcp_blocks_by_root_chunked_rpc() {
                             } else if messages_received < 4 {
                                 assert_eq!(response, rpc_response_altair.clone());
                             } else {
-                                assert_eq!(response, rpc_response_merge_small.clone());
+                                assert_eq!(response, rpc_response_bellatrix_small.clone());
                             }
                             messages_received += 1;
                             debug!(log, "Chunk received");
@@ -822,13 +825,13 @@ fn test_tcp_blocks_by_root_chunked_rpc() {
                             debug!(log, "Receiver got request");
 
                             for i in 0..messages_to_send {
-                                // Send equal base, altair and merge blocks
+                                // Send equal base, altair and bellatrix blocks
                                 let rpc_response = if i < 2 {
                                     rpc_response_base.clone()
                                 } else if i < 4 {
                                     rpc_response_altair.clone()
                                 } else {
-                                    rpc_response_merge_small.clone()
+                                    rpc_response_bellatrix_small.clone()
                                 };
                                 receiver.send_response(peer_id, id, rpc_response);
                                 debug!(log, "Sending message");
@@ -993,6 +996,96 @@ fn test_tcp_blocks_by_root_chunked_rpc_terminates_correctly() {
     })
 }
 
+#[test]
+fn test_disconnect_triggers_rpc_error() {
+    // set up the logging. The level and enabled logging or not
+    let log_level = Level::Debug;
+    let enable_logging = false;
+
+    let log = common::build_log(log_level, enable_logging);
+    let spec = E::default_spec();
+
+    let rt = Arc::new(Runtime::new().unwrap());
+    // get sender/receiver
+    rt.block_on(async {
+        let (mut sender, mut receiver) = common::build_node_pair(
+            Arc::downgrade(&rt),
+            &log,
+            ForkName::Base,
+            &spec,
+            Protocol::Tcp,
+        )
+        .await;
+
+        // BlocksByRoot Request
+        let rpc_request = Request::BlocksByRoot(BlocksByRootRequest::new(
+            // Must have at least one root for the request to create a stream
+            vec![Hash256::from_low_u64_be(0)],
+            &spec,
+        ));
+
+        // build the sender future
+        let sender_future = async {
+            loop {
+                match sender.next_event().await {
+                    NetworkEvent::PeerConnectedOutgoing(peer_id) => {
+                        // Send a STATUS message
+                        debug!(log, "Sending RPC");
+                        sender.send_request(peer_id, 42, rpc_request.clone());
+                    }
+                    NetworkEvent::RPCFailed { error, id: 42, .. } => match error {
+                        RPCError::Disconnected => return,
+                        other => panic!("received unexpected error {:?}", other),
+                    },
+                    other => {
+                        warn!(log, "Ignoring other event {:?}", other);
+                    }
+                }
+            }
+        };
+
+        // determine messages to send (PeerId, RequestId). If some, indicates we still need to send
+        // messages
+        let mut sending_peer = None;
+        let receiver_future = async {
+            loop {
+                // this future either drives the sending/receiving or times out allowing messages to be
+                // sent in the timeout
+                match futures::future::select(
+                    Box::pin(receiver.next_event()),
+                    Box::pin(tokio::time::sleep(Duration::from_secs(1))),
+                )
+                .await
+                {
+                    futures::future::Either::Left((ev, _)) => match ev {
+                        NetworkEvent::RequestReceived { peer_id, .. } => {
+                            sending_peer = Some(peer_id);
+                        }
+                        other => {
+                            warn!(log, "Ignoring other event {:?}", other);
+                        }
+                    },
+                    futures::future::Either::Right((_, _)) => {} // The timeout hit, send messages if required
+                }
+
+                // if we need to send messages send them here. This will happen after a delay
+                if let Some(peer_id) = sending_peer.take() {
+                    warn!(log, "Receiver got request, disconnecting peer");
+                    receiver.__hard_disconnect_testing_only(peer_id);
+                }
+            }
+        };
+
+        tokio::select! {
+            _ = sender_future => {}
+            _ = receiver_future => {}
+            _ = sleep(Duration::from_secs(30)) => {
+                panic!("Future timed out");
+            }
+        }
+    })
+}
+
 /// Establishes a pair of nodes and disconnects the pair based on the selected protocol via an RPC
 /// Goodbye message.
 fn goodbye_test(log_level: Level, enable_logging: bool, protocol: Protocol) {
diff --git a/beacon_node/network/Cargo.toml b/beacon_node/network/Cargo.toml
index d3d711884b4..406015360ef 100644
--- a/beacon_node/network/Cargo.toml
+++ b/beacon_node/network/Cargo.toml
@@ -58,3 +58,4 @@ environment = { workspace = true }
 disable-backfill = []
 fork_from_env = ["beacon_chain/fork_from_env"]
 portable = ["beacon_chain/portable"]
+test_logger = []
diff --git a/beacon_node/network/src/metrics.rs b/beacon_node/network/src/metrics.rs
index d19a41a28fc..309512076a0 100644
--- a/beacon_node/network/src/metrics.rs
+++ b/beacon_node/network/src/metrics.rs
@@ -244,54 +244,62 @@ lazy_static! {
         "sync_parent_block_lookups",
         "Number of parent block lookups underway"
     );
+    pub static ref SYNC_LOOKUP_CREATED: Result<IntCounter> = try_create_int_counter(
+        "sync_lookups_created_total",
+        "Total count of sync lookups created",
+    );
+    pub static ref SYNC_LOOKUP_DROPPED: Result<IntCounterVec> = try_create_int_counter_vec(
+        "sync_lookups_dropped_total",
+        "Total count of sync lookups dropped by reason",
+        &["reason"]
+    );
+    pub static ref SYNC_LOOKUP_COMPLETED: Result<IntCounter> = try_create_int_counter(
+        "sync_lookups_completed_total",
+        "Total count of sync lookups completed",
+    );
+    pub static ref SYNC_LOOKUPS_STUCK: Result<IntGauge> = try_create_int_gauge(
+        "sync_lookups_stuck",
+        "Current count of sync lookups that may be stuck",
+    );
 
     /*
      * Block Delay Metrics
      */
-    pub static ref BEACON_BLOCK_GOSSIP_PROPAGATION_VERIFICATION_DELAY_TIME: Result<Histogram> = try_create_histogram_with_buckets(
-        "beacon_block_gossip_propagation_verification_delay_time",
-        "Duration between when the block is received and when it is verified for propagation.",
-        // [0.001, 0.002, 0.005, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5]
-        decimal_buckets(-3,-1)
-    );
-    pub static ref BEACON_BLOCK_GOSSIP_SLOT_START_DELAY_TIME: Result<Histogram> = try_create_histogram_with_buckets(
-        "beacon_block_gossip_slot_start_delay_time",
-        "Duration between when the block is received and the start of the slot it belongs to.",
-        // Create a custom bucket list for greater granularity in block delay
-        Ok(vec![0.1, 0.2, 0.3,0.4,0.5,0.75,1.0,1.25,1.5,1.75,2.0,2.5,3.0,3.5,4.0,5.0,6.0,7.0,8.0,9.0,10.0,15.0,20.0])
-        // NOTE: Previous values, which we may want to switch back to.
-        // [0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50]
-        //decimal_buckets(-1,2)
-
+    pub static ref BEACON_BLOCK_DELAY_GOSSIP: Result<IntGauge> = try_create_int_gauge(
+        "beacon_block_delay_gossip",
+        "The first time we see this block from gossip as a delay from the start of the slot"
+    );
+    pub static ref BEACON_BLOCK_DELAY_GOSSIP_VERIFICATION: Result<IntGauge> = try_create_int_gauge(
+        "beacon_block_delay_gossip_verification",
+        "Keeps track of the time delay from the start of the slot to the point we propagate the block"
     );
-    pub static ref BEACON_BLOCK_LAST_DELAY: Result<IntGauge> = try_create_int_gauge(
-        "beacon_block_last_delay",
-        "Keeps track of the last block's delay from the start of the slot"
+    pub static ref BEACON_BLOCK_DELAY_FULL_VERIFICATION: Result<IntGauge> = try_create_int_gauge(
+        "beacon_block_delay_full_verification",
+        "The time it takes to verify a beacon block."
     );
 
-    pub static ref BEACON_BLOCK_GOSSIP_ARRIVED_LATE_TOTAL: Result<IntCounter> = try_create_int_counter(
-        "beacon_block_gossip_arrived_late_total",
+    pub static ref BEACON_BLOCK_DELAY_GOSSIP_ARRIVED_LATE_TOTAL: Result<IntCounter> = try_create_int_counter(
+        "beacon_block_delay_gossip_arrived_late_total",
         "Count of times when a gossip block arrived from the network later than the attestation deadline.",
     );
 
     /*
      * Blob Delay Metrics
      */
-    pub static ref BEACON_BLOB_GOSSIP_PROPAGATION_VERIFICATION_DELAY_TIME: Result<Histogram> = try_create_histogram_with_buckets(
-        "beacon_blob_gossip_propagation_verification_delay_time",
-        "Duration between when the blob is received over gossip and when it is verified for propagation.",
-        // [0.001, 0.002, 0.005, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5]
-        decimal_buckets(-3,-1)
-    );
-    pub static ref BEACON_BLOB_GOSSIP_SLOT_START_DELAY_TIME: Result<Histogram> = try_create_histogram_with_buckets(
-        "beacon_blob_gossip_slot_start_delay_time",
-        "Duration between when the blob is received over gossip and the start of the slot it belongs to.",
-        // Create a custom bucket list for greater granularity in block delay
-        Ok(vec![0.1, 0.2, 0.3,0.4,0.5,0.75,1.0,1.25,1.5,1.75,2.0,2.5,3.0,3.5,4.0,5.0,6.0,7.0,8.0,9.0,10.0,15.0,20.0])
-        // NOTE: Previous values, which we may want to switch back to.
-        // [0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50]
-        //decimal_buckets(-1,2)
+    pub static ref BEACON_BLOB_DELAY_GOSSIP: Result<IntGauge> = try_create_int_gauge(
+        "beacon_blob_delay_gossip_last_delay",
+        "The first time we see this blob as a delay from the start of the slot"
     );
+
+    pub static ref BEACON_BLOB_DELAY_GOSSIP_VERIFICATION: Result<IntGauge> = try_create_int_gauge(
+        "beacon_blob_delay_gossip_verification",
+        "Keeps track of the time delay from the start of the slot to the point we propagate the blob"
+    );
+    pub static ref BEACON_BLOB_DELAY_FULL_VERIFICATION: Result<IntGauge> = try_create_int_gauge(
+        "beacon_blob_last_full_verification_delay",
+        "The time it takes to verify a beacon blob"
+    );
+
     pub static ref BEACON_BLOB_RPC_SLOT_START_DELAY_TIME: Result<Histogram> = try_create_histogram_with_buckets(
         "beacon_blob_rpc_slot_start_delay_time",
         "Duration between when a blob is received over rpc and the start of the slot it belongs to.",
@@ -302,10 +310,6 @@ lazy_static! {
         //decimal_buckets(-1,2)
 
     );
-    pub static ref BEACON_BLOB_LAST_DELAY: Result<IntGauge> = try_create_int_gauge(
-        "beacon_blob_last_delay",
-        "Keeps track of the last blob's delay from the start of the slot"
-    );
 
     pub static ref BEACON_BLOB_GOSSIP_ARRIVED_LATE_TOTAL: Result<IntCounter> = try_create_int_counter(
         "beacon_blob_gossip_arrived_late_total",
diff --git a/beacon_node/network/src/network_beacon_processor/gossip_methods.rs b/beacon_node/network/src/network_beacon_processor/gossip_methods.rs
index f7bba900372..ac5d8b1c370 100644
--- a/beacon_node/network/src/network_beacon_processor/gossip_methods.rs
+++ b/beacon_node/network/src/network_beacon_processor/gossip_methods.rs
@@ -27,12 +27,12 @@ use std::fs;
 use std::io::Write;
 use std::path::PathBuf;
 use std::sync::Arc;
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 use store::hot_cold_store::HotColdDBError;
 use tokio::sync::mpsc;
 use types::{
-    Attestation, AttesterSlashing, BlobSidecar, EthSpec, Hash256, IndexedAttestation,
-    LightClientFinalityUpdate, LightClientOptimisticUpdate, ProposerSlashing,
+    beacon_block::BlockImportSource, Attestation, AttesterSlashing, BlobSidecar, EthSpec, Hash256,
+    IndexedAttestation, LightClientFinalityUpdate, LightClientOptimisticUpdate, ProposerSlashing,
     SignedAggregateAndProof, SignedBeaconBlock, SignedBlsToExecutionChange,
     SignedContributionAndProof, SignedVoluntaryExit, Slot, SubnetId, SyncCommitteeMessage,
     SyncSubnetId,
@@ -615,8 +615,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         let commitment = blob_sidecar.kzg_commitment;
         let delay = get_slot_delay_ms(seen_duration, slot, &self.chain.slot_clock);
         // Log metrics to track delay from other nodes on the network.
-        metrics::observe_duration(&metrics::BEACON_BLOB_GOSSIP_SLOT_START_DELAY_TIME, delay);
-        metrics::set_gauge(&metrics::BEACON_BLOB_LAST_DELAY, delay.as_millis() as i64);
+        metrics::set_gauge(&metrics::BEACON_BLOB_DELAY_GOSSIP, delay.as_millis() as i64);
         match self
             .chain
             .verify_blob_sidecar_for_gossip(blob_sidecar, blob_index)
@@ -654,9 +653,9 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                     .ok()
                     .and_then(|now| now.checked_sub(seen_duration))
                 {
-                    metrics::observe_duration(
-                        &metrics::BEACON_BLOB_GOSSIP_PROPAGATION_VERIFICATION_DELAY_TIME,
-                        duration,
+                    metrics::set_gauge(
+                        &metrics::BEACON_BLOB_DELAY_GOSSIP_VERIFICATION,
+                        duration.as_millis() as i64,
                     );
                 }
                 self.process_gossip_verified_blob(peer_id, gossip_verified_blob, seen_duration)
@@ -747,9 +746,9 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         self: &Arc<Self>,
         peer_id: PeerId,
         verified_blob: GossipVerifiedBlob<T>,
-        // This value is not used presently, but it might come in handy for debugging.
         _seen_duration: Duration,
     ) {
+        let processing_start_time = Instant::now();
         let block_root = verified_blob.block_root();
         let blob_slot = verified_blob.slot();
         let blob_index = verified_blob.id().index;
@@ -764,6 +763,11 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                     "block_root" => %block_root
                 );
                 self.chain.recompute_head_at_current_slot().await;
+
+                metrics::set_gauge(
+                    &metrics::BEACON_BLOB_DELAY_FULL_VERIFICATION,
+                    processing_start_time.elapsed().as_millis() as i64,
+                );
             }
             Ok(AvailabilityProcessingStatus::MissingComponents(slot, block_root)) => {
                 trace!(
@@ -774,24 +778,28 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                     "block_root" => %block_root,
                 );
             }
+            Err(BlockError::BlockIsAlreadyKnown(_)) => {
+                debug!(
+                    self.log,
+                    "Ignoring gossip blob already imported";
+                    "block_root" => ?block_root,
+                    "blob_index" =>  blob_index,
+                );
+            }
             Err(err) => {
                 debug!(
                     self.log,
                     "Invalid gossip blob";
                     "outcome" => ?err,
-                    "block root" => ?block_root,
-                    "block slot" =>  blob_slot,
-                    "blob index" =>  blob_index,
+                    "block_root" => ?block_root,
+                    "block_slot" =>  blob_slot,
+                    "blob_index" =>  blob_index,
                 );
                 self.gossip_penalize_peer(
                     peer_id,
                     PeerAction::MidToleranceError,
                     "bad_gossip_blob_ssz",
                 );
-                trace!(
-                    self.log,
-                    "Invalid gossip blob ssz";
-                );
             }
         }
     }
@@ -865,12 +873,9 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         let block_delay =
             get_block_delay_ms(seen_duration, block.message(), &self.chain.slot_clock);
         // Log metrics to track delay from other nodes on the network.
-        metrics::observe_duration(
-            &metrics::BEACON_BLOCK_GOSSIP_SLOT_START_DELAY_TIME,
-            block_delay,
-        );
+
         metrics::set_gauge(
-            &metrics::BEACON_BLOCK_LAST_DELAY,
+            &metrics::BEACON_BLOCK_DELAY_GOSSIP,
             block_delay.as_millis() as i64,
         );
 
@@ -898,7 +903,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         let verified_block = match verification_result {
             Ok(verified_block) => {
                 if block_delay >= self.chain.slot_clock.unagg_attestation_production_delay() {
-                    metrics::inc_counter(&metrics::BEACON_BLOCK_GOSSIP_ARRIVED_LATE_TOTAL);
+                    metrics::inc_counter(&metrics::BEACON_BLOCK_DELAY_GOSSIP_ARRIVED_LATE_TOTAL);
                     debug!(
                         self.log,
                         "Gossip block arrived late";
@@ -923,9 +928,9 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                     .ok()
                     .and_then(|now| now.checked_sub(seen_duration))
                 {
-                    metrics::observe_duration(
-                        &metrics::BEACON_BLOCK_GOSSIP_PROPAGATION_VERIFICATION_DELAY_TIME,
-                        duration,
+                    metrics::set_gauge(
+                        &metrics::BEACON_BLOCK_DELAY_GOSSIP_VERIFICATION,
+                        duration.as_millis() as i64,
                     );
                 }
 
@@ -1130,15 +1135,22 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         verified_block: GossipVerifiedBlock<T>,
         reprocess_tx: mpsc::Sender<ReprocessQueueMessage>,
         invalid_block_storage: InvalidBlockStorage,
-        // This value is not used presently, but it might come in handy for debugging.
         _seen_duration: Duration,
     ) {
+        let processing_start_time = Instant::now();
         let block = verified_block.block.block_cloned();
         let block_root = verified_block.block_root;
 
+        // TODO(block source)
+
         let result = self
             .chain
-            .process_block_with_early_caching(block_root, verified_block, NotifyExecutionLayer::Yes)
+            .process_block_with_early_caching(
+                block_root,
+                verified_block,
+                BlockImportSource::Gossip,
+                NotifyExecutionLayer::Yes,
+            )
             .await;
 
         match &result {
@@ -1168,6 +1180,11 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                 );
 
                 self.chain.recompute_head_at_current_slot().await;
+
+                metrics::set_gauge(
+                    &metrics::BEACON_BLOCK_DELAY_FULL_VERIFICATION,
+                    processing_start_time.elapsed().as_millis() as i64,
+                );
             }
             Ok(AvailabilityProcessingStatus::MissingComponents(slot, block_root)) => {
                 trace!(
@@ -1177,19 +1194,18 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                     "block_root" => %block_root,
                 );
             }
-            Err(BlockError::ParentUnknown(block)) => {
-                // Inform the sync manager to find parents for this block
-                // This should not occur. It should be checked by `should_forward_block`
+            Err(BlockError::ParentUnknown(_)) => {
+                // This should not occur. It should be checked by `should_forward_block`.
+                // Do not send sync message UnknownParentBlock to prevent conflicts with the
+                // BlockComponentProcessed message below. If this error ever happens, lookup sync
+                // can recover by receiving another block / blob / attestation referencing the
+                // chain that includes this block.
                 error!(
                     self.log,
                     "Block with unknown parent attempted to be processed";
+                    "block_root" => %block_root,
                     "peer_id" => %peer_id
                 );
-                self.send_sync_message(SyncMessage::UnknownParentBlock(
-                    peer_id,
-                    block.clone(),
-                    block_root,
-                ));
             }
             Err(ref e @ BlockError::ExecutionPayloadError(ref epe)) if !epe.penalize_peer() => {
                 debug!(
@@ -1253,6 +1269,11 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                 &self.log,
             );
         }
+
+        self.send_sync_message(SyncMessage::GossipBlockProcessResult {
+            block_root,
+            imported: matches!(result, Ok(AvailabilityProcessingStatus::Imported(_))),
+        });
     }
 
     pub fn process_gossip_voluntary_exit(
diff --git a/beacon_node/network/src/network_beacon_processor/mod.rs b/beacon_node/network/src/network_beacon_processor/mod.rs
index ce368d5d6d5..cabe39f9292 100644
--- a/beacon_node/network/src/network_beacon_processor/mod.rs
+++ b/beacon_node/network/src/network_beacon_processor/mod.rs
@@ -1,18 +1,13 @@
-use crate::{
-    service::NetworkMessage,
-    sync::{manager::BlockProcessType, SyncMessage},
-};
+use crate::sync::manager::BlockProcessType;
+use crate::{service::NetworkMessage, sync::manager::SyncMessage};
 use beacon_chain::block_verification_types::RpcBlock;
-use beacon_chain::{
-    builder::Witness, eth1_chain::CachingEth1Backend, test_utils::BeaconChainHarness, BeaconChain,
-};
+use beacon_chain::{builder::Witness, eth1_chain::CachingEth1Backend, BeaconChain};
 use beacon_chain::{BeaconChainTypes, NotifyExecutionLayer};
 use beacon_processor::{
     work_reprocessing_queue::ReprocessQueueMessage, BeaconProcessorChannels, BeaconProcessorSend,
     DuplicateCache, GossipAggregatePackage, GossipAttestationPackage, Work,
     WorkEvent as BeaconWorkEvent,
 };
-use environment::null_logger;
 use lighthouse_network::rpc::methods::{BlobsByRangeRequest, BlobsByRootRequest};
 use lighthouse_network::{
     rpc::{BlocksByRangeRequest, BlocksByRootRequest, LightClientBootstrapRequest, StatusMessage},
@@ -24,7 +19,6 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::Duration;
 use store::MemoryStore;
-use task_executor::test_utils::TestRuntime;
 use task_executor::TaskExecutor;
 use tokio::sync::mpsc::{self, error::TrySendError};
 use types::*;
@@ -106,14 +100,14 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         self.try_send(BeaconWorkEvent {
             drop_during_sync: true,
             work: Work::GossipAttestation {
-                attestation: GossipAttestationPackage {
+                attestation: Box::new(GossipAttestationPackage {
                     message_id,
                     peer_id,
                     attestation: Box::new(attestation),
                     subnet_id,
                     should_import,
                     seen_timestamp,
-                },
+                }),
                 process_individual: Box::new(process_individual),
                 process_batch: Box::new(process_batch),
             },
@@ -152,13 +146,13 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         self.try_send(BeaconWorkEvent {
             drop_during_sync: true,
             work: Work::GossipAggregate {
-                aggregate: GossipAggregatePackage {
+                aggregate: Box::new(GossipAggregatePackage {
                     message_id,
                     peer_id,
                     aggregate: Box::new(aggregate),
                     beacon_block_root,
                     seen_timestamp,
-                },
+                }),
                 process_individual: Box::new(process_individual),
                 process_batch: Box::new(process_batch),
             },
@@ -512,20 +506,15 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         request: BlocksByRangeRequest,
     ) -> Result<(), Error<T::EthSpec>> {
         let processor = self.clone();
-        let process_fn = move |send_idle_on_drop| {
-            let executor = processor.executor.clone();
-            processor.handle_blocks_by_range_request(
-                executor,
-                send_idle_on_drop,
-                peer_id,
-                request_id,
-                request,
-            )
+        let process_fn = async move {
+            processor
+                .handle_blocks_by_range_request(peer_id, request_id, request)
+                .await;
         };
 
         self.try_send(BeaconWorkEvent {
             drop_during_sync: false,
-            work: Work::BlocksByRangeRequest(Box::new(process_fn)),
+            work: Work::BlocksByRangeRequest(Box::pin(process_fn)),
         })
     }
 
@@ -537,20 +526,15 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         request: BlocksByRootRequest,
     ) -> Result<(), Error<T::EthSpec>> {
         let processor = self.clone();
-        let process_fn = move |send_idle_on_drop| {
-            let executor = processor.executor.clone();
-            processor.handle_blocks_by_root_request(
-                executor,
-                send_idle_on_drop,
-                peer_id,
-                request_id,
-                request,
-            )
+        let process_fn = async move {
+            processor
+                .handle_blocks_by_root_request(peer_id, request_id, request)
+                .await;
         };
 
         self.try_send(BeaconWorkEvent {
             drop_during_sync: false,
-            work: Work::BlocksByRootsRequest(Box::new(process_fn)),
+            work: Work::BlocksByRootsRequest(Box::pin(process_fn)),
         })
     }
 
@@ -667,6 +651,9 @@ impl<E: EthSpec> NetworkBeaconProcessor<TestBeaconChainType<E>> {
     // processor (but not much else).
     pub fn null_for_testing(
         network_globals: Arc<NetworkGlobals<E>>,
+        chain: Arc<BeaconChain<TestBeaconChainType<E>>>,
+        executor: TaskExecutor,
+        log: Logger,
     ) -> (Self, mpsc::Receiver<BeaconWorkEvent<E>>) {
         let BeaconProcessorChannels {
             beacon_processor_tx,
@@ -677,27 +664,17 @@ impl<E: EthSpec> NetworkBeaconProcessor<TestBeaconChainType<E>> {
 
         let (network_tx, _network_rx) = mpsc::unbounded_channel();
         let (sync_tx, _sync_rx) = mpsc::unbounded_channel();
-        let log = null_logger().unwrap();
-        let harness: BeaconChainHarness<TestBeaconChainType<E>> =
-            BeaconChainHarness::builder(E::default())
-                .spec(E::default_spec())
-                .deterministic_keypairs(8)
-                .logger(log.clone())
-                .fresh_ephemeral_store()
-                .mock_execution_layer()
-                .build();
-        let runtime = TestRuntime::default();
 
         let network_beacon_processor = Self {
             beacon_processor_send: beacon_processor_tx,
             duplicate_cache: DuplicateCache::default(),
-            chain: harness.chain,
+            chain,
             network_tx,
             sync_tx,
             reprocess_tx: work_reprocessing_tx,
             network_globals,
             invalid_block_storage: InvalidBlockStorage::Disabled,
-            executor: runtime.task_executor.clone(),
+            executor,
             log,
         };
 
diff --git a/beacon_node/network/src/network_beacon_processor/rpc_methods.rs b/beacon_node/network/src/network_beacon_processor/rpc_methods.rs
index 1b4b93adb0c..2a0c7ea089b 100644
--- a/beacon_node/network/src/network_beacon_processor/rpc_methods.rs
+++ b/beacon_node/network/src/network_beacon_processor/rpc_methods.rs
@@ -3,7 +3,6 @@ use crate::service::NetworkMessage;
 use crate::status::ToStatusMessage;
 use crate::sync::SyncMessage;
 use beacon_chain::{BeaconChainError, BeaconChainTypes, HistoricalBlockError, WhenSlotSkipped};
-use beacon_processor::SendOnDrop;
 use itertools::process_results;
 use lighthouse_network::rpc::methods::{BlobsByRangeRequest, BlobsByRootRequest};
 use lighthouse_network::rpc::*;
@@ -12,7 +11,6 @@ use slog::{debug, error, warn};
 use slot_clock::SlotClock;
 use std::collections::{hash_map::Entry, HashMap};
 use std::sync::Arc;
-use task_executor::TaskExecutor;
 use tokio_stream::StreamExt;
 use types::blob_sidecar::BlobIdentifier;
 use types::{Epoch, EthSpec, ForkName, Hash256, Slot};
@@ -128,90 +126,102 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
     }
 
     /// Handle a `BlocksByRoot` request from the peer.
-    pub fn handle_blocks_by_root_request(
+    pub async fn handle_blocks_by_root_request(
         self: Arc<Self>,
-        executor: TaskExecutor,
-        send_on_drop: SendOnDrop,
         peer_id: PeerId,
         request_id: PeerRequestId,
         request: BlocksByRootRequest,
     ) {
+        self.terminate_response_stream(
+            peer_id,
+            request_id,
+            self.clone()
+                .handle_blocks_by_root_request_inner(peer_id, request_id, request)
+                .await,
+            Response::BlocksByRoot,
+        );
+    }
+
+    /// Handle a `BlocksByRoot` request from the peer.
+    pub async fn handle_blocks_by_root_request_inner(
+        self: Arc<Self>,
+        peer_id: PeerId,
+        request_id: PeerRequestId,
+        request: BlocksByRootRequest,
+    ) -> Result<(), (RPCResponseErrorCode, &'static str)> {
+        let log_results = |peer_id, requested_blocks, send_block_count| {
+            debug!(
+                self.log,
+                "BlocksByRoot outgoing response processed";
+                "peer" => %peer_id,
+                "requested" => requested_blocks,
+                "returned" => %send_block_count
+            );
+        };
+
         let requested_blocks = request.block_roots().len();
         let mut block_stream = match self
             .chain
-            .get_blocks_checking_caches(request.block_roots().to_vec(), &executor)
+            .get_blocks_checking_caches(request.block_roots().to_vec())
         {
             Ok(block_stream) => block_stream,
-            Err(e) => return error!(self.log, "Error getting block stream"; "error" => ?e),
+            Err(e) => {
+                error!(self.log, "Error getting block stream"; "error" => ?e);
+                return Err((
+                    RPCResponseErrorCode::ServerError,
+                    "Error getting block stream",
+                ));
+            }
         };
         // Fetching blocks is async because it may have to hit the execution layer for payloads.
-        executor.spawn(
-            async move {
-                let mut send_block_count = 0;
-                let mut send_response = true;
-                while let Some((root, result)) = block_stream.next().await {
-                    match result.as_ref() {
-                        Ok(Some(block)) => {
-                            self.send_response(
-                                peer_id,
-                                Response::BlocksByRoot(Some(block.clone())),
-                                request_id,
-                            );
-                            send_block_count += 1;
-                        }
-                        Ok(None) => {
-                            debug!(
-                                self.log,
-                                "Peer requested unknown block";
-                                "peer" => %peer_id,
-                                "request_root" => ?root
-                            );
-                        }
-                        Err(BeaconChainError::BlockHashMissingFromExecutionLayer(_)) => {
-                            debug!(
-                                self.log,
-                                "Failed to fetch execution payload for blocks by root request";
-                                "block_root" => ?root,
-                                "reason" => "execution layer not synced",
-                            );
-                            // send the stream terminator
-                            self.send_error_response(
-                                peer_id,
-                                RPCResponseErrorCode::ResourceUnavailable,
-                                "Execution layer not synced".into(),
-                                request_id,
-                            );
-                            send_response = false;
-                            break;
-                        }
-                        Err(e) => {
-                            debug!(
-                                self.log,
-                                "Error fetching block for peer";
-                                "peer" => %peer_id,
-                                "request_root" => ?root,
-                                "error" => ?e,
-                            );
-                        }
-                    }
+        let mut send_block_count = 0;
+        while let Some((root, result)) = block_stream.next().await {
+            match result.as_ref() {
+                Ok(Some(block)) => {
+                    self.send_response(
+                        peer_id,
+                        Response::BlocksByRoot(Some(block.clone())),
+                        request_id,
+                    );
+                    send_block_count += 1;
                 }
-                debug!(
-                    self.log,
-                    "Received BlocksByRoot Request";
-                    "peer" => %peer_id,
-                    "requested" => requested_blocks,
-                    "returned" => %send_block_count
-                );
-
-                // send stream termination
-                if send_response {
-                    self.send_response(peer_id, Response::BlocksByRoot(None), request_id);
+                Ok(None) => {
+                    debug!(
+                        self.log,
+                        "Peer requested unknown block";
+                        "peer" => %peer_id,
+                        "request_root" => ?root
+                    );
                 }
-                drop(send_on_drop);
-            },
-            "load_blocks_by_root_blocks",
-        )
+                Err(BeaconChainError::BlockHashMissingFromExecutionLayer(_)) => {
+                    debug!(
+                        self.log,
+                        "Failed to fetch execution payload for blocks by root request";
+                        "block_root" => ?root,
+                        "reason" => "execution layer not synced",
+                    );
+                    log_results(peer_id, requested_blocks, send_block_count);
+                    return Err((
+                        RPCResponseErrorCode::ResourceUnavailable,
+                        "Execution layer not synced",
+                    ));
+                }
+                Err(e) => {
+                    debug!(
+                        self.log,
+                        "Error fetching block for peer";
+                        "peer" => %peer_id,
+                        "request_root" => ?root,
+                        "error" => ?e,
+                    );
+                }
+            }
+        }
+        log_results(peer_id, requested_blocks, send_block_count);
+
+        Ok(())
     }
+
     /// Handle a `BlobsByRoot` request from the peer.
     pub fn handle_blobs_by_root_request(
         self: Arc<Self>,
@@ -219,10 +229,25 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         request_id: PeerRequestId,
         request: BlobsByRootRequest,
     ) {
+        self.terminate_response_stream(
+            peer_id,
+            request_id,
+            self.handle_blobs_by_root_request_inner(peer_id, request_id, request),
+            Response::BlobsByRoot,
+        );
+    }
+
+    /// Handle a `BlobsByRoot` request from the peer.
+    pub fn handle_blobs_by_root_request_inner(
+        &self,
+        peer_id: PeerId,
+        request_id: PeerRequestId,
+        request: BlobsByRootRequest,
+    ) -> Result<(), (RPCResponseErrorCode, &'static str)> {
         let Some(requested_root) = request.blob_ids.as_slice().first().map(|id| id.block_root)
         else {
             // No blob ids requested.
-            return;
+            return Ok(());
         };
         let requested_indices = request
             .blob_ids
@@ -231,7 +256,6 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
             .map(|id| id.index)
             .collect::<Vec<_>>();
         let mut send_blob_count = 0;
-        let send_response = true;
 
         let mut blob_list_results = HashMap::new();
         for id in request.blob_ids.as_slice() {
@@ -280,17 +304,14 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         }
         debug!(
             self.log,
-            "Received BlobsByRoot Request";
+            "BlobsByRoot outgoing response processed";
             "peer" => %peer_id,
             "request_root" => %requested_root,
             "request_indices" => ?requested_indices,
             "returned" => send_blob_count
         );
 
-        // send stream termination
-        if send_response {
-            self.send_response(peer_id, Response::BlobsByRoot(None), request_id);
-        }
+        Ok(())
     }
 
     /// Handle a `LightClientBootstrap` request from the peer.
@@ -300,33 +321,29 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         request_id: PeerRequestId,
         request: LightClientBootstrapRequest,
     ) {
-        let block_root = request.root;
-        match self.chain.get_light_client_bootstrap(&block_root) {
-            Ok(Some((bootstrap, _))) => self.send_response(
-                peer_id,
-                Response::LightClientBootstrap(Arc::new(bootstrap)),
-                request_id,
-            ),
-            Ok(None) => self.send_error_response(
-                peer_id,
-                RPCResponseErrorCode::ResourceUnavailable,
-                "Bootstrap not available".into(),
-                request_id,
-            ),
-            Err(e) => {
-                self.send_error_response(
-                    peer_id,
+        self.terminate_response_single_item(
+            peer_id,
+            request_id,
+            match self.chain.get_light_client_bootstrap(&request.root) {
+                Ok(Some((bootstrap, _))) => Ok(Arc::new(bootstrap)),
+                Ok(None) => Err((
                     RPCResponseErrorCode::ResourceUnavailable,
-                    "Bootstrap not available".into(),
-                    request_id,
-                );
-                error!(self.log, "Error getting LightClientBootstrap instance";
-                    "block_root" => ?block_root,
-                    "peer" => %peer_id,
-                    "error" => ?e
-                )
-            }
-        };
+                    "Bootstrap not available",
+                )),
+                Err(e) => {
+                    error!(self.log, "Error getting LightClientBootstrap instance";
+                        "block_root" => ?request.root,
+                        "peer" => %peer_id,
+                        "error" => ?e
+                    );
+                    Err((
+                        RPCResponseErrorCode::ResourceUnavailable,
+                        "Bootstrap not available",
+                    ))
+                }
+            },
+            Response::LightClientBootstrap,
+        );
     }
 
     /// Handle a `LightClientOptimisticUpdate` request from the peer.
@@ -335,25 +352,22 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         peer_id: PeerId,
         request_id: PeerRequestId,
     ) {
-        let Some(light_client_optimistic_update) = self
-            .chain
-            .light_client_server_cache
-            .get_latest_optimistic_update()
-        else {
-            self.send_error_response(
-                peer_id,
-                RPCResponseErrorCode::ResourceUnavailable,
-                "Latest optimistic update not available".into(),
-                request_id,
-            );
-            return;
-        };
-
-        self.send_response(
+        self.terminate_response_single_item(
             peer_id,
-            Response::LightClientOptimisticUpdate(Arc::new(light_client_optimistic_update)),
             request_id,
-        )
+            match self
+                .chain
+                .light_client_server_cache
+                .get_latest_optimistic_update()
+            {
+                Some(update) => Ok(Arc::new(update)),
+                None => Err((
+                    RPCResponseErrorCode::ResourceUnavailable,
+                    "Latest optimistic update not available",
+                )),
+            },
+            Response::LightClientOptimisticUpdate,
+        );
     }
 
     /// Handle a `LightClientFinalityUpdate` request from the peer.
@@ -362,36 +376,48 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         peer_id: PeerId,
         request_id: PeerRequestId,
     ) {
-        let Some(light_client_finality_update) = self
-            .chain
-            .light_client_server_cache
-            .get_latest_finality_update()
-        else {
-            self.send_error_response(
-                peer_id,
-                RPCResponseErrorCode::ResourceUnavailable,
-                "Latest finality update not available".into(),
-                request_id,
-            );
-            return;
-        };
-
-        self.send_response(
+        self.terminate_response_single_item(
             peer_id,
-            Response::LightClientFinalityUpdate(Arc::new(light_client_finality_update)),
             request_id,
-        )
+            match self
+                .chain
+                .light_client_server_cache
+                .get_latest_finality_update()
+            {
+                Some(update) => Ok(Arc::new(update)),
+                None => Err((
+                    RPCResponseErrorCode::ResourceUnavailable,
+                    "Latest finality update not available",
+                )),
+            },
+            Response::LightClientFinalityUpdate,
+        );
     }
 
     /// Handle a `BlocksByRange` request from the peer.
-    pub fn handle_blocks_by_range_request(
+    pub async fn handle_blocks_by_range_request(
         self: Arc<Self>,
-        executor: TaskExecutor,
-        send_on_drop: SendOnDrop,
         peer_id: PeerId,
         request_id: PeerRequestId,
         req: BlocksByRangeRequest,
     ) {
+        self.terminate_response_stream(
+            peer_id,
+            request_id,
+            self.clone()
+                .handle_blocks_by_range_request_inner(peer_id, request_id, req)
+                .await,
+            Response::BlocksByRange,
+        );
+    }
+
+    /// Handle a `BlocksByRange` request from the peer.
+    pub async fn handle_blocks_by_range_request_inner(
+        self: Arc<Self>,
+        peer_id: PeerId,
+        request_id: PeerRequestId,
+        req: BlocksByRangeRequest,
+    ) -> Result<(), (RPCResponseErrorCode, &'static str)> {
         debug!(self.log, "Received BlocksByRange Request";
             "peer_id" => %peer_id,
             "count" => req.count(),
@@ -407,18 +433,17 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                         ForkName::Deneb | ForkName::Electra => {
                             self.chain.spec.max_request_blocks_deneb
                         }
-                        ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => {
-                            self.chain.spec.max_request_blocks
-                        }
+                        ForkName::Base
+                        | ForkName::Altair
+                        | ForkName::Bellatrix
+                        | ForkName::Capella => self.chain.spec.max_request_blocks,
                     }
                 });
         if *req.count() > max_request_size {
-            return self.send_error_response(
-                peer_id,
+            return Err((
                 RPCResponseErrorCode::InvalidRequest,
-                format!("Request exceeded max size {max_request_size}"),
-                request_id,
-            );
+                "Request exceeded max size",
+            ));
         }
 
         let forwards_block_root_iter = match self
@@ -436,25 +461,15 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                     "requested_slot" => slot,
                     "oldest_known_slot" => oldest_block_slot
                 );
-                return self.send_error_response(
-                    peer_id,
-                    RPCResponseErrorCode::ResourceUnavailable,
-                    "Backfilling".into(),
-                    request_id,
-                );
+                return Err((RPCResponseErrorCode::ResourceUnavailable, "Backfilling"));
             }
             Err(e) => {
-                self.send_error_response(
-                    peer_id,
-                    RPCResponseErrorCode::ServerError,
-                    "Database error".into(),
-                    request_id,
-                );
-                return error!(self.log, "Unable to obtain root iter";
+                error!(self.log, "Unable to obtain root iter";
                     "request" => ?req,
                     "peer" => %peer_id,
                     "error" => ?e
                 );
+                return Err((RPCResponseErrorCode::ServerError, "Database error"));
             }
         };
 
@@ -480,154 +495,129 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         let block_roots = match maybe_block_roots {
             Ok(block_roots) => block_roots,
             Err(e) => {
-                return error!(self.log, "Error during iteration over blocks";
+                error!(self.log, "Error during iteration over blocks";
                     "request" => ?req,
                     "peer" => %peer_id,
                     "error" => ?e
-                )
+                );
+                return Err((RPCResponseErrorCode::ServerError, "Iteration error"));
             }
         };
 
         // remove all skip slots
         let block_roots = block_roots.into_iter().flatten().collect::<Vec<_>>();
 
-        let mut block_stream = match self.chain.get_blocks(block_roots, &executor) {
+        let current_slot = self
+            .chain
+            .slot()
+            .unwrap_or_else(|_| self.chain.slot_clock.genesis_slot());
+
+        let log_results = |req: BlocksByRangeRequest, peer_id, blocks_sent| {
+            if blocks_sent < (*req.count() as usize) {
+                debug!(
+                    self.log,
+                    "BlocksByRange outgoing response processed";
+                    "peer" => %peer_id,
+                    "msg" => "Failed to return all requested blocks",
+                    "start_slot" => req.start_slot(),
+                    "current_slot" => current_slot,
+                    "requested" => req.count(),
+                    "returned" => blocks_sent
+                );
+            } else {
+                debug!(
+                    self.log,
+                    "BlocksByRange outgoing response processed";
+                    "peer" => %peer_id,
+                    "start_slot" => req.start_slot(),
+                    "current_slot" => current_slot,
+                    "requested" => req.count(),
+                    "returned" => blocks_sent
+                );
+            }
+        };
+
+        let mut block_stream = match self.chain.get_blocks(block_roots) {
             Ok(block_stream) => block_stream,
-            Err(e) => return error!(self.log, "Error getting block stream"; "error" => ?e),
+            Err(e) => {
+                error!(self.log, "Error getting block stream"; "error" => ?e);
+                return Err((RPCResponseErrorCode::ServerError, "Iterator error"));
+            }
         };
 
         // Fetching blocks is async because it may have to hit the execution layer for payloads.
-        executor.spawn(
-            async move {
-                let mut blocks_sent = 0;
-                let mut send_response = true;
-
-                while let Some((root, result)) = block_stream.next().await {
-                    match result.as_ref() {
-                        Ok(Some(block)) => {
-                            // Due to skip slots, blocks could be out of the range, we ensure they
-                            // are in the range before sending
-                            if block.slot() >= *req.start_slot()
-                                && block.slot() < req.start_slot() + req.count()
-                            {
-                                blocks_sent += 1;
-                                self.send_network_message(NetworkMessage::SendResponse {
-                                    peer_id,
-                                    response: Response::BlocksByRange(Some(block.clone())),
-                                    id: request_id,
-                                });
-                            }
-                        }
-                        Ok(None) => {
-                            error!(
-                                self.log,
-                                "Block in the chain is not in the store";
-                                "request" => ?req,
-                                "peer" => %peer_id,
-                                "request_root" => ?root
-                            );
-                            self.send_error_response(
-                                peer_id,
-                                RPCResponseErrorCode::ServerError,
-                                "Database inconsistency".into(),
-                                request_id,
-                            );
-                            send_response = false;
-                            break;
-                        }
-                        Err(BeaconChainError::BlockHashMissingFromExecutionLayer(_)) => {
-                            debug!(
-                                self.log,
-                                "Failed to fetch execution payload for blocks by range request";
-                                "block_root" => ?root,
-                                "reason" => "execution layer not synced",
-                            );
-                            // send the stream terminator
-                            self.send_error_response(
-                                peer_id,
-                                RPCResponseErrorCode::ResourceUnavailable,
-                                "Execution layer not synced".into(),
-                                request_id,
-                            );
-                            send_response = false;
-                            break;
-                        }
-                        Err(e) => {
-                            if matches!(
-                                e,
-                                BeaconChainError::ExecutionLayerErrorPayloadReconstruction(_block_hash, ref boxed_error)
-                                if matches!(**boxed_error, execution_layer::Error::EngineError(_))
-                            ) {
-                                warn!(
-                                    self.log,
-                                    "Error rebuilding payload for peer";
-                                    "info" => "this may occur occasionally when the EE is busy",
-                                    "block_root" => ?root,
-                                    "error" => ?e,
-                                );
-                            } else {
-                                error!(
-                                    self.log,
-                                    "Error fetching block for peer";
-                                    "block_root" => ?root,
-                                    "error" => ?e
-                                );
-                            }
-
-                            // send the stream terminator
-                            self.send_error_response(
-                                peer_id,
-                                RPCResponseErrorCode::ServerError,
-                                "Failed fetching blocks".into(),
-                                request_id,
-                            );
-                            send_response = false;
-                            break;
-                        }
+        let mut blocks_sent = 0;
+        while let Some((root, result)) = block_stream.next().await {
+            match result.as_ref() {
+                Ok(Some(block)) => {
+                    // Due to skip slots, blocks could be out of the range, we ensure they
+                    // are in the range before sending
+                    if block.slot() >= *req.start_slot()
+                        && block.slot() < req.start_slot() + req.count()
+                    {
+                        blocks_sent += 1;
+                        self.send_network_message(NetworkMessage::SendResponse {
+                            peer_id,
+                            response: Response::BlocksByRange(Some(block.clone())),
+                            id: request_id,
+                        });
                     }
                 }
-
-                let current_slot = self
-                    .chain
-                    .slot()
-                    .unwrap_or_else(|_| self.chain.slot_clock.genesis_slot());
-
-                if blocks_sent < (*req.count() as usize) {
-                    debug!(
+                Ok(None) => {
+                    error!(
                         self.log,
-                        "BlocksByRange outgoing response processed";
+                        "Block in the chain is not in the store";
+                        "request" => ?req,
                         "peer" => %peer_id,
-                        "msg" => "Failed to return all requested blocks",
-                        "start_slot" => req.start_slot(),
-                        "current_slot" => current_slot,
-                        "requested" => req.count(),
-                        "returned" => blocks_sent
+                        "request_root" => ?root
                     );
-                } else {
+                    log_results(req, peer_id, blocks_sent);
+                    return Err((RPCResponseErrorCode::ServerError, "Database inconsistency"));
+                }
+                Err(BeaconChainError::BlockHashMissingFromExecutionLayer(_)) => {
                     debug!(
                         self.log,
-                        "BlocksByRange outgoing response processed";
-                        "peer" => %peer_id,
-                        "start_slot" => req.start_slot(),
-                        "current_slot" => current_slot,
-                        "requested" => req.count(),
-                        "returned" => blocks_sent
+                        "Failed to fetch execution payload for blocks by range request";
+                        "block_root" => ?root,
+                        "reason" => "execution layer not synced",
                     );
+                    log_results(req, peer_id, blocks_sent);
+                    // send the stream terminator
+                    return Err((
+                        RPCResponseErrorCode::ResourceUnavailable,
+                        "Execution layer not synced",
+                    ));
                 }
-
-                if send_response {
+                Err(e) => {
+                    if matches!(
+                        e,
+                        BeaconChainError::ExecutionLayerErrorPayloadReconstruction(_block_hash, ref boxed_error)
+                        if matches!(**boxed_error, execution_layer::Error::EngineError(_))
+                    ) {
+                        warn!(
+                            self.log,
+                            "Error rebuilding payload for peer";
+                            "info" => "this may occur occasionally when the EE is busy",
+                            "block_root" => ?root,
+                            "error" => ?e,
+                        );
+                    } else {
+                        error!(
+                            self.log,
+                            "Error fetching block for peer";
+                            "block_root" => ?root,
+                            "error" => ?e
+                        );
+                    }
+                    log_results(req, peer_id, blocks_sent);
                     // send the stream terminator
-                    self.send_network_message(NetworkMessage::SendResponse {
-                        peer_id,
-                        response: Response::BlocksByRange(None),
-                        id: request_id,
-                    });
+                    return Err((RPCResponseErrorCode::ServerError, "Failed fetching blocks"));
                 }
+            }
+        }
 
-                drop(send_on_drop);
-            },
-            "load_blocks_by_range_blocks",
-        );
+        log_results(req, peer_id, blocks_sent);
+        Ok(())
     }
 
     /// Handle a `BlobsByRange` request from the peer.
@@ -637,6 +627,21 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         request_id: PeerRequestId,
         req: BlobsByRangeRequest,
     ) {
+        self.terminate_response_stream(
+            peer_id,
+            request_id,
+            self.handle_blobs_by_range_request_inner(peer_id, request_id, req),
+            Response::BlobsByRange,
+        );
+    }
+
+    /// Handle a `BlobsByRange` request from the peer.
+    fn handle_blobs_by_range_request_inner(
+        &self,
+        peer_id: PeerId,
+        request_id: PeerRequestId,
+        req: BlobsByRangeRequest,
+    ) -> Result<(), (RPCResponseErrorCode, &'static str)> {
         debug!(self.log, "Received BlobsByRange Request";
             "peer_id" => %peer_id,
             "count" => req.count,
@@ -645,12 +650,10 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
 
         // Should not send more than max request blocks
         if req.max_blobs_requested::<T::EthSpec>() > self.chain.spec.max_request_blob_sidecars {
-            return self.send_error_response(
-                peer_id,
+            return Err((
                 RPCResponseErrorCode::InvalidRequest,
-                "Request exceeded `MAX_REQUEST_BLOBS_SIDECARS`".into(),
-                request_id,
-            );
+                "Request exceeded `MAX_REQUEST_BLOBS_SIDECARS`",
+            ));
         }
 
         let request_start_slot = Slot::from(req.start_slot);
@@ -659,13 +662,10 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
             Some(boundary) => boundary.start_slot(T::EthSpec::slots_per_epoch()),
             None => {
                 debug!(self.log, "Deneb fork is disabled");
-                self.send_error_response(
-                    peer_id,
+                return Err((
                     RPCResponseErrorCode::InvalidRequest,
-                    "Deneb fork is disabled".into(),
-                    request_id,
-                );
-                return;
+                    "Deneb fork is disabled",
+                ));
             }
         };
 
@@ -685,19 +685,15 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
             );
 
             return if data_availability_boundary_slot < oldest_blob_slot {
-                self.send_error_response(
-                    peer_id,
+                Err((
                     RPCResponseErrorCode::ResourceUnavailable,
-                    "blobs pruned within boundary".into(),
-                    request_id,
-                )
+                    "blobs pruned within boundary",
+                ))
             } else {
-                self.send_error_response(
-                    peer_id,
+                Err((
                     RPCResponseErrorCode::InvalidRequest,
-                    "Req outside availability period".into(),
-                    request_id,
-                )
+                    "Req outside availability period",
+                ))
             };
         }
 
@@ -714,25 +710,15 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                         "requested_slot" => slot,
                         "oldest_known_slot" => oldest_block_slot
                     );
-                    return self.send_error_response(
-                        peer_id,
-                        RPCResponseErrorCode::ResourceUnavailable,
-                        "Backfilling".into(),
-                        request_id,
-                    );
+                    return Err((RPCResponseErrorCode::ResourceUnavailable, "Backfilling"));
                 }
                 Err(e) => {
-                    self.send_error_response(
-                        peer_id,
-                        RPCResponseErrorCode::ServerError,
-                        "Database error".into(),
-                        request_id,
-                    );
-                    return error!(self.log, "Unable to obtain root iter";
+                    error!(self.log, "Unable to obtain root iter";
                         "request" => ?req,
                         "peer" => %peer_id,
                         "error" => ?e
                     );
+                    return Err((RPCResponseErrorCode::ServerError, "Database error"));
                 }
             };
 
@@ -764,19 +750,35 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         let block_roots = match maybe_block_roots {
             Ok(block_roots) => block_roots,
             Err(e) => {
-                return error!(self.log, "Error during iteration over blocks";
+                error!(self.log, "Error during iteration over blocks";
                     "request" => ?req,
                     "peer" => %peer_id,
                     "error" => ?e
-                )
+                );
+                return Err((RPCResponseErrorCode::ServerError, "Database error"));
             }
         };
 
+        let current_slot = self
+            .chain
+            .slot()
+            .unwrap_or_else(|_| self.chain.slot_clock.genesis_slot());
+
+        let log_results = |peer_id, req: BlobsByRangeRequest, blobs_sent| {
+            debug!(
+                self.log,
+                "BlobsByRange outgoing response processed";
+                "peer" => %peer_id,
+                "start_slot" => req.start_slot,
+                "current_slot" => current_slot,
+                "requested" => req.count,
+                "returned" => blobs_sent
+            );
+        };
+
         // remove all skip slots
         let block_roots = block_roots.into_iter().flatten();
-
         let mut blobs_sent = 0;
-        let mut send_response = true;
 
         for root in block_roots {
             match self.chain.get_blobs(&root) {
@@ -799,40 +801,64 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                         "block_root" => ?root,
                         "error" => ?e
                     );
-                    self.send_error_response(
-                        peer_id,
+                    log_results(peer_id, req, blobs_sent);
+
+                    return Err((
                         RPCResponseErrorCode::ServerError,
-                        "No blobs and failed fetching corresponding block".into(),
-                        request_id,
-                    );
-                    send_response = false;
-                    break;
+                        "No blobs and failed fetching corresponding block",
+                    ));
                 }
             }
         }
+        log_results(peer_id, req, blobs_sent);
 
-        let current_slot = self
-            .chain
-            .slot()
-            .unwrap_or_else(|_| self.chain.slot_clock.genesis_slot());
+        Ok(())
+    }
 
-        debug!(
-            self.log,
-            "BlobsByRange Response processed";
-            "peer" => %peer_id,
-            "start_slot" => req.start_slot,
-            "current_slot" => current_slot,
-            "requested" => req.count,
-            "returned" => blobs_sent
-        );
+    /// Helper function to ensure single item protocol always end with either a single chunk or an
+    /// error
+    fn terminate_response_single_item<R, F: Fn(R) -> Response<T::EthSpec>>(
+        &self,
+        peer_id: PeerId,
+        request_id: PeerRequestId,
+        result: Result<R, (RPCResponseErrorCode, &'static str)>,
+        into_response: F,
+    ) {
+        match result {
+            Ok(resp) => {
+                // Not necessary to explicitly send a termination message if this InboundRequest
+                // returns <= 1 for InboundRequest::expected_responses
+                // https://github.com/sigp/lighthouse/blob/3058b96f2560f1da04ada4f9d8ba8e5651794ff6/beacon_node/lighthouse_network/src/rpc/handler.rs#L555-L558
+                self.send_network_message(NetworkMessage::SendResponse {
+                    peer_id,
+                    response: into_response(resp),
+                    id: request_id,
+                });
+            }
+            Err((error_code, reason)) => {
+                self.send_error_response(peer_id, error_code, reason.into(), request_id);
+            }
+        }
+    }
 
-        if send_response {
-            // send the stream terminator
-            self.send_network_message(NetworkMessage::SendResponse {
+    /// Helper function to ensure streamed protocols with multiple responses always end with either
+    /// a stream termination or an error
+    fn terminate_response_stream<R, F: FnOnce(Option<R>) -> Response<T::EthSpec>>(
+        &self,
+        peer_id: PeerId,
+        request_id: PeerRequestId,
+        result: Result<(), (RPCResponseErrorCode, &'static str)>,
+        into_response: F,
+    ) {
+        match result {
+            Ok(_) => self.send_network_message(NetworkMessage::SendResponse {
                 peer_id,
-                response: Response::BlobsByRange(None),
+                response: into_response(None),
                 id: request_id,
-            });
+            }),
+            Err((error_code, reason)) => {
+                self.send_error_response(peer_id, error_code, reason.into(), request_id);
+            }
         }
     }
 }
diff --git a/beacon_node/network/src/network_beacon_processor/sync_methods.rs b/beacon_node/network/src/network_beacon_processor/sync_methods.rs
index 887974c6e0b..acd02ab6ad8 100644
--- a/beacon_node/network/src/network_beacon_processor/sync_methods.rs
+++ b/beacon_node/network/src/network_beacon_processor/sync_methods.rs
@@ -24,6 +24,7 @@ use store::KzgCommitment;
 use tokio::sync::mpsc;
 use types::beacon_block_body::format_kzg_commitments;
 use types::blob_sidecar::FixedBlobSidecarList;
+use types::BlockImportSource;
 use types::{Epoch, Hash256};
 
 /// Id associated to a batch processing request, either a sync batch or a parent lookup.
@@ -33,8 +34,6 @@ pub enum ChainSegmentProcessId {
     RangeBatchId(ChainId, Epoch),
     /// Processing ID for a backfill syncing batch.
     BackSyncBatchId(Epoch),
-    /// Processing Id of the parent lookup of a block.
-    ParentLookup(Hash256),
 }
 
 /// Returned when a chain segment import fails.
@@ -155,7 +154,12 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
 
         let result = self
             .chain
-            .process_block_with_early_caching(block_root, block, NotifyExecutionLayer::Yes)
+            .process_block_with_early_caching(
+                block_root,
+                block,
+                BlockImportSource::Lookup,
+                NotifyExecutionLayer::Yes,
+            )
             .await;
 
         metrics::inc_counter(&metrics::BEACON_PROCESSOR_RPC_BLOCK_IMPORTED_TOTAL);
@@ -172,17 +176,15 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
             if reprocess_tx.try_send(reprocess_msg).is_err() {
                 error!(self.log, "Failed to inform block import"; "source" => "rpc", "block_root" => %hash)
             };
-            if matches!(process_type, BlockProcessType::SingleBlock { .. }) {
-                self.chain.block_times_cache.write().set_time_observed(
-                    hash,
-                    slot,
-                    seen_timestamp,
-                    None,
-                    None,
-                );
+            self.chain.block_times_cache.write().set_time_observed(
+                hash,
+                slot,
+                seen_timestamp,
+                None,
+                None,
+            );
 
-                self.chain.recompute_head_at_current_slot().await;
-            }
+            self.chain.recompute_head_at_current_slot().await;
         }
         // Sync handles these results
         self.send_sync_message(SyncMessage::BlockComponentProcessed {
@@ -396,41 +398,6 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                     }
                 }
             }
-            // this is a parent lookup request from the sync manager
-            ChainSegmentProcessId::ParentLookup(chain_head) => {
-                debug!(
-                    self.log, "Processing parent lookup";
-                    "chain_hash" => %chain_head,
-                    "blocks" => downloaded_blocks.len()
-                );
-                // parent blocks are ordered from highest slot to lowest, so we need to process in
-                // reverse
-                match self
-                    .process_blocks(downloaded_blocks.iter().rev(), notify_execution_layer)
-                    .await
-                {
-                    (imported_blocks, Err(e)) => {
-                        debug!(self.log, "Parent lookup failed"; "error" => %e.message);
-                        match e.peer_action {
-                            Some(penalty) => BatchProcessResult::FaultyFailure {
-                                imported_blocks: imported_blocks > 0,
-                                penalty,
-                            },
-                            None => BatchProcessResult::NonFaultyFailure,
-                        }
-                    }
-                    (imported_blocks, Ok(_)) => {
-                        debug!(
-                            self.log, "Parent lookup processed successfully";
-                            "chain_hash" => %chain_head,
-                            "imported_blocks" => imported_blocks
-                        );
-                        BatchProcessResult::Success {
-                            was_non_empty: imported_blocks > 0,
-                        }
-                    }
-                }
-            }
         };
 
         self.send_sync_message(SyncMessage::BatchProcessed { sync_type, result });
diff --git a/beacon_node/network/src/network_beacon_processor/tests.rs b/beacon_node/network/src/network_beacon_processor/tests.rs
index dd58eb83555..4ba4c4ddd1d 100644
--- a/beacon_node/network/src/network_beacon_processor/tests.rs
+++ b/beacon_node/network/src/network_beacon_processor/tests.rs
@@ -311,9 +311,7 @@ impl TestRig {
                 block_root,
                 RpcBlock::new_without_blobs(Some(block_root), self.next_block.clone()),
                 std::time::Duration::default(),
-                BlockProcessType::ParentLookup {
-                    chain_hash: Hash256::random(),
-                },
+                BlockProcessType::SingleBlock { id: 0 },
             )
             .unwrap();
     }
diff --git a/beacon_node/network/src/router.rs b/beacon_node/network/src/router.rs
index a0dd0665acf..1937fc11cf9 100644
--- a/beacon_node/network/src/router.rs
+++ b/beacon_node/network/src/router.rs
@@ -493,17 +493,11 @@ impl<T: BeaconChainTypes> Router<T> {
     ) {
         let request_id = match request_id {
             RequestId::Sync(sync_id) => match sync_id {
-                SyncId::SingleBlock { .. }
-                | SyncId::SingleBlob { .. }
-                | SyncId::ParentLookup { .. }
-                | SyncId::ParentLookupBlob { .. } => {
+                SyncId::SingleBlock { .. } | SyncId::SingleBlob { .. } => {
                     crit!(self.log, "Block lookups do not request BBRange requests"; "peer_id" => %peer_id);
                     return;
                 }
-                id @ (SyncId::BackFillBlocks { .. }
-                | SyncId::RangeBlocks { .. }
-                | SyncId::BackFillBlockAndBlobs { .. }
-                | SyncId::RangeBlockAndBlobs { .. }) => id,
+                id @ SyncId::RangeBlockAndBlobs { .. } => id,
             },
             RequestId::Router => {
                 crit!(self.log, "All BBRange requests belong to sync"; "peer_id" => %peer_id);
@@ -561,15 +555,12 @@ impl<T: BeaconChainTypes> Router<T> {
     ) {
         let request_id = match request_id {
             RequestId::Sync(sync_id) => match sync_id {
-                id @ (SyncId::SingleBlock { .. } | SyncId::ParentLookup { .. }) => id,
-                SyncId::BackFillBlocks { .. }
-                | SyncId::RangeBlocks { .. }
-                | SyncId::RangeBlockAndBlobs { .. }
-                | SyncId::BackFillBlockAndBlobs { .. } => {
+                id @ SyncId::SingleBlock { .. } => id,
+                SyncId::RangeBlockAndBlobs { .. } => {
                     crit!(self.log, "Batch syncing do not request BBRoot requests"; "peer_id" => %peer_id);
                     return;
                 }
-                SyncId::SingleBlob { .. } | SyncId::ParentLookupBlob { .. } => {
+                SyncId::SingleBlob { .. } => {
                     crit!(self.log, "Blob response to block by roots request"; "peer_id" => %peer_id);
                     return;
                 }
@@ -602,15 +593,12 @@ impl<T: BeaconChainTypes> Router<T> {
     ) {
         let request_id = match request_id {
             RequestId::Sync(sync_id) => match sync_id {
-                id @ (SyncId::SingleBlob { .. } | SyncId::ParentLookupBlob { .. }) => id,
-                SyncId::SingleBlock { .. } | SyncId::ParentLookup { .. } => {
+                id @ SyncId::SingleBlob { .. } => id,
+                SyncId::SingleBlock { .. } => {
                     crit!(self.log, "Block response to blobs by roots request"; "peer_id" => %peer_id);
                     return;
                 }
-                SyncId::BackFillBlocks { .. }
-                | SyncId::RangeBlocks { .. }
-                | SyncId::RangeBlockAndBlobs { .. }
-                | SyncId::BackFillBlockAndBlobs { .. } => {
+                SyncId::RangeBlockAndBlobs { .. } => {
                     crit!(self.log, "Batch syncing does not request BBRoot requests"; "peer_id" => %peer_id);
                     return;
                 }
diff --git a/beacon_node/network/src/sync/backfill_sync/mod.rs b/beacon_node/network/src/sync/backfill_sync/mod.rs
index 915aeb82ec4..4be92d59a4b 100644
--- a/beacon_node/network/src/sync/backfill_sync/mod.rs
+++ b/beacon_node/network/src/sync/backfill_sync/mod.rs
@@ -10,6 +10,7 @@
 
 use crate::network_beacon_processor::ChainSegmentProcessId;
 use crate::sync::manager::{BatchProcessResult, Id};
+use crate::sync::network_context::RangeRequestId;
 use crate::sync::network_context::SyncNetworkContext;
 use crate::sync::range_sync::{
     BatchConfig, BatchId, BatchInfo, BatchOperationOutcome, BatchProcessingResult, BatchState,
@@ -86,16 +87,17 @@ pub enum ProcessResult {
 }
 
 /// The ways a backfill sync can fail.
+// The info in the enum variants is displayed in logging, clippy thinks it's dead code.
 #[derive(Debug)]
 pub enum BackFillError {
     /// A batch failed to be downloaded.
-    BatchDownloadFailed(BatchId),
+    BatchDownloadFailed(#[allow(dead_code)] BatchId),
     /// A batch could not be processed.
-    BatchProcessingFailed(BatchId),
+    BatchProcessingFailed(#[allow(dead_code)] BatchId),
     /// A batch entered an invalid state.
-    BatchInvalidState(BatchId, String),
+    BatchInvalidState(#[allow(dead_code)] BatchId, #[allow(dead_code)] String),
     /// The sync algorithm entered an invalid state.
-    InvalidSyncState(String),
+    InvalidSyncState(#[allow(dead_code)] String),
     /// The chain became paused.
     Paused,
 }
@@ -305,11 +307,7 @@ impl<T: BeaconChainTypes> BackFillSync<T> {
     /// A peer has disconnected.
     /// If the peer has active batches, those are considered failed and re-requested.
     #[must_use = "A failure here indicates the backfill sync has failed and the global sync state should be updated"]
-    pub fn peer_disconnected(
-        &mut self,
-        peer_id: &PeerId,
-        network: &mut SyncNetworkContext<T>,
-    ) -> Result<(), BackFillError> {
+    pub fn peer_disconnected(&mut self, peer_id: &PeerId) -> Result<(), BackFillError> {
         if matches!(
             self.state(),
             BackFillState::Failed | BackFillState::NotRequired
@@ -317,37 +315,7 @@ impl<T: BeaconChainTypes> BackFillSync<T> {
             return Ok(());
         }
 
-        if let Some(batch_ids) = self.active_requests.remove(peer_id) {
-            // fail the batches
-            for id in batch_ids {
-                if let Some(batch) = self.batches.get_mut(&id) {
-                    match batch.download_failed(false) {
-                        Ok(BatchOperationOutcome::Failed { blacklist: _ }) => {
-                            self.fail_sync(BackFillError::BatchDownloadFailed(id))?;
-                        }
-                        Ok(BatchOperationOutcome::Continue) => {}
-                        Err(e) => {
-                            self.fail_sync(BackFillError::BatchInvalidState(id, e.0))?;
-                        }
-                    }
-                    // If we have run out of peers in which to retry this batch, the backfill state
-                    // transitions to a paused state.
-                    // We still need to reset the state for all the affected batches, so we should not
-                    // short circuit early
-                    if self.retry_batch_download(network, id).is_err() {
-                        debug!(
-                            self.log,
-                            "Batch could not be retried";
-                            "batch_id" => id,
-                            "error" => "no synced peers"
-                        );
-                    }
-                } else {
-                    debug!(self.log, "Batch not found while removing peer";
-                        "peer" => %peer_id, "batch" => id)
-                }
-            }
-        }
+        self.active_requests.remove(peer_id);
 
         // Remove the peer from the participation list
         self.participating_peers.remove(peer_id);
@@ -961,7 +929,12 @@ impl<T: BeaconChainTypes> BackFillSync<T> {
     ) -> Result<(), BackFillError> {
         if let Some(batch) = self.batches.get_mut(&batch_id) {
             let (request, is_blob_batch) = batch.to_blocks_by_range_request();
-            match network.backfill_blocks_by_range_request(peer, is_blob_batch, request, batch_id) {
+            match network.blocks_and_blobs_by_range_request(
+                peer,
+                is_blob_batch,
+                request,
+                RangeRequestId::BackfillSync { batch_id },
+            ) {
                 Ok(request_id) => {
                     // inform the batch about the new request
                     if let Err(e) = batch.start_downloading_from_peer(peer, request_id) {
diff --git a/beacon_node/network/src/sync/block_lookups/common.rs b/beacon_node/network/src/sync/block_lookups/common.rs
index 08d0758c7e8..400d382d6d4 100644
--- a/beacon_node/network/src/sync/block_lookups/common.rs
+++ b/beacon_node/network/src/sync/block_lookups/common.rs
@@ -1,23 +1,17 @@
-use crate::sync::block_lookups::parent_lookup::PARENT_FAIL_TOLERANCE;
 use crate::sync::block_lookups::single_block_lookup::{
-    LookupRequestError, LookupVerifyError, SingleBlockLookup, SingleLookupRequestState, State,
+    LookupRequestError, SingleBlockLookup, SingleLookupRequestState,
 };
-use crate::sync::block_lookups::{
-    BlobRequestState, BlockLookups, BlockRequestState, PeerId, SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS,
-};
-use crate::sync::manager::{BlockProcessType, Id, SingleLookupReqId};
-use crate::sync::network_context::SyncNetworkContext;
+use crate::sync::block_lookups::{BlobRequestState, BlockRequestState, PeerId};
+use crate::sync::manager::{Id, SLOT_IMPORT_TOLERANCE};
+use crate::sync::network_context::{LookupRequestResult, SyncNetworkContext};
 use beacon_chain::block_verification_types::RpcBlock;
-use beacon_chain::data_availability_checker::ChildComponents;
-use beacon_chain::{get_block_root, BeaconChainTypes};
-use lighthouse_network::rpc::methods::BlobsByRootRequest;
-use lighthouse_network::rpc::BlocksByRootRequest;
-use rand::prelude::IteratorRandom;
-use std::ops::IndexMut;
+use beacon_chain::BeaconChainTypes;
 use std::sync::Arc;
-use std::time::Duration;
-use types::blob_sidecar::{BlobIdentifier, FixedBlobSidecarList};
-use types::{BlobSidecar, ChainSpec, Hash256, SignedBeaconBlock};
+use types::blob_sidecar::FixedBlobSidecarList;
+use types::SignedBeaconBlock;
+
+use super::single_block_lookup::DownloadResult;
+use super::SingleLookupId;
 
 #[derive(Debug, Copy, Clone)]
 pub enum ResponseType {
@@ -25,42 +19,10 @@ pub enum ResponseType {
     Blob,
 }
 
-#[derive(Debug, Copy, Clone)]
-pub enum LookupType {
-    Current,
-    Parent,
-}
-
-/// This trait helps differentiate `SingleBlockLookup`s from `ParentLookup`s .This is useful in
-/// ensuring requests and responses are handled separately and enables us to use different failure
-/// tolerances for each, while re-using the same basic request and retry logic.
-pub trait Lookup {
-    const MAX_ATTEMPTS: u8;
-    fn lookup_type() -> LookupType;
-    fn max_attempts() -> u8 {
-        Self::MAX_ATTEMPTS
-    }
-}
-
-/// A `Lookup` that is a part of a `ParentLookup`.
-pub struct Parent;
-
-impl Lookup for Parent {
-    const MAX_ATTEMPTS: u8 = PARENT_FAIL_TOLERANCE;
-    fn lookup_type() -> LookupType {
-        LookupType::Parent
-    }
-}
-
-/// A `Lookup` that part of a single block lookup.
-pub struct Current;
-
-impl Lookup for Current {
-    const MAX_ATTEMPTS: u8 = SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS;
-    fn lookup_type() -> LookupType {
-        LookupType::Current
-    }
-}
+/// The maximum depth we will search for a parent block. In principle we should have sync'd any
+/// canonical chain to its head once the peer connects. A chain should not appear where it's depth
+/// is further back than the most recent head slot.
+pub(crate) const PARENT_DEPTH_TOLERANCE: usize = SLOT_IMPORT_TOLERANCE * 2;
 
 /// This trait unifies common single block lookup functionality across blocks and blobs. This
 /// includes making requests, verifying responses, and handling processing results. A
@@ -70,394 +32,137 @@ impl Lookup for Current {
 /// The use of the `ResponseType` associated type gives us a degree of type
 /// safety when handling a block/blob response ensuring we only mutate the correct corresponding
 /// state.
-pub trait RequestState<L: Lookup, T: BeaconChainTypes> {
-    /// The type of the request .
-    type RequestType;
-
-    /// A block or blob response.
-    type ResponseType;
-
+pub trait RequestState<T: BeaconChainTypes> {
     /// The type created after validation.
     type VerifiedResponseType: Clone;
 
-    /// We convert a `VerifiedResponseType` to this type prior to sending it to the beacon processor.
-    type ReconstructedResponseType;
-
-    /* Request building methods */
-
-    /// Construct a new request.
-    fn build_request(
-        &mut self,
-        spec: &ChainSpec,
-    ) -> Result<(PeerId, Self::RequestType), LookupRequestError> {
-        // Verify and construct request.
-        self.too_many_attempts()?;
-        let peer = self.get_peer()?;
-        let request = self.new_request(spec);
-        Ok((peer, request))
-    }
-
-    /// Construct a new request and send it.
-    fn build_request_and_send(
-        &mut self,
-        id: Id,
-        cx: &SyncNetworkContext<T>,
-    ) -> Result<(), LookupRequestError> {
-        // Check if request is necessary.
-        if !matches!(self.get_state().state, State::AwaitingDownload) {
-            return Ok(());
-        }
-
-        // Construct request.
-        let (peer_id, request) = self.build_request(&cx.chain.spec)?;
-
-        // Update request state.
-        self.get_state_mut().state = State::Downloading { peer_id };
-        self.get_state_mut().req_counter += 1;
-
-        // Make request
-        let id = SingleLookupReqId {
-            id,
-            req_counter: self.get_state().req_counter,
-        };
-        Self::make_request(id, peer_id, request, cx)
-    }
-
-    /// Verify the current request has not exceeded the maximum number of attempts.
-    fn too_many_attempts(&self) -> Result<(), LookupRequestError> {
-        let max_attempts = L::max_attempts();
-        let request_state = self.get_state();
-
-        if request_state.failed_attempts() >= max_attempts {
-            let cannot_process =
-                request_state.failed_processing >= request_state.failed_downloading;
-            Err(LookupRequestError::TooManyAttempts { cannot_process })
-        } else {
-            Ok(())
-        }
-    }
-
-    /// Get the next peer to request. Draws from the set of peers we think should have both the
-    /// block and blob first. If that fails, we draw from the set of peers that may have either.
-    fn get_peer(&mut self) -> Result<PeerId, LookupRequestError> {
-        let request_state = self.get_state_mut();
-        let peer_id = request_state
-            .available_peers
-            .iter()
-            .choose(&mut rand::thread_rng())
-            .copied()
-            .ok_or(LookupRequestError::NoPeers)?;
-        request_state.used_peers.insert(peer_id);
-        Ok(peer_id)
-    }
-
-    /// Initialize `Self::RequestType`.
-    fn new_request(&self, spec: &ChainSpec) -> Self::RequestType;
-
-    /// Send the request to the network service.
+    /// Request the network context to prepare a request of a component of `block_root`. If the
+    /// request is not necessary because the component is already known / processed, return false.
+    /// Return true if it sent a request and we can expect an event back from the network.
     fn make_request(
-        id: SingleLookupReqId,
+        &self,
+        id: Id,
         peer_id: PeerId,
-        request: Self::RequestType,
-        cx: &SyncNetworkContext<T>,
-    ) -> Result<(), LookupRequestError>;
+        downloaded_block_expected_blobs: Option<usize>,
+        cx: &mut SyncNetworkContext<T>,
+    ) -> Result<LookupRequestResult, LookupRequestError>;
 
     /* Response handling methods */
 
-    /// Verify the response is valid based on what we requested.
-    fn verify_response(
-        &mut self,
-        expected_block_root: Hash256,
-        response: Option<Self::ResponseType>,
-    ) -> Result<Option<Self::VerifiedResponseType>, LookupVerifyError> {
-        let request_state = self.get_state_mut();
-        match request_state.state {
-            State::AwaitingDownload => {
-                request_state.register_failure_downloading();
-                Err(LookupVerifyError::ExtraBlocksReturned)
-            }
-            State::Downloading { peer_id } => {
-                self.verify_response_inner(expected_block_root, response, peer_id)
-            }
-            State::Processing { peer_id: _ } => match response {
-                Some(_) => {
-                    // We sent the block for processing and received an extra block.
-                    request_state.register_failure_downloading();
-                    Err(LookupVerifyError::ExtraBlocksReturned)
-                }
-                None => {
-                    // This is simply the stream termination and we are already processing the
-                    // block
-                    Ok(None)
-                }
-            },
-        }
-    }
-
-    /// The response verification unique to block or blobs.
-    fn verify_response_inner(
-        &mut self,
-        expected_block_root: Hash256,
-        response: Option<Self::ResponseType>,
-        peer_id: PeerId,
-    ) -> Result<Option<Self::VerifiedResponseType>, LookupVerifyError>;
-
-    /// A getter for the parent root of the response. Returns an `Option` because we won't know
-    /// the blob parent if we don't end up getting any blobs in the response.
-    fn get_parent_root(verified_response: &Self::VerifiedResponseType) -> Option<Hash256>;
-
-    /// Caches the verified response in the lookup if necessary. This is only necessary for lookups
-    /// triggered by `UnknownParent` errors.
-    fn add_to_child_components(
-        verified_response: Self::VerifiedResponseType,
-        components: &mut ChildComponents<T::EthSpec>,
-    );
-
-    /// Convert a verified response to the type we send to the beacon processor.
-    fn verified_to_reconstructed(
-        block_root: Hash256,
-        verified: Self::VerifiedResponseType,
-    ) -> Self::ReconstructedResponseType;
-
     /// Send the response to the beacon processor.
-    fn send_reconstructed_for_processing(
+    fn send_for_processing(
         id: Id,
-        bl: &BlockLookups<T>,
-        block_root: Hash256,
-        verified: Self::ReconstructedResponseType,
-        duration: Duration,
+        result: DownloadResult<Self::VerifiedResponseType>,
         cx: &SyncNetworkContext<T>,
     ) -> Result<(), LookupRequestError>;
 
-    /// Register a failure to process the block or blob.
-    fn register_failure_downloading(&mut self) {
-        self.get_state_mut().register_failure_downloading()
-    }
-
     /* Utility methods */
 
     /// Returns the `ResponseType` associated with this trait implementation. Useful in logging.
     fn response_type() -> ResponseType;
 
     /// A getter for the `BlockRequestState` or `BlobRequestState` associated with this trait.
-    fn request_state_mut(request: &mut SingleBlockLookup<L, T>) -> &mut Self;
+    fn request_state_mut(request: &mut SingleBlockLookup<T>) -> &mut Self;
 
     /// A getter for a reference to the `SingleLookupRequestState` associated with this trait.
-    fn get_state(&self) -> &SingleLookupRequestState;
+    fn get_state(&self) -> &SingleLookupRequestState<Self::VerifiedResponseType>;
 
     /// A getter for a mutable reference to the SingleLookupRequestState associated with this trait.
-    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState;
+    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState<Self::VerifiedResponseType>;
 }
 
-impl<L: Lookup, T: BeaconChainTypes> RequestState<L, T> for BlockRequestState<L> {
-    type RequestType = BlocksByRootRequest;
-    type ResponseType = Arc<SignedBeaconBlock<T::EthSpec>>;
+impl<T: BeaconChainTypes> RequestState<T> for BlockRequestState<T::EthSpec> {
     type VerifiedResponseType = Arc<SignedBeaconBlock<T::EthSpec>>;
-    type ReconstructedResponseType = RpcBlock<T::EthSpec>;
-
-    fn new_request(&self, spec: &ChainSpec) -> BlocksByRootRequest {
-        BlocksByRootRequest::new(vec![self.requested_block_root], spec)
-    }
 
     fn make_request(
-        id: SingleLookupReqId,
+        &self,
+        id: SingleLookupId,
         peer_id: PeerId,
-        request: Self::RequestType,
-        cx: &SyncNetworkContext<T>,
-    ) -> Result<(), LookupRequestError> {
-        cx.block_lookup_request(id, peer_id, request, L::lookup_type())
+        _: Option<usize>,
+        cx: &mut SyncNetworkContext<T>,
+    ) -> Result<LookupRequestResult, LookupRequestError> {
+        cx.block_lookup_request(id, peer_id, self.requested_block_root)
             .map_err(LookupRequestError::SendFailed)
     }
 
-    fn verify_response_inner(
-        &mut self,
-        expected_block_root: Hash256,
-        response: Option<Self::ResponseType>,
-        peer_id: PeerId,
-    ) -> Result<Option<Arc<SignedBeaconBlock<T::EthSpec>>>, LookupVerifyError> {
-        match response {
-            Some(block) => {
-                // Compute the block root using this specific function so that we can get timing
-                // metrics.
-                let block_root = get_block_root(&block);
-                if block_root != expected_block_root {
-                    // return an error and drop the block
-                    // NOTE: we take this is as a download failure to prevent counting the
-                    // attempt as a chain failure, but simply a peer failure.
-                    self.state.register_failure_downloading();
-                    Err(LookupVerifyError::RootMismatch)
-                } else {
-                    // Return the block for processing.
-                    self.state.state = State::Processing { peer_id };
-                    Ok(Some(block))
-                }
-            }
-            None => {
-                self.state.register_failure_downloading();
-                Err(LookupVerifyError::NoBlockReturned)
-            }
-        }
-    }
-
-    fn get_parent_root(verified_response: &Arc<SignedBeaconBlock<T::EthSpec>>) -> Option<Hash256> {
-        Some(verified_response.parent_root())
-    }
-
-    fn add_to_child_components(
-        verified_response: Arc<SignedBeaconBlock<T::EthSpec>>,
-        components: &mut ChildComponents<T::EthSpec>,
-    ) {
-        components.merge_block(verified_response);
-    }
-
-    fn verified_to_reconstructed(
-        block_root: Hash256,
-        block: Arc<SignedBeaconBlock<T::EthSpec>>,
-    ) -> RpcBlock<T::EthSpec> {
-        RpcBlock::new_without_blobs(Some(block_root), block)
-    }
-
-    fn send_reconstructed_for_processing(
-        id: Id,
-        bl: &BlockLookups<T>,
-        block_root: Hash256,
-        constructed: RpcBlock<T::EthSpec>,
-        duration: Duration,
+    fn send_for_processing(
+        id: SingleLookupId,
+        download_result: DownloadResult<Self::VerifiedResponseType>,
         cx: &SyncNetworkContext<T>,
     ) -> Result<(), LookupRequestError> {
-        bl.send_block_for_processing(
+        let DownloadResult {
+            value,
             block_root,
-            constructed,
-            duration,
-            BlockProcessType::SingleBlock { id },
-            cx,
+            seen_timestamp,
+            peer_id: _,
+        } = download_result;
+        cx.send_block_for_processing(
+            id,
+            block_root,
+            RpcBlock::new_without_blobs(Some(block_root), value),
+            seen_timestamp,
         )
+        .map_err(LookupRequestError::SendFailed)
     }
 
     fn response_type() -> ResponseType {
         ResponseType::Block
     }
-    fn request_state_mut(request: &mut SingleBlockLookup<L, T>) -> &mut Self {
+    fn request_state_mut(request: &mut SingleBlockLookup<T>) -> &mut Self {
         &mut request.block_request_state
     }
-    fn get_state(&self) -> &SingleLookupRequestState {
+    fn get_state(&self) -> &SingleLookupRequestState<Self::VerifiedResponseType> {
         &self.state
     }
-    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState {
+    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState<Self::VerifiedResponseType> {
         &mut self.state
     }
 }
 
-impl<L: Lookup, T: BeaconChainTypes> RequestState<L, T> for BlobRequestState<L, T::EthSpec> {
-    type RequestType = BlobsByRootRequest;
-    type ResponseType = Arc<BlobSidecar<T::EthSpec>>;
+impl<T: BeaconChainTypes> RequestState<T> for BlobRequestState<T::EthSpec> {
     type VerifiedResponseType = FixedBlobSidecarList<T::EthSpec>;
-    type ReconstructedResponseType = FixedBlobSidecarList<T::EthSpec>;
-
-    fn new_request(&self, spec: &ChainSpec) -> BlobsByRootRequest {
-        let blob_id_vec: Vec<BlobIdentifier> = self.requested_ids.clone().into();
-        BlobsByRootRequest::new(blob_id_vec, spec)
-    }
 
     fn make_request(
-        id: SingleLookupReqId,
-        peer_id: PeerId,
-        request: Self::RequestType,
-        cx: &SyncNetworkContext<T>,
-    ) -> Result<(), LookupRequestError> {
-        cx.blob_lookup_request(id, peer_id, request, L::lookup_type())
-            .map_err(LookupRequestError::SendFailed)
-    }
-
-    fn verify_response_inner(
-        &mut self,
-        expected_block_root: Hash256,
-        blob: Option<Self::ResponseType>,
+        &self,
+        id: Id,
         peer_id: PeerId,
-    ) -> Result<Option<FixedBlobSidecarList<T::EthSpec>>, LookupVerifyError> {
-        match blob {
-            Some(blob) => {
-                let received_id = blob.id();
-
-                if !self.requested_ids.contains(&received_id) {
-                    Err(LookupVerifyError::UnrequestedBlobId(received_id))
-                } else if !blob.verify_blob_sidecar_inclusion_proof().unwrap_or(false) {
-                    Err(LookupVerifyError::InvalidInclusionProof)
-                } else if blob.block_root() != expected_block_root {
-                    Err(LookupVerifyError::UnrequestedHeader)
-                } else {
-                    Ok(())
-                }
-                .map_err(|e| {
-                    self.state.register_failure_downloading();
-                    e
-                })?;
-
-                // State should remain downloading until we receive the stream terminator.
-                self.requested_ids.remove(&received_id);
-
-                // The inclusion proof check above ensures `blob.index` is < MAX_BLOBS_PER_BLOCK
-                let blob_index = blob.index;
-                *self.blob_download_queue.index_mut(blob_index as usize) = Some(blob);
-                Ok(None)
-            }
-            None => {
-                self.state.state = State::Processing { peer_id };
-                let blobs = std::mem::take(&mut self.blob_download_queue);
-                Ok(Some(blobs))
-            }
-        }
-    }
-
-    fn get_parent_root(verified_response: &FixedBlobSidecarList<T::EthSpec>) -> Option<Hash256> {
-        verified_response
-            .into_iter()
-            .filter_map(|blob| blob.as_ref())
-            .map(|blob| blob.block_parent_root())
-            .next()
-    }
-
-    fn add_to_child_components(
-        verified_response: FixedBlobSidecarList<T::EthSpec>,
-        components: &mut ChildComponents<T::EthSpec>,
-    ) {
-        components.merge_blobs(verified_response);
-    }
-
-    fn verified_to_reconstructed(
-        _block_root: Hash256,
-        blobs: FixedBlobSidecarList<T::EthSpec>,
-    ) -> FixedBlobSidecarList<T::EthSpec> {
-        blobs
+        downloaded_block_expected_blobs: Option<usize>,
+        cx: &mut SyncNetworkContext<T>,
+    ) -> Result<LookupRequestResult, LookupRequestError> {
+        cx.blob_lookup_request(
+            id,
+            peer_id,
+            self.block_root,
+            downloaded_block_expected_blobs,
+        )
+        .map_err(LookupRequestError::SendFailed)
     }
 
-    fn send_reconstructed_for_processing(
+    fn send_for_processing(
         id: Id,
-        bl: &BlockLookups<T>,
-        block_root: Hash256,
-        verified: FixedBlobSidecarList<T::EthSpec>,
-        duration: Duration,
+        download_result: DownloadResult<Self::VerifiedResponseType>,
         cx: &SyncNetworkContext<T>,
     ) -> Result<(), LookupRequestError> {
-        bl.send_blobs_for_processing(
+        let DownloadResult {
+            value,
             block_root,
-            verified,
-            duration,
-            BlockProcessType::SingleBlob { id },
-            cx,
-        )
+            seen_timestamp,
+            peer_id: _,
+        } = download_result;
+        cx.send_blobs_for_processing(id, block_root, value, seen_timestamp)
+            .map_err(LookupRequestError::SendFailed)
     }
 
     fn response_type() -> ResponseType {
         ResponseType::Blob
     }
-    fn request_state_mut(request: &mut SingleBlockLookup<L, T>) -> &mut Self {
+    fn request_state_mut(request: &mut SingleBlockLookup<T>) -> &mut Self {
         &mut request.blob_request_state
     }
-    fn get_state(&self) -> &SingleLookupRequestState {
+    fn get_state(&self) -> &SingleLookupRequestState<Self::VerifiedResponseType> {
         &self.state
     }
-    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState {
+    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState<Self::VerifiedResponseType> {
         &mut self.state
     }
 }
diff --git a/beacon_node/network/src/sync/block_lookups/mod.rs b/beacon_node/network/src/sync/block_lookups/mod.rs
index 76efc728fd5..48dda03facd 100644
--- a/beacon_node/network/src/sync/block_lookups/mod.rs
+++ b/beacon_node/network/src/sync/block_lookups/mod.rs
@@ -1,1350 +1,657 @@
-use self::parent_lookup::ParentVerifyError;
-use self::single_block_lookup::SingleBlockLookup;
-use super::manager::BlockProcessingResult;
-use super::BatchProcessResult;
-use super::{manager::BlockProcessType, network_context::SyncNetworkContext};
+use self::parent_chain::{compute_parent_chains, NodeChain};
+pub use self::single_block_lookup::DownloadResult;
+use self::single_block_lookup::{LookupRequestError, LookupResult, SingleBlockLookup};
+use super::manager::{BlockProcessType, BlockProcessingResult};
+use super::network_context::{RpcProcessingResult, SyncNetworkContext};
 use crate::metrics;
-use crate::network_beacon_processor::ChainSegmentProcessId;
-use crate::sync::block_lookups::common::LookupType;
-use crate::sync::block_lookups::parent_lookup::{ParentLookup, RequestError};
-use crate::sync::block_lookups::single_block_lookup::{CachedChild, LookupRequestError};
+use crate::sync::block_lookups::common::{ResponseType, PARENT_DEPTH_TOLERANCE};
+use crate::sync::block_lookups::parent_chain::find_oldest_fork_ancestor;
 use crate::sync::manager::{Id, SingleLookupReqId};
-use beacon_chain::block_verification_types::{AsBlock, RpcBlock};
-pub use beacon_chain::data_availability_checker::ChildComponents;
-use beacon_chain::data_availability_checker::{
-    AvailabilityCheckErrorCategory, DataAvailabilityChecker,
-};
-use beacon_chain::validator_monitor::timestamp_now;
+use beacon_chain::block_verification_types::AsBlock;
+use beacon_chain::data_availability_checker::AvailabilityCheckErrorCategory;
 use beacon_chain::{AvailabilityProcessingStatus, BeaconChainTypes, BlockError};
-pub use common::Current;
-pub use common::Lookup;
-pub use common::Parent;
 pub use common::RequestState;
 use fnv::FnvHashMap;
-use lighthouse_network::rpc::RPCError;
 use lighthouse_network::{PeerAction, PeerId};
 use lru_cache::LRUTimeCache;
 pub use single_block_lookup::{BlobRequestState, BlockRequestState};
-use slog::{debug, error, trace, warn, Logger};
-use smallvec::SmallVec;
-use std::collections::{HashMap, VecDeque};
+use slog::{debug, error, warn, Logger};
+use std::collections::hash_map::Entry;
 use std::sync::Arc;
 use std::time::Duration;
 use store::Hash256;
-use types::blob_sidecar::FixedBlobSidecarList;
-use types::Slot;
+use types::{BlobSidecar, EthSpec, SignedBeaconBlock};
 
 pub mod common;
-mod parent_lookup;
+pub mod parent_chain;
 mod single_block_lookup;
 #[cfg(test)]
 mod tests;
 
-pub type DownloadedBlock<E> = (Hash256, RpcBlock<E>);
-
 const FAILED_CHAINS_CACHE_EXPIRY_SECONDS: u64 = 60;
-pub const SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS: u8 = 3;
+pub const SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS: u8 = 4;
+const LOOKUP_MAX_DURATION_SECS: u64 = 60;
 
-pub struct BlockLookups<T: BeaconChainTypes> {
-    /// Parent chain lookups being downloaded.
-    parent_lookups: SmallVec<[ParentLookup<T>; 3]>,
+pub enum BlockComponent<E: EthSpec> {
+    Block(DownloadResult<Arc<SignedBeaconBlock<E>>>),
+    Blob(DownloadResult<Arc<BlobSidecar<E>>>),
+}
+
+impl<E: EthSpec> BlockComponent<E> {
+    fn parent_root(&self) -> Hash256 {
+        match self {
+            BlockComponent::Block(block) => block.value.parent_root(),
+            BlockComponent::Blob(blob) => blob.value.block_parent_root(),
+        }
+    }
+    fn get_type(&self) -> &'static str {
+        match self {
+            BlockComponent::Block(_) => "block",
+            BlockComponent::Blob(_) => "blob",
+        }
+    }
+}
 
-    processing_parent_lookups: HashMap<Hash256, (Vec<Hash256>, SingleBlockLookup<Parent, T>)>,
+pub type SingleLookupId = u32;
+
+enum Action {
+    Retry,
+    ParentUnknown { parent_root: Hash256 },
+    Drop,
+    Continue,
+}
 
+pub struct BlockLookups<T: BeaconChainTypes> {
     /// A cache of failed chain lookups to prevent duplicate searches.
     failed_chains: LRUTimeCache<Hash256>,
 
-    single_block_lookups: FnvHashMap<Id, SingleBlockLookup<Current, T>>,
-
-    pub(crate) da_checker: Arc<DataAvailabilityChecker<T>>,
+    // TODO: Why not index lookups by block_root?
+    single_block_lookups: FnvHashMap<SingleLookupId, SingleBlockLookup<T>>,
 
     /// The logger for the import manager.
     log: Logger,
 }
 
 impl<T: BeaconChainTypes> BlockLookups<T> {
-    pub fn new(da_checker: Arc<DataAvailabilityChecker<T>>, log: Logger) -> Self {
+    pub fn new(log: Logger) -> Self {
         Self {
-            parent_lookups: Default::default(),
-            processing_parent_lookups: Default::default(),
             failed_chains: LRUTimeCache::new(Duration::from_secs(
                 FAILED_CHAINS_CACHE_EXPIRY_SECONDS,
             )),
             single_block_lookups: Default::default(),
-            da_checker,
             log,
         }
     }
 
+    #[cfg(test)]
+    pub(crate) fn insert_failed_chain(&mut self, block_root: Hash256) {
+        self.failed_chains.insert(block_root);
+    }
+
+    #[cfg(test)]
+    pub(crate) fn get_failed_chains(&mut self) -> Vec<Hash256> {
+        self.failed_chains.keys().cloned().collect()
+    }
+
+    #[cfg(test)]
+    pub(crate) fn active_single_lookups(&self) -> Vec<(Id, Hash256, Option<Hash256>)> {
+        self.single_block_lookups
+            .iter()
+            .map(|(id, e)| (*id, e.block_root(), e.awaiting_parent()))
+            .collect()
+    }
+
+    /// Returns a vec of all parent lookup chains by tip, in descending slot order (tip first)
+    pub(crate) fn active_parent_lookups(&self) -> Vec<NodeChain> {
+        compute_parent_chains(
+            &self
+                .single_block_lookups
+                .values()
+                .map(|lookup| lookup.into())
+                .collect::<Vec<_>>(),
+        )
+    }
+
     /* Lookup requests */
 
-    /// Creates a lookup for the block with the given `block_root` and immediately triggers it.
-    pub fn search_block(
+    /// Creates a parent lookup for the block with the given `block_root` and immediately triggers it.
+    /// If a parent lookup exists or is triggered, a current lookup will be created.
+    pub fn search_child_and_parent(
         &mut self,
         block_root: Hash256,
-        peer_source: &[PeerId],
+        block_component: BlockComponent<T::EthSpec>,
+        peer_id: PeerId,
         cx: &mut SyncNetworkContext<T>,
     ) {
-        self.new_current_lookup(block_root, None, peer_source, cx)
+        let parent_root = block_component.parent_root();
+
+        let parent_lookup_exists =
+            self.search_parent_of_child(parent_root, block_root, &[peer_id], cx);
+        // Only create the child lookup if the parent exists
+        if parent_lookup_exists {
+            // `search_parent_of_child` ensures that parent root is not a failed chain
+            self.new_current_lookup(
+                block_root,
+                Some(block_component),
+                Some(parent_root),
+                // On a `UnknownParentBlock` or `UnknownParentBlob` event the peer is not required
+                // to have the rest of the block components (refer to decoupled blob gossip). Create
+                // the lookup with zero peers to house the block components.
+                &[],
+                cx,
+            );
+        }
     }
 
-    /// Creates a lookup for the block with the given `block_root`, while caching other block
-    /// components we've already received. The block components are cached here because we haven't
-    /// imported its parent and therefore can't fully validate it and store it in the data
-    /// availability cache.
-    ///
-    /// The request is immediately triggered.
-    pub fn search_child_block(
+    /// Seach a block whose parent root is unknown.
+    /// Returns true if the lookup is created or already exists
+    pub fn search_unknown_block(
         &mut self,
         block_root: Hash256,
-        child_components: ChildComponents<T::EthSpec>,
         peer_source: &[PeerId],
         cx: &mut SyncNetworkContext<T>,
     ) {
-        self.new_current_lookup(block_root, Some(child_components), peer_source, cx)
+        self.new_current_lookup(block_root, None, None, peer_source, cx);
     }
 
-    /// Attempts to trigger the request matching the given `block_root`.
-    pub fn trigger_single_lookup(
+    /// A block or blob triggers the search of a parent.
+    /// Check if this new lookup extends a bad chain:
+    /// - Extending `child_block_root_trigger` would exceed the max depth
+    /// - `block_root_to_search` is a failed chain
+    /// Returns true if the lookup is created or already exists
+    pub fn search_parent_of_child(
         &mut self,
-        mut single_block_lookup: SingleBlockLookup<Current, T>,
-        cx: &SyncNetworkContext<T>,
-    ) {
-        let block_root = single_block_lookup.block_root();
-        match single_block_lookup.request_block_and_blobs(cx) {
-            Ok(()) => self.add_single_lookup(single_block_lookup),
-            Err(e) => {
-                debug!(self.log, "Single block lookup failed";
-                    "error" => ?e,
-                    "block_root" => ?block_root,
-                );
+        block_root_to_search: Hash256,
+        child_block_root_trigger: Hash256,
+        peers: &[PeerId],
+        cx: &mut SyncNetworkContext<T>,
+    ) -> bool {
+        let parent_chains = self.active_parent_lookups();
+
+        for (chain_idx, parent_chain) in parent_chains.iter().enumerate() {
+            if parent_chain.ancestor() == child_block_root_trigger
+                && parent_chain.len() >= PARENT_DEPTH_TOLERANCE
+            {
+                debug!(self.log, "Parent lookup chain too long"; "block_root" => ?block_root_to_search);
+
+                // Searching for this parent would extend a parent chain over the max
+                // Insert the tip only to failed chains
+                self.failed_chains.insert(parent_chain.tip);
+
+                // Note: Drop only the chain that's too long until it merges with another chain
+                // that's not too long. Consider this attack: there's a chain of valid unknown
+                // blocks A -> B. A malicious peer builds `PARENT_DEPTH_TOLERANCE` garbage
+                // blocks on top of A forming A -> C. The malicious peer forces us to fetch C
+                // from it, which will result in parent A hitting the chain_too_long error. Then
+                // the valid chain A -> B is dropped too.
+                if let Ok(block_to_drop) = find_oldest_fork_ancestor(parent_chains, chain_idx) {
+                    // Drop all lookups descending from the child of the too long parent chain
+                    if let Some((lookup_id, lookup)) = self
+                        .single_block_lookups
+                        .iter()
+                        .find(|(_, l)| l.block_root() == block_to_drop)
+                    {
+                        for &peer_id in lookup.all_used_peers() {
+                            cx.report_peer(
+                                peer_id,
+                                PeerAction::LowToleranceError,
+                                "chain_too_long",
+                            );
+                        }
+                        self.drop_lookup_and_children(*lookup_id);
+                    }
+                }
+
+                return false;
             }
         }
-    }
 
-    /// Adds a lookup to the `single_block_lookups` map.
-    pub fn add_single_lookup(&mut self, single_block_lookup: SingleBlockLookup<Current, T>) {
-        self.single_block_lookups
-            .insert(single_block_lookup.id, single_block_lookup);
-
-        metrics::set_gauge(
-            &metrics::SYNC_SINGLE_BLOCK_LOOKUPS,
-            self.single_block_lookups.len() as i64,
-        );
+        // `block_root_to_search` is a failed chain check happens inside new_current_lookup
+        self.new_current_lookup(block_root_to_search, None, None, peers, cx)
     }
 
     /// Searches for a single block hash. If the blocks parent is unknown, a chain of blocks is
     /// constructed.
-    pub fn new_current_lookup(
+    /// Returns true if the lookup is created or already exists
+    fn new_current_lookup(
         &mut self,
         block_root: Hash256,
-        child_components: Option<ChildComponents<T::EthSpec>>,
+        block_component: Option<BlockComponent<T::EthSpec>>,
+        awaiting_parent: Option<Hash256>,
         peers: &[PeerId],
         cx: &mut SyncNetworkContext<T>,
-    ) {
+    ) -> bool {
+        // If this block or it's parent is part of a known failed chain, ignore it.
+        if self.failed_chains.contains(&block_root) {
+            debug!(self.log, "Block is from a past failed chain. Dropping"; "block_root" => ?block_root);
+            for peer_id in peers {
+                cx.report_peer(*peer_id, PeerAction::MidToleranceError, "failed_chain");
+            }
+            return false;
+        }
+
         // Do not re-request a block that is already being requested
         if let Some((_, lookup)) = self
             .single_block_lookups
             .iter_mut()
             .find(|(_id, lookup)| lookup.is_for_block(block_root))
         {
-            lookup.add_peers(peers);
-            if let Some(components) = child_components {
-                lookup.add_child_components(components);
+            for peer in peers {
+                if lookup.add_peer(*peer) {
+                    debug!(self.log, "Adding peer to existing single block lookup"; "block_root" => ?block_root, "peer" => ?peer);
+                }
             }
-            return;
-        }
 
-        if let Some(parent_lookup) = self.parent_lookups.iter_mut().find(|parent_req| {
-            parent_req.is_for_block(block_root) || parent_req.contains_block(&block_root)
-        }) {
-            parent_lookup.add_peers(peers);
-
-            // If the block was already downloaded, or is being downloaded in this moment, do not
-            // request it.
-            trace!(self.log, "Already searching for block in a parent lookup request"; "block_root" => ?block_root);
-            return;
+            if let Some(block_component) = block_component {
+                let component_type = block_component.get_type();
+                let imported = lookup.add_child_components(block_component);
+                if !imported {
+                    debug!(self.log, "Lookup child component ignored"; "block_root" => ?block_root, "type" => component_type);
+                }
+            }
+            return true;
         }
 
-        if self
-            .processing_parent_lookups
-            .values()
-            .any(|(hashes, _last_parent_request)| hashes.contains(&block_root))
-        {
-            // we are already processing this block, ignore it.
-            trace!(self.log, "Already processing block in a parent request"; "block_root" => ?block_root);
-            return;
+        // Ensure that awaiting parent exists, otherwise this lookup won't be able to make progress
+        if let Some(awaiting_parent) = awaiting_parent {
+            if !self
+                .single_block_lookups
+                .iter()
+                .any(|(_, lookup)| lookup.is_for_block(awaiting_parent))
+            {
+                warn!(self.log, "Ignoring child lookup parent lookup not found"; "block_root" => ?awaiting_parent);
+                return false;
+            }
         }
 
-        let msg = if child_components.is_some() {
+        // If we know that this lookup has unknown parent (is awaiting a parent lookup to resolve),
+        // signal here to hold processing downloaded data.
+        let mut lookup = SingleBlockLookup::new(block_root, peers, cx.next_id(), awaiting_parent);
+
+        let msg = if block_component.is_some() {
             "Searching for components of a block with unknown parent"
         } else {
             "Searching for block components"
         };
-
-        let lookup = SingleBlockLookup::new(
-            block_root,
-            child_components,
-            peers,
-            self.da_checker.clone(),
-            cx.next_id(),
-        );
-
         debug!(
             self.log,
             "{}", msg;
             "peer_ids" => ?peers,
-            "block" => ?block_root,
+            "block_root" => ?block_root,
+            "id" => lookup.id,
         );
-        self.trigger_single_lookup(lookup, cx);
-    }
-
-    /// If a block is attempted to be processed but we do not know its parent, this function is
-    /// called in order to find the block's parent.
-    pub fn search_parent(
-        &mut self,
-        slot: Slot,
-        block_root: Hash256,
-        parent_root: Hash256,
-        peer_id: PeerId,
-        cx: &mut SyncNetworkContext<T>,
-    ) {
-        // If this block or it's parent is part of a known failed chain, ignore it.
-        if self.failed_chains.contains(&parent_root) || self.failed_chains.contains(&block_root) {
-            debug!(self.log, "Block is from a past failed chain. Dropping";
-                "block_root" => ?block_root, "block_slot" => slot);
-            return;
-        }
+        metrics::inc_counter(&metrics::SYNC_LOOKUP_CREATED);
 
-        // Make sure this block is not already downloaded, and that neither it or its parent is
-        // being searched for.
-        if let Some(parent_lookup) = self.parent_lookups.iter_mut().find(|parent_req| {
-            parent_req.contains_block(&parent_root) || parent_req.is_for_block(parent_root)
-        }) {
-            parent_lookup.add_peer(peer_id);
-            // we are already searching for this block, ignore it
-            debug!(self.log, "Already searching for parent block";
-                "block_root" => ?block_root, "parent_root" => ?parent_root);
-            return;
+        // Add block components to the new request
+        if let Some(block_component) = block_component {
+            lookup.add_child_components(block_component);
         }
 
-        if self
-            .processing_parent_lookups
-            .iter()
-            .any(|(chain_hash, (hashes, _peers))| {
-                chain_hash == &block_root
-                    || hashes.contains(&block_root)
-                    || hashes.contains(&parent_root)
-            })
-        {
-            // we are already processing this block, ignore it.
-            debug!(self.log, "Already processing parent block";
-                "block_root" => ?block_root, "parent_root" => ?parent_root);
-            return;
-        }
-        let parent_lookup = ParentLookup::new(
-            block_root,
-            parent_root,
-            peer_id,
-            self.da_checker.clone(),
-            cx,
-        );
-
-        debug!(self.log, "Created new parent lookup"; "block_root" => ?block_root, "parent_root" => ?parent_root);
+        let id = lookup.id;
+        let lookup = match self.single_block_lookups.entry(id) {
+            Entry::Vacant(entry) => entry.insert(lookup),
+            Entry::Occupied(_) => {
+                // Should never happen
+                warn!(self.log, "Lookup exists with same id"; "id" => id);
+                return false;
+            }
+        };
 
-        self.request_parent(parent_lookup, cx);
+        let result = lookup.continue_requests(cx);
+        self.on_lookup_result(id, result, "new_current_lookup", cx);
+        self.update_metrics();
+        true
     }
 
     /* Lookup responses */
 
-    /// Get a single block lookup by its ID. This method additionally ensures the `req_counter`
-    /// matches the current `req_counter` for the lookup. This ensures any stale responses from requests
-    /// that have been retried are ignored.
-    fn get_single_lookup<R: RequestState<Current, T>>(
+    /// Process a block or blob response received from a single lookup request.
+    pub fn on_download_response<R: RequestState<T>>(
         &mut self,
         id: SingleLookupReqId,
-    ) -> Option<SingleBlockLookup<Current, T>> {
-        let mut lookup = self.single_block_lookups.remove(&id.id)?;
-
-        let request_state = R::request_state_mut(&mut lookup);
-        if id.req_counter != request_state.get_state().req_counter {
-            // We don't want to drop the lookup, just ignore the old response.
-            self.single_block_lookups.insert(id.id, lookup);
-            return None;
-        }
-        Some(lookup)
-    }
-
-    /// Checks whether a single block lookup is waiting for a parent lookup to complete. This is
-    /// necessary because we want to make sure all parents are processed before sending a child
-    /// for processing, otherwise the block will fail validation and will be returned to the network
-    /// layer with an `UnknownParent` error.
-    pub fn has_pending_parent_request(&self, block_root: Hash256) -> bool {
-        self.parent_lookups
-            .iter()
-            .any(|parent_lookup| parent_lookup.chain_hash() == block_root)
+        peer_id: PeerId,
+        response: RpcProcessingResult<R::VerifiedResponseType>,
+        cx: &mut SyncNetworkContext<T>,
+    ) {
+        let result = self.on_download_response_inner::<R>(id, peer_id, response, cx);
+        self.on_lookup_result(id.lookup_id, result, "download_response", cx);
     }
 
     /// Process a block or blob response received from a single lookup request.
-    pub fn single_lookup_response<R: RequestState<Current, T>>(
+    pub fn on_download_response_inner<R: RequestState<T>>(
         &mut self,
-        lookup_id: SingleLookupReqId,
+        id: SingleLookupReqId,
         peer_id: PeerId,
-        response: Option<R::ResponseType>,
-        seen_timestamp: Duration,
-        cx: &SyncNetworkContext<T>,
-    ) {
-        let id = lookup_id.id;
-        let response_type = R::response_type();
+        response: RpcProcessingResult<R::VerifiedResponseType>,
+        cx: &mut SyncNetworkContext<T>,
+    ) -> Result<LookupResult, LookupRequestError> {
+        // Note: no need to downscore peers here, already downscored on network context
 
-        let Some(lookup) = self.get_single_lookup::<R>(lookup_id) else {
-            if response.is_some() {
-                // We don't have the ability to cancel in-flight RPC requests. So this can happen
-                // if we started this RPC request, and later saw the block/blobs via gossip.
-                debug!(
-                    self.log,
-                    "Block returned for single block lookup not present";
-                        "response_type" => ?response_type,
-                );
-            }
-            return;
+        let response_type = R::response_type();
+        let Some(lookup) = self.single_block_lookups.get_mut(&id.lookup_id) else {
+            // We don't have the ability to cancel in-flight RPC requests. So this can happen
+            // if we started this RPC request, and later saw the block/blobs via gossip.
+            debug!(self.log, "Block returned for single block lookup not present"; "id" => ?id);
+            return Err(LookupRequestError::UnknownLookup);
         };
 
-        let expected_block_root = lookup.block_root();
-        if response.is_some() {
-            debug!(self.log,
-                "Peer returned response for single lookup";
-                "peer_id" => %peer_id ,
-                "id" => ?id,
-                "block_root" => ?expected_block_root,
-                "response_type" => ?response_type,
-            );
-        }
+        let block_root = lookup.block_root();
+        let request_state = R::request_state_mut(lookup).get_state_mut();
 
-        match self.single_lookup_response_inner::<R>(peer_id, response, seen_timestamp, cx, lookup)
-        {
-            Ok(lookup) => {
-                self.single_block_lookups.insert(id, lookup);
-            }
-            Err(e) => {
+        match response {
+            Ok((response, seen_timestamp)) => {
                 debug!(self.log,
-                    "Single lookup request failed";
-                    "error" => ?e,
-                    "block_root" => ?expected_block_root,
-                );
-            }
-        }
-
-        metrics::set_gauge(
-            &metrics::SYNC_SINGLE_BLOCK_LOOKUPS,
-            self.single_block_lookups.len() as i64,
-        );
-    }
-
-    /// Consolidates error handling for `single_lookup_response`. An `Err` here should always mean
-    /// the lookup is dropped.
-    fn single_lookup_response_inner<R: RequestState<Current, T>>(
-        &self,
-        peer_id: PeerId,
-        response: Option<R::ResponseType>,
-        seen_timestamp: Duration,
-        cx: &SyncNetworkContext<T>,
-        mut lookup: SingleBlockLookup<Current, T>,
-    ) -> Result<SingleBlockLookup<Current, T>, LookupRequestError> {
-        let response_type = R::response_type();
-        let log = self.log.clone();
-        let expected_block_root = lookup.block_root();
-        let request_state = R::request_state_mut(&mut lookup);
-
-        match request_state.verify_response(expected_block_root, response) {
-            Ok(Some(verified_response)) => {
-                self.handle_verified_response::<Current, R>(
-                    seen_timestamp,
-                    cx,
-                    BlockProcessType::SingleBlock { id: lookup.id },
-                    verified_response,
-                    &mut lookup,
-                )?;
-            }
-            Ok(None) => {}
-            Err(e) => {
-                debug!(
-                    log,
-                    "Single lookup response verification failed, retrying";
-                    "block_root" => ?expected_block_root,
+                    "Received lookup download success";
+                    "block_root" => ?block_root,
+                    "id" => ?id,
                     "peer_id" => %peer_id,
                     "response_type" => ?response_type,
-                    "error" => ?e
                 );
-                let msg = e.into();
-                cx.report_peer(peer_id, PeerAction::LowToleranceError, msg);
 
-                request_state.register_failure_downloading();
-                lookup.request_block_and_blobs(cx)?;
-            }
-        }
-        Ok(lookup)
-    }
-
-    fn handle_verified_response<L: Lookup, R: RequestState<L, T>>(
-        &self,
-        seen_timestamp: Duration,
-        cx: &SyncNetworkContext<T>,
-        process_type: BlockProcessType,
-        verified_response: R::VerifiedResponseType,
-        lookup: &mut SingleBlockLookup<L, T>,
-    ) -> Result<(), LookupRequestError> {
-        let id = lookup.id;
-        let block_root = lookup.block_root();
-
-        R::request_state_mut(lookup)
-            .get_state_mut()
-            .component_downloaded = true;
-
-        let cached_child = lookup.add_response::<R>(verified_response.clone());
-        match cached_child {
-            CachedChild::Ok(block) => {
-                // If we have an outstanding parent request for this block, delay sending the response until
-                // all parent blocks have been processed, otherwise we will fail validation with an
-                // `UnknownParent`.
-                let delay_send = match L::lookup_type() {
-                    LookupType::Parent => false,
-                    LookupType::Current => self.has_pending_parent_request(lookup.block_root()),
-                };
-
-                if !delay_send {
-                    self.send_block_for_processing(
+                // Register the download peer here. Once we have received some data over the wire we
+                // attribute it to this peer for scoring latter regardless of how the request was
+                // done.
+                request_state.on_download_success(
+                    id.req_id,
+                    DownloadResult {
+                        value: response,
                         block_root,
-                        block,
                         seen_timestamp,
-                        process_type,
-                        cx,
-                    )?
-                }
-            }
-            CachedChild::DownloadIncomplete => {
-                // If this was the result of a block request, we can't determine if the block peer
-                // did anything wrong. If we already had both a block and blobs response processed,
-                // we should penalize the blobs peer because they did not provide all blobs on the
-                // initial request.
-                if lookup.both_components_downloaded() {
-                    lookup.penalize_blob_peer(cx);
-                    lookup
-                        .blob_request_state
-                        .state
-                        .register_failure_downloading();
-                }
-                lookup.request_block_and_blobs(cx)?;
-            }
-            CachedChild::NotRequired => R::send_reconstructed_for_processing(
-                id,
-                self,
-                block_root,
-                R::verified_to_reconstructed(block_root, verified_response),
-                seen_timestamp,
-                cx,
-            )?,
-            CachedChild::Err(e) => {
-                warn!(self.log, "Consistency error in cached block";
-                    "error" => ?e,
-                    "block_root" => ?block_root
-                );
-                lookup.handle_consistency_failure(cx);
-                lookup.request_block_and_blobs(cx)?;
-            }
-        }
-        Ok(())
-    }
-
-    /// Get a parent block lookup by its ID. This method additionally ensures the `req_counter`
-    /// matches the current `req_counter` for the lookup. This any stale responses from requests
-    /// that have been retried are ignored.
-    fn get_parent_lookup<R: RequestState<Parent, T>>(
-        &mut self,
-        id: SingleLookupReqId,
-    ) -> Option<ParentLookup<T>> {
-        let mut parent_lookup = if let Some(pos) = self
-            .parent_lookups
-            .iter()
-            .position(|request| request.current_parent_request.id == id.id)
-        {
-            self.parent_lookups.remove(pos)
-        } else {
-            return None;
-        };
-
-        if R::request_state_mut(&mut parent_lookup.current_parent_request)
-            .get_state()
-            .req_counter
-            != id.req_counter
-        {
-            self.parent_lookups.push(parent_lookup);
-            return None;
-        }
-        Some(parent_lookup)
-    }
-
-    /// Process a response received from a parent lookup request.
-    pub fn parent_lookup_response<R: RequestState<Parent, T>>(
-        &mut self,
-        id: SingleLookupReqId,
-        peer_id: PeerId,
-        response: Option<R::ResponseType>,
-        seen_timestamp: Duration,
-        cx: &SyncNetworkContext<T>,
-    ) {
-        let Some(mut parent_lookup) = self.get_parent_lookup::<R>(id) else {
-            if response.is_some() {
-                debug!(self.log, "Response for a parent lookup request that was not found"; "peer_id" => %peer_id);
-            }
-            return;
-        };
-
-        if response.is_some() {
-            debug!(self.log,
-                "Peer returned response for parent lookup";
-                "peer_id" => %peer_id ,
-                "id" => ?id,
-                "block_root" => ?parent_lookup.current_parent_request.block_request_state.requested_block_root,
-                "response_type" => ?R::response_type(),
-            );
-        }
-
-        match self.parent_lookup_response_inner::<R>(
-            peer_id,
-            response,
-            seen_timestamp,
-            cx,
-            &mut parent_lookup,
-        ) {
-            Ok(()) => {
-                self.parent_lookups.push(parent_lookup);
-            }
-            Err(e) => {
-                self.handle_parent_request_error(&mut parent_lookup, cx, e);
-            }
-        }
-
-        metrics::set_gauge(
-            &metrics::SYNC_PARENT_BLOCK_LOOKUPS,
-            self.parent_lookups.len() as i64,
-        );
-    }
-
-    /// Consolidates error handling for `parent_lookup_response`. An `Err` here should always mean
-    /// the lookup is dropped.
-    fn parent_lookup_response_inner<R: RequestState<Parent, T>>(
-        &mut self,
-        peer_id: PeerId,
-        response: Option<R::ResponseType>,
-        seen_timestamp: Duration,
-        cx: &SyncNetworkContext<T>,
-        parent_lookup: &mut ParentLookup<T>,
-    ) -> Result<(), RequestError> {
-        match parent_lookup.verify_response::<R>(response, &mut self.failed_chains) {
-            Ok(Some(verified_response)) => {
-                self.handle_verified_response::<Parent, R>(
-                    seen_timestamp,
-                    cx,
-                    BlockProcessType::ParentLookup {
-                        chain_hash: parent_lookup.chain_hash(),
+                        peer_id,
                     },
-                    verified_response,
-                    &mut parent_lookup.current_parent_request,
                 )?;
+                // continue_request will send for  processing as the request state is AwaitingProcessing
             }
-            Ok(None) => {}
-            Err(e) => self.handle_parent_verify_error::<R>(peer_id, parent_lookup, e, cx)?,
-        };
-        Ok(())
-    }
-
-    /// Handle logging and peer scoring for `ParentVerifyError`s during parent lookup requests.
-    fn handle_parent_verify_error<R: RequestState<Parent, T>>(
-        &mut self,
-        peer_id: PeerId,
-        parent_lookup: &mut ParentLookup<T>,
-        e: ParentVerifyError,
-        cx: &SyncNetworkContext<T>,
-    ) -> Result<(), RequestError> {
-        match e {
-            ParentVerifyError::RootMismatch
-            | ParentVerifyError::NoBlockReturned
-            | ParentVerifyError::NotEnoughBlobsReturned
-            | ParentVerifyError::ExtraBlocksReturned
-            | ParentVerifyError::UnrequestedBlobId(_)
-            | ParentVerifyError::InvalidInclusionProof
-            | ParentVerifyError::UnrequestedHeader
-            | ParentVerifyError::ExtraBlobsReturned
-            | ParentVerifyError::InvalidIndex(_) => {
-                let e = e.into();
-                warn!(self.log, "Peer sent invalid response to parent request";
-                        "peer_id" => %peer_id, "reason" => %e);
-
-                // We do not tolerate these kinds of errors. We will accept a few but these are signs
-                // of a faulty peer.
-                cx.report_peer(peer_id, PeerAction::LowToleranceError, e);
-
-                // We try again if possible.
-                parent_lookup.request_parent(cx)?;
-            }
-            ParentVerifyError::PreviousFailure { parent_root } => {
-                debug!(
-                    self.log,
-                    "Parent chain ignored due to past failure";
-                    "block" => %parent_root,
+            Err(e) => {
+                debug!(self.log,
+                    "Received lookup download failure";
+                    "block_root" => ?block_root,
+                    "id" => ?id,
+                    "peer_id" => %peer_id,
+                    "response_type" => ?response_type,
+                    "error" => %e,
                 );
-                // Add the root block to failed chains
-                self.failed_chains.insert(parent_lookup.chain_hash());
 
-                cx.report_peer(
-                    peer_id,
-                    PeerAction::MidToleranceError,
-                    "bbroot_failed_chains",
-                );
+                request_state.on_download_failure(id.req_id)?;
+                // continue_request will retry a download as the request state is AwaitingDownload
             }
         }
-        Ok(())
-    }
 
-    /// Handle logging and peer scoring for `RequestError`s during parent lookup requests.
-    fn handle_parent_request_error(
-        &mut self,
-        parent_lookup: &mut ParentLookup<T>,
-        cx: &SyncNetworkContext<T>,
-        e: RequestError,
-    ) {
-        debug!(self.log, "Failed to request parent";  "error" => e.as_static());
-        match e {
-            RequestError::SendFailed(_) => {
-                // Probably shutting down, nothing to do here. Drop the request
-            }
-            RequestError::ChainTooLong => {
-                self.failed_chains.insert(parent_lookup.chain_hash());
-                // This indicates faulty peers.
-                for &peer_id in parent_lookup.used_peers() {
-                    cx.report_peer(peer_id, PeerAction::LowToleranceError, e.as_static())
-                }
-            }
-            RequestError::TooManyAttempts { cannot_process } => {
-                // We only consider the chain failed if we were unable to process it.
-                // We could have failed because one peer continually failed to send us
-                // bad blocks. We still allow other peers to send us this chain. Note
-                // that peers that do this, still get penalised.
-                if cannot_process {
-                    self.failed_chains.insert(parent_lookup.chain_hash());
-                }
-                // This indicates faulty peers.
-                for &peer_id in parent_lookup.used_peers() {
-                    cx.report_peer(peer_id, PeerAction::LowToleranceError, e.as_static())
-                }
-            }
-            RequestError::NoPeers => {
-                // This happens if the peer disconnects while the block is being
-                // processed. Drop the request without extra penalty
-            }
-        }
+        lookup.continue_requests(cx)
     }
 
     /* Error responses */
 
-    pub fn peer_disconnected(&mut self, peer_id: &PeerId, cx: &mut SyncNetworkContext<T>) {
-        /* Check disconnection for single lookups */
-        self.single_block_lookups.retain(|_, req| {
-            let should_drop_lookup =
-                req.should_drop_lookup_on_disconnected_peer(peer_id, cx, &self.log);
-
-            !should_drop_lookup
+    pub fn peer_disconnected(&mut self, peer_id: &PeerId) {
+        self.single_block_lookups.retain(|_, lookup| {
+            if lookup.remove_peer(peer_id) {
+                debug!(self.log, "Dropping single lookup after peer disconnection"; "block_root" => ?lookup.block_root());
+                false
+            } else {
+                true
+            }
         });
-
-        /* Check disconnection for parent lookups */
-        while let Some(pos) = self
-            .parent_lookups
-            .iter_mut()
-            .position(|req| req.check_peer_disconnected(peer_id).is_err())
-        {
-            let parent_lookup = self.parent_lookups.remove(pos);
-            debug!(self.log, "Dropping parent lookup after peer disconnected"; &parent_lookup);
-            self.request_parent(parent_lookup, cx);
-        }
     }
 
-    /// An RPC error has occurred during a parent lookup. This function handles this case.
-    pub fn parent_lookup_failed<R: RequestState<Parent, T>>(
-        &mut self,
-        id: SingleLookupReqId,
-        peer_id: PeerId,
-        cx: &SyncNetworkContext<T>,
-        error: RPCError,
-    ) {
-        let msg = error.as_static_str();
-        let Some(mut parent_lookup) = self.get_parent_lookup::<R>(id) else {
-            debug!(self.log,
-                "RPC failure for a block parent lookup request that was not found";
-                "peer_id" => %peer_id,
-                "error" => msg
-            );
-            return;
-        };
-        R::request_state_mut(&mut parent_lookup.current_parent_request)
-            .register_failure_downloading();
-        trace!(self.log, "Parent lookup block request failed"; &parent_lookup, "error" => msg);
-
-        self.request_parent(parent_lookup, cx);
-
-        metrics::set_gauge(
-            &metrics::SYNC_PARENT_BLOCK_LOOKUPS,
-            self.parent_lookups.len() as i64,
-        );
-    }
+    /* Processing responses */
 
-    /// An RPC error has occurred during a single lookup. This function handles this case.\
-    pub fn single_block_lookup_failed<R: RequestState<Current, T>>(
+    pub fn on_processing_result(
         &mut self,
-        id: SingleLookupReqId,
-        peer_id: &PeerId,
-        cx: &SyncNetworkContext<T>,
-        error: RPCError,
+        process_type: BlockProcessType,
+        result: BlockProcessingResult<T::EthSpec>,
+        cx: &mut SyncNetworkContext<T>,
     ) {
-        let msg = error.as_static_str();
-        let log = self.log.clone();
-        let Some(mut lookup) = self.get_single_lookup::<R>(id) else {
-            debug!(log, "Error response to dropped lookup"; "error" => ?error);
-            return;
+        let lookup_result = match process_type {
+            BlockProcessType::SingleBlock { id } => {
+                self.on_processing_result_inner::<BlockRequestState<T::EthSpec>>(id, result, cx)
+            }
+            BlockProcessType::SingleBlob { id } => {
+                self.on_processing_result_inner::<BlobRequestState<T::EthSpec>>(id, result, cx)
+            }
         };
-        let block_root = lookup.block_root();
-        let request_state = R::request_state_mut(&mut lookup);
-        let response_type = R::response_type();
-        trace!(log,
-            "Single lookup failed";
-            "block_root" => ?block_root,
-            "error" => msg,
-            "peer_id" => %peer_id,
-            "response_type" => ?response_type
-        );
-        let id = id.id;
-        request_state.register_failure_downloading();
-        if let Err(e) = lookup.request_block_and_blobs(cx) {
-            debug!(self.log,
-                "Single lookup retry failed";
-                "error" => ?e,
-                "block_root" => ?block_root,
-            );
-            self.single_block_lookups.remove(&id);
-        }
-
-        metrics::set_gauge(
-            &metrics::SYNC_SINGLE_BLOCK_LOOKUPS,
-            self.single_block_lookups.len() as i64,
-        );
+        let id = match process_type {
+            BlockProcessType::SingleBlock { id } | BlockProcessType::SingleBlob { id } => id,
+        };
+        self.on_lookup_result(id, lookup_result, "processing_result", cx);
     }
 
-    /* Processing responses */
-
-    pub fn single_block_component_processed<R: RequestState<Current, T>>(
+    pub fn on_processing_result_inner<R: RequestState<T>>(
         &mut self,
-        target_id: Id,
+        lookup_id: SingleLookupId,
         result: BlockProcessingResult<T::EthSpec>,
         cx: &mut SyncNetworkContext<T>,
-    ) {
-        let Some(mut lookup) = self.single_block_lookups.remove(&target_id) else {
-            debug!(self.log, "Unknown single block lookup"; "target_id" => target_id);
-            return;
+    ) -> Result<LookupResult, LookupRequestError> {
+        let Some(lookup) = self.single_block_lookups.get_mut(&lookup_id) else {
+            debug!(self.log, "Unknown single block lookup"; "id" => lookup_id);
+            return Err(LookupRequestError::UnknownLookup);
         };
 
-        let root = lookup.block_root();
-        let request_state = R::request_state_mut(&mut lookup);
+        let block_root = lookup.block_root();
+        let request_state = R::request_state_mut(lookup).get_state_mut();
 
-        let peer_id = match request_state.get_state().processing_peer() {
-            Ok(peer_id) => peer_id,
-            Err(e) => {
-                debug!(self.log, "Attempting to process single block lookup in bad state"; "id" => target_id, "response_type" => ?R::response_type(), "error" => e);
-                return;
-            }
-        };
         debug!(
             self.log,
-            "Block component processed for lookup";
-            "response_type" => ?R::response_type(),
-            "block_root" => ?root,
+            "Received lookup processing result";
+            "component" => ?R::response_type(),
+            "block_root" => ?block_root,
+            "id" => lookup_id,
             "result" => ?result,
-            "id" => target_id,
         );
 
-        match result {
-            BlockProcessingResult::Ok(status) => match status {
-                AvailabilityProcessingStatus::Imported(root) => {
-                    trace!(self.log, "Single block processing succeeded"; "block" => %root);
-                }
-                AvailabilityProcessingStatus::MissingComponents(_, _block_root) => {
-                    match self.handle_missing_components::<R>(cx, &mut lookup) {
-                        Ok(()) => {
-                            self.single_block_lookups.insert(target_id, lookup);
-                        }
-                        Err(e) => {
-                            // Drop with an additional error.
-                            warn!(self.log, "Single block lookup failed"; "block" => %root, "error" => ?e);
-                        }
-                    }
+        let action = match result {
+            BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(_))
+            | BlockProcessingResult::Err(BlockError::BlockIsAlreadyKnown(_)) => {
+                // Successfully imported
+                request_state.on_processing_success()?;
+                Action::Continue
+            }
+
+            BlockProcessingResult::Ok(AvailabilityProcessingStatus::MissingComponents(
+                _,
+                _block_root,
+            )) => {
+                // `on_processing_success` is called here to ensure the request state is updated prior to checking
+                // if both components have been processed.
+                request_state.on_processing_success()?;
+
+                if lookup.both_components_processed() {
+                    // We don't request for other block components until being sure that the block has
+                    // data. If we request blobs / columns to a peer we are sure those must exist.
+                    // Therefore if all components are processed and we still receive `MissingComponents`
+                    // it indicates an internal bug.
+                    return Err(LookupRequestError::MissingComponentsAfterAllProcessed);
+                } else {
+                    // Continue request, potentially request blobs
+                    Action::Retry
                 }
-            },
+            }
             BlockProcessingResult::Ignored => {
                 // Beacon processor signalled to ignore the block processing result.
                 // This implies that the cpu is overloaded. Drop the request.
                 warn!(
                     self.log,
-                    "Single block processing was ignored, cpu might be overloaded";
-                    "action" => "dropping single block request"
+                    "Lookup component processing ignored, cpu might be overloaded";
+                    "component" => ?R::response_type(),
                 );
+                Action::Drop
             }
             BlockProcessingResult::Err(e) => {
-                match self.handle_single_lookup_block_error(cx, lookup, peer_id, e) {
-                    Ok(Some(lookup)) => {
-                        self.single_block_lookups.insert(target_id, lookup);
+                match e {
+                    BlockError::BeaconChainError(e) => {
+                        // Internal error
+                        error!(self.log, "Beacon chain error processing lookup component"; "block_root" => %block_root, "error" => ?e);
+                        Action::Drop
                     }
-                    Ok(None) => {
-                        // Drop without an additional error.
+                    BlockError::ParentUnknown(block) => {
+                        // Reverts the status of this request to `AwaitingProcessing` holding the
+                        // downloaded data. A future call to `continue_requests` will re-submit it
+                        // once there are no pending parent requests.
+                        // Note: `BlockError::ParentUnknown` is only returned when processing
+                        // blocks, not blobs.
+                        request_state.revert_to_awaiting_processing()?;
+                        Action::ParentUnknown {
+                            parent_root: block.parent_root(),
+                        }
                     }
-                    Err(e) => {
-                        // Drop with an additional error.
-                        warn!(self.log, "Single block lookup failed"; "block" => %root, "error" => ?e);
+                    ref e @ BlockError::ExecutionPayloadError(ref epe) if !epe.penalize_peer() => {
+                        // These errors indicate that the execution layer is offline
+                        // and failed to validate the execution payload. Do not downscore peer.
+                        debug!(
+                            self.log,
+                            "Single block lookup failed. Execution layer is offline / unsynced / misconfigured";
+                            "block_root" => ?block_root,
+                            "error" => ?e
+                        );
+                        Action::Drop
+                    }
+                    BlockError::AvailabilityCheck(e)
+                        if e.category() == AvailabilityCheckErrorCategory::Internal =>
+                    {
+                        // There errors indicate internal problems and should not downscore the  peer
+                        warn!(self.log, "Internal availability check failure"; "block_root" => ?block_root, "error" => ?e);
+
+                        // Here we choose *not* to call `on_processing_failure` because this could result in a bad
+                        // lookup state transition. This error invalidates both blob and block requests, and we don't know the
+                        // state of both requests. Blobs may have already successfullly processed for example.
+                        // We opt to drop the lookup instead.
+                        Action::Drop
+                    }
+                    other => {
+                        debug!(self.log, "Invalid lookup component"; "block_root" => ?block_root, "component" => ?R::response_type(), "error" => ?other);
+
+                        let peer_id = request_state.on_processing_failure()?;
+                        cx.report_peer(
+                            peer_id,
+                            PeerAction::MidToleranceError,
+                            match R::response_type() {
+                                ResponseType::Block => "lookup_block_processing_failure",
+                                ResponseType::Blob => "lookup_blobs_processing_failure",
+                            },
+                        );
+
+                        Action::Retry
                     }
                 }
             }
         };
-    }
 
-    /// Handles a `MissingComponents` block processing error. Handles peer scoring and retries.
-    ///
-    /// If this was the result of a block request, we can't determined if the block peer did anything
-    /// wrong. If we already had both a block and blobs response processed, we should penalize the
-    /// blobs peer because they did not provide all blobs on the initial request.
-    fn handle_missing_components<R: RequestState<Current, T>>(
-        &self,
-        cx: &SyncNetworkContext<T>,
-        lookup: &mut SingleBlockLookup<Current, T>,
-    ) -> Result<(), LookupRequestError> {
-        let request_state = R::request_state_mut(lookup);
-
-        request_state.get_state_mut().component_processed = true;
-        if lookup.both_components_processed() {
-            lookup.penalize_blob_peer(cx);
-
-            // Try it again if possible.
-            lookup
-                .blob_request_state
-                .state
-                .register_failure_processing();
-            lookup.request_block_and_blobs(cx)?;
-        }
-        Ok(())
-    }
-
-    /// Handles peer scoring and retries related to a `BlockError` in response to a single block
-    /// or blob lookup processing result.
-    fn handle_single_lookup_block_error(
-        &mut self,
-        cx: &mut SyncNetworkContext<T>,
-        mut lookup: SingleBlockLookup<Current, T>,
-        peer_id: PeerId,
-        e: BlockError<T::EthSpec>,
-    ) -> Result<Option<SingleBlockLookup<Current, T>>, LookupRequestError> {
-        let root = lookup.block_root();
-        trace!(self.log, "Single block processing failed"; "block" => %root, "error" => %e);
-        match e {
-            BlockError::BlockIsAlreadyKnown(_) => {
-                // No error here
-                return Ok(None);
+        match action {
+            Action::Retry => {
+                // Trigger download for all components in case `MissingComponents` failed the blob
+                // request. Also if blobs are `AwaitingProcessing` and need to be progressed
+                lookup.continue_requests(cx)
             }
-            BlockError::BeaconChainError(e) => {
-                // Internal error
-                error!(self.log, "Beacon chain error processing single block"; "block_root" => %root, "error" => ?e);
-                return Ok(None);
+            Action::ParentUnknown { parent_root } => {
+                let peers = lookup.all_available_peers().cloned().collect::<Vec<_>>();
+                lookup.set_awaiting_parent(parent_root);
+                debug!(self.log, "Marking lookup as awaiting parent"; "id" => lookup.id, "block_root" => ?block_root, "parent_root" => ?parent_root);
+                self.search_parent_of_child(parent_root, block_root, &peers, cx);
+                Ok(LookupResult::Pending)
             }
-            BlockError::ParentUnknown(block) => {
-                let slot = block.slot();
-                let parent_root = block.parent_root();
-                lookup.add_child_components(block.into());
-                lookup.request_block_and_blobs(cx)?;
-                self.search_parent(slot, root, parent_root, peer_id, cx);
+            Action::Drop => {
+                // Drop with noop
+                Err(LookupRequestError::Failed)
             }
-            ref e @ BlockError::ExecutionPayloadError(ref epe) if !epe.penalize_peer() => {
-                // These errors indicate that the execution layer is offline
-                // and failed to validate the execution payload. Do not downscore peer.
-                debug!(
-                    self.log,
-                    "Single block lookup failed. Execution layer is offline / unsynced / misconfigured";
-                    "root" => %root,
-                    "error" => ?e
-                );
-                return Ok(None);
-            }
-            BlockError::AvailabilityCheck(e) => match e.category() {
-                AvailabilityCheckErrorCategory::Internal => {
-                    warn!(self.log, "Internal availability check failure"; "root" => %root, "peer_id" => %peer_id, "error" => ?e);
-                    lookup
-                        .block_request_state
-                        .state
-                        .register_failure_downloading();
-                    lookup
-                        .blob_request_state
-                        .state
-                        .register_failure_downloading();
-                    lookup.request_block_and_blobs(cx)?
-                }
-                AvailabilityCheckErrorCategory::Malicious => {
-                    warn!(self.log, "Availability check failure"; "root" => %root, "peer_id" => %peer_id, "error" => ?e);
-                    lookup.handle_availability_check_failure(cx);
-                    lookup.request_block_and_blobs(cx)?
-                }
-            },
-            other => {
-                warn!(self.log, "Peer sent invalid block in single block lookup"; "root" => %root, "error" => ?other, "peer_id" => %peer_id);
-                if let Ok(block_peer) = lookup.block_request_state.state.processing_peer() {
-                    cx.report_peer(
-                        block_peer,
-                        PeerAction::MidToleranceError,
-                        "single_block_failure",
-                    );
-
-                    // Try it again if possible.
-                    lookup
-                        .block_request_state
-                        .state
-                        .register_failure_processing();
-                    lookup.request_block_and_blobs(cx)?
-                }
+            Action::Continue => {
+                // Drop this completed lookup only
+                Ok(LookupResult::Completed)
             }
         }
-        Ok(Some(lookup))
     }
 
-    pub fn parent_block_processed(
+    pub fn on_external_processing_result(
         &mut self,
-        chain_hash: Hash256,
-        result: BlockProcessingResult<T::EthSpec>,
+        block_root: Hash256,
+        imported: bool,
         cx: &mut SyncNetworkContext<T>,
     ) {
-        let index = self
-            .parent_lookups
-            .iter()
-            .enumerate()
-            .find(|(_, lookup)| lookup.chain_hash() == chain_hash)
-            .map(|(index, _)| index);
-
-        let Some(mut parent_lookup) = index.map(|index| self.parent_lookups.remove(index)) else {
-            return debug!(self.log, "Process response for a parent lookup request that was not found"; "chain_hash" => %chain_hash);
+        let Some((id, lookup)) = self
+            .single_block_lookups
+            .iter_mut()
+            .find(|(_, lookup)| lookup.is_for_block(block_root))
+        else {
+            // Ok to ignore gossip process events
+            return;
         };
 
-        match &result {
-            BlockProcessingResult::Ok(status) => match status {
-                AvailabilityProcessingStatus::Imported(block_root) => {
-                    debug!(self.log, "Parent block processing succeeded"; &parent_lookup, "block_root" => ?block_root)
-                }
-                AvailabilityProcessingStatus::MissingComponents(_, block_root) => {
-                    debug!(self.log, "Parent missing parts, triggering single block lookup"; &parent_lookup,"block_root" => ?block_root)
-                }
-            },
-            BlockProcessingResult::Err(e) => {
-                debug!(self.log, "Parent block processing failed"; &parent_lookup, "error" => %e)
-            }
-            BlockProcessingResult::Ignored => {
-                debug!(
-                    self.log,
-                    "Parent block processing job was ignored";
-                    "action" => "re-requesting block",
-                    &parent_lookup
-                );
-            }
-        }
-
-        match result {
-            BlockProcessingResult::Ok(AvailabilityProcessingStatus::MissingComponents(
-                _,
-                block_root,
-            )) => {
-                let expected_block_root = parent_lookup.current_parent_request.block_root();
-                if block_root != expected_block_root {
-                    warn!(
-                        self.log,
-                        "Parent block processing result/request root mismatch";
-                        "request" =>?expected_block_root,
-                        "result" => ?block_root
-                    );
-                    return;
-                }
-
-                // We only send parent blocks + blobs for processing together. This means a
-                // `MissingComponents` response here indicates missing blobs. Therefore we always
-                // register a blob processing failure here.
-                parent_lookup
-                    .current_parent_request
-                    .blob_request_state
-                    .state
-                    .register_failure_processing();
-                match parent_lookup
-                    .current_parent_request
-                    .request_block_and_blobs(cx)
-                {
-                    Ok(()) => self.parent_lookups.push(parent_lookup),
-                    Err(e) => self.handle_parent_request_error(&mut parent_lookup, cx, e.into()),
-                }
-            }
-            BlockProcessingResult::Err(BlockError::ParentUnknown(block)) => {
-                parent_lookup.add_unknown_parent_block(block);
-                self.request_parent(parent_lookup, cx);
-            }
-            BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(_))
-            | BlockProcessingResult::Err(BlockError::BlockIsAlreadyKnown(_)) => {
-                // Check if the beacon processor is available
-                let Some(beacon_processor) = cx.beacon_processor_if_enabled() else {
-                    return trace!(
-                        self.log,
-                        "Dropping parent chain segment that was ready for processing.";
-                        parent_lookup
-                    );
-                };
-                let (chain_hash, blocks, hashes, block_request) =
-                    parent_lookup.parts_for_processing();
-
-                let blocks = self.add_child_block_to_chain(chain_hash, blocks, cx).into();
-
-                let process_id = ChainSegmentProcessId::ParentLookup(chain_hash);
-
-                match beacon_processor.send_chain_segment(process_id, blocks) {
-                    Ok(_) => {
-                        self.processing_parent_lookups
-                            .insert(chain_hash, (hashes, block_request));
-                    }
-                    Err(e) => {
-                        error!(
-                            self.log,
-                            "Failed to send chain segment to processor";
-                            "error" => ?e
-                        );
-                    }
-                }
-            }
-            ref e @ BlockProcessingResult::Err(BlockError::ExecutionPayloadError(ref epe))
-                if !epe.penalize_peer() =>
-            {
-                // These errors indicate that the execution layer is offline
-                // and failed to validate the execution payload. Do not downscore peer.
-                debug!(
-                    self.log,
-                    "Parent lookup failed. Execution layer is offline";
-                    "chain_hash" => %chain_hash,
-                    "error" => ?e
-                );
-            }
-            BlockProcessingResult::Err(outcome) => {
-                self.handle_parent_block_error(outcome, cx, parent_lookup);
-            }
-            BlockProcessingResult::Ignored => {
-                // Beacon processor signalled to ignore the block processing result.
-                // This implies that the cpu is overloaded. Drop the request.
-                warn!(
-                    self.log,
-                    "Parent block processing was ignored, cpu might be overloaded";
-                    "action" => "dropping parent request"
-                );
-            }
-        }
-
-        metrics::set_gauge(
-            &metrics::SYNC_PARENT_BLOCK_LOOKUPS,
-            self.parent_lookups.len() as i64,
-        );
-    }
-
-    /// Find the child block that spawned the parent lookup request and add it to the chain
-    /// to send for processing.
-    fn add_child_block_to_chain(
-        &mut self,
-        chain_hash: Hash256,
-        mut blocks: VecDeque<RpcBlock<T::EthSpec>>,
-        cx: &SyncNetworkContext<T>,
-    ) -> VecDeque<RpcBlock<T::EthSpec>> {
-        // Find the child block that spawned the parent lookup request and add it to the chain
-        // to send for processing.
-        if let Some(child_lookup_id) = self
-            .single_block_lookups
-            .iter()
-            .find_map(|(id, lookup)| (lookup.block_root() == chain_hash).then_some(*id))
-        {
-            let Some(child_lookup) = self.single_block_lookups.get_mut(&child_lookup_id) else {
-                debug!(self.log, "Missing child for parent lookup request"; "child_root" => ?chain_hash);
-                return blocks;
-            };
-            match child_lookup.get_cached_child_block() {
-                CachedChild::Ok(rpc_block) => {
-                    // Insert this block at the front. This order is important because we later check
-                    // for linear roots in `filter_chain_segment`
-                    blocks.push_front(rpc_block);
-                }
-                CachedChild::DownloadIncomplete => {
-                    trace!(self.log, "Parent lookup chain complete, awaiting child response"; "chain_hash" => ?chain_hash);
-                }
-                CachedChild::NotRequired => {
-                    warn!(self.log, "Child not cached for parent lookup"; "chain_hash" => %chain_hash);
-                }
-                CachedChild::Err(e) => {
-                    warn!(
-                        self.log,
-                        "Consistency error in child block triggering chain or parent lookups";
-                        "error" => ?e,
-                        "chain_hash" => ?chain_hash
-                    );
-                    child_lookup.handle_consistency_failure(cx);
-                    if let Err(e) = child_lookup.request_block_and_blobs(cx) {
-                        debug!(self.log,
-                            "Failed to request block and blobs, dropping lookup";
-                            "error" => ?e
-                        );
-                        self.single_block_lookups.remove(&child_lookup_id);
-                    }
-                }
-            }
+        let lookup_result = if imported {
+            Ok(LookupResult::Completed)
         } else {
-            debug!(self.log, "Missing child for parent lookup request"; "child_root" => ?chain_hash);
+            lookup.continue_requests(cx)
         };
-        blocks
+        let id = *id;
+        self.on_lookup_result(id, lookup_result, "external_processing_result", cx);
     }
 
-    /// Handle the peer scoring, retries, and logging related to a `BlockError` returned from
-    /// processing a block + blobs for a parent lookup.
-    fn handle_parent_block_error(
-        &mut self,
-        outcome: BlockError<<T as BeaconChainTypes>::EthSpec>,
-        cx: &SyncNetworkContext<T>,
-        mut parent_lookup: ParentLookup<T>,
-    ) {
-        // We should always have a block peer.
-        let Ok(block_peer_id) = parent_lookup.block_processing_peer() else {
-            return;
-        };
-
-        // We may not have a blob peer, if there were no blobs required for this block.
-        let blob_peer_id = parent_lookup.blob_processing_peer().ok();
+    /// Makes progress on the immediate children of `block_root`
+    pub fn continue_child_lookups(&mut self, block_root: Hash256, cx: &mut SyncNetworkContext<T>) {
+        let mut lookup_results = vec![]; // < need to buffer lookup results to not re-borrow &mut self
 
-        // all else we consider the chain a failure and downvote the peer that sent
-        // us the last block
-        warn!(
-            self.log, "Invalid parent chain";
-            "score_adjustment" => %PeerAction::MidToleranceError,
-            "outcome" => ?outcome,
-            "block_peer_id" => %block_peer_id,
-        );
-        // This currently can be a host of errors. We permit this due to the partial
-        // ambiguity.
-        cx.report_peer(
-            block_peer_id,
-            PeerAction::MidToleranceError,
-            "parent_request_err",
-        );
-        // Don't downscore the same peer twice
-        if let Some(blob_peer_id) = blob_peer_id {
-            if block_peer_id != blob_peer_id {
-                debug!(
-                    self.log, "Additionally down-scoring blob peer";
-                    "score_adjustment" => %PeerAction::MidToleranceError,
-                    "outcome" => ?outcome,
-                    "blob_peer_id" => %blob_peer_id,
-                );
-                cx.report_peer(
-                    blob_peer_id,
-                    PeerAction::MidToleranceError,
-                    "parent_request_err",
-                );
+        for (id, lookup) in self.single_block_lookups.iter_mut() {
+            if lookup.awaiting_parent() == Some(block_root) {
+                lookup.resolve_awaiting_parent();
+                debug!(self.log, "Continuing child lookup"; "parent_root" => ?block_root, "id" => id, "block_root" => ?lookup.block_root());
+                let result = lookup.continue_requests(cx);
+                lookup_results.push((*id, result));
             }
         }
 
-        // Try again if possible
-        parent_lookup.processing_failed();
-        self.request_parent(parent_lookup, cx);
-    }
-
-    pub fn parent_chain_processed(
-        &mut self,
-        chain_hash: Hash256,
-        result: BatchProcessResult,
-        cx: &SyncNetworkContext<T>,
-    ) {
-        let Some((_hashes, request)) = self.processing_parent_lookups.remove(&chain_hash) else {
-            return debug!(self.log, "Chain process response for a parent lookup request that was not found"; "chain_hash" => %chain_hash, "result" => ?result);
-        };
-
-        debug!(self.log, "Parent chain processed"; "chain_hash" => %chain_hash, "result" => ?result);
-        match result {
-            BatchProcessResult::Success { .. } => {
-                let Some(id) = self
-                    .single_block_lookups
-                    .iter()
-                    .find_map(|(id, req)| (req.block_root() == chain_hash).then_some(*id))
-                else {
-                    warn!(self.log, "No id found for single block lookup"; "chain_hash" => %chain_hash);
-                    return;
-                };
-
-                let Some(lookup) = self.single_block_lookups.get_mut(&id) else {
-                    warn!(self.log, "No id found for single block lookup"; "chain_hash" => %chain_hash);
-                    return;
-                };
-
-                match lookup.get_cached_child_block() {
-                    CachedChild::Ok(rpc_block) => {
-                        // This is the correct block, send it for processing
-                        if self
-                            .send_block_for_processing(
-                                chain_hash,
-                                rpc_block,
-                                timestamp_now(),
-                                BlockProcessType::SingleBlock { id },
-                                cx,
-                            )
-                            .is_err()
-                        {
-                            // Remove to avoid inconsistencies
-                            self.single_block_lookups.remove(&id);
-                        }
-                    }
-                    CachedChild::DownloadIncomplete => {
-                        trace!(self.log, "Parent chain complete, awaiting child response"; "chain_hash" => %chain_hash);
-                    }
-                    CachedChild::NotRequired => {
-                        warn!(self.log, "Child not cached for parent lookup"; "chain_hash" => %chain_hash);
-                    }
-                    CachedChild::Err(e) => {
-                        warn!(
-                            self.log,
-                            "Consistency error in child block triggering parent lookup";
-                            "chain_hash" => %chain_hash,
-                            "error" => ?e
-                        );
-                        lookup.handle_consistency_failure(cx);
-                        if let Err(e) = lookup.request_block_and_blobs(cx) {
-                            debug!(self.log,
-                                "Failed to request block and blobs, dropping lookup";
-                                "error" => ?e
-                            );
-                            self.single_block_lookups.remove(&id);
-                        }
-                    }
-                }
-            }
-            BatchProcessResult::FaultyFailure {
-                imported_blocks: _,
-                penalty,
-            } => {
-                self.failed_chains.insert(chain_hash);
-                for peer_source in request.all_peers() {
-                    cx.report_peer(peer_source, penalty, "parent_chain_failure")
-                }
-            }
-            BatchProcessResult::NonFaultyFailure => {
-                // We might request this chain again if there is need but otherwise, don't try again
-            }
+        for (id, result) in lookup_results {
+            self.on_lookup_result(id, result, "continue_child_lookups", cx);
         }
-
-        metrics::set_gauge(
-            &metrics::SYNC_PARENT_BLOCK_LOOKUPS,
-            self.parent_lookups.len() as i64,
-        );
     }
 
-    /* Helper functions */
+    /// Drops `dropped_id` lookup and all its children recursively. Lookups awaiting a parent need
+    /// the parent to make progress to resolve, therefore we must drop them if the parent is
+    /// dropped.
+    pub fn drop_lookup_and_children(&mut self, dropped_id: SingleLookupId) {
+        if let Some(dropped_lookup) = self.single_block_lookups.remove(&dropped_id) {
+            debug!(self.log, "Dropping child lookup"; "id" => ?dropped_id, "block_root" => ?dropped_lookup.block_root());
 
-    fn send_block_for_processing(
-        &self,
-        block_root: Hash256,
-        block: RpcBlock<T::EthSpec>,
-        duration: Duration,
-        process_type: BlockProcessType,
-        cx: &SyncNetworkContext<T>,
-    ) -> Result<(), LookupRequestError> {
-        match cx.beacon_processor_if_enabled() {
-            Some(beacon_processor) => {
-                debug!(self.log, "Sending block for processing"; "block" => ?block_root, "process" => ?process_type);
-                if let Err(e) = beacon_processor.send_rpc_beacon_block(
-                    block_root,
-                    block,
-                    duration,
-                    process_type,
-                ) {
-                    error!(
-                        self.log,
-                        "Failed to send sync block to processor";
-                        "error" => ?e
-                    );
-                    Err(LookupRequestError::SendFailed(
-                        "beacon processor send failure",
-                    ))
-                } else {
-                    Ok(())
-                }
-            }
-            None => {
-                trace!(self.log, "Dropping block ready for processing. Beacon processor not available"; "block" => %block_root);
-                Err(LookupRequestError::SendFailed(
-                    "beacon processor unavailable",
-                ))
+            let child_lookups = self
+                .single_block_lookups
+                .iter()
+                .filter(|(_, lookup)| lookup.awaiting_parent() == Some(dropped_lookup.block_root()))
+                .map(|(id, _)| *id)
+                .collect::<Vec<_>>();
+
+            for id in child_lookups {
+                self.drop_lookup_and_children(id);
             }
         }
     }
 
-    fn send_blobs_for_processing(
-        &self,
-        block_root: Hash256,
-        blobs: FixedBlobSidecarList<T::EthSpec>,
-        duration: Duration,
-        process_type: BlockProcessType,
-        cx: &SyncNetworkContext<T>,
-    ) -> Result<(), LookupRequestError> {
-        match cx.beacon_processor_if_enabled() {
-            Some(beacon_processor) => {
-                trace!(self.log, "Sending blobs for processing"; "block" => ?block_root, "process_type" => ?process_type);
-                if let Err(e) =
-                    beacon_processor.send_rpc_blobs(block_root, blobs, duration, process_type)
-                {
-                    error!(
-                        self.log,
-                        "Failed to send sync blobs to processor";
-                        "error" => ?e
-                    );
-                    Err(LookupRequestError::SendFailed(
-                        "beacon processor send failure",
-                    ))
+    /// Common handler a lookup request error, drop it and update metrics
+    fn on_lookup_result(
+        &mut self,
+        id: SingleLookupId,
+        result: Result<LookupResult, LookupRequestError>,
+        source: &str,
+        cx: &mut SyncNetworkContext<T>,
+    ) {
+        match result {
+            Ok(LookupResult::Pending) => {} // no action
+            Ok(LookupResult::Completed) => {
+                if let Some(lookup) = self.single_block_lookups.remove(&id) {
+                    debug!(self.log, "Dropping completed lookup"; "block" => ?lookup.block_root(), "id" => id);
+                    metrics::inc_counter(&metrics::SYNC_LOOKUP_COMPLETED);
+                    // Block imported, continue the requests of pending child blocks
+                    self.continue_child_lookups(lookup.block_root(), cx);
+                    self.update_metrics();
                 } else {
-                    Ok(())
+                    debug!(self.log, "Attempting to drop non-existent lookup"; "id" => id);
                 }
             }
-            None => {
-                trace!(self.log, "Dropping blobs ready for processing. Beacon processor not available"; "block_root" => %block_root);
-                Err(LookupRequestError::SendFailed(
-                    "beacon processor unavailable",
-                ))
+            Err(error) => {
+                debug!(self.log, "Dropping lookup on request error"; "id" => id, "source" => source, "error" => ?error);
+                metrics::inc_counter_vec(&metrics::SYNC_LOOKUP_DROPPED, &[error.into()]);
+                self.drop_lookup_and_children(id);
+                self.update_metrics();
             }
         }
     }
 
-    /// Attempts to request the next unknown parent. This method handles peer scoring and dropping
-    /// the lookup in the event of failure.
-    fn request_parent(&mut self, mut parent_lookup: ParentLookup<T>, cx: &SyncNetworkContext<T>) {
-        let response = parent_lookup.request_parent(cx);
-
-        match response {
-            Err(e) => {
-                self.handle_parent_request_error(&mut parent_lookup, cx, e);
-            }
-            Ok(_) => self.parent_lookups.push(parent_lookup),
-        }
-
-        // We remove and add back again requests so we want this updated regardless of outcome.
-        metrics::set_gauge(
-            &metrics::SYNC_PARENT_BLOCK_LOOKUPS,
-            self.parent_lookups.len() as i64,
-        );
-    }
+    /* Helper functions */
 
     /// Drops all the single block requests and returns how many requests were dropped.
     pub fn drop_single_block_requests(&mut self) -> usize {
@@ -1353,8 +660,27 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         requests_to_drop
     }
 
-    /// Drops all the parent chain requests and returns how many requests were dropped.
-    pub fn drop_parent_chain_requests(&mut self) -> usize {
-        self.parent_lookups.drain(..).len()
+    pub fn update_metrics(&self) {
+        metrics::set_gauge(
+            &metrics::SYNC_SINGLE_BLOCK_LOOKUPS,
+            self.single_block_lookups.len() as i64,
+        );
+    }
+
+    pub fn log_stuck_lookups(&self) {
+        let mut stuck_count = 0;
+        for lookup in self.single_block_lookups.values() {
+            if lookup.elapsed_since_created() > Duration::from_secs(LOOKUP_MAX_DURATION_SECS) {
+                debug!(self.log, "Lookup maybe stuck";
+                    // Fields id and block_root are also part of the summary. However, logging them
+                    // here allows log parsers o index them and have better search
+                    "id" => lookup.id,
+                    "block_root" => ?lookup.block_root(),
+                    "summary" => ?lookup,
+                );
+                stuck_count += 1;
+            }
+        }
+        metrics::set_gauge(&metrics::SYNC_LOOKUPS_STUCK, stuck_count);
     }
 }
diff --git a/beacon_node/network/src/sync/block_lookups/parent_chain.rs b/beacon_node/network/src/sync/block_lookups/parent_chain.rs
new file mode 100644
index 00000000000..7f4fe5119f6
--- /dev/null
+++ b/beacon_node/network/src/sync/block_lookups/parent_chain.rs
@@ -0,0 +1,198 @@
+use super::single_block_lookup::SingleBlockLookup;
+use beacon_chain::BeaconChainTypes;
+use std::collections::{HashMap, HashSet};
+use types::Hash256;
+
+/// Summary of a lookup of which we may not know it's parent_root yet
+pub(crate) struct Node {
+    block_root: Hash256,
+    parent_root: Option<Hash256>,
+}
+
+impl<T: BeaconChainTypes> From<&SingleBlockLookup<T>> for Node {
+    fn from(value: &SingleBlockLookup<T>) -> Self {
+        Self {
+            block_root: value.block_root(),
+            parent_root: value.awaiting_parent(),
+        }
+    }
+}
+
+/// Wrapper around a chain of block roots that have a least one element (tip)
+pub(crate) struct NodeChain {
+    // Parent chain blocks in descending slot order
+    pub(crate) chain: Vec<Hash256>,
+    pub(crate) tip: Hash256,
+}
+
+impl NodeChain {
+    /// Returns the block_root of the oldest ancestor (min slot) of this chain
+    pub(crate) fn ancestor(&self) -> Hash256 {
+        self.chain.last().copied().unwrap_or(self.tip)
+    }
+    pub(crate) fn len(&self) -> usize {
+        self.chain.len()
+    }
+}
+
+/// Given a set of nodes that reference each other, returns a list of chains with unique tips that
+/// contain at least two elements. In descending slot order (tip first).
+pub(crate) fn compute_parent_chains(nodes: &[Node]) -> Vec<NodeChain> {
+    let mut child_to_parent = HashMap::new();
+    let mut parent_to_child = HashMap::<Hash256, Vec<Hash256>>::new();
+    for node in nodes {
+        child_to_parent.insert(node.block_root, node.parent_root);
+        if let Some(parent_root) = node.parent_root {
+            parent_to_child
+                .entry(parent_root)
+                .or_default()
+                .push(node.block_root);
+        }
+    }
+
+    let mut parent_chains = vec![];
+
+    // Iterate blocks with no children
+    for tip in nodes {
+        let mut block_root = tip.block_root;
+        if !parent_to_child.contains_key(&block_root) {
+            let mut chain = vec![];
+
+            // Resolve chain of blocks
+            while let Some(parent_root) = child_to_parent.get(&block_root) {
+                // block_root is a known block that may or may not have a parent root
+                chain.push(block_root);
+                if let Some(parent_root) = parent_root {
+                    block_root = *parent_root;
+                } else {
+                    break;
+                }
+            }
+
+            if chain.len() > 1 {
+                parent_chains.push(NodeChain {
+                    chain,
+                    tip: tip.block_root,
+                });
+            }
+        }
+    }
+
+    parent_chains
+}
+
+/// Given a list of node chains, find the oldest node of a specific chain that is not contained in
+/// any other chain.
+pub(crate) fn find_oldest_fork_ancestor(
+    parent_chains: Vec<NodeChain>,
+    chain_idx: usize,
+) -> Result<Hash256, &'static str> {
+    let mut other_blocks = HashSet::new();
+
+    // Register blocks from other chains
+    for (i, parent_chain) in parent_chains.iter().enumerate() {
+        if i != chain_idx {
+            for block in &parent_chain.chain {
+                other_blocks.insert(block);
+            }
+        }
+    }
+
+    // Should never happen
+    let parent_chain = parent_chains
+        .get(chain_idx)
+        .ok_or("chain_idx out of bounds")?;
+    // Find the first block in the target parent chain that is not in other parent chains
+    // Iterate in ascending slot order
+    for block in parent_chain.chain.iter().rev() {
+        if !other_blocks.contains(block) {
+            return Ok(*block);
+        }
+    }
+
+    // No match means that the chain is fully contained within another chain. This should never
+    // happen, but if that was the case just return the tip
+    Ok(parent_chain.tip)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{compute_parent_chains, find_oldest_fork_ancestor, Node};
+    use types::Hash256;
+
+    fn h(n: u64) -> Hash256 {
+        Hash256::from_low_u64_be(n)
+    }
+
+    fn n(block: u64) -> Node {
+        Node {
+            block_root: h(block),
+            parent_root: None,
+        }
+    }
+
+    fn np(parent: u64, block: u64) -> Node {
+        Node {
+            block_root: h(block),
+            parent_root: Some(h(parent)),
+        }
+    }
+
+    fn compute_parent_chains_test(nodes: &[Node], expected_chain: Vec<Vec<Hash256>>) {
+        assert_eq!(
+            compute_parent_chains(nodes)
+                .iter()
+                .map(|c| c.chain.clone())
+                .collect::<Vec<_>>(),
+            expected_chain
+        );
+    }
+
+    fn find_oldest_fork_ancestor_test(nodes: &[Node], expected: Hash256) {
+        let chains = compute_parent_chains(nodes);
+        println!(
+            "chains {:?}",
+            chains.iter().map(|c| &c.chain).collect::<Vec<_>>()
+        );
+        assert_eq!(find_oldest_fork_ancestor(chains, 0).unwrap(), expected);
+    }
+
+    #[test]
+    fn compute_parent_chains_empty_case() {
+        compute_parent_chains_test(&[], vec![]);
+    }
+
+    #[test]
+    fn compute_parent_chains_single_branch() {
+        compute_parent_chains_test(&[n(0), np(0, 1), np(1, 2)], vec![vec![h(2), h(1), h(0)]]);
+    }
+
+    #[test]
+    fn compute_parent_chains_single_branch_with_solo() {
+        compute_parent_chains_test(
+            &[n(0), np(0, 1), np(1, 2), np(3, 4)],
+            vec![vec![h(2), h(1), h(0)]],
+        );
+    }
+
+    #[test]
+    fn compute_parent_chains_two_forking_branches() {
+        compute_parent_chains_test(
+            &[n(0), np(0, 1), np(1, 2), np(1, 3)],
+            vec![vec![h(2), h(1), h(0)], vec![h(3), h(1), h(0)]],
+        );
+    }
+
+    #[test]
+    fn compute_parent_chains_two_independent_branches() {
+        compute_parent_chains_test(
+            &[n(0), np(0, 1), np(1, 2), n(3), np(3, 4)],
+            vec![vec![h(2), h(1), h(0)], vec![h(4), h(3)]],
+        );
+    }
+
+    #[test]
+    fn find_oldest_fork_ancestor_simple_case() {
+        find_oldest_fork_ancestor_test(&[n(0), np(0, 1), np(1, 2), np(0, 3)], h(1))
+    }
+}
diff --git a/beacon_node/network/src/sync/block_lookups/parent_lookup.rs b/beacon_node/network/src/sync/block_lookups/parent_lookup.rs
deleted file mode 100644
index a3cdfd7b00b..00000000000
--- a/beacon_node/network/src/sync/block_lookups/parent_lookup.rs
+++ /dev/null
@@ -1,296 +0,0 @@
-use super::single_block_lookup::{LookupRequestError, LookupVerifyError, SingleBlockLookup};
-use super::{DownloadedBlock, PeerId};
-use crate::sync::block_lookups::common::Parent;
-use crate::sync::block_lookups::common::RequestState;
-use crate::sync::{manager::SLOT_IMPORT_TOLERANCE, network_context::SyncNetworkContext};
-use beacon_chain::block_verification_types::AsBlock;
-use beacon_chain::block_verification_types::RpcBlock;
-use beacon_chain::data_availability_checker::{ChildComponents, DataAvailabilityChecker};
-use beacon_chain::BeaconChainTypes;
-use itertools::Itertools;
-use std::collections::VecDeque;
-use std::sync::Arc;
-use store::Hash256;
-use strum::IntoStaticStr;
-use types::blob_sidecar::BlobIdentifier;
-
-/// How many attempts we try to find a parent of a block before we give up trying.
-pub(crate) const PARENT_FAIL_TOLERANCE: u8 = 5;
-/// The maximum depth we will search for a parent block. In principle we should have sync'd any
-/// canonical chain to its head once the peer connects. A chain should not appear where it's depth
-/// is further back than the most recent head slot.
-pub(crate) const PARENT_DEPTH_TOLERANCE: usize = SLOT_IMPORT_TOLERANCE * 2;
-
-/// Maintains a sequential list of parents to lookup and the lookup's current state.
-pub(crate) struct ParentLookup<T: BeaconChainTypes> {
-    /// The root of the block triggering this parent request.
-    chain_hash: Hash256,
-    /// The blocks that have currently been downloaded.
-    downloaded_blocks: Vec<DownloadedBlock<T::EthSpec>>,
-    /// Request of the last parent.
-    pub current_parent_request: SingleBlockLookup<Parent, T>,
-}
-
-#[derive(Debug, PartialEq, Eq, IntoStaticStr)]
-pub enum ParentVerifyError {
-    RootMismatch,
-    NoBlockReturned,
-    NotEnoughBlobsReturned,
-    ExtraBlocksReturned,
-    UnrequestedBlobId(BlobIdentifier),
-    InvalidInclusionProof,
-    UnrequestedHeader,
-    ExtraBlobsReturned,
-    InvalidIndex(u64),
-    PreviousFailure { parent_root: Hash256 },
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum RequestError {
-    SendFailed(&'static str),
-    ChainTooLong,
-    /// We witnessed too many failures trying to complete this parent lookup.
-    TooManyAttempts {
-        /// We received more failures trying to process the blocks than downloading them
-        /// from peers.
-        cannot_process: bool,
-    },
-    NoPeers,
-}
-
-impl<T: BeaconChainTypes> ParentLookup<T> {
-    pub fn new(
-        block_root: Hash256,
-        parent_root: Hash256,
-        peer_id: PeerId,
-        da_checker: Arc<DataAvailabilityChecker<T>>,
-        cx: &mut SyncNetworkContext<T>,
-    ) -> Self {
-        let current_parent_request = SingleBlockLookup::new(
-            parent_root,
-            Some(ChildComponents::empty(block_root)),
-            &[peer_id],
-            da_checker,
-            cx.next_id(),
-        );
-
-        Self {
-            chain_hash: block_root,
-            downloaded_blocks: vec![],
-            current_parent_request,
-        }
-    }
-
-    pub fn contains_block(&self, block_root: &Hash256) -> bool {
-        self.downloaded_blocks
-            .iter()
-            .any(|(root, _d_block)| root == block_root)
-    }
-
-    pub fn is_for_block(&self, block_root: Hash256) -> bool {
-        self.current_parent_request.is_for_block(block_root)
-    }
-
-    /// Attempts to request the next unknown parent. If the request fails, it should be removed.
-    pub fn request_parent(&mut self, cx: &SyncNetworkContext<T>) -> Result<(), RequestError> {
-        // check to make sure this request hasn't failed
-        if self.downloaded_blocks.len() + 1 >= PARENT_DEPTH_TOLERANCE {
-            return Err(RequestError::ChainTooLong);
-        }
-
-        self.current_parent_request
-            .request_block_and_blobs(cx)
-            .map_err(Into::into)
-    }
-
-    pub fn check_peer_disconnected(&mut self, peer_id: &PeerId) -> Result<(), ()> {
-        self.current_parent_request
-            .block_request_state
-            .state
-            .check_peer_disconnected(peer_id)
-            .and_then(|()| {
-                self.current_parent_request
-                    .blob_request_state
-                    .state
-                    .check_peer_disconnected(peer_id)
-            })
-    }
-
-    pub fn add_unknown_parent_block(&mut self, block: RpcBlock<T::EthSpec>) {
-        let next_parent = block.parent_root();
-        // Cache the block.
-        let current_root = self.current_parent_request.block_root();
-        self.downloaded_blocks.push((current_root, block));
-
-        // Update the parent request.
-        self.current_parent_request
-            .update_requested_parent_block(next_parent)
-    }
-
-    pub fn block_processing_peer(&self) -> Result<PeerId, String> {
-        self.current_parent_request
-            .block_request_state
-            .state
-            .processing_peer()
-    }
-
-    pub fn blob_processing_peer(&self) -> Result<PeerId, String> {
-        self.current_parent_request
-            .blob_request_state
-            .state
-            .processing_peer()
-    }
-
-    /// Consumes the parent request and destructures it into it's parts.
-    #[allow(clippy::type_complexity)]
-    pub fn parts_for_processing(
-        self,
-    ) -> (
-        Hash256,
-        VecDeque<RpcBlock<T::EthSpec>>,
-        Vec<Hash256>,
-        SingleBlockLookup<Parent, T>,
-    ) {
-        let ParentLookup {
-            chain_hash,
-            downloaded_blocks,
-            current_parent_request,
-        } = self;
-        let block_count = downloaded_blocks.len();
-        let mut blocks = VecDeque::with_capacity(block_count);
-        let mut hashes = Vec::with_capacity(block_count);
-        for (hash, block) in downloaded_blocks.into_iter() {
-            blocks.push_back(block);
-            hashes.push(hash);
-        }
-        (chain_hash, blocks, hashes, current_parent_request)
-    }
-
-    /// Get the parent lookup's chain hash.
-    pub fn chain_hash(&self) -> Hash256 {
-        self.chain_hash
-    }
-
-    pub fn processing_failed(&mut self) {
-        self.current_parent_request
-            .block_request_state
-            .state
-            .register_failure_processing();
-        self.current_parent_request
-            .blob_request_state
-            .state
-            .register_failure_processing();
-        if let Some(components) = self.current_parent_request.child_components.as_mut() {
-            components.downloaded_block = None;
-            components.downloaded_blobs = <_>::default();
-        }
-    }
-
-    /// Verifies that the received block is what we requested. If so, parent lookup now waits for
-    /// the processing result of the block.
-    pub fn verify_response<R: RequestState<Parent, T>>(
-        &mut self,
-        block: Option<R::ResponseType>,
-        failed_chains: &mut lru_cache::LRUTimeCache<Hash256>,
-    ) -> Result<Option<R::VerifiedResponseType>, ParentVerifyError> {
-        let expected_block_root = self.current_parent_request.block_root();
-        let request_state = R::request_state_mut(&mut self.current_parent_request);
-        let root_and_verified = request_state.verify_response(expected_block_root, block)?;
-
-        // check if the parent of this block isn't in the failed cache. If it is, this chain should
-        // be dropped and the peer downscored.
-        if let Some(parent_root) = root_and_verified
-            .as_ref()
-            .and_then(|block| R::get_parent_root(block))
-        {
-            if failed_chains.contains(&parent_root) {
-                request_state.register_failure_downloading();
-                return Err(ParentVerifyError::PreviousFailure { parent_root });
-            }
-        }
-
-        Ok(root_and_verified)
-    }
-
-    pub fn add_peer(&mut self, peer: PeerId) {
-        self.current_parent_request.add_peer(peer)
-    }
-
-    /// Adds a list of peers to the parent request.
-    pub fn add_peers(&mut self, peers: &[PeerId]) {
-        self.current_parent_request.add_peers(peers)
-    }
-
-    pub fn used_peers(&self) -> impl Iterator<Item = &PeerId> + '_ {
-        self.current_parent_request
-            .block_request_state
-            .state
-            .used_peers
-            .iter()
-            .chain(
-                self.current_parent_request
-                    .blob_request_state
-                    .state
-                    .used_peers
-                    .iter(),
-            )
-            .unique()
-    }
-}
-
-impl From<LookupVerifyError> for ParentVerifyError {
-    fn from(e: LookupVerifyError) -> Self {
-        use LookupVerifyError as E;
-        match e {
-            E::RootMismatch => ParentVerifyError::RootMismatch,
-            E::NoBlockReturned => ParentVerifyError::NoBlockReturned,
-            E::ExtraBlocksReturned => ParentVerifyError::ExtraBlocksReturned,
-            E::UnrequestedBlobId(blob_id) => ParentVerifyError::UnrequestedBlobId(blob_id),
-            E::InvalidInclusionProof => ParentVerifyError::InvalidInclusionProof,
-            E::UnrequestedHeader => ParentVerifyError::UnrequestedHeader,
-            E::ExtraBlobsReturned => ParentVerifyError::ExtraBlobsReturned,
-            E::InvalidIndex(index) => ParentVerifyError::InvalidIndex(index),
-            E::NotEnoughBlobsReturned => ParentVerifyError::NotEnoughBlobsReturned,
-        }
-    }
-}
-
-impl From<LookupRequestError> for RequestError {
-    fn from(e: LookupRequestError) -> Self {
-        use LookupRequestError as E;
-        match e {
-            E::TooManyAttempts { cannot_process } => {
-                RequestError::TooManyAttempts { cannot_process }
-            }
-            E::NoPeers => RequestError::NoPeers,
-            E::SendFailed(msg) => RequestError::SendFailed(msg),
-        }
-    }
-}
-
-impl<T: BeaconChainTypes> slog::KV for ParentLookup<T> {
-    fn serialize(
-        &self,
-        record: &slog::Record,
-        serializer: &mut dyn slog::Serializer,
-    ) -> slog::Result {
-        serializer.emit_arguments("chain_hash", &format_args!("{}", self.chain_hash))?;
-        slog::Value::serialize(&self.current_parent_request, record, "parent", serializer)?;
-        serializer.emit_usize("downloaded_blocks", self.downloaded_blocks.len())?;
-        slog::Result::Ok(())
-    }
-}
-
-impl RequestError {
-    pub fn as_static(&self) -> &'static str {
-        match self {
-            RequestError::SendFailed(e) => e,
-            RequestError::ChainTooLong => "chain_too_long",
-            RequestError::TooManyAttempts { cannot_process } if *cannot_process => {
-                "too_many_processing_attempts"
-            }
-            RequestError::TooManyAttempts { cannot_process: _ } => "too_many_downloading_attempts",
-            RequestError::NoPeers => "no_peers",
-        }
-    }
-}
diff --git a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
index 7f3849c161b..b35a3e91fb6 100644
--- a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
+++ b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
@@ -1,42 +1,28 @@
-use super::PeerId;
-use crate::sync::block_lookups::common::{Lookup, RequestState};
+use super::common::ResponseType;
+use super::{BlockComponent, PeerId, SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS};
+use crate::sync::block_lookups::common::RequestState;
 use crate::sync::block_lookups::Id;
-use crate::sync::network_context::SyncNetworkContext;
-use beacon_chain::block_verification_types::RpcBlock;
-use beacon_chain::data_availability_checker::ChildComponents;
-use beacon_chain::data_availability_checker::{
-    AvailabilityCheckError, DataAvailabilityChecker, MissingBlobs,
-};
+use crate::sync::network_context::{LookupRequestResult, ReqId, SyncNetworkContext};
 use beacon_chain::BeaconChainTypes;
-use lighthouse_network::PeerAction;
-use slog::{trace, Logger};
+use derivative::Derivative;
+use itertools::Itertools;
+use rand::seq::IteratorRandom;
 use std::collections::HashSet;
 use std::fmt::Debug;
-use std::marker::PhantomData;
 use std::sync::Arc;
+use std::time::{Duration, Instant};
 use store::Hash256;
 use strum::IntoStaticStr;
-use types::blob_sidecar::{BlobIdentifier, FixedBlobSidecarList};
-use types::EthSpec;
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum State {
-    AwaitingDownload,
-    Downloading { peer_id: PeerId },
-    Processing { peer_id: PeerId },
-}
-
-#[derive(Debug, PartialEq, Eq, IntoStaticStr)]
-pub enum LookupVerifyError {
-    RootMismatch,
-    NoBlockReturned,
-    ExtraBlocksReturned,
-    UnrequestedBlobId(BlobIdentifier),
-    InvalidInclusionProof,
-    UnrequestedHeader,
-    ExtraBlobsReturned,
-    NotEnoughBlobsReturned,
-    InvalidIndex(u64),
+use types::blob_sidecar::FixedBlobSidecarList;
+use types::{EthSpec, SignedBeaconBlock};
+
+// Dedicated enum for LookupResult to force its usage
+#[must_use = "LookupResult must be handled with on_lookup_result"]
+pub enum LookupResult {
+    /// Lookup completed successfully
+    Completed,
+    /// Lookup is expecting some future event from the network
+    Pending,
 }
 
 #[derive(Debug, PartialEq, Eq, IntoStaticStr)]
@@ -46,369 +32,301 @@ pub enum LookupRequestError {
         /// The failed attempts were primarily due to processing failures.
         cannot_process: bool,
     },
+    /// No peers left to serve this lookup
     NoPeers,
+    /// Error sending event to network or beacon processor
     SendFailed(&'static str),
+    /// Inconsistent lookup request state
+    BadState(String),
+    /// Lookup failed for some other reason and should be dropped
+    Failed,
+    /// Received MissingComponents when all components have been processed. This should never
+    /// happen, and indicates some internal bug
+    MissingComponentsAfterAllProcessed,
+    /// Attempted to retrieve a not known lookup id
+    UnknownLookup,
+    /// Received a download result for a different request id than the in-flight request.
+    /// There should only exist a single request at a time. Having multiple requests is a bug and
+    /// can result in undefined state, so it's treated as a hard error and the lookup is dropped.
+    UnexpectedRequestId {
+        expected_req_id: ReqId,
+        req_id: ReqId,
+    },
 }
 
-pub struct SingleBlockLookup<L: Lookup, T: BeaconChainTypes> {
+#[derive(Derivative)]
+#[derivative(Debug(bound = "T: BeaconChainTypes"))]
+pub struct SingleBlockLookup<T: BeaconChainTypes> {
     pub id: Id,
-    pub block_request_state: BlockRequestState<L>,
-    pub blob_request_state: BlobRequestState<L, T::EthSpec>,
-    pub da_checker: Arc<DataAvailabilityChecker<T>>,
-    /// Only necessary for requests triggered by an `UnknownBlockParent` or `UnknownBlockParent`
-    /// because any blocks or blobs without parents won't hit the data availability cache.
-    pub child_components: Option<ChildComponents<T::EthSpec>>,
+    pub block_request_state: BlockRequestState<T::EthSpec>,
+    pub blob_request_state: BlobRequestState<T::EthSpec>,
+    block_root: Hash256,
+    awaiting_parent: Option<Hash256>,
+    created: Instant,
 }
 
-impl<L: Lookup, T: BeaconChainTypes> SingleBlockLookup<L, T> {
+impl<T: BeaconChainTypes> SingleBlockLookup<T> {
     pub fn new(
         requested_block_root: Hash256,
-        child_components: Option<ChildComponents<T::EthSpec>>,
         peers: &[PeerId],
-        da_checker: Arc<DataAvailabilityChecker<T>>,
         id: Id,
+        awaiting_parent: Option<Hash256>,
     ) -> Self {
-        let is_deneb = da_checker.is_deneb();
         Self {
             id,
             block_request_state: BlockRequestState::new(requested_block_root, peers),
-            blob_request_state: BlobRequestState::new(requested_block_root, peers, is_deneb),
-            da_checker,
-            child_components,
+            blob_request_state: BlobRequestState::new(requested_block_root, peers),
+            block_root: requested_block_root,
+            awaiting_parent,
+            created: Instant::now(),
         }
     }
 
     /// Get the block root that is being requested.
     pub fn block_root(&self) -> Hash256 {
-        self.block_request_state.requested_block_root
+        self.block_root
     }
 
-    /// Check the block root matches the requested block root.
-    pub fn is_for_block(&self, block_root: Hash256) -> bool {
-        self.block_root() == block_root
+    pub fn awaiting_parent(&self) -> Option<Hash256> {
+        self.awaiting_parent
     }
 
-    /// Update the requested block, this should only be used in a chain of parent lookups to request
-    /// the next parent.
-    pub fn update_requested_parent_block(&mut self, block_root: Hash256) {
-        self.block_request_state.requested_block_root = block_root;
-        self.block_request_state.state.state = State::AwaitingDownload;
-        self.blob_request_state.state.state = State::AwaitingDownload;
-        self.block_request_state.state.component_downloaded = false;
-        self.blob_request_state.state.component_downloaded = false;
-        self.block_request_state.state.component_processed = false;
-        self.blob_request_state.state.component_processed = false;
-        self.child_components = Some(ChildComponents::empty(block_root));
+    /// Mark this lookup as awaiting a parent lookup from being processed. Meanwhile don't send
+    /// components for processing.
+    pub fn set_awaiting_parent(&mut self, parent_root: Hash256) {
+        self.awaiting_parent = Some(parent_root)
     }
 
-    /// Get all unique peers across block and blob requests.
-    pub fn all_peers(&self) -> HashSet<PeerId> {
-        let mut all_peers = self.block_request_state.state.used_peers.clone();
-        all_peers.extend(self.blob_request_state.state.used_peers.clone());
-        all_peers
+    /// Mark this lookup as no longer awaiting a parent lookup. Components can be sent for
+    /// processing.
+    pub fn resolve_awaiting_parent(&mut self) {
+        self.awaiting_parent = None;
     }
 
-    /// Send the necessary requests for blocks and/or blobs. This will check whether we have
-    /// downloaded the block and/or blobs already and will not send requests if so. It will also
-    /// inspect the request state or blocks and blobs to ensure we are not already processing or
-    /// downloading the block and/or blobs.
-    pub fn request_block_and_blobs(
-        &mut self,
-        cx: &SyncNetworkContext<T>,
-    ) -> Result<(), LookupRequestError> {
-        let block_already_downloaded = self.block_already_downloaded();
-        let blobs_already_downloaded = self.blobs_already_downloaded();
-
-        if !block_already_downloaded {
-            self.block_request_state
-                .build_request_and_send(self.id, cx)?;
-        }
-        if !blobs_already_downloaded {
-            self.blob_request_state
-                .build_request_and_send(self.id, cx)?;
-        }
-        Ok(())
+    /// Returns the time elapsed since this lookup was created
+    pub fn elapsed_since_created(&self) -> Duration {
+        self.created.elapsed()
     }
 
-    /// Returns a `CachedChild`, which is a wrapper around a `RpcBlock` that is either:
-    ///
-    /// 1. `NotRequired`: there is no child caching required for this lookup.
-    /// 2. `DownloadIncomplete`: Child caching is required, but all components are not yet downloaded.
-    /// 3. `Ok`: The child is required and we have downloaded it.
-    /// 4. `Err`: The child is required, but has failed consistency checks.
-    pub fn get_cached_child_block(&self) -> CachedChild<T::EthSpec> {
-        if let Some(components) = self.child_components.as_ref() {
-            let Some(block) = components.downloaded_block.as_ref() else {
-                return CachedChild::DownloadIncomplete;
-            };
-
-            if !self.missing_blob_ids().is_empty() {
-                return CachedChild::DownloadIncomplete;
+    /// Maybe insert a verified response into this lookup. Returns true if imported
+    pub fn add_child_components(&mut self, block_component: BlockComponent<T::EthSpec>) -> bool {
+        match block_component {
+            BlockComponent::Block(block) => self
+                .block_request_state
+                .state
+                .insert_verified_response(block),
+            BlockComponent::Blob(_) => {
+                // For now ignore single blobs, as the blob request state assumes all blobs are
+                // attributed to the same peer = the peer serving the remaining blobs. Ignoring this
+                // block component has a minor effect, causing the node to re-request this blob
+                // once the parent chain is successfully resolved
+                false
             }
-
-            match RpcBlock::new_from_fixed(
-                self.block_request_state.requested_block_root,
-                block.clone(),
-                components.downloaded_blobs.clone(),
-            ) {
-                Ok(rpc_block) => CachedChild::Ok(rpc_block),
-                Err(e) => CachedChild::Err(e),
-            }
-        } else {
-            CachedChild::NotRequired
         }
     }
 
-    /// Accepts a verified response, and adds it to the child components if required. This method
-    /// returns a `CachedChild` which provides a completed block + blob response if all components have been
-    /// received, or information about whether the child is required and if it has been downloaded.
-    pub fn add_response<R: RequestState<L, T>>(
-        &mut self,
-        verified_response: R::VerifiedResponseType,
-    ) -> CachedChild<T::EthSpec> {
-        if let Some(child_components) = self.child_components.as_mut() {
-            R::add_to_child_components(verified_response, child_components);
-            self.get_cached_child_block()
-        } else {
-            CachedChild::NotRequired
-        }
+    /// Check the block root matches the requested block root.
+    pub fn is_for_block(&self, block_root: Hash256) -> bool {
+        self.block_root() == block_root
     }
 
-    /// Add a child component to the lookup request. Merges with any existing child components.
-    pub fn add_child_components(&mut self, components: ChildComponents<T::EthSpec>) {
-        if let Some(ref mut existing_components) = self.child_components {
-            let ChildComponents {
-                block_root: _,
-                downloaded_block,
-                downloaded_blobs,
-            } = components;
-            if let Some(block) = downloaded_block {
-                existing_components.merge_block(block);
-            }
-            existing_components.merge_blobs(downloaded_blobs);
-        } else {
-            self.child_components = Some(components);
-        }
+    /// Get all unique used peers across block and blob requests.
+    pub fn all_used_peers(&self) -> impl Iterator<Item = &PeerId> + '_ {
+        self.block_request_state
+            .state
+            .get_used_peers()
+            .chain(self.blob_request_state.state.get_used_peers())
+            .unique()
     }
 
-    /// Add all given peers to both block and blob request states.
-    pub fn add_peer(&mut self, peer_id: PeerId) {
-        self.block_request_state.state.add_peer(&peer_id);
-        self.blob_request_state.state.add_peer(&peer_id);
+    /// Get all unique available peers across block and blob requests.
+    pub fn all_available_peers(&self) -> impl Iterator<Item = &PeerId> + '_ {
+        self.block_request_state
+            .state
+            .get_available_peers()
+            .chain(self.blob_request_state.state.get_available_peers())
+            .unique()
     }
 
-    /// Add all given peers to both block and blob request states.
-    pub fn add_peers(&mut self, peers: &[PeerId]) {
-        for peer in peers {
-            self.add_peer(*peer);
+    /// Makes progress on all requests of this lookup. Any error is not recoverable and must result
+    /// in dropping the lookup. May mark the lookup as completed.
+    pub fn continue_requests(
+        &mut self,
+        cx: &mut SyncNetworkContext<T>,
+    ) -> Result<LookupResult, LookupRequestError> {
+        // TODO: Check what's necessary to download, specially for blobs
+        self.continue_request::<BlockRequestState<T::EthSpec>>(cx)?;
+        self.continue_request::<BlobRequestState<T::EthSpec>>(cx)?;
+
+        // If all components of this lookup are already processed, there will be no future events
+        // that can make progress so it must be dropped. Consider the lookup completed.
+        // This case can happen if we receive the components from gossip during a retry.
+        if self.block_request_state.state.is_processed()
+            && self.blob_request_state.state.is_processed()
+        {
+            Ok(LookupResult::Completed)
+        } else {
+            Ok(LookupResult::Pending)
         }
     }
 
-    /// Returns true if the block has already been downloaded.
-    pub fn both_components_downloaded(&self) -> bool {
-        self.block_request_state.state.component_downloaded
-            && self.blob_request_state.state.component_downloaded
-    }
-
-    /// Returns true if the block has already been downloaded.
-    pub fn both_components_processed(&self) -> bool {
-        self.block_request_state.state.component_processed
-            && self.blob_request_state.state.component_processed
-    }
-
-    /// Checks both the block and blob request states to see if the peer is disconnected.
-    ///
-    /// Returns true if the lookup should be dropped.
-    pub fn should_drop_lookup_on_disconnected_peer(
+    /// Potentially makes progress on this request if it's in a progress-able state
+    fn continue_request<R: RequestState<T>>(
         &mut self,
-        peer_id: &PeerId,
-        cx: &SyncNetworkContext<T>,
-        log: &Logger,
-    ) -> bool {
-        let block_root = self.block_root();
-        let block_peer_disconnected = self
+        cx: &mut SyncNetworkContext<T>,
+    ) -> Result<(), LookupRequestError> {
+        let id = self.id;
+        let awaiting_parent = self.awaiting_parent.is_some();
+        let downloaded_block_expected_blobs = self
             .block_request_state
             .state
-            .check_peer_disconnected(peer_id)
-            .is_err();
-        let blob_peer_disconnected = self
-            .blob_request_state
-            .state
-            .check_peer_disconnected(peer_id)
-            .is_err();
-
-        if block_peer_disconnected || blob_peer_disconnected {
-            if let Err(e) = self.request_block_and_blobs(cx) {
-                trace!(log, "Single lookup failed on peer disconnection"; "block_root" => ?block_root, "error" => ?e);
-                return true;
+            .peek_downloaded_data()
+            .map(|block| block.num_expected_blobs());
+        let block_is_processed = self.block_request_state.state.is_processed();
+        let request = R::request_state_mut(self);
+
+        // Attempt to progress awaiting downloads
+        if request.get_state().is_awaiting_download() {
+            // Verify the current request has not exceeded the maximum number of attempts.
+            let request_state = request.get_state();
+            if request_state.failed_attempts() >= SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS {
+                let cannot_process = request_state.more_failed_processing_attempts();
+                return Err(LookupRequestError::TooManyAttempts { cannot_process });
             }
-        }
-        false
-    }
-
-    /// Returns `true` if the block has already been downloaded.
-    pub(crate) fn block_already_downloaded(&self) -> bool {
-        if let Some(components) = self.child_components.as_ref() {
-            components.downloaded_block.is_some()
-        } else {
-            self.da_checker.has_block(&self.block_root())
-        }
-    }
 
-    /// Updates the `requested_ids` field of the `BlockRequestState` with the most recent picture
-    /// of which blobs still need to be requested. Returns `true` if there are no more blobs to
-    /// request.
-    pub(crate) fn blobs_already_downloaded(&mut self) -> bool {
-        if matches!(self.blob_request_state.state.state, State::AwaitingDownload) {
-            self.update_blobs_request();
-        }
-        self.blob_request_state.requested_ids.is_empty()
-    }
+            let Some(peer_id) = request.get_state_mut().use_rand_available_peer() else {
+                if awaiting_parent {
+                    // Allow lookups awaiting for a parent to have zero peers. If when the parent
+                    // resolve they still have zero peers the lookup will fail gracefully.
+                    return Ok(());
+                } else {
+                    return Err(LookupRequestError::NoPeers);
+                }
+            };
 
-    /// Updates this request with the most recent picture of which blobs still need to be requested.
-    pub fn update_blobs_request(&mut self) {
-        self.blob_request_state.requested_ids = self.missing_blob_ids();
-    }
+            match request.make_request(id, peer_id, downloaded_block_expected_blobs, cx)? {
+                LookupRequestResult::RequestSent(req_id) => {
+                    request.get_state_mut().on_download_start(req_id)?
+                }
+                LookupRequestResult::NoRequestNeeded => {
+                    request.get_state_mut().on_completed_request()?
+                }
+                // Sync will receive a future event to make progress on the request, do nothing now
+                LookupRequestResult::Pending => return Ok(()),
+            }
 
-    /// If `child_components` is `Some`, we know block components won't hit the data
-    /// availability cache, so we don't check its processing cache unless `child_components`
-    /// is `None`.
-    pub(crate) fn missing_blob_ids(&self) -> MissingBlobs {
-        let block_root = self.block_root();
-        if let Some(components) = self.child_components.as_ref() {
-            self.da_checker.get_missing_blob_ids(
-                block_root,
-                &components.downloaded_block,
-                &components.downloaded_blobs,
-            )
-        } else {
-            let Some(processing_components) = self.da_checker.get_processing_components(block_root)
-            else {
-                return MissingBlobs::new_without_block(block_root, self.da_checker.is_deneb());
-            };
-            self.da_checker.get_missing_blob_ids(
-                block_root,
-                &processing_components.block,
-                &processing_components.blob_commitments,
-            )
+        // Otherwise, attempt to progress awaiting processing
+        // If this request is awaiting a parent lookup to be processed, do not send for processing.
+        // The request will be rejected with unknown parent error.
+        } else if !awaiting_parent
+            && (block_is_processed || matches!(R::response_type(), ResponseType::Block))
+        {
+            // maybe_start_processing returns Some if state == AwaitingProcess. This pattern is
+            // useful to conditionally access the result data.
+            if let Some(result) = request.get_state_mut().maybe_start_processing() {
+                return R::send_for_processing(id, result, cx);
+            }
         }
+
+        Ok(())
     }
 
-    /// Penalizes a blob peer if it should have blobs but didn't return them to us.
-    pub fn penalize_blob_peer(&mut self, cx: &SyncNetworkContext<T>) {
-        if let Ok(blob_peer) = self.blob_request_state.state.processing_peer() {
-            cx.report_peer(
-                blob_peer,
-                PeerAction::MidToleranceError,
-                "single_blob_failure",
-            );
-        }
+    /// Add peer to all request states. The peer must be able to serve this request.
+    /// Returns true if the peer was newly inserted into some request state.
+    pub fn add_peer(&mut self, peer_id: PeerId) -> bool {
+        let inserted_block = self.block_request_state.state.add_peer(&peer_id);
+        let inserted_blob = self.blob_request_state.state.add_peer(&peer_id);
+        inserted_block || inserted_blob
     }
 
-    /// This failure occurs on download, so register a failure downloading, penalize the peer
-    /// and clear the blob cache.
-    pub fn handle_consistency_failure(&mut self, cx: &SyncNetworkContext<T>) {
-        self.penalize_blob_peer(cx);
-        if let Some(cached_child) = self.child_components.as_mut() {
-            cached_child.clear_blobs();
-        }
-        self.blob_request_state.state.register_failure_downloading()
+    /// Returns true if the block has already been downloaded.
+    pub fn both_components_processed(&self) -> bool {
+        self.block_request_state.state.is_processed()
+            && self.blob_request_state.state.is_processed()
     }
 
-    /// This failure occurs after processing, so register a failure processing, penalize the peer
-    /// and clear the blob cache.
-    pub fn handle_availability_check_failure(&mut self, cx: &SyncNetworkContext<T>) {
-        self.penalize_blob_peer(cx);
-        if let Some(cached_child) = self.child_components.as_mut() {
-            cached_child.clear_blobs();
-        }
-        self.blob_request_state.state.register_failure_processing()
+    /// Remove peer from available peers. Return true if there are no more available peers and all
+    /// requests are not expecting any future event (AwaitingDownload).
+    pub fn remove_peer(&mut self, peer_id: &PeerId) -> bool {
+        self.block_request_state.state.remove_peer(peer_id)
+            && self.blob_request_state.state.remove_peer(peer_id)
     }
 }
 
 /// The state of the blob request component of a `SingleBlockLookup`.
-pub struct BlobRequestState<L: Lookup, E: EthSpec> {
-    /// The latest picture of which blobs still need to be requested. This includes information
-    /// from both block/blobs downloaded in the network layer and any blocks/blobs that exist in
-    /// the data availability checker.
-    pub requested_ids: MissingBlobs,
-    /// Where we store blobs until we receive the stream terminator.
-    pub blob_download_queue: FixedBlobSidecarList<E>,
-    pub state: SingleLookupRequestState,
-    _phantom: PhantomData<L>,
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct BlobRequestState<E: EthSpec> {
+    #[derivative(Debug = "ignore")]
+    pub block_root: Hash256,
+    pub state: SingleLookupRequestState<FixedBlobSidecarList<E>>,
 }
 
-impl<L: Lookup, E: EthSpec> BlobRequestState<L, E> {
-    pub fn new(block_root: Hash256, peer_source: &[PeerId], is_deneb: bool) -> Self {
-        let default_ids = MissingBlobs::new_without_block(block_root, is_deneb);
+impl<E: EthSpec> BlobRequestState<E> {
+    pub fn new(block_root: Hash256, peer_source: &[PeerId]) -> Self {
         Self {
-            requested_ids: default_ids,
-            blob_download_queue: <_>::default(),
+            block_root,
             state: SingleLookupRequestState::new(peer_source),
-            _phantom: PhantomData,
         }
     }
 }
 
 /// The state of the block request component of a `SingleBlockLookup`.
-pub struct BlockRequestState<L: Lookup> {
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct BlockRequestState<E: EthSpec> {
+    #[derivative(Debug = "ignore")]
     pub requested_block_root: Hash256,
-    pub state: SingleLookupRequestState,
-    _phantom: PhantomData<L>,
+    pub state: SingleLookupRequestState<Arc<SignedBeaconBlock<E>>>,
 }
 
-impl<L: Lookup> BlockRequestState<L> {
+impl<E: EthSpec> BlockRequestState<E> {
     pub fn new(block_root: Hash256, peers: &[PeerId]) -> Self {
         Self {
             requested_block_root: block_root,
             state: SingleLookupRequestState::new(peers),
-            _phantom: PhantomData,
         }
     }
 }
 
-/// This is the status of cached components for a lookup if they are required. It provides information
-/// about whether we should send a responses immediately for processing, whether we require more
-/// responses, or whether all cached components have been received and the reconstructed block
-/// should be sent for processing.
-pub enum CachedChild<E: EthSpec> {
-    /// All child components have been received, this is the reconstructed block, including all.
-    /// It has been checked for consistency between blobs and block, but no consensus checks have
-    /// been performed and no kzg verification has been performed.
-    Ok(RpcBlock<E>),
-    /// All child components have not yet been received.
-    DownloadIncomplete,
-    /// Child components should not be cached, send this directly for processing.
-    NotRequired,
-    /// There was an error during consistency checks between block and blobs.
-    Err(AvailabilityCheckError),
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct DownloadResult<T: Clone> {
+    pub value: T,
+    pub block_root: Hash256,
+    pub seen_timestamp: Duration,
+    pub peer_id: PeerId,
 }
+
+#[derive(PartialEq, Eq, IntoStaticStr)]
+pub enum State<T: Clone> {
+    AwaitingDownload,
+    Downloading(ReqId),
+    AwaitingProcess(DownloadResult<T>),
+    /// Request is processing, sent by lookup sync
+    Processing(DownloadResult<T>),
+    /// Request is processed
+    Processed,
+}
+
 /// Object representing the state of a single block or blob lookup request.
-#[derive(PartialEq, Eq, Debug)]
-pub struct SingleLookupRequestState {
+#[derive(PartialEq, Eq, Derivative)]
+#[derivative(Debug)]
+pub struct SingleLookupRequestState<T: Clone> {
     /// State of this request.
-    pub state: State,
+    state: State<T>,
     /// Peers that should have this block or blob.
-    pub available_peers: HashSet<PeerId>,
+    #[derivative(Debug(format_with = "fmt_peer_set"))]
+    available_peers: HashSet<PeerId>,
     /// Peers from which we have requested this block.
-    pub used_peers: HashSet<PeerId>,
+    #[derivative(Debug = "ignore")]
+    used_peers: HashSet<PeerId>,
     /// How many times have we attempted to process this block or blob.
-    pub failed_processing: u8,
+    failed_processing: u8,
     /// How many times have we attempted to download this block or blob.
-    pub failed_downloading: u8,
-    /// Whether or not we have downloaded this block or blob.
-    pub component_downloaded: bool,
-    /// Whether or not we have processed this block or blob.
-    pub component_processed: bool,
-    /// Should be incremented everytime this request is retried. The purpose of this is to
-    /// differentiate retries of the same block/blob request within a lookup. We currently penalize
-    /// peers and retry requests prior to receiving the stream terminator. This means responses
-    /// from a prior request may arrive after a new request has been sent, this counter allows
-    /// us to differentiate these two responses.
-    pub req_counter: u32,
+    failed_downloading: u8,
 }
 
-impl SingleLookupRequestState {
+impl<T: Clone> SingleLookupRequestState<T> {
     pub fn new(peers: &[PeerId]) -> Self {
         let mut available_peers = HashSet::default();
         for peer in peers.iter().copied() {
@@ -421,269 +339,239 @@ impl SingleLookupRequestState {
             used_peers: HashSet::default(),
             failed_processing: 0,
             failed_downloading: 0,
-            component_downloaded: false,
-            component_processed: false,
-            req_counter: 0,
         }
     }
 
-    /// Registers a failure in processing a block.
-    pub fn register_failure_processing(&mut self) {
-        self.failed_processing = self.failed_processing.saturating_add(1);
-        self.state = State::AwaitingDownload;
+    pub fn is_awaiting_download(&self) -> bool {
+        match self.state {
+            State::AwaitingDownload => true,
+            State::Downloading { .. }
+            | State::AwaitingProcess { .. }
+            | State::Processing { .. }
+            | State::Processed { .. } => false,
+        }
     }
 
-    /// Registers a failure in downloading a block. This might be a peer disconnection or a wrong
-    /// block.
-    pub fn register_failure_downloading(&mut self) {
-        self.failed_downloading = self.failed_downloading.saturating_add(1);
-        self.state = State::AwaitingDownload;
+    pub fn is_processed(&self) -> bool {
+        match self.state {
+            State::AwaitingDownload
+            | State::Downloading { .. }
+            | State::AwaitingProcess { .. }
+            | State::Processing { .. } => false,
+            State::Processed { .. } => true,
+        }
     }
 
-    /// The total number of failures, whether it be processing or downloading.
-    pub fn failed_attempts(&self) -> u8 {
-        self.failed_processing + self.failed_downloading
+    pub fn peek_downloaded_data(&self) -> Option<&T> {
+        match &self.state {
+            State::AwaitingDownload => None,
+            State::Downloading { .. } => None,
+            State::AwaitingProcess(result) => Some(&result.value),
+            State::Processing(result) => Some(&result.value),
+            State::Processed { .. } => None,
+        }
     }
 
-    /// This method should be used for peers wrapped in `PeerId::BlockAndBlobs`.
-    pub fn add_peer(&mut self, peer_id: &PeerId) {
-        self.available_peers.insert(*peer_id);
+    /// Switch to `AwaitingProcessing` if the request is in `AwaitingDownload` state, otherwise
+    /// ignore.
+    pub fn insert_verified_response(&mut self, result: DownloadResult<T>) -> bool {
+        if let State::AwaitingDownload = &self.state {
+            self.state = State::AwaitingProcess(result);
+            true
+        } else {
+            false
+        }
     }
 
-    /// If a peer disconnects, this request could be failed. If so, an error is returned
-    pub fn check_peer_disconnected(&mut self, dc_peer_id: &PeerId) -> Result<(), ()> {
-        self.available_peers.remove(dc_peer_id);
-        if let State::Downloading { peer_id } = &self.state {
-            if peer_id == dc_peer_id {
-                // Peer disconnected before providing a block
-                self.register_failure_downloading();
-                return Err(());
+    /// Switch to `Downloading` if the request is in `AwaitingDownload` state, otherwise returns None.
+    pub fn on_download_start(&mut self, req_id: ReqId) -> Result<(), LookupRequestError> {
+        match &self.state {
+            State::AwaitingDownload => {
+                self.state = State::Downloading(req_id);
+                Ok(())
             }
+            other => Err(LookupRequestError::BadState(format!(
+                "Bad state on_download_start expected AwaitingDownload got {other}"
+            ))),
         }
-        Ok(())
     }
 
-    /// Returns the id peer we downloaded from if we have downloaded a verified block, otherwise
-    /// returns an error.
-    pub fn processing_peer(&self) -> Result<PeerId, String> {
+    /// Registers a failure in downloading a block. This might be a peer disconnection or a wrong
+    /// block.
+    pub fn on_download_failure(&mut self, req_id: ReqId) -> Result<(), LookupRequestError> {
         match &self.state {
-            State::Processing { peer_id } => Ok(*peer_id),
-            other => Err(format!("not in processing state: {}", other).to_string()),
+            State::Downloading(expected_req_id) => {
+                if req_id != *expected_req_id {
+                    return Err(LookupRequestError::UnexpectedRequestId {
+                        expected_req_id: *expected_req_id,
+                        req_id,
+                    });
+                }
+                self.failed_downloading = self.failed_downloading.saturating_add(1);
+                self.state = State::AwaitingDownload;
+                Ok(())
+            }
+            other => Err(LookupRequestError::BadState(format!(
+                "Bad state on_download_failure expected Downloading got {other}"
+            ))),
         }
     }
-}
 
-impl<L: Lookup, T: BeaconChainTypes> slog::Value for SingleBlockLookup<L, T> {
-    fn serialize(
-        &self,
-        _record: &slog::Record,
-        key: slog::Key,
-        serializer: &mut dyn slog::Serializer,
-    ) -> slog::Result {
-        serializer.emit_str("request", key)?;
-        serializer.emit_arguments("lookup_type", &format_args!("{:?}", L::lookup_type()))?;
-        serializer.emit_arguments("hash", &format_args!("{}", self.block_root()))?;
-        serializer.emit_arguments(
-            "blob_ids",
-            &format_args!("{:?}", self.blob_request_state.requested_ids.indices()),
-        )?;
-        serializer.emit_arguments(
-            "block_request_state.state",
-            &format_args!("{:?}", self.block_request_state.state),
-        )?;
-        serializer.emit_arguments(
-            "blob_request_state.state",
-            &format_args!("{:?}", self.blob_request_state.state),
-        )?;
-        slog::Result::Ok(())
+    pub fn on_download_success(
+        &mut self,
+        req_id: ReqId,
+        result: DownloadResult<T>,
+    ) -> Result<(), LookupRequestError> {
+        match &self.state {
+            State::Downloading(expected_req_id) => {
+                if req_id != *expected_req_id {
+                    return Err(LookupRequestError::UnexpectedRequestId {
+                        expected_req_id: *expected_req_id,
+                        req_id,
+                    });
+                }
+                self.state = State::AwaitingProcess(result);
+                Ok(())
+            }
+            other => Err(LookupRequestError::BadState(format!(
+                "Bad state on_download_success expected Downloading got {other}"
+            ))),
+        }
     }
-}
 
-impl slog::Value for SingleLookupRequestState {
-    fn serialize(
-        &self,
-        record: &slog::Record,
-        key: slog::Key,
-        serializer: &mut dyn slog::Serializer,
-    ) -> slog::Result {
-        serializer.emit_str("request_state", key)?;
+    /// Switch to `Processing` if the request is in `AwaitingProcess` state, otherwise returns None.
+    pub fn maybe_start_processing(&mut self) -> Option<DownloadResult<T>> {
+        // For 2 lines replace state with placeholder to gain ownership of `result`
         match &self.state {
-            State::AwaitingDownload => {
-                "awaiting_download".serialize(record, "state", serializer)?
+            State::AwaitingProcess(result) => {
+                let result = result.clone();
+                self.state = State::Processing(result.clone());
+                Some(result)
             }
-            State::Downloading { peer_id } => {
-                serializer.emit_arguments("downloading_peer", &format_args!("{}", peer_id))?
+            _ => None,
+        }
+    }
+
+    /// Revert into `AwaitingProcessing`, if the payload if not invalid and can be submitted for
+    /// processing latter.
+    pub fn revert_to_awaiting_processing(&mut self) -> Result<(), LookupRequestError> {
+        match &self.state {
+            State::Processing(result) => {
+                self.state = State::AwaitingProcess(result.clone());
+                Ok(())
             }
-            State::Processing { peer_id } => {
-                serializer.emit_arguments("processing_peer", &format_args!("{}", peer_id))?
+            other => Err(LookupRequestError::BadState(format!(
+                "Bad state on revert_to_awaiting_processing expected Processing got {other}"
+            ))),
+        }
+    }
+
+    /// Registers a failure in processing a block.
+    pub fn on_processing_failure(&mut self) -> Result<PeerId, LookupRequestError> {
+        match &self.state {
+            State::Processing(result) => {
+                let peer_id = result.peer_id;
+                self.failed_processing = self.failed_processing.saturating_add(1);
+                self.state = State::AwaitingDownload;
+                Ok(peer_id)
             }
+            other => Err(LookupRequestError::BadState(format!(
+                "Bad state on_processing_failure expected Processing got {other}"
+            ))),
         }
-        serializer.emit_u8("failed_downloads", self.failed_downloading)?;
-        serializer.emit_u8("failed_processing", self.failed_processing)?;
-        slog::Result::Ok(())
     }
-}
 
-impl std::fmt::Display for State {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            State::AwaitingDownload => write!(f, "AwaitingDownload"),
-            State::Downloading { .. } => write!(f, "Downloading"),
-            State::Processing { .. } => write!(f, "Processing"),
+    pub fn on_processing_success(&mut self) -> Result<(), LookupRequestError> {
+        match &self.state {
+            State::Processing(_) => {
+                self.state = State::Processed;
+                Ok(())
+            }
+            other => Err(LookupRequestError::BadState(format!(
+                "Bad state on_processing_success expected Processing got {other}"
+            ))),
         }
     }
-}
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::sync::block_lookups::common::LookupType;
-    use beacon_chain::builder::Witness;
-    use beacon_chain::eth1_chain::CachingEth1Backend;
-    use sloggers::null::NullLoggerBuilder;
-    use sloggers::Build;
-    use slot_clock::{SlotClock, TestingSlotClock};
-    use std::time::Duration;
-    use store::{HotColdDB, MemoryStore, StoreConfig};
-    use types::{
-        test_utils::{SeedableRng, TestRandom, XorShiftRng},
-        ChainSpec, MinimalEthSpec as E, SignedBeaconBlock, Slot,
-    };
-
-    fn rand_block() -> SignedBeaconBlock<E> {
-        let mut rng = XorShiftRng::from_seed([42; 16]);
-        SignedBeaconBlock::from_block(
-            types::BeaconBlock::Base(types::BeaconBlockBase {
-                ..<_>::random_for_test(&mut rng)
-            }),
-            types::Signature::random_for_test(&mut rng),
-        )
-    }
-    type T = Witness<TestingSlotClock, CachingEth1Backend<E>, E, MemoryStore<E>, MemoryStore<E>>;
-
-    struct TestLookup1;
-
-    impl Lookup for TestLookup1 {
-        const MAX_ATTEMPTS: u8 = 3;
-
-        fn lookup_type() -> LookupType {
-            panic!()
+    /// Mark a request as complete without any download or processing
+    pub fn on_completed_request(&mut self) -> Result<(), LookupRequestError> {
+        match &self.state {
+            State::AwaitingDownload => {
+                self.state = State::Processed;
+                Ok(())
+            }
+            other => Err(LookupRequestError::BadState(format!(
+                "Bad state on_completed_request expected AwaitingDownload got {other}"
+            ))),
         }
     }
 
-    struct TestLookup2;
+    /// The total number of failures, whether it be processing or downloading.
+    pub fn failed_attempts(&self) -> u8 {
+        self.failed_processing + self.failed_downloading
+    }
 
-    impl Lookup for TestLookup2 {
-        const MAX_ATTEMPTS: u8 = 4;
+    pub fn more_failed_processing_attempts(&self) -> bool {
+        self.failed_processing >= self.failed_downloading
+    }
 
-        fn lookup_type() -> LookupType {
-            panic!()
-        }
+    /// Add peer to this request states. The peer must be able to serve this request.
+    /// Returns true if the peer is newly inserted.
+    pub fn add_peer(&mut self, peer_id: &PeerId) -> bool {
+        self.available_peers.insert(*peer_id)
     }
 
-    #[test]
-    fn test_happy_path() {
-        let peer_id = PeerId::random();
-        let block = rand_block();
-        let spec = E::default_spec();
-        let slot_clock = TestingSlotClock::new(
-            Slot::new(0),
-            Duration::from_secs(0),
-            Duration::from_secs(spec.seconds_per_slot),
-        );
-        let log = NullLoggerBuilder.build().expect("logger should build");
-        let store =
-            HotColdDB::open_ephemeral(StoreConfig::default(), ChainSpec::minimal(), log.clone())
-                .expect("store");
-        let da_checker = Arc::new(
-            DataAvailabilityChecker::new(slot_clock, None, store.into(), &log, spec.clone())
-                .expect("data availability checker"),
-        );
-        let mut sl = SingleBlockLookup::<TestLookup1, T>::new(
-            block.canonical_root(),
-            None,
-            &[peer_id],
-            da_checker,
-            1,
-        );
-        <BlockRequestState<TestLookup1> as RequestState<TestLookup1, T>>::build_request(
-            &mut sl.block_request_state,
-            &spec,
-        )
-        .unwrap();
-        sl.block_request_state.state.state = State::Downloading { peer_id };
-
-        <BlockRequestState<TestLookup1> as RequestState<TestLookup1, T>>::verify_response(
-            &mut sl.block_request_state,
-            block.canonical_root(),
-            Some(block.into()),
-        )
-        .unwrap()
-        .unwrap();
-    }
-
-    #[test]
-    fn test_block_lookup_failures() {
-        let peer_id = PeerId::random();
-        let block = rand_block();
-        let spec = E::default_spec();
-        let slot_clock = TestingSlotClock::new(
-            Slot::new(0),
-            Duration::from_secs(0),
-            Duration::from_secs(spec.seconds_per_slot),
-        );
-        let log = NullLoggerBuilder.build().expect("logger should build");
-        let store =
-            HotColdDB::open_ephemeral(StoreConfig::default(), ChainSpec::minimal(), log.clone())
-                .expect("store");
-
-        let da_checker = Arc::new(
-            DataAvailabilityChecker::new(slot_clock, None, store.into(), &log, spec.clone())
-                .expect("data availability checker"),
-        );
-
-        let mut sl = SingleBlockLookup::<TestLookup2, T>::new(
-            block.canonical_root(),
-            None,
-            &[peer_id],
-            da_checker,
-            1,
-        );
-        for _ in 1..TestLookup2::MAX_ATTEMPTS {
-            <BlockRequestState<TestLookup2> as RequestState<TestLookup2, T>>::build_request(
-                &mut sl.block_request_state,
-                &spec,
-            )
-            .unwrap();
-            sl.block_request_state.state.register_failure_downloading();
-        }
+    /// Remove peer from available peers. Return true if there are no more available peers and the
+    /// request is not expecting any future event (AwaitingDownload).
+    pub fn remove_peer(&mut self, disconnected_peer_id: &PeerId) -> bool {
+        self.available_peers.remove(disconnected_peer_id);
+        self.available_peers.is_empty() && self.is_awaiting_download()
+    }
+
+    pub fn get_used_peers(&self) -> impl Iterator<Item = &PeerId> {
+        self.used_peers.iter()
+    }
+
+    pub fn get_available_peers(&self) -> impl Iterator<Item = &PeerId> {
+        self.available_peers.iter()
+    }
 
-        // Now we receive the block and send it for processing
-        <BlockRequestState<TestLookup2> as RequestState<TestLookup2, T>>::build_request(
-            &mut sl.block_request_state,
-            &spec,
-        )
-        .unwrap();
-        sl.block_request_state.state.state = State::Downloading { peer_id };
-
-        <BlockRequestState<TestLookup2> as RequestState<TestLookup2, T>>::verify_response(
-            &mut sl.block_request_state,
-            block.canonical_root(),
-            Some(block.into()),
-        )
-        .unwrap()
-        .unwrap();
-
-        // One processing failure maxes the available attempts
-        sl.block_request_state.state.register_failure_processing();
-        assert_eq!(
-            <BlockRequestState<TestLookup2> as RequestState<TestLookup2, T>>::build_request(
-                &mut sl.block_request_state,
-                &spec
-            ),
-            Err(LookupRequestError::TooManyAttempts {
-                cannot_process: false
-            })
-        )
+    /// Selects a random peer from available peers if any, inserts it in used peers and returns it.
+    pub fn use_rand_available_peer(&mut self) -> Option<PeerId> {
+        let peer_id = self
+            .available_peers
+            .iter()
+            .choose(&mut rand::thread_rng())
+            .copied()?;
+        self.used_peers.insert(peer_id);
+        Some(peer_id)
+    }
+}
+
+// Display is used in the BadState assertions above
+impl<T: Clone> std::fmt::Display for State<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", Into::<&'static str>::into(self))
     }
 }
+
+// Debug is used in the log_stuck_lookups print to include some more info. Implements custom Debug
+// to not dump an entire block or blob to terminal which don't add valuable data.
+impl<T: Clone> std::fmt::Debug for State<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::AwaitingDownload { .. } => write!(f, "AwaitingDownload"),
+            Self::Downloading(req_id) => write!(f, "Downloading({:?})", req_id),
+            Self::AwaitingProcess(d) => write!(f, "AwaitingProcess({:?})", d.peer_id),
+            Self::Processing(d) => write!(f, "Processing({:?})", d.peer_id),
+            Self::Processed { .. } => write!(f, "Processed"),
+        }
+    }
+}
+
+fn fmt_peer_set(
+    peer_set: &HashSet<PeerId>,
+    f: &mut std::fmt::Formatter,
+) -> Result<(), std::fmt::Error> {
+    write!(f, "{}", peer_set.len())
+}
diff --git a/beacon_node/network/src/sync/block_lookups/tests.rs b/beacon_node/network/src/sync/block_lookups/tests.rs
index 2822cb7ba0b..2a59c24d580 100644
--- a/beacon_node/network/src/sync/block_lookups/tests.rs
+++ b/beacon_node/network/src/sync/block_lookups/tests.rs
@@ -1,43 +1,96 @@
 use crate::network_beacon_processor::NetworkBeaconProcessor;
 
 use crate::service::RequestId;
-use crate::sync::manager::{RequestId as SyncId, SingleLookupReqId};
+use crate::sync::manager::{
+    BlockProcessType, RequestId as SyncRequestId, SingleLookupReqId, SyncManager,
+};
+use crate::sync::SyncMessage;
 use crate::NetworkMessage;
 use std::sync::Arc;
 
 use super::*;
 
-use crate::sync::block_lookups::common::ResponseType;
+use crate::sync::block_lookups::common::{ResponseType, PARENT_DEPTH_TOLERANCE};
+use beacon_chain::blob_verification::GossipVerifiedBlob;
+use beacon_chain::block_verification_types::{BlockImportData, RpcBlock};
 use beacon_chain::builder::Witness;
+use beacon_chain::data_availability_checker::Availability;
 use beacon_chain::eth1_chain::CachingEth1Backend;
 use beacon_chain::test_utils::{
     build_log, generate_rand_block_and_blobs, BeaconChainHarness, EphemeralHarnessType, NumBlobs,
 };
+use beacon_chain::{
+    AvailabilityPendingExecutedBlock, PayloadVerificationOutcome, PayloadVerificationStatus,
+};
 use beacon_processor::WorkEvent;
-use lighthouse_network::rpc::RPCResponseErrorCode;
+use lighthouse_network::rpc::{RPCError, RPCResponseErrorCode};
+use lighthouse_network::types::SyncState;
 use lighthouse_network::{NetworkGlobals, Request};
+use slog::info;
 use slot_clock::{ManualSlotClock, SlotClock, TestingSlotClock};
 use store::MemoryStore;
 use tokio::sync::mpsc;
+use types::test_utils::TestRandom;
 use types::{
     test_utils::{SeedableRng, XorShiftRng},
-    BlobSidecar, EthSpec, ForkName, MinimalEthSpec as E, SignedBeaconBlock,
+    BlobSidecar, ForkName, MinimalEthSpec as E, SignedBeaconBlock, Slot,
 };
+use types::{BeaconState, BeaconStateBase};
 
 type T = Witness<ManualSlotClock, CachingEth1Backend<E>, E, MemoryStore<E>, MemoryStore<E>>;
 
+/// This test utility enables integration testing of Lighthouse sync components.
+///
+/// It covers the following:
+/// 1. Sending `SyncMessage` to `SyncManager` to trigger `RangeSync`, `BackFillSync` and `BlockLookups` behaviours.
+/// 2. Making assertions on `WorkEvent`s received from sync
+/// 3. Making assertion on `NetworkMessage` received from sync (Outgoing RPC requests).
+///
+/// The test utility covers testing the interactions from and to `SyncManager`. In diagram form:
+///                      +-----------------+
+///                      | BeaconProcessor |
+///                      +---------+-------+
+///                             ^  |
+///                             |  |
+///                   WorkEvent |  | SyncMsg
+///                             |  | (Result)
+///                             |  v
+/// +--------+            +-----+-----------+             +----------------+
+/// | Router +----------->|  SyncManager    +------------>| NetworkService |
+/// +--------+  SyncMsg   +-----------------+ NetworkMsg  +----------------+
+///           (RPC resp)  |  - RangeSync    |  (RPC req)
+///                       +-----------------+
+///                       |  - BackFillSync |
+///                       +-----------------+
+///                       |  - BlockLookups |
+///                       +-----------------+
 struct TestRig {
+    /// Receiver for `BeaconProcessor` events (e.g. block processing results).
     beacon_processor_rx: mpsc::Receiver<WorkEvent<E>>,
+    beacon_processor_rx_queue: Vec<WorkEvent<E>>,
+    /// Receiver for `NetworkMessage` (e.g. outgoing RPC requests from sync)
     network_rx: mpsc::UnboundedReceiver<NetworkMessage<E>>,
+    /// Stores all `NetworkMessage`s received from `network_recv`. (e.g. outgoing RPC requests)
+    network_rx_queue: Vec<NetworkMessage<E>>,
+    /// To send `SyncMessage`. For sending RPC responses or block processing results to sync.
+    sync_manager: SyncManager<T>,
+    /// To manipulate sync state and peer connection status
+    network_globals: Arc<NetworkGlobals<E>>,
+    /// Beacon chain harness
+    harness: BeaconChainHarness<EphemeralHarnessType<E>>,
+    /// `rng` for generating test blocks and blobs.
     rng: XorShiftRng,
-    harness: BeaconChainHarness<T>,
+    fork_name: ForkName,
+    log: Logger,
 }
 
 const D: Duration = Duration::new(0, 0);
+const PARENT_FAIL_TOLERANCE: u8 = SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS;
 
 impl TestRig {
-    fn test_setup(enable_log: bool) -> (BlockLookups<T>, SyncNetworkContext<T>, Self) {
-        let log = build_log(slog::Level::Debug, enable_log);
+    fn test_setup() -> Self {
+        let enable_log = cfg!(feature = "test_logger");
+        let log = build_log(slog::Level::Trace, enable_log);
 
         // Initialise a new beacon chain
         let harness = BeaconChainHarness::<EphemeralHarnessType<E>>::builder(E)
@@ -56,108 +109,617 @@ impl TestRig {
 
         let (network_tx, network_rx) = mpsc::unbounded_channel();
         let globals = Arc::new(NetworkGlobals::new_test_globals(Vec::new(), &log));
-        let (network_beacon_processor, beacon_processor_rx) =
-            NetworkBeaconProcessor::null_for_testing(globals);
+        let (beacon_processor, beacon_processor_rx) = NetworkBeaconProcessor::null_for_testing(
+            globals,
+            chain.clone(),
+            harness.runtime.task_executor.clone(),
+            log.clone(),
+        );
+
+        let (_sync_send, sync_recv) = mpsc::unbounded_channel::<SyncMessage<E>>();
+
+        let fork_name = chain.spec.fork_name_at_slot::<E>(chain.slot().unwrap());
+
+        // All current tests expect synced and EL online state
+        beacon_processor
+            .network_globals
+            .set_sync_state(SyncState::Synced);
+
         let rng = XorShiftRng::from_seed([42; 16]);
-        let rig = TestRig {
+        TestRig {
             beacon_processor_rx,
+            beacon_processor_rx_queue: vec![],
             network_rx,
+            network_rx_queue: vec![],
             rng,
+            network_globals: beacon_processor.network_globals.clone(),
+            sync_manager: SyncManager::new(
+                chain,
+                network_tx,
+                beacon_processor.into(),
+                sync_recv,
+                log.clone(),
+            ),
             harness,
-        };
+            fork_name,
+            log,
+        }
+    }
 
-        let bl = BlockLookups::new(
-            chain.data_availability_checker.clone(),
-            log.new(slog::o!("component" => "block_lookups")),
-        );
-        let cx = {
-            SyncNetworkContext::new(
-                network_tx,
-                Arc::new(network_beacon_processor),
-                chain,
-                log.new(slog::o!("component" => "network_context")),
-            )
-        };
+    fn test_setup_after_deneb() -> Option<Self> {
+        let r = Self::test_setup();
+        if r.after_deneb() {
+            Some(r)
+        } else {
+            None
+        }
+    }
+
+    fn log(&self, msg: &str) {
+        info!(self.log, "TEST_RIG"; "msg" => msg);
+    }
+
+    fn after_deneb(&self) -> bool {
+        matches!(self.fork_name, ForkName::Deneb | ForkName::Electra)
+    }
+
+    fn trigger_unknown_parent_block(&mut self, peer_id: PeerId, block: Arc<SignedBeaconBlock<E>>) {
+        let block_root = block.canonical_root();
+        self.send_sync_message(SyncMessage::UnknownParentBlock(
+            peer_id,
+            RpcBlock::new_without_blobs(Some(block_root), block),
+            block_root,
+        ))
+    }
 
-        (bl, cx, rig)
+    fn trigger_unknown_parent_blob(&mut self, peer_id: PeerId, blob: BlobSidecar<E>) {
+        self.send_sync_message(SyncMessage::UnknownParentBlob(peer_id, blob.into()));
     }
 
-    fn rand_block(&mut self, fork_name: ForkName) -> SignedBeaconBlock<E> {
-        self.rand_block_and_blobs(fork_name, NumBlobs::None).0
+    fn trigger_unknown_block_from_attestation(&mut self, block_root: Hash256, peer_id: PeerId) {
+        self.send_sync_message(SyncMessage::UnknownBlockHashFromAttestation(
+            peer_id, block_root,
+        ));
+    }
+
+    fn rand_block(&mut self) -> SignedBeaconBlock<E> {
+        self.rand_block_and_blobs(NumBlobs::None).0
     }
 
     fn rand_block_and_blobs(
         &mut self,
-        fork_name: ForkName,
         num_blobs: NumBlobs,
     ) -> (SignedBeaconBlock<E>, Vec<BlobSidecar<E>>) {
+        let fork_name = self.fork_name;
         let rng = &mut self.rng;
         generate_rand_block_and_blobs::<E>(fork_name, num_blobs, rng)
     }
 
-    #[track_caller]
-    fn expect_lookup_request(&mut self, response_type: ResponseType) -> SingleLookupReqId {
-        match response_type {
-            ResponseType::Block => match self.network_rx.try_recv() {
-                Ok(NetworkMessage::SendRequest {
-                    peer_id: _,
-                    request: Request::BlocksByRoot(_request),
-                    request_id: RequestId::Sync(SyncId::SingleBlock { id }),
-                }) => id,
-                other => {
-                    panic!("Expected block request, found {:?}", other);
-                }
+    pub fn rand_block_and_parent(
+        &mut self,
+    ) -> (SignedBeaconBlock<E>, SignedBeaconBlock<E>, Hash256, Hash256) {
+        let parent = self.rand_block();
+        let parent_root = parent.canonical_root();
+        let mut block = self.rand_block();
+        *block.message_mut().parent_root_mut() = parent_root;
+        let block_root = block.canonical_root();
+        (parent, block, parent_root, block_root)
+    }
+
+    fn send_sync_message(&mut self, sync_message: SyncMessage<E>) {
+        self.sync_manager.handle_message(sync_message);
+    }
+
+    fn active_single_lookups(&self) -> Vec<(Id, Hash256, Option<Hash256>)> {
+        self.sync_manager.active_single_lookups()
+    }
+
+    fn active_single_lookups_count(&self) -> usize {
+        self.sync_manager.active_single_lookups().len()
+    }
+
+    fn active_parent_lookups(&self) -> Vec<Vec<Hash256>> {
+        self.sync_manager.active_parent_lookups()
+    }
+
+    fn active_parent_lookups_count(&self) -> usize {
+        self.sync_manager.active_parent_lookups().len()
+    }
+
+    fn assert_single_lookups_count(&self, count: usize) {
+        assert_eq!(
+            self.active_single_lookups_count(),
+            count,
+            "Unexpected count of single lookups. Current lookups: {:?}",
+            self.active_single_lookups()
+        );
+    }
+
+    fn assert_parent_lookups_count(&self, count: usize) {
+        assert_eq!(
+            self.active_parent_lookups_count(),
+            count,
+            "Unexpected count of parent lookups. Parent lookups: {:?}. Current lookups: {:?}",
+            self.active_parent_lookups(),
+            self.active_single_lookups()
+        );
+    }
+
+    fn assert_lookup_is_active(&self, block_root: Hash256) {
+        let lookups = self.sync_manager.active_single_lookups();
+        if !lookups.iter().any(|l| l.1 == block_root) {
+            panic!("Expected lookup {block_root} to be the only active: {lookups:?}");
+        }
+    }
+
+    fn insert_failed_chain(&mut self, block_root: Hash256) {
+        self.sync_manager.insert_failed_chain(block_root);
+    }
+
+    fn assert_not_failed_chain(&mut self, chain_hash: Hash256) {
+        let failed_chains = self.sync_manager.get_failed_chains();
+        if failed_chains.contains(&chain_hash) {
+            panic!("failed chains contain {chain_hash:?}: {failed_chains:?}");
+        }
+    }
+
+    fn failed_chains_contains(&mut self, chain_hash: &Hash256) -> bool {
+        self.sync_manager.get_failed_chains().contains(chain_hash)
+    }
+
+    fn find_single_lookup_for(&self, block_root: Hash256) -> Id {
+        self.active_single_lookups()
+            .iter()
+            .find(|(_, b, _)| b == &block_root)
+            .unwrap_or_else(|| panic!("no single block lookup found for {block_root}"))
+            .0
+    }
+
+    fn expect_no_active_single_lookups(&self) {
+        assert!(
+            self.active_single_lookups().is_empty(),
+            "expect no single block lookups: {:?}",
+            self.active_single_lookups()
+        );
+    }
+
+    fn expect_no_active_lookups(&self) {
+        self.expect_no_active_single_lookups();
+    }
+
+    fn expect_no_active_lookups_empty_network(&mut self) {
+        self.expect_no_active_lookups();
+        self.expect_empty_network();
+    }
+
+    fn new_connected_peer(&mut self) -> PeerId {
+        let peer_id = PeerId::random();
+        self.network_globals
+            .peers
+            .write()
+            .__add_connected_peer_testing_only(&peer_id);
+        peer_id
+    }
+
+    fn parent_chain_processed_success(
+        &mut self,
+        chain_hash: Hash256,
+        blocks: &[Arc<SignedBeaconBlock<E>>],
+    ) {
+        // Send import events for all pending parent blocks
+        for _ in blocks {
+            self.parent_block_processed_imported(chain_hash);
+        }
+        // Send final import event for the block that triggered the lookup
+        self.single_block_component_processed_imported(chain_hash);
+    }
+
+    /// Locate a parent lookup chain with tip hash `chain_hash`
+    fn find_oldest_parent_lookup(&self, chain_hash: Hash256) -> Hash256 {
+        let parent_chain = self
+            .active_parent_lookups()
+            .into_iter()
+            .find(|chain| chain.first() == Some(&chain_hash))
+            .unwrap_or_else(|| {
+                panic!(
+                    "No parent chain with chain_hash {chain_hash:?}: Parent lookups {:?} Single lookups {:?}",
+                    self.active_parent_lookups(),
+                    self.active_single_lookups(),
+                )
+            });
+        *parent_chain.last().unwrap()
+    }
+
+    fn parent_block_processed(&mut self, chain_hash: Hash256, result: BlockProcessingResult<E>) {
+        let id = self.find_single_lookup_for(self.find_oldest_parent_lookup(chain_hash));
+        self.single_block_component_processed(id, result);
+    }
+
+    fn parent_blob_processed(&mut self, chain_hash: Hash256, result: BlockProcessingResult<E>) {
+        let id = self.find_single_lookup_for(self.find_oldest_parent_lookup(chain_hash));
+        self.single_blob_component_processed(id, result);
+    }
+
+    fn parent_block_processed_imported(&mut self, chain_hash: Hash256) {
+        self.parent_block_processed(
+            chain_hash,
+            BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(chain_hash)),
+        );
+    }
+
+    fn single_block_component_processed(&mut self, id: Id, result: BlockProcessingResult<E>) {
+        self.send_sync_message(SyncMessage::BlockComponentProcessed {
+            process_type: BlockProcessType::SingleBlock { id },
+            result,
+        })
+    }
+
+    fn single_block_component_processed_imported(&mut self, block_root: Hash256) {
+        let id = self.find_single_lookup_for(block_root);
+        self.single_block_component_processed(
+            id,
+            BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(block_root)),
+        )
+    }
+
+    fn single_blob_component_processed(&mut self, id: Id, result: BlockProcessingResult<E>) {
+        self.send_sync_message(SyncMessage::BlockComponentProcessed {
+            process_type: BlockProcessType::SingleBlob { id },
+            result,
+        })
+    }
+
+    fn parent_lookup_block_response(
+        &mut self,
+        id: SingleLookupReqId,
+        peer_id: PeerId,
+        beacon_block: Option<Arc<SignedBeaconBlock<E>>>,
+    ) {
+        self.log("parent_lookup_block_response");
+        self.send_sync_message(SyncMessage::RpcBlock {
+            request_id: SyncRequestId::SingleBlock { id },
+            peer_id,
+            beacon_block,
+            seen_timestamp: D,
+        });
+    }
+
+    fn single_lookup_block_response(
+        &mut self,
+        id: SingleLookupReqId,
+        peer_id: PeerId,
+        beacon_block: Option<Arc<SignedBeaconBlock<E>>>,
+    ) {
+        self.log("single_lookup_block_response");
+        self.send_sync_message(SyncMessage::RpcBlock {
+            request_id: SyncRequestId::SingleBlock { id },
+            peer_id,
+            beacon_block,
+            seen_timestamp: D,
+        });
+    }
+
+    fn parent_lookup_blob_response(
+        &mut self,
+        id: SingleLookupReqId,
+        peer_id: PeerId,
+        blob_sidecar: Option<Arc<BlobSidecar<E>>>,
+    ) {
+        self.log(&format!(
+            "parent_lookup_blob_response {:?}",
+            blob_sidecar.as_ref().map(|b| b.index)
+        ));
+        self.send_sync_message(SyncMessage::RpcBlob {
+            request_id: SyncRequestId::SingleBlob { id },
+            peer_id,
+            blob_sidecar,
+            seen_timestamp: D,
+        });
+    }
+
+    fn single_lookup_blob_response(
+        &mut self,
+        id: SingleLookupReqId,
+        peer_id: PeerId,
+        blob_sidecar: Option<Arc<BlobSidecar<E>>>,
+    ) {
+        self.send_sync_message(SyncMessage::RpcBlob {
+            request_id: SyncRequestId::SingleBlob { id },
+            peer_id,
+            blob_sidecar,
+            seen_timestamp: D,
+        });
+    }
+
+    fn complete_single_lookup_blob_download(
+        &mut self,
+        id: SingleLookupReqId,
+        peer_id: PeerId,
+        blobs: Vec<BlobSidecar<E>>,
+    ) {
+        for blob in blobs {
+            self.single_lookup_blob_response(id, peer_id, Some(blob.into()));
+        }
+        self.single_lookup_blob_response(id, peer_id, None);
+    }
+
+    fn complete_single_lookup_blob_lookup_valid(
+        &mut self,
+        id: SingleLookupReqId,
+        peer_id: PeerId,
+        blobs: Vec<BlobSidecar<E>>,
+        import: bool,
+    ) {
+        let block_root = blobs.first().unwrap().block_root();
+        let block_slot = blobs.first().unwrap().slot();
+        self.complete_single_lookup_blob_download(id, peer_id, blobs);
+        self.expect_block_process(ResponseType::Blob);
+        self.single_blob_component_processed(
+            id.lookup_id,
+            if import {
+                BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(block_root))
+            } else {
+                BlockProcessingResult::Ok(AvailabilityProcessingStatus::MissingComponents(
+                    block_slot, block_root,
+                ))
             },
-            ResponseType::Blob => match self.network_rx.try_recv() {
-                Ok(NetworkMessage::SendRequest {
-                    peer_id: _,
-                    request: Request::BlobsByRoot(_request),
-                    request_id: RequestId::Sync(SyncId::SingleBlob { id }),
-                }) => id,
-                other => {
-                    panic!("Expected blob request, found {:?}", other);
-                }
+        );
+    }
+
+    fn complete_lookup_block_download(&mut self, block: SignedBeaconBlock<E>) {
+        let block_root = block.canonical_root();
+        let id = self.expect_block_lookup_request(block_root);
+        self.expect_empty_network();
+        let peer_id = self.new_connected_peer();
+        self.single_lookup_block_response(id, peer_id, Some(block.into()));
+        self.single_lookup_block_response(id, peer_id, None);
+    }
+
+    fn complete_lookup_block_import_valid(&mut self, block_root: Hash256, import: bool) {
+        self.expect_block_process(ResponseType::Block);
+        let id = self.find_single_lookup_for(block_root);
+        self.single_block_component_processed(
+            id,
+            if import {
+                BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(block_root))
+            } else {
+                BlockProcessingResult::Ok(AvailabilityProcessingStatus::MissingComponents(
+                    Slot::new(0),
+                    block_root,
+                ))
             },
+        )
+    }
+
+    fn complete_single_lookup_block_valid(&mut self, block: SignedBeaconBlock<E>, import: bool) {
+        let block_root = block.canonical_root();
+        self.complete_lookup_block_download(block);
+        self.complete_lookup_block_import_valid(block_root, import)
+    }
+
+    fn parent_lookup_failed(&mut self, id: SingleLookupReqId, peer_id: PeerId, error: RPCError) {
+        self.send_sync_message(SyncMessage::RpcError {
+            peer_id,
+            request_id: SyncRequestId::SingleBlock { id },
+            error,
+        })
+    }
+
+    fn parent_lookup_failed_unavailable(&mut self, id: SingleLookupReqId, peer_id: PeerId) {
+        self.parent_lookup_failed(
+            id,
+            peer_id,
+            RPCError::ErrorResponse(
+                RPCResponseErrorCode::ResourceUnavailable,
+                "older than deneb".into(),
+            ),
+        );
+    }
+
+    fn single_lookup_failed(&mut self, id: SingleLookupReqId, peer_id: PeerId, error: RPCError) {
+        self.send_sync_message(SyncMessage::RpcError {
+            peer_id,
+            request_id: SyncRequestId::SingleBlock { id },
+            error,
+        })
+    }
+
+    fn peer_disconnected(&mut self, disconnected_peer_id: PeerId) {
+        self.send_sync_message(SyncMessage::Disconnect(disconnected_peer_id));
+
+        // Return RPCErrors for all active requests of peer
+        self.drain_network_rx();
+        while let Ok(request_id) = self.pop_received_network_event(|ev| match ev {
+            NetworkMessage::SendRequest {
+                peer_id,
+                request_id: RequestId::Sync(id),
+                ..
+            } if *peer_id == disconnected_peer_id => Some(*id),
+            _ => None,
+        }) {
+            self.send_sync_message(SyncMessage::RpcError {
+                peer_id: disconnected_peer_id,
+                request_id,
+                error: RPCError::Disconnected,
+            });
+        }
+    }
+
+    fn drain_network_rx(&mut self) {
+        while let Ok(event) = self.network_rx.try_recv() {
+            self.network_rx_queue.push(event);
+        }
+    }
+
+    fn drain_processor_rx(&mut self) {
+        while let Ok(event) = self.beacon_processor_rx.try_recv() {
+            self.beacon_processor_rx_queue.push(event);
+        }
+    }
+
+    fn pop_received_network_event<T, F: Fn(&NetworkMessage<E>) -> Option<T>>(
+        &mut self,
+        predicate_transform: F,
+    ) -> Result<T, String> {
+        self.drain_network_rx();
+
+        if let Some(index) = self
+            .network_rx_queue
+            .iter()
+            .position(|x| predicate_transform(x).is_some())
+        {
+            // Transform the item, knowing that it won't be None because we checked it in the position predicate.
+            let transformed = predicate_transform(&self.network_rx_queue[index]).unwrap();
+            self.network_rx_queue.remove(index);
+            Ok(transformed)
+        } else {
+            Err(format!("current network messages {:?}", self.network_rx_queue).to_string())
+        }
+    }
+
+    fn pop_received_processor_event<T, F: Fn(&WorkEvent<E>) -> Option<T>>(
+        &mut self,
+        predicate_transform: F,
+    ) -> Result<T, String> {
+        self.drain_processor_rx();
+
+        if let Some(index) = self
+            .beacon_processor_rx_queue
+            .iter()
+            .position(|x| predicate_transform(x).is_some())
+        {
+            // Transform the item, knowing that it won't be None because we checked it in the position predicate.
+            let transformed = predicate_transform(&self.beacon_processor_rx_queue[index]).unwrap();
+            self.beacon_processor_rx_queue.remove(index);
+            Ok(transformed)
+        } else {
+            Err(format!(
+                "current processor messages {:?}",
+                self.beacon_processor_rx_queue
+            )
+            .to_string())
         }
     }
 
+    fn find_block_lookup_request(
+        &mut self,
+        for_block: Hash256,
+    ) -> Result<SingleLookupReqId, String> {
+        self.pop_received_network_event(|ev| match ev {
+            NetworkMessage::SendRequest {
+                peer_id: _,
+                request: Request::BlocksByRoot(request),
+                request_id: RequestId::Sync(SyncRequestId::SingleBlock { id }),
+            } if request.block_roots().to_vec().contains(&for_block) => Some(*id),
+            _ => None,
+        })
+    }
+
     #[track_caller]
-    fn expect_parent_request(&mut self, response_type: ResponseType) -> SingleLookupReqId {
-        match response_type {
-            ResponseType::Block => match self.network_rx.try_recv() {
-                Ok(NetworkMessage::SendRequest {
-                    peer_id: _,
-                    request: Request::BlocksByRoot(_request),
-                    request_id: RequestId::Sync(SyncId::ParentLookup { id }),
-                }) => id,
-                other => panic!("Expected parent request, found {:?}", other),
-            },
-            ResponseType::Blob => match self.network_rx.try_recv() {
-                Ok(NetworkMessage::SendRequest {
-                    peer_id: _,
-                    request: Request::BlobsByRoot(_request),
-                    request_id: RequestId::Sync(SyncId::ParentLookupBlob { id }),
-                }) => id,
-                other => panic!("Expected parent blobs request, found {:?}", other),
-            },
+    fn expect_block_lookup_request(&mut self, for_block: Hash256) -> SingleLookupReqId {
+        self.find_block_lookup_request(for_block)
+            .unwrap_or_else(|e| panic!("Expected block request for {for_block:?}: {e}"))
+    }
+
+    fn find_blob_lookup_request(
+        &mut self,
+        for_block: Hash256,
+    ) -> Result<SingleLookupReqId, String> {
+        self.pop_received_network_event(|ev| match ev {
+            NetworkMessage::SendRequest {
+                peer_id: _,
+                request: Request::BlobsByRoot(request),
+                request_id: RequestId::Sync(SyncRequestId::SingleBlob { id }),
+            } if request
+                .blob_ids
+                .to_vec()
+                .iter()
+                .any(|r| r.block_root == for_block) =>
+            {
+                Some(*id)
+            }
+            _ => None,
+        })
+    }
+
+    #[track_caller]
+    fn expect_blob_lookup_request(&mut self, for_block: Hash256) -> SingleLookupReqId {
+        self.find_blob_lookup_request(for_block)
+            .unwrap_or_else(|e| panic!("Expected blob request for {for_block:?}: {e}"))
+    }
+
+    #[track_caller]
+    fn expect_block_parent_request(&mut self, for_block: Hash256) -> SingleLookupReqId {
+        self.pop_received_network_event(|ev| match ev {
+            NetworkMessage::SendRequest {
+                peer_id: _,
+                request: Request::BlocksByRoot(request),
+                request_id: RequestId::Sync(SyncRequestId::SingleBlock { id }),
+            } if request.block_roots().to_vec().contains(&for_block) => Some(*id),
+            _ => None,
+        })
+        .unwrap_or_else(|e| panic!("Expected block parent request for {for_block:?}: {e}"))
+    }
+
+    fn expect_no_requests_for(&mut self, block_root: Hash256) {
+        if let Ok(request) = self.find_block_lookup_request(block_root) {
+            panic!("Expected no block request for {block_root:?} found {request:?}");
+        }
+        if let Ok(request) = self.find_blob_lookup_request(block_root) {
+            panic!("Expected no blob request for {block_root:?} found {request:?}");
         }
     }
 
+    #[track_caller]
+    fn expect_blob_parent_request(&mut self, for_block: Hash256) -> SingleLookupReqId {
+        self.pop_received_network_event(|ev| match ev {
+            NetworkMessage::SendRequest {
+                peer_id: _,
+                request: Request::BlobsByRoot(request),
+                request_id: RequestId::Sync(SyncRequestId::SingleBlob { id }),
+            } if request
+                .blob_ids
+                .to_vec()
+                .iter()
+                .all(|r| r.block_root == for_block) =>
+            {
+                Some(*id)
+            }
+            _ => None,
+        })
+        .unwrap_or_else(|e| panic!("Expected blob parent request for {for_block:?}: {e}"))
+    }
+
     #[track_caller]
     fn expect_block_process(&mut self, response_type: ResponseType) {
         match response_type {
-            ResponseType::Block => match self.beacon_processor_rx.try_recv() {
-                Ok(work) => {
-                    assert_eq!(work.work_type(), beacon_processor::RPC_BLOCK);
-                }
-                other => panic!("Expected block process, found {:?}", other),
-            },
-            ResponseType::Blob => match self.beacon_processor_rx.try_recv() {
-                Ok(work) => {
-                    assert_eq!(work.work_type(), beacon_processor::RPC_BLOBS);
-                }
-                other => panic!("Expected blob process, found {:?}", other),
-            },
+            ResponseType::Block => self
+                .pop_received_processor_event(|ev| {
+                    (ev.work_type() == beacon_processor::RPC_BLOCK).then_some(())
+                })
+                .unwrap_or_else(|e| panic!("Expected block work event: {e}")),
+            ResponseType::Blob => self
+                .pop_received_processor_event(|ev| {
+                    (ev.work_type() == beacon_processor::RPC_BLOBS).then_some(())
+                })
+                .unwrap_or_else(|e| panic!("Expected blobs work event: {e}")),
+        }
+    }
+
+    fn expect_no_penalty_for(&mut self, peer_id: PeerId) {
+        self.drain_network_rx();
+        let downscore_events = self
+            .network_rx_queue
+            .iter()
+            .filter_map(|ev| match ev {
+                NetworkMessage::ReportPeer {
+                    peer_id: p_id, msg, ..
+                } if p_id == &peer_id => Some(msg),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        if !downscore_events.is_empty() {
+            panic!("Some downscore events for {peer_id}: {downscore_events:?}");
         }
     }
 
@@ -165,1014 +727,782 @@ impl TestRig {
     fn expect_parent_chain_process(&mut self) {
         match self.beacon_processor_rx.try_recv() {
             Ok(work) => {
-                assert_eq!(work.work_type(), beacon_processor::CHAIN_SEGMENT);
+                // Parent chain sends blocks one by one
+                assert_eq!(work.work_type(), beacon_processor::RPC_BLOCK);
             }
-            other => panic!("Expected chain segment process, found {:?}", other),
+            other => panic!(
+                "Expected rpc_block from chain segment process, found {:?}",
+                other
+            ),
         }
     }
 
     #[track_caller]
     fn expect_empty_network(&mut self) {
-        assert_eq!(
-            self.network_rx.try_recv().expect_err("must err"),
-            mpsc::error::TryRecvError::Empty
-        );
+        self.drain_network_rx();
+        if !self.network_rx_queue.is_empty() {
+            panic!("expected no network events: {:#?}", self.network_rx_queue);
+        }
     }
 
     #[track_caller]
     fn expect_empty_beacon_processor(&mut self) {
-        assert_eq!(
-            self.beacon_processor_rx.try_recv().expect_err("must err"),
-            mpsc::error::TryRecvError::Empty
-        );
+        match self.beacon_processor_rx.try_recv() {
+            Err(mpsc::error::TryRecvError::Empty) => {} // ok
+            Ok(event) => panic!("expected empty beacon processor: {:?}", event),
+            other => panic!("unexpected err {:?}", other),
+        }
     }
 
     #[track_caller]
-    pub fn expect_penalty(&mut self) {
-        match self.network_rx.try_recv() {
-            Ok(NetworkMessage::ReportPeer { .. }) => {}
-            other => panic!("Expected peer penalty, found {:?}", other),
-        }
+    pub fn expect_penalty(&mut self, peer_id: PeerId, expect_penalty_msg: &'static str) {
+        let penalty_msg = self
+            .pop_received_network_event(|ev| match ev {
+                NetworkMessage::ReportPeer {
+                    peer_id: p_id, msg, ..
+                } if p_id == &peer_id => Some(msg.to_owned()),
+                _ => None,
+            })
+            .unwrap_or_else(|_| {
+                panic!(
+                    "Expected '{expect_penalty_msg}' penalty for peer {peer_id}: {:#?}",
+                    self.network_rx_queue
+                )
+            });
+        assert_eq!(
+            penalty_msg, expect_penalty_msg,
+            "Unexpected penalty msg for {peer_id}"
+        );
     }
 
-    pub fn block_with_parent(
-        &mut self,
-        parent_root: Hash256,
-        fork_name: ForkName,
-    ) -> SignedBeaconBlock<E> {
-        let mut block = self.rand_block(fork_name);
-        *block.message_mut().parent_root_mut() = parent_root;
-        block
+    pub fn expect_single_penalty(&mut self, peer_id: PeerId, expect_penalty_msg: &'static str) {
+        self.expect_penalty(peer_id, expect_penalty_msg);
+        self.expect_no_penalty_for(peer_id);
     }
 
     pub fn block_with_parent_and_blobs(
         &mut self,
         parent_root: Hash256,
-        fork_name: ForkName,
         num_blobs: NumBlobs,
     ) -> (SignedBeaconBlock<E>, Vec<BlobSidecar<E>>) {
-        let (mut block, mut blobs) = self.rand_block_and_blobs(fork_name, num_blobs);
+        let (mut block, mut blobs) = self.rand_block_and_blobs(num_blobs);
         *block.message_mut().parent_root_mut() = parent_root;
         blobs.iter_mut().for_each(|blob| {
             blob.signed_block_header = block.signed_block_header();
         });
         (block, blobs)
     }
+
+    pub fn rand_blockchain(&mut self, depth: usize) -> Vec<Arc<SignedBeaconBlock<E>>> {
+        let mut blocks = Vec::<Arc<SignedBeaconBlock<E>>>::with_capacity(depth);
+        for slot in 0..depth {
+            let parent = blocks
+                .last()
+                .map(|b| b.canonical_root())
+                .unwrap_or_else(Hash256::random);
+            let mut block = self.rand_block();
+            *block.message_mut().parent_root_mut() = parent;
+            *block.message_mut().slot_mut() = slot.into();
+            blocks.push(block.into());
+        }
+        self.log(&format!(
+            "Blockchain dump {:#?}",
+            blocks
+                .iter()
+                .map(|b| format!(
+                    "block {} {} parent {}",
+                    b.slot(),
+                    b.canonical_root(),
+                    b.parent_root()
+                ))
+                .collect::<Vec<_>>()
+        ));
+        blocks
+    }
+
+    fn insert_block_to_da_checker(&mut self, block: Arc<SignedBeaconBlock<E>>) {
+        let state = BeaconState::Base(BeaconStateBase::random_for_test(&mut self.rng));
+        let parent_block = self.rand_block();
+        let import_data = BlockImportData::<E>::__new_for_test(
+            block.canonical_root(),
+            state,
+            parent_block.into(),
+        );
+        let payload_verification_outcome = PayloadVerificationOutcome {
+            payload_verification_status: PayloadVerificationStatus::Verified,
+            is_valid_merge_transition_block: false,
+        };
+        let executed_block =
+            AvailabilityPendingExecutedBlock::new(block, import_data, payload_verification_outcome);
+        match self
+            .harness
+            .chain
+            .data_availability_checker
+            .put_pending_executed_block(executed_block)
+            .unwrap()
+        {
+            Availability::Available(_) => panic!("block removed from da_checker, available"),
+            Availability::MissingComponents(block_root) => {
+                self.log(&format!("inserted block to da_checker {block_root:?}"))
+            }
+        };
+    }
+
+    fn insert_blob_to_da_checker(&mut self, blob: BlobSidecar<E>) {
+        match self
+            .harness
+            .chain
+            .data_availability_checker
+            .put_gossip_blob(GossipVerifiedBlob::__assumed_valid(blob.into()))
+            .unwrap()
+        {
+            Availability::Available(_) => panic!("blob removed from da_checker, available"),
+            Availability::MissingComponents(block_root) => {
+                self.log(&format!("inserted blob to da_checker {block_root:?}"))
+            }
+        };
+    }
+
+    fn insert_block_to_processing_cache(&mut self, block: Arc<SignedBeaconBlock<E>>) {
+        self.harness
+            .chain
+            .reqresp_pre_import_cache
+            .write()
+            .insert(block.canonical_root(), block);
+    }
+
+    fn simulate_block_gossip_processing_becomes_invalid(&mut self, block_root: Hash256) {
+        self.harness
+            .chain
+            .reqresp_pre_import_cache
+            .write()
+            .remove(&block_root);
+
+        self.send_sync_message(SyncMessage::GossipBlockProcessResult {
+            block_root,
+            imported: false,
+        });
+    }
+
+    fn simulate_block_gossip_processing_becomes_valid_missing_components(
+        &mut self,
+        block: Arc<SignedBeaconBlock<E>>,
+    ) {
+        let block_root = block.canonical_root();
+        self.harness
+            .chain
+            .reqresp_pre_import_cache
+            .write()
+            .remove(&block_root);
+
+        self.insert_block_to_da_checker(block);
+
+        self.send_sync_message(SyncMessage::GossipBlockProcessResult {
+            block_root,
+            imported: false,
+        });
+    }
+}
+
+#[test]
+fn stable_rng() {
+    let mut rng = XorShiftRng::from_seed([42; 16]);
+    let (block, _) = generate_rand_block_and_blobs::<E>(ForkName::Base, NumBlobs::None, &mut rng);
+    assert_eq!(
+        block.canonical_root(),
+        Hash256::from_slice(
+            &hex::decode("adfd2e9e7a7976e8ccaed6eaf0257ed36a5b476732fee63ff44966602fd099ec")
+                .unwrap()
+        ),
+        "rng produces a consistent value"
+    );
 }
 
 #[test]
 fn test_single_block_lookup_happy_path() {
-    let response_type = ResponseType::Block;
-    let (mut bl, mut cx, mut rig) = TestRig::test_setup(false);
-    let fork_name = rig
-        .harness
-        .spec
-        .fork_name_at_slot::<E>(rig.harness.chain.slot().unwrap());
-
-    let block = rig.rand_block(fork_name);
-    let peer_id = PeerId::random();
+    let mut rig = TestRig::test_setup();
+    let block = rig.rand_block();
+    let peer_id = rig.new_connected_peer();
     let block_root = block.canonical_root();
     // Trigger the request
-    bl.search_block(block_root, &[peer_id], &mut cx);
-    let id = rig.expect_lookup_request(response_type);
-    // If we're in deneb, a blob request should have been triggered as well,
-    // we don't require a response because we're generateing 0-blob blocks in this test.
-    if matches!(fork_name, ForkName::Deneb | ForkName::Electra) {
-        let _ = rig.expect_lookup_request(ResponseType::Blob);
-    }
+    rig.trigger_unknown_block_from_attestation(block_root, peer_id);
+    let id = rig.expect_block_lookup_request(block_root);
 
     // The peer provides the correct block, should not be penalized. Now the block should be sent
     // for processing.
-    bl.single_lookup_response::<BlockRequestState<Current>>(
-        id,
-        peer_id,
-        Some(block.into()),
-        D,
-        &cx,
-    );
+    rig.single_lookup_block_response(id, peer_id, Some(block.into()));
     rig.expect_empty_network();
-    rig.expect_block_process(response_type);
+    rig.expect_block_process(ResponseType::Block);
 
     // The request should still be active.
-    assert_eq!(bl.single_block_lookups.len(), 1);
+    assert_eq!(rig.active_single_lookups_count(), 1);
 
     // Send the stream termination. Peer should have not been penalized, and the request removed
     // after processing.
-    bl.single_lookup_response::<BlockRequestState<Current>>(id, peer_id, None, D, &cx);
-    bl.single_block_component_processed::<BlockRequestState<Current>>(
-        id.id,
-        BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(block_root)),
-        &mut cx,
-    );
+    rig.single_lookup_block_response(id, peer_id, None);
+    rig.single_block_component_processed_imported(block_root);
     rig.expect_empty_network();
-    assert_eq!(bl.single_block_lookups.len(), 0);
+    rig.expect_no_active_lookups();
 }
 
+// Tests that if a peer does not respond with a block, we downscore and retry the block only
 #[test]
 fn test_single_block_lookup_empty_response() {
-    let response_type = ResponseType::Block;
-    let (mut bl, mut cx, mut rig) = TestRig::test_setup(false);
-    let fork_name = rig
-        .harness
-        .spec
-        .fork_name_at_slot::<E>(rig.harness.chain.slot().unwrap());
+    let mut r = TestRig::test_setup();
 
-    let block_hash = Hash256::random();
-    let peer_id = PeerId::random();
+    let block = r.rand_block();
+    let block_root = block.canonical_root();
+    let peer_id = r.new_connected_peer();
 
     // Trigger the request
-    bl.search_block(block_hash, &[peer_id], &mut cx);
-    let id = rig.expect_lookup_request(response_type);
-    // If we're in deneb, a blob request should have been triggered as well,
-    // we don't require a response because we're generateing 0-blob blocks in this test.
-    if matches!(fork_name, ForkName::Deneb | ForkName::Electra) {
-        let _ = rig.expect_lookup_request(ResponseType::Blob);
-    }
+    r.trigger_unknown_block_from_attestation(block_root, peer_id);
+    let id = r.expect_block_lookup_request(block_root);
 
     // The peer does not have the block. It should be penalized.
-    bl.single_lookup_response::<BlockRequestState<Current>>(id, peer_id, None, D, &cx);
-    rig.expect_penalty();
-
-    rig.expect_lookup_request(response_type); // it should be retried
+    r.single_lookup_block_response(id, peer_id, None);
+    r.expect_penalty(peer_id, "NoResponseReturned");
+    // it should be retried
+    let id = r.expect_block_lookup_request(block_root);
+    // Send the right block this time.
+    r.single_lookup_block_response(id, peer_id, Some(block.into()));
+    r.expect_block_process(ResponseType::Block);
+    r.single_block_component_processed_imported(block_root);
+    r.expect_no_active_lookups();
 }
 
 #[test]
 fn test_single_block_lookup_wrong_response() {
-    let response_type = ResponseType::Block;
-    let (mut bl, mut cx, mut rig) = TestRig::test_setup(false);
+    let mut rig = TestRig::test_setup();
 
-    let fork_name = rig
-        .harness
-        .spec
-        .fork_name_at_slot::<E>(rig.harness.chain.slot().unwrap());
     let block_hash = Hash256::random();
-    let peer_id = PeerId::random();
+    let peer_id = rig.new_connected_peer();
 
     // Trigger the request
-    bl.search_block(block_hash, &[peer_id], &mut cx);
-    let id = rig.expect_lookup_request(response_type);
-    // If we're in deneb, a blob request should have been triggered as well,
-    // we don't require a response because we're generateing 0-blob blocks in this test.
-    if matches!(fork_name, ForkName::Deneb | ForkName::Electra) {
-        let _ = rig.expect_lookup_request(ResponseType::Blob);
-    }
+    rig.trigger_unknown_block_from_attestation(block_hash, peer_id);
+    let id = rig.expect_block_lookup_request(block_hash);
 
     // Peer sends something else. It should be penalized.
-    let bad_block = rig.rand_block(fork_name);
-    bl.single_lookup_response::<BlockRequestState<Current>>(
-        id,
-        peer_id,
-        Some(bad_block.into()),
-        D,
-        &cx,
-    );
-    rig.expect_penalty();
-    rig.expect_lookup_request(response_type); // should be retried
+    let bad_block = rig.rand_block();
+    rig.single_lookup_block_response(id, peer_id, Some(bad_block.into()));
+    rig.expect_penalty(peer_id, "UnrequestedBlockRoot");
+    rig.expect_block_lookup_request(block_hash); // should be retried
 
     // Send the stream termination. This should not produce an additional penalty.
-    bl.single_lookup_response::<BlockRequestState<Current>>(id, peer_id, None, D, &cx);
+    rig.single_lookup_block_response(id, peer_id, None);
     rig.expect_empty_network();
 }
 
 #[test]
 fn test_single_block_lookup_failure() {
-    let response_type = ResponseType::Block;
-    let (mut bl, mut cx, mut rig) = TestRig::test_setup(false);
+    let mut rig = TestRig::test_setup();
 
-    let fork_name = rig
-        .harness
-        .spec
-        .fork_name_at_slot::<E>(rig.harness.chain.slot().unwrap());
     let block_hash = Hash256::random();
-    let peer_id = PeerId::random();
+    let peer_id = rig.new_connected_peer();
 
     // Trigger the request
-    bl.search_block(block_hash, &[peer_id], &mut cx);
-    let id = rig.expect_lookup_request(response_type);
-    // If we're in deneb, a blob request should have been triggered as well,
-    // we don't require a response because we're generateing 0-blob blocks in this test.
-    if matches!(fork_name, ForkName::Deneb | ForkName::Electra) {
-        let _ = rig.expect_lookup_request(ResponseType::Blob);
-    }
+    rig.trigger_unknown_block_from_attestation(block_hash, peer_id);
+    let id = rig.expect_block_lookup_request(block_hash);
 
     // The request fails. RPC failures are handled elsewhere so we should not penalize the peer.
-    bl.single_block_lookup_failed::<BlockRequestState<Current>>(
-        id,
-        &peer_id,
-        &cx,
-        RPCError::UnsupportedProtocol,
-    );
-    rig.expect_lookup_request(response_type);
+    rig.single_lookup_failed(id, peer_id, RPCError::UnsupportedProtocol);
+    rig.expect_block_lookup_request(block_hash);
     rig.expect_empty_network();
 }
 
 #[test]
 fn test_single_block_lookup_becomes_parent_request() {
-    let response_type = ResponseType::Block;
-    let (mut bl, mut cx, mut rig) = TestRig::test_setup(false);
+    let mut rig = TestRig::test_setup();
 
-    let fork_name = rig
-        .harness
-        .spec
-        .fork_name_at_slot::<E>(rig.harness.chain.slot().unwrap());
-    let block = Arc::new(rig.rand_block(fork_name));
-    let peer_id = PeerId::random();
+    let block = Arc::new(rig.rand_block());
+    let block_root = block.canonical_root();
+    let parent_root = block.parent_root();
+    let peer_id = rig.new_connected_peer();
 
     // Trigger the request
-    bl.search_block(block.canonical_root(), &[peer_id], &mut cx);
-    let id = rig.expect_lookup_request(response_type);
-    // If we're in deneb, a blob request should have been triggered as well,
-    // we don't require a response because we're generateing 0-blob blocks in this test.
-    if matches!(fork_name, ForkName::Deneb | ForkName::Electra) {
-        let _ = rig.expect_lookup_request(ResponseType::Blob);
-    }
+    rig.trigger_unknown_block_from_attestation(block.canonical_root(), peer_id);
+    let id = rig.expect_block_parent_request(block_root);
 
     // The peer provides the correct block, should not be penalized. Now the block should be sent
     // for processing.
-    bl.single_lookup_response::<BlockRequestState<Current>>(
-        id,
-        peer_id,
-        Some(block.clone()),
-        D,
-        &cx,
-    );
+    rig.single_lookup_block_response(id, peer_id, Some(block.clone()));
     rig.expect_empty_network();
-    rig.expect_block_process(response_type);
+    rig.expect_block_process(ResponseType::Block);
 
     // The request should still be active.
-    assert_eq!(bl.single_block_lookups.len(), 1);
+    assert_eq!(rig.active_single_lookups_count(), 1);
 
     // Send the stream termination. Peer should have not been penalized, and the request moved to a
     // parent request after processing.
-    bl.single_block_component_processed::<BlockRequestState<Current>>(
-        id.id,
+    rig.single_block_component_processed(
+        id.lookup_id,
         BlockError::ParentUnknown(RpcBlock::new_without_blobs(None, block)).into(),
-        &mut cx,
     );
-    assert_eq!(bl.single_block_lookups.len(), 1);
-    rig.expect_parent_request(response_type);
-    // If we're in deneb, a blob request should have been triggered as well,
-    // we don't require a response because we're generateing 0-blob blocks in this test.
-    if matches!(fork_name, ForkName::Deneb | ForkName::Electra) {
-        let _ = rig.expect_parent_request(ResponseType::Blob);
-    }
+    assert_eq!(rig.active_single_lookups_count(), 2); // 2 = current + parent
+    rig.expect_block_parent_request(parent_root);
     rig.expect_empty_network();
-    assert_eq!(bl.parent_lookups.len(), 1);
+    assert_eq!(rig.active_parent_lookups_count(), 1);
 }
 
 #[test]
 fn test_parent_lookup_happy_path() {
-    let response_type = ResponseType::Block;
-    let (mut bl, mut cx, mut rig) = TestRig::test_setup(false);
-
-    let fork_name = rig
-        .harness
-        .spec
-        .fork_name_at_slot::<E>(rig.harness.chain.slot().unwrap());
-    let parent = rig.rand_block(fork_name);
-    let block = rig.block_with_parent(parent.canonical_root(), fork_name);
-    let chain_hash = block.canonical_root();
-    let peer_id = PeerId::random();
-    let block_root = block.canonical_root();
-    let parent_root = block.parent_root();
-    let slot = block.slot();
+    let mut rig = TestRig::test_setup();
+
+    let (parent, block, parent_root, block_root) = rig.rand_block_and_parent();
+    let peer_id = rig.new_connected_peer();
 
     // Trigger the request
-    bl.search_parent(slot, block_root, parent_root, peer_id, &mut cx);
-    let id = rig.expect_parent_request(response_type);
-    // If we're in deneb, a blob request should have been triggered as well,
-    // we don't require a response because we're generateing 0-blob blocks in this test.
-    if matches!(fork_name, ForkName::Deneb | ForkName::Electra) {
-        let _ = rig.expect_parent_request(ResponseType::Blob);
-    }
+    rig.trigger_unknown_parent_block(peer_id, block.into());
+    let id = rig.expect_block_parent_request(parent_root);
 
     // Peer sends the right block, it should be sent for processing. Peer should not be penalized.
-    bl.parent_lookup_response::<BlockRequestState<Parent>>(
-        id,
-        peer_id,
-        Some(parent.into()),
-        D,
-        &cx,
-    );
-    rig.expect_block_process(response_type);
+    rig.parent_lookup_block_response(id, peer_id, Some(parent.into()));
+    // No request of blobs because the block has not data
+    rig.expect_empty_network();
+    rig.expect_block_process(ResponseType::Block);
     rig.expect_empty_network();
 
+    // Add peer to child lookup to prevent it being dropped
+    rig.trigger_unknown_block_from_attestation(block_root, peer_id);
     // Processing succeeds, now the rest of the chain should be sent for processing.
-    bl.parent_block_processed(
-        chain_hash,
+    rig.parent_block_processed(
+        block_root,
         BlockError::BlockIsAlreadyKnown(block_root).into(),
-        &mut cx,
     );
     rig.expect_parent_chain_process();
-    let process_result = BatchProcessResult::Success {
-        was_non_empty: true,
-    };
-    bl.parent_chain_processed(chain_hash, process_result, &cx);
-    assert_eq!(bl.parent_lookups.len(), 0);
+    rig.parent_chain_processed_success(block_root, &[]);
+    rig.expect_no_active_lookups_empty_network();
 }
 
 #[test]
 fn test_parent_lookup_wrong_response() {
-    let response_type = ResponseType::Block;
-    let (mut bl, mut cx, mut rig) = TestRig::test_setup(false);
-
-    let fork_name = rig
-        .harness
-        .spec
-        .fork_name_at_slot::<E>(rig.harness.chain.slot().unwrap());
-    let parent = rig.rand_block(fork_name);
-    let block = rig.block_with_parent(parent.canonical_root(), fork_name);
-    let chain_hash = block.canonical_root();
-    let peer_id = PeerId::random();
-    let block_root = block.canonical_root();
-    let parent_root = block.parent_root();
-    let slot = block.slot();
+    let mut rig = TestRig::test_setup();
+
+    let (parent, block, parent_root, block_root) = rig.rand_block_and_parent();
+    let peer_id = rig.new_connected_peer();
 
     // Trigger the request
-    bl.search_parent(slot, block_root, parent_root, peer_id, &mut cx);
-    let id1 = rig.expect_parent_request(response_type);
-    // If we're in deneb, a blob request should have been triggered as well,
-    // we don't require a response because we're generateing 0-blob blocks in this test.
-    if matches!(fork_name, ForkName::Deneb | ForkName::Electra) {
-        let _ = rig.expect_parent_request(ResponseType::Blob);
-    }
+    rig.trigger_unknown_parent_block(peer_id, block.into());
+    let id1 = rig.expect_block_parent_request(parent_root);
 
     // Peer sends the wrong block, peer should be penalized and the block re-requested.
-    let bad_block = rig.rand_block(fork_name);
-    bl.parent_lookup_response::<BlockRequestState<Parent>>(
-        id1,
-        peer_id,
-        Some(bad_block.into()),
-        D,
-        &cx,
-    );
-    rig.expect_penalty();
-    let id2 = rig.expect_parent_request(response_type);
+    let bad_block = rig.rand_block();
+    rig.parent_lookup_block_response(id1, peer_id, Some(bad_block.into()));
+    rig.expect_penalty(peer_id, "UnrequestedBlockRoot");
+    let id2 = rig.expect_block_parent_request(parent_root);
 
     // Send the stream termination for the first request. This should not produce extra penalties.
-    bl.parent_lookup_response::<BlockRequestState<Parent>>(id1, peer_id, None, D, &cx);
+    rig.parent_lookup_block_response(id1, peer_id, None);
     rig.expect_empty_network();
 
     // Send the right block this time.
-    bl.parent_lookup_response::<BlockRequestState<Parent>>(
-        id2,
-        peer_id,
-        Some(parent.into()),
-        D,
-        &cx,
-    );
-    rig.expect_block_process(response_type);
-
-    // Processing succeeds, now the rest of the chain should be sent for processing.
-    bl.parent_block_processed(
-        chain_hash,
-        BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(block_root)),
-        &mut cx,
-    );
-    rig.expect_parent_chain_process();
-    let process_result = BatchProcessResult::Success {
-        was_non_empty: true,
-    };
-    bl.parent_chain_processed(chain_hash, process_result, &cx);
-    assert_eq!(bl.parent_lookups.len(), 0);
-}
-
-#[test]
-fn test_parent_lookup_empty_response() {
-    let response_type = ResponseType::Block;
-    let (mut bl, mut cx, mut rig) = TestRig::test_setup(false);
-
-    let fork_name = rig
-        .harness
-        .spec
-        .fork_name_at_slot::<E>(rig.harness.chain.slot().unwrap());
-    let parent = rig.rand_block(fork_name);
-    let block = rig.block_with_parent(parent.canonical_root(), fork_name);
-    let chain_hash = block.canonical_root();
-    let peer_id = PeerId::random();
-    let block_root = block.canonical_root();
-    let parent_root = block.parent_root();
-    let slot = block.slot();
-
-    // Trigger the request
-    bl.search_parent(slot, block_root, parent_root, peer_id, &mut cx);
-    let id1 = rig.expect_parent_request(response_type);
-    // If we're in deneb, a blob request should have been triggered as well,
-    // we don't require a response because we're generateing 0-blob blocks in this test.
-    if matches!(fork_name, ForkName::Deneb | ForkName::Electra) {
-        let _ = rig.expect_parent_request(ResponseType::Blob);
-    }
-
-    // Peer sends an empty response, peer should be penalized and the block re-requested.
-    bl.parent_lookup_response::<BlockRequestState<Parent>>(id1, peer_id, None, D, &cx);
-    rig.expect_penalty();
-    let id2 = rig.expect_parent_request(response_type);
-
-    // Send the right block this time.
-    bl.parent_lookup_response::<BlockRequestState<Parent>>(
-        id2,
-        peer_id,
-        Some(parent.into()),
-        D,
-        &cx,
-    );
-    rig.expect_block_process(response_type);
+    rig.parent_lookup_block_response(id2, peer_id, Some(parent.into()));
+    rig.expect_block_process(ResponseType::Block);
 
+    // Add peer to child lookup to prevent it being dropped
+    rig.trigger_unknown_block_from_attestation(block_root, peer_id);
     // Processing succeeds, now the rest of the chain should be sent for processing.
-    bl.parent_block_processed(
-        chain_hash,
-        BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(block_root)),
-        &mut cx,
-    );
+    rig.parent_block_processed_imported(block_root);
     rig.expect_parent_chain_process();
-    let process_result = BatchProcessResult::Success {
-        was_non_empty: true,
-    };
-    bl.parent_chain_processed(chain_hash, process_result, &cx);
-    assert_eq!(bl.parent_lookups.len(), 0);
+    rig.parent_chain_processed_success(block_root, &[]);
+    rig.expect_no_active_lookups_empty_network();
 }
 
 #[test]
 fn test_parent_lookup_rpc_failure() {
-    let response_type = ResponseType::Block;
-    let (mut bl, mut cx, mut rig) = TestRig::test_setup(false);
-
-    let fork_name = rig
-        .harness
-        .spec
-        .fork_name_at_slot::<E>(rig.harness.chain.slot().unwrap());
-    let parent = rig.rand_block(fork_name);
-    let block = rig.block_with_parent(parent.canonical_root(), fork_name);
-    let chain_hash = block.canonical_root();
-    let peer_id = PeerId::random();
-    let block_root = block.canonical_root();
-    let parent_root = block.parent_root();
-    let slot = block.slot();
+    let mut rig = TestRig::test_setup();
+
+    let (parent, block, parent_root, block_root) = rig.rand_block_and_parent();
+    let peer_id = rig.new_connected_peer();
 
     // Trigger the request
-    bl.search_parent(slot, block_root, parent_root, peer_id, &mut cx);
-    let id1 = rig.expect_parent_request(response_type);
-    // If we're in deneb, a blob request should have been triggered as well,
-    // we don't require a response because we're generateing 0-blob blocks in this test.
-    if matches!(fork_name, ForkName::Deneb | ForkName::Electra) {
-        let _ = rig.expect_parent_request(ResponseType::Blob);
-    }
+    rig.trigger_unknown_parent_block(peer_id, block.into());
+    let id = rig.expect_block_parent_request(parent_root);
 
     // The request fails. It should be tried again.
-    bl.parent_lookup_failed::<BlockRequestState<Parent>>(
-        id1,
-        peer_id,
-        &cx,
-        RPCError::ErrorResponse(
-            RPCResponseErrorCode::ResourceUnavailable,
-            "older than deneb".into(),
-        ),
-    );
-    let id2 = rig.expect_parent_request(response_type);
+    rig.parent_lookup_failed_unavailable(id, peer_id);
+    let id = rig.expect_block_parent_request(parent_root);
 
     // Send the right block this time.
-    bl.parent_lookup_response::<BlockRequestState<Parent>>(
-        id2,
-        peer_id,
-        Some(parent.into()),
-        D,
-        &cx,
-    );
-    rig.expect_block_process(response_type);
+    rig.parent_lookup_block_response(id, peer_id, Some(parent.into()));
+    rig.expect_block_process(ResponseType::Block);
 
+    // Add peer to child lookup to prevent it being dropped
+    rig.trigger_unknown_block_from_attestation(block_root, peer_id);
     // Processing succeeds, now the rest of the chain should be sent for processing.
-    bl.parent_block_processed(
-        chain_hash,
-        BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(block_root)),
-        &mut cx,
-    );
+    rig.parent_block_processed_imported(block_root);
     rig.expect_parent_chain_process();
-    let process_result = BatchProcessResult::Success {
-        was_non_empty: true,
-    };
-    bl.parent_chain_processed(chain_hash, process_result, &cx);
-    assert_eq!(bl.parent_lookups.len(), 0);
+    rig.parent_chain_processed_success(block_root, &[]);
+    rig.expect_no_active_lookups_empty_network();
 }
 
 #[test]
 fn test_parent_lookup_too_many_attempts() {
-    let response_type = ResponseType::Block;
-    let (mut bl, mut cx, mut rig) = TestRig::test_setup(false);
-
-    let fork_name = rig
-        .harness
-        .spec
-        .fork_name_at_slot::<E>(rig.harness.chain.slot().unwrap());
-    let parent = rig.rand_block(fork_name);
-    let block = rig.block_with_parent(parent.canonical_root(), fork_name);
-    let peer_id = PeerId::random();
-    let block_root = block.canonical_root();
+    let mut rig = TestRig::test_setup();
+
+    let block = rig.rand_block();
     let parent_root = block.parent_root();
-    let slot = block.slot();
+    let peer_id = rig.new_connected_peer();
 
     // Trigger the request
-    bl.search_parent(slot, block_root, parent_root, peer_id, &mut cx);
-    for i in 1..=parent_lookup::PARENT_FAIL_TOLERANCE {
-        let id = rig.expect_parent_request(response_type);
-        // If we're in deneb, a blob request should have been triggered as well,
-        // we don't require a response because we're generateing 0-blob blocks in this test.
-        if matches!(fork_name, ForkName::Deneb | ForkName::Electra) && i == 1 {
-            let _ = rig.expect_parent_request(ResponseType::Blob);
-        }
-        match i % 2 {
+    rig.trigger_unknown_parent_block(peer_id, block.into());
+    for i in 1..=PARENT_FAIL_TOLERANCE {
+        let id = rig.expect_block_parent_request(parent_root);
+        // Blobs are only requested in the first iteration as this test only retries blocks
+
+        if i % 2 == 0 {
             // make sure every error is accounted for
-            0 => {
-                // The request fails. It should be tried again.
-                bl.parent_lookup_failed::<BlockRequestState<Parent>>(
-                    id,
-                    peer_id,
-                    &cx,
-                    RPCError::ErrorResponse(
-                        RPCResponseErrorCode::ResourceUnavailable,
-                        "older than deneb".into(),
-                    ),
-                );
-            }
-            _ => {
-                // Send a bad block this time. It should be tried again.
-                let bad_block = rig.rand_block(fork_name);
-                bl.parent_lookup_response::<BlockRequestState<Parent>>(
-                    id,
-                    peer_id,
-                    Some(bad_block.into()),
-                    D,
-                    &cx,
-                );
-                // Send the stream termination
-
-                // Note, previously we would send the same lookup id with a stream terminator,
-                // we'd ignore it because we'd intrepret it as an unrequested response, since
-                // we already got one response for the block. I'm not sure what the intent is
-                // for having this stream terminator line in this test at all. Receiving an invalid
-                // block and a stream terminator with the same Id now results in two failed attempts,
-                // I'm unsure if this is how it should behave?
-                //
-                bl.parent_lookup_response::<BlockRequestState<Parent>>(id, peer_id, None, D, &cx);
-                rig.expect_penalty();
-            }
-        }
-        if i < parent_lookup::PARENT_FAIL_TOLERANCE {
-            assert_eq!(
-                bl.parent_lookups[0]
-                    .current_parent_request
-                    .block_request_state
-                    .state
-                    .failed_attempts(),
-                dbg!(i)
-            );
+            // The request fails. It should be tried again.
+            rig.parent_lookup_failed_unavailable(id, peer_id);
+        } else {
+            // Send a bad block this time. It should be tried again.
+            let bad_block = rig.rand_block();
+            rig.parent_lookup_block_response(id, peer_id, Some(bad_block.into()));
+            // Send the stream termination
+
+            // Note, previously we would send the same lookup id with a stream terminator,
+            // we'd ignore it because we'd intrepret it as an unrequested response, since
+            // we already got one response for the block. I'm not sure what the intent is
+            // for having this stream terminator line in this test at all. Receiving an invalid
+            // block and a stream terminator with the same Id now results in two failed attempts,
+            // I'm unsure if this is how it should behave?
+            //
+            rig.parent_lookup_block_response(id, peer_id, None);
+            rig.expect_penalty(peer_id, "UnrequestedBlockRoot");
         }
     }
 
-    assert_eq!(bl.parent_lookups.len(), 0);
+    rig.expect_no_active_lookups_empty_network();
 }
 
 #[test]
 fn test_parent_lookup_too_many_download_attempts_no_blacklist() {
-    let response_type = ResponseType::Block;
-    let (mut bl, mut cx, mut rig) = TestRig::test_setup(false);
-
-    let fork_name = rig
-        .harness
-        .spec
-        .fork_name_at_slot::<E>(rig.harness.chain.slot().unwrap());
-    let parent = rig.rand_block(fork_name);
-    let block = rig.block_with_parent(parent.canonical_root(), fork_name);
-    let block_hash = block.canonical_root();
-    let peer_id = PeerId::random();
-    let block_root = block.canonical_root();
-    let parent_root = block.parent_root();
-    let slot = block.slot();
+    let mut rig = TestRig::test_setup();
+
+    let (parent, block, parent_root, block_root) = rig.rand_block_and_parent();
+    let peer_id = rig.new_connected_peer();
 
     // Trigger the request
-    bl.search_parent(slot, block_root, parent_root, peer_id, &mut cx);
-    for i in 1..=parent_lookup::PARENT_FAIL_TOLERANCE {
-        assert!(!bl.failed_chains.contains(&block_hash));
-        let id = rig.expect_parent_request(response_type);
-        // If we're in deneb, a blob request should have been triggered as well,
-        // we don't require a response because we're generateing 0-blob blocks in this test.
-        if matches!(fork_name, ForkName::Deneb | ForkName::Electra) && i == 1 {
-            let _ = rig.expect_parent_request(ResponseType::Blob);
-        }
+    rig.trigger_unknown_parent_block(peer_id, block.into());
+    for i in 1..=PARENT_FAIL_TOLERANCE {
+        assert!(!rig.failed_chains_contains(&block_root));
+        let id = rig.expect_block_parent_request(parent_root);
         if i % 2 != 0 {
             // The request fails. It should be tried again.
-            bl.parent_lookup_failed::<BlockRequestState<Parent>>(
-                id,
-                peer_id,
-                &cx,
-                RPCError::ErrorResponse(
-                    RPCResponseErrorCode::ResourceUnavailable,
-                    "older than deneb".into(),
-                ),
-            );
+            rig.parent_lookup_failed_unavailable(id, peer_id);
         } else {
             // Send a bad block this time. It should be tried again.
-            let bad_block = rig.rand_block(fork_name);
-            bl.parent_lookup_response::<BlockRequestState<Parent>>(
-                id,
-                peer_id,
-                Some(bad_block.into()),
-                D,
-                &cx,
-            );
-            rig.expect_penalty();
-        }
-        if i < parent_lookup::PARENT_FAIL_TOLERANCE {
-            assert_eq!(
-                bl.parent_lookups[0]
-                    .current_parent_request
-                    .block_request_state
-                    .state
-                    .failed_attempts(),
-                dbg!(i)
-            );
+            let bad_block = rig.rand_block();
+            rig.parent_lookup_block_response(id, peer_id, Some(bad_block.into()));
+            rig.expect_penalty(peer_id, "UnrequestedBlockRoot");
         }
     }
 
-    assert_eq!(bl.parent_lookups.len(), 0);
-    assert!(!bl.failed_chains.contains(&block_hash));
-    assert!(!bl.failed_chains.contains(&parent.canonical_root()));
+    assert!(!rig.failed_chains_contains(&block_root));
+    assert!(!rig.failed_chains_contains(&parent.canonical_root()));
+    rig.expect_no_active_lookups_empty_network();
 }
 
 #[test]
 fn test_parent_lookup_too_many_processing_attempts_must_blacklist() {
-    let response_type = ResponseType::Block;
-    const PROCESSING_FAILURES: u8 = parent_lookup::PARENT_FAIL_TOLERANCE / 2 + 1;
-    let (mut bl, mut cx, mut rig) = TestRig::test_setup(false);
-    let fork_name = rig
-        .harness
-        .spec
-        .fork_name_at_slot::<E>(rig.harness.chain.slot().unwrap());
-
-    let parent = Arc::new(rig.rand_block(fork_name));
-    let block = rig.block_with_parent(parent.canonical_root(), fork_name);
-    let peer_id = PeerId::random();
-    let block_root = block.canonical_root();
-    let parent_root = block.parent_root();
-    let slot = block.slot();
+    const PROCESSING_FAILURES: u8 = PARENT_FAIL_TOLERANCE / 2 + 1;
+    let mut rig = TestRig::test_setup();
+    let (parent, block, parent_root, block_root) = rig.rand_block_and_parent();
+    let peer_id = rig.new_connected_peer();
 
     // Trigger the request
-    bl.search_parent(slot, block_root, parent_root, peer_id, &mut cx);
+    rig.trigger_unknown_parent_block(peer_id, block.into());
 
-    // Fail downloading the block
-    for i in 0..(parent_lookup::PARENT_FAIL_TOLERANCE - PROCESSING_FAILURES) {
-        let id = rig.expect_parent_request(response_type);
-        // If we're in deneb, a blob request should have been triggered as well,
-        // we don't require a response because we're generateing 0-blob blocks in this test.
-        if matches!(fork_name, ForkName::Deneb | ForkName::Electra) && i == 0 {
-            let _ = rig.expect_parent_request(ResponseType::Blob);
-        }
+    rig.log("Fail downloading the block");
+    for _ in 0..(PARENT_FAIL_TOLERANCE - PROCESSING_FAILURES) {
+        let id = rig.expect_block_parent_request(parent_root);
         // The request fails. It should be tried again.
-        bl.parent_lookup_failed::<BlockRequestState<Parent>>(
-            id,
-            peer_id,
-            &cx,
-            RPCError::ErrorResponse(
-                RPCResponseErrorCode::ResourceUnavailable,
-                "older than deneb".into(),
-            ),
-        );
+        rig.parent_lookup_failed_unavailable(id, peer_id);
     }
 
-    // Now fail processing a block in the parent request
-    for i in 0..PROCESSING_FAILURES {
-        let id = dbg!(rig.expect_parent_request(response_type));
-        if matches!(fork_name, ForkName::Deneb | ForkName::Electra) && i != 0 {
-            let _ = rig.expect_parent_request(ResponseType::Blob);
-        }
-        // If we're in deneb, a blob request should have been triggered as well,
-        // we don't require a response because we're generateing 0-blob blocks in this test.
-        assert!(!bl.failed_chains.contains(&block_root));
+    rig.log("Now fail processing a block in the parent request");
+    for _ in 0..PROCESSING_FAILURES {
+        let id = rig.expect_block_parent_request(parent_root);
+        // Blobs are only requested in the previous first iteration as this test only retries blocks
+        rig.assert_not_failed_chain(block_root);
         // send the right parent but fail processing
-        bl.parent_lookup_response::<BlockRequestState<Parent>>(
-            id,
-            peer_id,
-            Some(parent.clone()),
-            D,
-            &cx,
-        );
-        bl.parent_block_processed(block_root, BlockError::InvalidSignature.into(), &mut cx);
-        bl.parent_lookup_response::<BlockRequestState<Parent>>(id, peer_id, None, D, &cx);
-        rig.expect_penalty();
+        rig.parent_lookup_block_response(id, peer_id, Some(parent.clone().into()));
+        rig.parent_block_processed(block_root, BlockError::InvalidSignature.into());
+        rig.parent_lookup_block_response(id, peer_id, None);
+        rig.expect_penalty(peer_id, "lookup_block_processing_failure");
     }
 
-    assert!(bl.failed_chains.contains(&block_root));
-    assert_eq!(bl.parent_lookups.len(), 0);
+    rig.assert_not_failed_chain(block_root);
+    rig.expect_no_active_lookups_empty_network();
 }
 
 #[test]
 fn test_parent_lookup_too_deep() {
-    let response_type = ResponseType::Block;
-    let (mut bl, mut cx, mut rig) = TestRig::test_setup(false);
-    let fork_name = rig
-        .harness
-        .spec
-        .fork_name_at_slot::<E>(rig.harness.chain.slot().unwrap());
-    let mut blocks =
-        Vec::<Arc<SignedBeaconBlock<E>>>::with_capacity(parent_lookup::PARENT_DEPTH_TOLERANCE);
-    while blocks.len() < parent_lookup::PARENT_DEPTH_TOLERANCE {
-        let parent = blocks
-            .last()
-            .map(|b| b.canonical_root())
-            .unwrap_or_else(Hash256::random);
-        let block = Arc::new(rig.block_with_parent(parent, fork_name));
-        blocks.push(block);
-    }
-
-    let peer_id = PeerId::random();
+    let mut rig = TestRig::test_setup();
+    let mut blocks = rig.rand_blockchain(PARENT_DEPTH_TOLERANCE);
+
+    let peer_id = rig.new_connected_peer();
     let trigger_block = blocks.pop().unwrap();
     let chain_hash = trigger_block.canonical_root();
-    let trigger_block_root = trigger_block.canonical_root();
-    let trigger_parent_root = trigger_block.parent_root();
-    let trigger_slot = trigger_block.slot();
-    bl.search_parent(
-        trigger_slot,
-        trigger_block_root,
-        trigger_parent_root,
-        peer_id,
-        &mut cx,
-    );
+    rig.trigger_unknown_parent_block(peer_id, trigger_block);
 
     for block in blocks.into_iter().rev() {
-        let id = rig.expect_parent_request(response_type);
-        // If we're in deneb, a blob request should have been triggered as well,
-        // we don't require a response because we're generateing 0-blob blocks in this test.
-        if matches!(fork_name, ForkName::Deneb | ForkName::Electra) {
-            let _ = rig.expect_parent_request(ResponseType::Blob);
-        }
+        let id = rig.expect_block_parent_request(block.canonical_root());
         // the block
-        bl.parent_lookup_response::<BlockRequestState<Parent>>(
-            id,
-            peer_id,
-            Some(block.clone()),
-            D,
-            &cx,
-        );
+        rig.parent_lookup_block_response(id, peer_id, Some(block.clone()));
         // the stream termination
-        bl.parent_lookup_response::<BlockRequestState<Parent>>(id, peer_id, None, D, &cx);
+        rig.parent_lookup_block_response(id, peer_id, None);
         // the processing request
-        rig.expect_block_process(response_type);
+        rig.expect_block_process(ResponseType::Block);
         // the processing result
-        bl.parent_block_processed(
+        rig.parent_block_processed(
             chain_hash,
             BlockError::ParentUnknown(RpcBlock::new_without_blobs(None, block)).into(),
-            &mut cx,
         )
     }
 
-    rig.expect_penalty();
-    assert!(bl.failed_chains.contains(&chain_hash));
+    rig.expect_penalty(peer_id, "chain_too_long");
+    assert!(rig.failed_chains_contains(&chain_hash));
 }
 
 #[test]
-fn test_parent_lookup_disconnection() {
-    let (mut bl, mut cx, mut rig) = TestRig::test_setup(false);
-    let peer_id = PeerId::random();
-    let fork_name = rig
-        .harness
-        .spec
-        .fork_name_at_slot::<E>(rig.harness.chain.slot().unwrap());
-    let trigger_block = rig.rand_block(fork_name);
-    let trigger_block_root = trigger_block.canonical_root();
-    let trigger_parent_root = trigger_block.parent_root();
-    let trigger_slot = trigger_block.slot();
-    bl.search_parent(
-        trigger_slot,
-        trigger_block_root,
-        trigger_parent_root,
-        peer_id,
-        &mut cx,
-    );
+fn test_parent_lookup_disconnection_no_peers_left() {
+    let mut rig = TestRig::test_setup();
+    let peer_id = rig.new_connected_peer();
+    let trigger_block = rig.rand_block();
+    rig.trigger_unknown_parent_block(peer_id, trigger_block.into());
+
+    rig.peer_disconnected(peer_id);
+    rig.expect_no_active_lookups();
+}
 
-    bl.peer_disconnected(&peer_id, &mut cx);
-    assert!(bl.parent_lookups.is_empty());
+#[test]
+fn test_lookup_disconnection_peer_left() {
+    let mut rig = TestRig::test_setup();
+    let peer_ids = (0..2).map(|_| rig.new_connected_peer()).collect::<Vec<_>>();
+    let block_root = Hash256::random();
+    // lookup should have two peers associated with the same block
+    for peer_id in peer_ids.iter() {
+        rig.trigger_unknown_block_from_attestation(block_root, *peer_id);
+    }
+    // Disconnect the first peer only, which is the one handling the request
+    rig.peer_disconnected(*peer_ids.first().unwrap());
+    rig.assert_single_lookups_count(1);
+}
+
+#[test]
+fn test_skip_creating_failed_parent_lookup() {
+    let mut rig = TestRig::test_setup();
+    let (_, block, parent_root, _) = rig.rand_block_and_parent();
+    let peer_id = rig.new_connected_peer();
+    rig.insert_failed_chain(parent_root);
+    rig.trigger_unknown_parent_block(peer_id, block.into());
+    // Expect single penalty for peer, despite dropping two lookups
+    rig.expect_single_penalty(peer_id, "failed_chain");
+    // Both current and parent lookup should be rejected
+    rig.expect_no_active_lookups();
 }
 
 #[test]
 fn test_single_block_lookup_ignored_response() {
-    let response_type = ResponseType::Block;
-    let (mut bl, mut cx, mut rig) = TestRig::test_setup(false);
+    let mut rig = TestRig::test_setup();
 
-    let fork_name = rig
-        .harness
-        .spec
-        .fork_name_at_slot::<E>(rig.harness.chain.slot().unwrap());
-    let block = rig.rand_block(fork_name);
-    let peer_id = PeerId::random();
+    let block = rig.rand_block();
+    let peer_id = rig.new_connected_peer();
 
     // Trigger the request
-    bl.search_block(block.canonical_root(), &[peer_id], &mut cx);
-    let id = rig.expect_lookup_request(response_type);
-    // If we're in deneb, a blob request should have been triggered as well,
-    // we don't require a response because we're generateing 0-blob blocks in this test.
-    if matches!(fork_name, ForkName::Deneb | ForkName::Electra) {
-        let _ = rig.expect_lookup_request(ResponseType::Blob);
-    }
+    rig.trigger_unknown_block_from_attestation(block.canonical_root(), peer_id);
+    let id = rig.expect_block_lookup_request(block.canonical_root());
 
     // The peer provides the correct block, should not be penalized. Now the block should be sent
     // for processing.
-    bl.single_lookup_response::<BlockRequestState<Current>>(
-        id,
-        peer_id,
-        Some(block.into()),
-        D,
-        &cx,
-    );
+    rig.single_lookup_block_response(id, peer_id, Some(block.into()));
     rig.expect_empty_network();
-    rig.expect_block_process(response_type);
+    rig.expect_block_process(ResponseType::Block);
 
     // The request should still be active.
-    assert_eq!(bl.single_block_lookups.len(), 1);
+    assert_eq!(rig.active_single_lookups_count(), 1);
 
     // Send the stream termination. Peer should have not been penalized, and the request removed
     // after processing.
-    bl.single_lookup_response::<BlockRequestState<Current>>(id, peer_id, None, D, &cx);
+    rig.single_lookup_block_response(id, peer_id, None);
     // Send an Ignored response, the request should be dropped
-    bl.single_block_component_processed::<BlockRequestState<Current>>(
-        id.id,
-        BlockProcessingResult::Ignored,
-        &mut cx,
-    );
-    rig.expect_empty_network();
-    assert_eq!(bl.single_block_lookups.len(), 0);
+    rig.single_block_component_processed(id.lookup_id, BlockProcessingResult::Ignored);
+    rig.expect_no_active_lookups_empty_network();
 }
 
 #[test]
 fn test_parent_lookup_ignored_response() {
-    let response_type = ResponseType::Block;
-    let (mut bl, mut cx, mut rig) = TestRig::test_setup(false);
-
-    let fork_name = rig
-        .harness
-        .spec
-        .fork_name_at_slot::<E>(rig.harness.chain.slot().unwrap());
-    let parent = rig.rand_block(fork_name);
-    let block = rig.block_with_parent(parent.canonical_root(), fork_name);
-    let chain_hash = block.canonical_root();
-    let peer_id = PeerId::random();
-    let block_root = block.canonical_root();
-    let parent_root = block.parent_root();
-    let slot = block.slot();
+    let mut rig = TestRig::test_setup();
 
-    // Trigger the request
-    bl.search_parent(slot, block_root, parent_root, peer_id, &mut cx);
-    let id = rig.expect_parent_request(response_type);
+    let (parent, block, parent_root, block_root) = rig.rand_block_and_parent();
+    let peer_id = rig.new_connected_peer();
 
-    // If we're in deneb, a blob request should have been triggered as well,
-    // we don't require a response because we're generateing 0-blob blocks in this test.
-    if matches!(fork_name, ForkName::Deneb | ForkName::Electra) {
-        let _ = rig.expect_parent_request(ResponseType::Blob);
-    }
+    // Trigger the request
+    rig.trigger_unknown_parent_block(peer_id, block.clone().into());
+    let id = rig.expect_block_parent_request(parent_root);
+    // Note: single block lookup for current `block` does not trigger any request because it does
+    // not have blobs, and the block is already cached
 
     // Peer sends the right block, it should be sent for processing. Peer should not be penalized.
-    bl.parent_lookup_response::<BlockRequestState<Parent>>(
-        id,
-        peer_id,
-        Some(parent.into()),
-        D,
-        &cx,
-    );
-    rig.expect_block_process(response_type);
+    rig.parent_lookup_block_response(id, peer_id, Some(parent.into()));
+    rig.expect_block_process(ResponseType::Block);
     rig.expect_empty_network();
 
     // Return an Ignored result. The request should be dropped
-    bl.parent_block_processed(chain_hash, BlockProcessingResult::Ignored, &mut cx);
+    rig.parent_block_processed(block_root, BlockProcessingResult::Ignored);
     rig.expect_empty_network();
-    assert_eq!(bl.parent_lookups.len(), 0);
+    rig.expect_no_active_lookups();
 }
 
 /// This is a regression test.
 #[test]
 fn test_same_chain_race_condition() {
-    let response_type = ResponseType::Block;
-    let (mut bl, mut cx, mut rig) = TestRig::test_setup(true);
+    let mut rig = TestRig::test_setup();
 
-    let fork_name = rig
-        .harness
-        .spec
-        .fork_name_at_slot::<E>(rig.harness.chain.slot().unwrap());
-    #[track_caller]
-    fn parent_lookups_consistency(bl: &BlockLookups<T>) {
-        let hashes: Vec<_> = bl
-            .parent_lookups
-            .iter()
-            .map(|req| req.chain_hash())
-            .collect();
-        let expected = hashes.len();
-        assert_eq!(
-            expected,
-            hashes
-                .into_iter()
-                .collect::<std::collections::HashSet<_>>()
-                .len(),
-            "duplicated chain hashes in parent queue"
-        )
-    }
     // if we use one or two blocks it will match on the hash or the parent hash, so make a longer
     // chain.
     let depth = 4;
-    let mut blocks = Vec::<Arc<SignedBeaconBlock<E>>>::with_capacity(depth);
-    while blocks.len() < depth {
-        let parent = blocks
-            .last()
-            .map(|b| b.canonical_root())
-            .unwrap_or_else(Hash256::random);
-        let block = Arc::new(rig.block_with_parent(parent, fork_name));
-        blocks.push(block);
-    }
-
-    let peer_id = PeerId::random();
+    let mut blocks = rig.rand_blockchain(depth);
+    let peer_id = rig.new_connected_peer();
     let trigger_block = blocks.pop().unwrap();
     let chain_hash = trigger_block.canonical_root();
-    let trigger_block_root = trigger_block.canonical_root();
-    let trigger_parent_root = trigger_block.parent_root();
-    let trigger_slot = trigger_block.slot();
-    bl.search_parent(
-        trigger_slot,
-        trigger_block_root,
-        trigger_parent_root,
-        peer_id,
-        &mut cx,
-    );
+    rig.trigger_unknown_parent_block(peer_id, trigger_block.clone());
 
-    for (i, block) in blocks.into_iter().rev().enumerate() {
-        let id = rig.expect_parent_request(response_type);
-        // If we're in deneb, a blob request should have been triggered as well,
-        // we don't require a response because we're generateing 0-blob blocks in this test.
-        if matches!(fork_name, ForkName::Deneb | ForkName::Electra) {
-            let _ = rig.expect_parent_request(ResponseType::Blob);
-        }
+    for (i, block) in blocks.clone().into_iter().rev().enumerate() {
+        let id = rig.expect_block_parent_request(block.canonical_root());
         // the block
-        bl.parent_lookup_response::<BlockRequestState<Parent>>(
-            id,
-            peer_id,
-            Some(block.clone()),
-            D,
-            &cx,
-        );
+        rig.parent_lookup_block_response(id, peer_id, Some(block.clone()));
         // the stream termination
-        bl.parent_lookup_response::<BlockRequestState<Parent>>(id, peer_id, None, D, &cx);
+        rig.parent_lookup_block_response(id, peer_id, None);
         // the processing request
-        rig.expect_block_process(response_type);
+        rig.expect_block_process(ResponseType::Block);
         // the processing result
         if i + 2 == depth {
-            // one block was removed
-            bl.parent_block_processed(
+            rig.log(&format!("Block {i} was removed and is already known"));
+            rig.parent_block_processed(
                 chain_hash,
                 BlockError::BlockIsAlreadyKnown(block.canonical_root()).into(),
-                &mut cx,
             )
         } else {
-            bl.parent_block_processed(
+            rig.log(&format!("Block {i} ParentUnknown"));
+            rig.parent_block_processed(
                 chain_hash,
                 BlockError::ParentUnknown(RpcBlock::new_without_blobs(None, block)).into(),
-                &mut cx,
             )
         }
-        parent_lookups_consistency(&bl)
     }
 
-    // Processing succeeds, now the rest of the chain should be sent for processing.
-    rig.expect_parent_chain_process();
-
     // Try to get this block again while the chain is being processed. We should not request it again.
-    let peer_id = PeerId::random();
-    let trigger_block_root = trigger_block.canonical_root();
-    let trigger_parent_root = trigger_block.parent_root();
-    let trigger_slot = trigger_block.slot();
-    bl.search_parent(
-        trigger_slot,
-        trigger_block_root,
-        trigger_parent_root,
-        peer_id,
-        &mut cx,
-    );
-    parent_lookups_consistency(&bl);
+    let peer_id = rig.new_connected_peer();
+    rig.trigger_unknown_parent_block(peer_id, trigger_block.clone());
+    rig.expect_empty_network();
+
+    // Add a peer to the tip child lookup which has zero peers
+    rig.trigger_unknown_block_from_attestation(trigger_block.canonical_root(), peer_id);
+
+    rig.log("Processing succeeds, now the rest of the chain should be sent for processing.");
+    for block in blocks.iter().skip(1).chain(&[trigger_block]) {
+        rig.expect_parent_chain_process();
+        rig.single_block_component_processed_imported(block.canonical_root());
+    }
+    rig.expect_no_active_lookups_empty_network();
+}
+
+#[test]
+fn block_in_da_checker_skips_download() {
+    let Some(mut r) = TestRig::test_setup_after_deneb() else {
+        return;
+    };
+    let (block, blobs) = r.rand_block_and_blobs(NumBlobs::Number(1));
+    let block_root = block.canonical_root();
+    let peer_id = r.new_connected_peer();
+    r.insert_block_to_da_checker(block.into());
+    r.trigger_unknown_block_from_attestation(block_root, peer_id);
+    // Should not trigger block request
+    let id = r.expect_blob_lookup_request(block_root);
+    r.expect_empty_network();
+    // Resolve blob and expect lookup completed
+    r.complete_single_lookup_blob_lookup_valid(id, peer_id, blobs, true);
+    r.expect_no_active_lookups();
+}
+
+#[test]
+fn block_in_processing_cache_becomes_invalid() {
+    let Some(mut r) = TestRig::test_setup_after_deneb() else {
+        return;
+    };
+    let (block, blobs) = r.rand_block_and_blobs(NumBlobs::Number(1));
+    let block_root = block.canonical_root();
+    let peer_id = r.new_connected_peer();
+    r.insert_block_to_processing_cache(block.clone().into());
+    r.trigger_unknown_block_from_attestation(block_root, peer_id);
+    // Should not trigger block request
+    r.expect_empty_network();
+    // Simulate invalid block, removing it from processing cache
+    r.simulate_block_gossip_processing_becomes_invalid(block_root);
+    // Should download block, then issue blobs request
+    r.complete_lookup_block_download(block);
+    let id = r.expect_blob_lookup_request(block_root);
+    r.complete_lookup_block_import_valid(block_root, false);
+    // Resolve blob and expect lookup completed
+    r.complete_single_lookup_blob_lookup_valid(id, peer_id, blobs, true);
+    r.expect_no_active_lookups();
+}
+
+#[test]
+fn block_in_processing_cache_becomes_valid_imported() {
+    let Some(mut r) = TestRig::test_setup_after_deneb() else {
+        return;
+    };
+    let (block, blobs) = r.rand_block_and_blobs(NumBlobs::Number(1));
+    let block_root = block.canonical_root();
+    let peer_id = r.new_connected_peer();
+    r.insert_block_to_processing_cache(block.clone().into());
+    r.trigger_unknown_block_from_attestation(block_root, peer_id);
+    // Should not trigger block request
+    r.expect_empty_network();
+    // Resolve the block from processing step
+    r.simulate_block_gossip_processing_becomes_valid_missing_components(block.into());
+    let id = r.expect_blob_lookup_request(block_root);
+    // Resolve blob and expect lookup completed
+    r.complete_single_lookup_blob_lookup_valid(id, peer_id, blobs, true);
+    r.expect_no_active_lookups();
+}
 
-    let process_result = BatchProcessResult::Success {
-        was_non_empty: true,
+// IGNORE: wait for change that delays blob fetching to knowing the block
+#[ignore]
+#[test]
+fn blobs_in_da_checker_skip_download() {
+    let Some(mut r) = TestRig::test_setup_after_deneb() else {
+        return;
     };
-    bl.parent_chain_processed(chain_hash, process_result, &cx);
-    assert_eq!(bl.parent_lookups.len(), 0);
+    let (block, blobs) = r.rand_block_and_blobs(NumBlobs::Number(1));
+    let block_root = block.canonical_root();
+    let peer_id = r.new_connected_peer();
+    for blob in blobs {
+        r.insert_blob_to_da_checker(blob);
+    }
+    r.trigger_unknown_block_from_attestation(block_root, peer_id);
+    // Should download and process the block
+    r.complete_single_lookup_block_valid(block, true);
+    // Should not trigger blob request
+    r.expect_empty_network();
+    r.expect_no_active_lookups();
 }
 
 mod deneb_only {
     use super::*;
-    use beacon_chain::data_availability_checker::AvailabilityCheckError;
+    use beacon_chain::{
+        block_verification_types::RpcBlock, data_availability_checker::AvailabilityCheckError,
+    };
     use ssz_types::VariableList;
-    use std::ops::IndexMut;
-    use std::str::FromStr;
+    use std::collections::VecDeque;
 
     struct DenebTester {
-        bl: BlockLookups<T>,
-        cx: SyncNetworkContext<T>,
         rig: TestRig,
         block: Arc<SignedBeaconBlock<E>>,
         blobs: Vec<Arc<BlobSidecar<E>>>,
+        parent_block_roots: Vec<Hash256>,
         parent_block: VecDeque<Arc<SignedBeaconBlock<E>>>,
         parent_blobs: VecDeque<Vec<Arc<BlobSidecar<E>>>>,
         unknown_parent_block: Option<Arc<SignedBeaconBlock<E>>>,
@@ -1188,31 +1518,26 @@ mod deneb_only {
 
     enum RequestTrigger {
         AttestationUnknownBlock,
-        GossipUnknownParentBlock { num_parents: usize },
-        GossipUnknownParentBlob { num_parents: usize },
+        GossipUnknownParentBlock(usize),
+        GossipUnknownParentBlob(usize),
     }
 
     impl RequestTrigger {
         fn num_parents(&self) -> usize {
             match self {
                 RequestTrigger::AttestationUnknownBlock => 0,
-                RequestTrigger::GossipUnknownParentBlock { num_parents } => *num_parents,
-                RequestTrigger::GossipUnknownParentBlob { num_parents } => *num_parents,
+                RequestTrigger::GossipUnknownParentBlock(num_parents) => *num_parents,
+                RequestTrigger::GossipUnknownParentBlob(num_parents) => *num_parents,
             }
         }
     }
 
     impl DenebTester {
         fn new(request_trigger: RequestTrigger) -> Option<Self> {
-            let fork_name = get_fork_name();
-            if !matches!(fork_name, ForkName::Deneb) {
+            let Some(mut rig) = TestRig::test_setup_after_deneb() else {
                 return None;
-            }
-            let (mut bl, mut cx, mut rig) = TestRig::test_setup(false);
-            rig.harness.chain.slot_clock.set_slot(
-                E::slots_per_epoch() * rig.harness.spec.deneb_fork_epoch.unwrap().as_u64(),
-            );
-            let (block, blobs) = rig.rand_block_and_blobs(fork_name, NumBlobs::Random);
+            };
+            let (block, blobs) = rig.rand_block_and_blobs(NumBlobs::Random);
             let mut block = Arc::new(block);
             let mut blobs = blobs.into_iter().map(Arc::new).collect::<Vec<_>>();
             let slot = block.slot();
@@ -1220,6 +1545,7 @@ mod deneb_only {
             let num_parents = request_trigger.num_parents();
             let mut parent_block_chain = VecDeque::with_capacity(num_parents);
             let mut parent_blobs_chain = VecDeque::with_capacity(num_parents);
+            let mut parent_block_roots = vec![];
             for _ in 0..num_parents {
                 // Set the current  block as the parent.
                 let parent_root = block.canonical_root();
@@ -1227,10 +1553,11 @@ mod deneb_only {
                 let parent_blobs = blobs.clone();
                 parent_block_chain.push_front(parent_block);
                 parent_blobs_chain.push_front(parent_blobs);
+                parent_block_roots.push(parent_root);
 
                 // Create the next block.
                 let (child_block, child_blobs) =
-                    rig.block_with_parent_and_blobs(parent_root, get_fork_name(), NumBlobs::Random);
+                    rig.block_with_parent_and_blobs(parent_root, NumBlobs::Random);
                 let mut child_block = Arc::new(child_block);
                 let mut child_blobs = child_blobs.into_iter().map(Arc::new).collect::<Vec<_>>();
 
@@ -1239,75 +1566,49 @@ mod deneb_only {
                 std::mem::swap(&mut child_blobs, &mut blobs);
             }
             let block_root = block.canonical_root();
-            let parent_root = block.parent_root();
 
-            let peer_id = PeerId::random();
+            let peer_id = rig.new_connected_peer();
 
             // Trigger the request
             let (block_req_id, blob_req_id, parent_block_req_id, parent_blob_req_id) =
                 match request_trigger {
                     RequestTrigger::AttestationUnknownBlock => {
-                        bl.search_block(block_root, &[peer_id], &mut cx);
-                        let block_req_id = rig.expect_lookup_request(ResponseType::Block);
-                        let blob_req_id = rig.expect_lookup_request(ResponseType::Blob);
-                        (Some(block_req_id), Some(blob_req_id), None, None)
+                        rig.send_sync_message(SyncMessage::UnknownBlockHashFromAttestation(
+                            peer_id, block_root,
+                        ));
+                        let block_req_id = rig.expect_block_lookup_request(block_root);
+                        (Some(block_req_id), None, None, None)
                     }
                     RequestTrigger::GossipUnknownParentBlock { .. } => {
-                        bl.search_child_block(
+                        rig.send_sync_message(SyncMessage::UnknownParentBlock(
+                            peer_id,
+                            RpcBlock::new_without_blobs(Some(block_root), block.clone()),
                             block_root,
-                            ChildComponents::new(block_root, Some(block.clone()), None),
-                            &[peer_id],
-                            &mut cx,
-                        );
-
-                        let blob_req_id = rig.expect_lookup_request(ResponseType::Blob);
-                        rig.expect_empty_network(); // expect no block request
-                        bl.search_parent(slot, block_root, parent_root, peer_id, &mut cx);
-                        let parent_block_req_id = rig.expect_parent_request(ResponseType::Block);
-                        let parent_blob_req_id = rig.expect_parent_request(ResponseType::Blob);
-                        (
-                            None,
-                            Some(blob_req_id),
-                            Some(parent_block_req_id),
-                            Some(parent_blob_req_id),
-                        )
+                        ));
+
+                        let parent_root = block.parent_root();
+                        let parent_block_req_id = rig.expect_block_parent_request(parent_root);
+                        rig.expect_empty_network(); // expect no more requests
+                        (None, None, Some(parent_block_req_id), None)
                     }
                     RequestTrigger::GossipUnknownParentBlob { .. } => {
                         let single_blob = blobs.first().cloned().unwrap();
-                        let child_root = single_blob.block_root();
-
-                        let mut lookup_blobs = FixedBlobSidecarList::default();
-                        *lookup_blobs.index_mut(0) = Some(single_blob);
-                        bl.search_child_block(
-                            child_root,
-                            ChildComponents::new(child_root, None, Some(lookup_blobs)),
-                            &[peer_id],
-                            &mut cx,
-                        );
-
-                        let block_req_id = rig.expect_lookup_request(ResponseType::Block);
-                        let blobs_req_id = rig.expect_lookup_request(ResponseType::Blob);
-                        rig.expect_empty_network(); // expect no block request
-                        bl.search_parent(slot, child_root, parent_root, peer_id, &mut cx);
-                        let parent_block_req_id = rig.expect_parent_request(ResponseType::Block);
-                        let parent_blob_req_id = rig.expect_parent_request(ResponseType::Blob);
-                        (
-                            Some(block_req_id),
-                            Some(blobs_req_id),
-                            Some(parent_block_req_id),
-                            Some(parent_blob_req_id),
-                        )
+                        let parent_root = single_blob.block_parent_root();
+                        rig.send_sync_message(SyncMessage::UnknownParentBlob(peer_id, single_blob));
+
+                        let parent_block_req_id = rig.expect_block_parent_request(parent_root);
+                        rig.expect_empty_network(); // expect no more requests
+                        (None, None, Some(parent_block_req_id), None)
                     }
                 };
 
             Some(Self {
-                bl,
-                cx,
                 rig,
                 block,
                 blobs,
                 parent_block: parent_block_chain,
                 parent_blobs: parent_blobs_chain,
+                parent_block_roots,
                 unknown_parent_block: None,
                 unknown_parent_blobs: None,
                 peer_id,
@@ -1320,95 +1621,113 @@ mod deneb_only {
             })
         }
 
+        fn log(self, msg: &str) -> Self {
+            self.rig.log(msg);
+            self
+        }
+
+        fn trigger_unknown_block_from_attestation(mut self) -> Self {
+            let block_root = self.block.canonical_root();
+            self.rig
+                .trigger_unknown_block_from_attestation(block_root, self.peer_id);
+            self
+        }
+
         fn parent_block_response(mut self) -> Self {
             self.rig.expect_empty_network();
             let block = self.parent_block.pop_front().unwrap().clone();
             let _ = self.unknown_parent_block.insert(block.clone());
-            self.bl.parent_lookup_response::<BlockRequestState<Parent>>(
+            self.rig.parent_lookup_block_response(
                 self.parent_block_req_id.expect("parent request id"),
                 self.peer_id,
                 Some(block),
-                D,
-                &self.cx,
             );
 
-            assert_eq!(self.bl.parent_lookups.len(), 1);
+            self.rig.assert_parent_lookups_count(1);
             self
         }
 
+        fn parent_block_response_expect_blobs(mut self) -> Self {
+            self.rig.expect_empty_network();
+            let block = self.parent_block.pop_front().unwrap().clone();
+            let _ = self.unknown_parent_block.insert(block.clone());
+            self.rig.parent_lookup_block_response(
+                self.parent_block_req_id.expect("parent request id"),
+                self.peer_id,
+                Some(block),
+            );
+
+            // Expect blobs request after sending block
+            let s = self.expect_parent_blobs_request();
+
+            s.rig.assert_parent_lookups_count(1);
+            s
+        }
+
         fn parent_blob_response(mut self) -> Self {
             let blobs = self.parent_blobs.pop_front().unwrap();
             let _ = self.unknown_parent_blobs.insert(blobs.clone());
             for blob in &blobs {
-                self.bl
-                    .parent_lookup_response::<BlobRequestState<Parent, E>>(
-                        self.parent_blob_req_id.expect("parent blob request id"),
-                        self.peer_id,
-                        Some(blob.clone()),
-                        D,
-                        &self.cx,
-                    );
-                assert_eq!(self.bl.parent_lookups.len(), 1);
-            }
-            self.bl
-                .parent_lookup_response::<BlobRequestState<Parent, E>>(
-                    self.parent_blob_req_id.expect("blob request id"),
+                self.rig.parent_lookup_blob_response(
+                    self.parent_blob_req_id.expect("parent blob request id"),
                     self.peer_id,
-                    None,
-                    D,
-                    &self.cx,
+                    Some(blob.clone()),
                 );
+                assert_eq!(self.rig.active_parent_lookups_count(), 1);
+            }
+            self.rig.parent_lookup_blob_response(
+                self.parent_blob_req_id.expect("parent blob request id"),
+                self.peer_id,
+                None,
+            );
 
             self
         }
 
         fn block_response_triggering_process(self) -> Self {
-            let mut me = self.block_response();
+            let mut me = self.block_response_and_expect_blob_request();
             me.rig.expect_block_process(ResponseType::Block);
 
             // The request should still be active.
-            assert_eq!(me.bl.single_block_lookups.len(), 1);
+            assert_eq!(me.rig.active_single_lookups_count(), 1);
             me
         }
 
-        fn block_response(mut self) -> Self {
+        fn block_response_and_expect_blob_request(mut self) -> Self {
             // The peer provides the correct block, should not be penalized. Now the block should be sent
             // for processing.
-            self.bl
-                .single_lookup_response::<BlockRequestState<Current>>(
-                    self.block_req_id.expect("block request id"),
-                    self.peer_id,
-                    Some(self.block.clone()),
-                    D,
-                    &self.cx,
-                );
-            self.rig.expect_empty_network();
+            self.rig.single_lookup_block_response(
+                self.block_req_id.expect("block request id"),
+                self.peer_id,
+                Some(self.block.clone()),
+            );
+            // After responding with block the node will issue a blob request
+            let mut s = self.expect_blobs_request();
+
+            s.rig.expect_empty_network();
 
             // The request should still be active.
-            assert_eq!(self.bl.single_block_lookups.len(), 1);
-            self
+            s.rig.assert_lookup_is_active(s.block.canonical_root());
+            s
         }
 
         fn blobs_response(mut self) -> Self {
+            self.rig
+                .log(&format!("blobs response {}", self.blobs.len()));
             for blob in &self.blobs {
-                self.bl
-                    .single_lookup_response::<BlobRequestState<Current, E>>(
-                        self.blob_req_id.expect("blob request id"),
-                        self.peer_id,
-                        Some(blob.clone()),
-                        D,
-                        &self.cx,
-                    );
-                assert_eq!(self.bl.single_block_lookups.len(), 1);
-            }
-            self.bl
-                .single_lookup_response::<BlobRequestState<Current, E>>(
+                self.rig.single_lookup_blob_response(
                     self.blob_req_id.expect("blob request id"),
                     self.peer_id,
-                    None,
-                    D,
-                    &self.cx,
+                    Some(blob.clone()),
                 );
+                self.rig
+                    .assert_lookup_is_active(self.block.canonical_root());
+            }
+            self.rig.single_lookup_blob_response(
+                self.blob_req_id.expect("blob request id"),
+                self.peer_id,
+                None,
+            );
             self
         }
 
@@ -1426,183 +1745,240 @@ mod deneb_only {
         }
 
         fn empty_block_response(mut self) -> Self {
-            self.bl
-                .single_lookup_response::<BlockRequestState<Current>>(
-                    self.block_req_id.expect("block request id"),
-                    self.peer_id,
-                    None,
-                    D,
-                    &self.cx,
-                );
+            self.rig.single_lookup_block_response(
+                self.block_req_id.expect("block request id"),
+                self.peer_id,
+                None,
+            );
             self
         }
 
         fn empty_blobs_response(mut self) -> Self {
-            self.bl
-                .single_lookup_response::<BlobRequestState<Current, E>>(
-                    self.blob_req_id.expect("blob request id"),
-                    self.peer_id,
-                    None,
-                    D,
-                    &self.cx,
-                );
+            self.rig.single_lookup_blob_response(
+                self.blob_req_id.expect("blob request id"),
+                self.peer_id,
+                None,
+            );
             self
         }
 
-        fn empty_parent_block_response(mut self) -> Self {
-            self.bl.parent_lookup_response::<BlockRequestState<Parent>>(
-                self.parent_block_req_id.expect("block request id"),
+        fn empty_parent_blobs_response(mut self) -> Self {
+            self.rig.parent_lookup_blob_response(
+                self.parent_blob_req_id.expect("blob request id"),
                 self.peer_id,
                 None,
-                D,
-                &self.cx,
             );
             self
         }
 
-        fn empty_parent_blobs_response(mut self) -> Self {
-            self.bl
-                .parent_lookup_response::<BlobRequestState<Parent, E>>(
-                    self.parent_blob_req_id.expect("blob request id"),
-                    self.peer_id,
-                    None,
-                    D,
-                    &self.cx,
-                );
+        fn block_missing_components(mut self) -> Self {
+            self.rig.single_block_component_processed(
+                self.block_req_id.expect("block request id").lookup_id,
+                BlockProcessingResult::Ok(AvailabilityProcessingStatus::MissingComponents(
+                    self.block.slot(),
+                    self.block_root,
+                )),
+            );
+            self.rig.expect_empty_network();
+            self.rig.assert_single_lookups_count(1);
+            self
+        }
+
+        fn blob_imported(mut self) -> Self {
+            self.rig.single_blob_component_processed(
+                self.blob_req_id.expect("blob request id").lookup_id,
+                BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(self.block_root)),
+            );
+            self.rig.expect_empty_network();
+            self.rig.assert_single_lookups_count(0);
             self
         }
 
         fn block_imported(mut self) -> Self {
             // Missing blobs should be the request is not removed, the outstanding blobs request should
             // mean we do not send a new request.
-            self.bl
-                .single_block_component_processed::<BlockRequestState<Current>>(
-                    self.block_req_id.expect("block request id").id,
-                    BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(
-                        self.block_root,
-                    )),
-                    &mut self.cx,
-                );
+            self.rig.single_block_component_processed(
+                self.block_req_id
+                    .or(self.blob_req_id)
+                    .expect("block request id")
+                    .lookup_id,
+                BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(self.block_root)),
+            );
             self.rig.expect_empty_network();
-            assert_eq!(self.bl.single_block_lookups.len(), 0);
+            self.rig.assert_single_lookups_count(0);
             self
         }
 
         fn parent_block_imported(mut self) -> Self {
-            self.bl.parent_block_processed(
+            let parent_root = *self.parent_block_roots.first().unwrap();
+            self.rig
+                .log(&format!("parent_block_imported {parent_root:?}"));
+            self.rig.parent_block_processed(
                 self.block_root,
-                BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(self.block_root)),
-                &mut self.cx,
+                BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(parent_root)),
             );
-            self.rig.expect_empty_network();
-            assert_eq!(self.bl.parent_lookups.len(), 0);
+            self.rig.expect_no_requests_for(parent_root);
+            self.rig.assert_parent_lookups_count(0);
+            self
+        }
+
+        fn parent_block_missing_components(mut self) -> Self {
+            let parent_root = *self.parent_block_roots.first().unwrap();
+            self.rig
+                .log(&format!("parent_block_missing_components {parent_root:?}"));
+            self.rig.parent_block_processed(
+                self.block_root,
+                BlockProcessingResult::Ok(AvailabilityProcessingStatus::MissingComponents(
+                    Slot::new(0),
+                    parent_root,
+                )),
+            );
+            self.rig.expect_no_requests_for(parent_root);
+            self
+        }
+
+        fn parent_blob_imported(mut self) -> Self {
+            let parent_root = *self.parent_block_roots.first().unwrap();
+            self.rig
+                .log(&format!("parent_blob_imported {parent_root:?}"));
+            self.rig.parent_blob_processed(
+                self.block_root,
+                BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(parent_root)),
+            );
+
+            self.rig.expect_no_requests_for(parent_root);
+            self.rig.assert_parent_lookups_count(0);
             self
         }
 
         fn parent_block_unknown_parent(mut self) -> Self {
+            self.rig.log("parent_block_unknown_parent");
             let block = self.unknown_parent_block.take().unwrap();
+            // Now this block is the one we expect requests from
+            self.block = block.clone();
             let block = RpcBlock::new(
                 Some(block.canonical_root()),
                 block,
                 self.unknown_parent_blobs.take().map(VariableList::from),
             )
             .unwrap();
-            self.bl.parent_block_processed(
+            self.rig.parent_block_processed(
                 self.block_root,
                 BlockProcessingResult::Err(BlockError::ParentUnknown(block)),
-                &mut self.cx,
             );
-            assert_eq!(self.bl.parent_lookups.len(), 1);
+            assert_eq!(self.rig.active_parent_lookups_count(), 1);
             self
         }
 
         fn invalid_parent_processed(mut self) -> Self {
-            self.bl.parent_block_processed(
+            self.rig.parent_block_processed(
                 self.block_root,
                 BlockProcessingResult::Err(BlockError::ProposalSignatureInvalid),
-                &mut self.cx,
             );
-            assert_eq!(self.bl.parent_lookups.len(), 1);
+            assert_eq!(self.rig.active_parent_lookups_count(), 1);
             self
         }
 
         fn invalid_block_processed(mut self) -> Self {
-            self.bl
-                .single_block_component_processed::<BlockRequestState<Current>>(
-                    self.block_req_id.expect("block request id").id,
-                    BlockProcessingResult::Err(BlockError::ProposalSignatureInvalid),
-                    &mut self.cx,
-                );
-            assert_eq!(self.bl.single_block_lookups.len(), 1);
+            self.rig.single_block_component_processed(
+                self.block_req_id.expect("block request id").lookup_id,
+                BlockProcessingResult::Err(BlockError::ProposalSignatureInvalid),
+            );
+            self.rig.assert_single_lookups_count(1);
             self
         }
 
         fn invalid_blob_processed(mut self) -> Self {
-            self.bl
-                .single_block_component_processed::<BlobRequestState<Current, E>>(
-                    self.blob_req_id.expect("blob request id").id,
-                    BlockProcessingResult::Err(BlockError::AvailabilityCheck(
-                        AvailabilityCheckError::KzgVerificationFailed,
-                    )),
-                    &mut self.cx,
-                );
-            assert_eq!(self.bl.single_block_lookups.len(), 1);
+            self.rig.log("invalid_blob_processed");
+            self.rig.single_blob_component_processed(
+                self.blob_req_id.expect("blob request id").lookup_id,
+                BlockProcessingResult::Err(BlockError::AvailabilityCheck(
+                    AvailabilityCheckError::KzgVerificationFailed,
+                )),
+            );
+            self.rig.assert_single_lookups_count(1);
             self
         }
 
         fn missing_components_from_block_request(mut self) -> Self {
-            self.bl
-                .single_block_component_processed::<BlockRequestState<Current>>(
-                    self.block_req_id.expect("block request id").id,
-                    BlockProcessingResult::Ok(AvailabilityProcessingStatus::MissingComponents(
-                        self.slot,
-                        self.block_root,
-                    )),
-                    &mut self.cx,
-                );
-            assert_eq!(self.bl.single_block_lookups.len(), 1);
+            self.rig.single_block_component_processed(
+                self.block_req_id.expect("block request id").lookup_id,
+                BlockProcessingResult::Ok(AvailabilityProcessingStatus::MissingComponents(
+                    self.slot,
+                    self.block_root,
+                )),
+            );
+            // Add block to da_checker so blobs request can continue
+            self.rig.insert_block_to_da_checker(self.block.clone());
+
+            self.rig.assert_single_lookups_count(1);
             self
         }
 
-        fn missing_components_from_blob_request(mut self) -> Self {
-            self.bl
-                .single_block_component_processed::<BlobRequestState<Current, E>>(
-                    self.blob_req_id.expect("blob request id").id,
-                    BlockProcessingResult::Ok(AvailabilityProcessingStatus::MissingComponents(
-                        self.slot,
-                        self.block_root,
-                    )),
-                    &mut self.cx,
-                );
-            assert_eq!(self.bl.single_block_lookups.len(), 1);
-            self
+        fn complete_current_block_and_blobs_lookup(self) -> Self {
+            self.expect_block_request()
+                .block_response_and_expect_blob_request()
+                .blobs_response()
+                // TODO: Should send blobs for processing
+                .expect_block_process()
+                .block_imported()
+        }
+
+        fn parent_block_then_empty_parent_blobs(self) -> Self {
+            self.log(
+                " Return empty blobs for parent, block errors with missing components, downscore",
+            )
+            .parent_block_response()
+            .expect_parent_blobs_request()
+            .empty_parent_blobs_response()
+            .expect_penalty("NotEnoughResponsesReturned")
+            .log("Re-request parent blobs, succeed and import parent")
+            .expect_parent_blobs_request()
+            .parent_blob_response()
+            .expect_block_process()
+            .parent_block_missing_components()
+            // Insert new peer into child request before completing parent
+            .trigger_unknown_block_from_attestation()
+            .parent_blob_imported()
         }
 
-        fn expect_penalty(mut self) -> Self {
-            self.rig.expect_penalty();
+        fn expect_penalty(mut self, expect_penalty_msg: &'static str) -> Self {
+            self.rig.expect_penalty(self.peer_id, expect_penalty_msg);
             self
         }
         fn expect_no_penalty(mut self) -> Self {
             self.rig.expect_empty_network();
             self
         }
+        fn expect_no_penalty_and_no_requests(mut self) -> Self {
+            self.rig.expect_empty_network();
+            self
+        }
         fn expect_block_request(mut self) -> Self {
-            let id = self.rig.expect_lookup_request(ResponseType::Block);
+            let id = self
+                .rig
+                .expect_block_lookup_request(self.block.canonical_root());
             self.block_req_id = Some(id);
             self
         }
         fn expect_blobs_request(mut self) -> Self {
-            let id = self.rig.expect_lookup_request(ResponseType::Blob);
+            let id = self
+                .rig
+                .expect_blob_lookup_request(self.block.canonical_root());
             self.blob_req_id = Some(id);
             self
         }
         fn expect_parent_block_request(mut self) -> Self {
-            let id = self.rig.expect_parent_request(ResponseType::Block);
+            let id = self
+                .rig
+                .expect_block_parent_request(self.block.parent_root());
             self.parent_block_req_id = Some(id);
             self
         }
         fn expect_parent_blobs_request(mut self) -> Self {
-            let id = self.rig.expect_parent_request(ResponseType::Blob);
+            let id = self
+                .rig
+                .expect_blob_parent_request(self.block.parent_root());
             self.parent_blob_req_id = Some(id);
             self
         }
@@ -1623,83 +1999,32 @@ mod deneb_only {
             self.blobs.push(first_blob);
             self
         }
-        fn expect_parent_chain_process(mut self) -> Self {
-            self.rig.expect_parent_chain_process();
-            self
-        }
         fn expect_block_process(mut self) -> Self {
             self.rig.expect_block_process(ResponseType::Block);
             self
         }
+        fn expect_no_active_lookups(self) -> Self {
+            self.rig.expect_no_active_lookups();
+            self
+        }
         fn search_parent_dup(mut self) -> Self {
-            self.bl.search_parent(
-                self.slot,
-                self.block_root,
-                self.block.parent_root(),
-                self.peer_id,
-                &mut self.cx,
-            );
+            self.rig
+                .trigger_unknown_parent_block(self.peer_id, self.block.clone());
             self
         }
     }
 
-    fn get_fork_name() -> ForkName {
-        ForkName::from_str(
-            &std::env::var(beacon_chain::test_utils::FORK_NAME_ENV_VAR).unwrap_or_else(|e| {
-                panic!(
-                    "{} env var must be defined when using fork_from_env: {:?}",
-                    beacon_chain::test_utils::FORK_NAME_ENV_VAR,
-                    e
-                )
-            }),
-        )
-        .unwrap()
-    }
-
     #[test]
     fn single_block_and_blob_lookup_block_returned_first_attestation() {
         let Some(tester) = DenebTester::new(RequestTrigger::AttestationUnknownBlock) else {
             return;
         };
-
-        tester
-            .block_response_triggering_process()
-            .blobs_response()
-            .blobs_response_was_valid()
-            .block_imported();
-    }
-
-    #[test]
-    fn single_block_and_blob_lookup_blobs_returned_first_attestation() {
-        let Some(tester) = DenebTester::new(RequestTrigger::AttestationUnknownBlock) else {
-            return;
-        };
-
         tester
+            .block_response_and_expect_blob_request()
             .blobs_response()
+            .block_missing_components() // blobs not yet imported
             .blobs_response_was_valid()
-            .block_response_triggering_process()
-            .block_imported();
-    }
-
-    #[test]
-    fn single_block_and_blob_lookup_empty_response_attestation() {
-        let Some(tester) = DenebTester::new(RequestTrigger::AttestationUnknownBlock) else {
-            return;
-        };
-
-        tester
-            .empty_block_response()
-            .expect_penalty()
-            .expect_block_request()
-            .expect_no_blobs_request()
-            .empty_blobs_response()
-            .expect_empty_beacon_processor()
-            .expect_no_penalty()
-            .expect_no_block_request()
-            .expect_no_blobs_request()
-            .block_response_triggering_process()
-            .missing_components_from_block_request();
+            .blob_imported(); // now blobs resolve as imported
     }
 
     #[test]
@@ -1707,53 +2032,29 @@ mod deneb_only {
         let Some(tester) = DenebTester::new(RequestTrigger::AttestationUnknownBlock) else {
             return;
         };
-
         tester
-            .block_response_triggering_process()
+            .block_response_and_expect_blob_request()
             .missing_components_from_block_request()
             .empty_blobs_response()
-            .missing_components_from_blob_request()
-            .expect_penalty()
+            .expect_penalty("NotEnoughResponsesReturned")
             .expect_blobs_request()
             .expect_no_block_request();
     }
 
-    #[test]
-    fn single_blob_response_then_empty_block_response_attestation() {
-        let Some(tester) = DenebTester::new(RequestTrigger::AttestationUnknownBlock) else {
-            return;
-        };
-
-        tester
-            .blobs_response()
-            .blobs_response_was_valid()
-            .expect_no_penalty()
-            .expect_no_block_request()
-            .expect_no_blobs_request()
-            .missing_components_from_blob_request()
-            .empty_block_response()
-            .expect_penalty()
-            .expect_block_request()
-            .expect_no_blobs_request();
-    }
-
     #[test]
     fn single_invalid_block_response_then_blob_response_attestation() {
         let Some(tester) = DenebTester::new(RequestTrigger::AttestationUnknownBlock) else {
             return;
         };
-
         tester
             .block_response_triggering_process()
             .invalid_block_processed()
-            .expect_penalty()
+            .expect_penalty("lookup_block_processing_failure")
             .expect_block_request()
             .expect_no_blobs_request()
             .blobs_response()
-            .missing_components_from_blob_request()
-            .expect_no_penalty()
-            .expect_no_block_request()
-            .expect_no_block_request();
+            // blobs not sent for processing until the block is processed
+            .expect_no_penalty_and_no_requests();
     }
 
     #[test]
@@ -1761,13 +2062,12 @@ mod deneb_only {
         let Some(tester) = DenebTester::new(RequestTrigger::AttestationUnknownBlock) else {
             return;
         };
-
         tester
             .block_response_triggering_process()
             .missing_components_from_block_request()
             .blobs_response()
             .invalid_blob_processed()
-            .expect_penalty()
+            .expect_penalty("lookup_blobs_processing_failure")
             .expect_blobs_request()
             .expect_no_block_request();
     }
@@ -1777,14 +2077,12 @@ mod deneb_only {
         let Some(tester) = DenebTester::new(RequestTrigger::AttestationUnknownBlock) else {
             return;
         };
-
         tester
             .block_response_triggering_process()
             .missing_components_from_block_request()
             .invalidate_blobs_too_few()
             .blobs_response()
-            .missing_components_from_blob_request()
-            .expect_penalty()
+            .expect_penalty("NotEnoughResponsesReturned")
             .expect_blobs_request()
             .expect_no_block_request();
     }
@@ -1794,313 +2092,156 @@ mod deneb_only {
         let Some(tester) = DenebTester::new(RequestTrigger::AttestationUnknownBlock) else {
             return;
         };
-
         tester
             .block_response_triggering_process()
             .invalidate_blobs_too_many()
             .blobs_response()
-            .expect_penalty()
-            .expect_blobs_request()
+            .expect_penalty("TooManyResponses")
+            // Network context returns "download success" because the request has enough blobs + it
+            // downscores the peer for returning too many.
             .expect_no_block_request();
     }
 
-    #[test]
-    fn too_few_blobs_response_then_block_response_attestation() {
-        let Some(tester) = DenebTester::new(RequestTrigger::AttestationUnknownBlock) else {
-            return;
-        };
-
-        tester
-            .invalidate_blobs_too_few()
-            .blobs_response()
-            .blobs_response_was_valid()
-            .expect_no_penalty()
-            .expect_no_blobs_request()
-            .expect_no_block_request()
-            .block_response_triggering_process();
-    }
-
-    #[test]
-    fn too_many_blobs_response_then_block_response_attestation() {
-        let Some(tester) = DenebTester::new(RequestTrigger::AttestationUnknownBlock) else {
-            return;
-        };
-
-        tester
-            .invalidate_blobs_too_many()
-            .blobs_response()
-            .expect_penalty()
-            .expect_blobs_request()
-            .expect_no_block_request()
-            .block_response_triggering_process();
-    }
-
+    // Test peer returning block that has unknown parent, and a new lookup is created
     #[test]
     fn parent_block_unknown_parent() {
-        let Some(tester) =
-            DenebTester::new(RequestTrigger::GossipUnknownParentBlock { num_parents: 1 })
-        else {
+        let Some(tester) = DenebTester::new(RequestTrigger::GossipUnknownParentBlock(1)) else {
             return;
         };
-
         tester
-            .blobs_response()
             .expect_empty_beacon_processor()
-            .parent_block_response()
+            .parent_block_response_expect_blobs()
             .parent_blob_response()
             .expect_block_process()
             .parent_block_unknown_parent()
             .expect_parent_block_request()
-            .expect_parent_blobs_request()
             .expect_empty_beacon_processor();
     }
 
+    // Test peer returning invalid (processing) block, expect retry
     #[test]
     fn parent_block_invalid_parent() {
-        let Some(tester) =
-            DenebTester::new(RequestTrigger::GossipUnknownParentBlock { num_parents: 1 })
-        else {
+        let Some(tester) = DenebTester::new(RequestTrigger::GossipUnknownParentBlock(1)) else {
             return;
         };
-
         tester
-            .blobs_response()
-            .expect_empty_beacon_processor()
-            .parent_block_response()
+            .parent_block_response_expect_blobs()
             .parent_blob_response()
             .expect_block_process()
             .invalid_parent_processed()
-            .expect_penalty()
+            .expect_penalty("lookup_block_processing_failure")
             .expect_parent_block_request()
-            .expect_parent_blobs_request()
             .expect_empty_beacon_processor();
     }
 
+    // Tests that if a peer does not respond with a block, we downscore and retry the block only
     #[test]
-    fn parent_block_and_blob_lookup_parent_returned_first() {
-        let Some(tester) =
-            DenebTester::new(RequestTrigger::GossipUnknownParentBlock { num_parents: 1 })
-        else {
-            return;
-        };
-
-        tester
-            .parent_block_response()
-            .parent_blob_response()
-            .expect_block_process()
-            .parent_block_imported()
-            .blobs_response()
-            .expect_parent_chain_process();
-    }
-
-    #[test]
-    fn parent_block_and_blob_lookup_child_returned_first() {
-        let Some(tester) =
-            DenebTester::new(RequestTrigger::GossipUnknownParentBlock { num_parents: 1 })
-        else {
-            return;
-        };
-
-        tester
-            .blobs_response()
-            .expect_no_penalty()
-            .expect_no_block_request()
-            .expect_no_blobs_request()
-            .parent_block_response()
-            .parent_blob_response()
-            .expect_block_process()
-            .parent_block_imported()
-            .expect_parent_chain_process();
-    }
-
-    #[test]
-    fn empty_parent_block_then_parent_blob() {
-        let Some(tester) =
-            DenebTester::new(RequestTrigger::GossipUnknownParentBlock { num_parents: 1 })
-        else {
+    fn empty_block_is_retried() {
+        let Some(tester) = DenebTester::new(RequestTrigger::AttestationUnknownBlock) else {
             return;
         };
-
         tester
-            .empty_parent_block_response()
-            .expect_penalty()
-            .expect_parent_block_request()
+            .empty_block_response()
+            .expect_penalty("NoResponseReturned")
+            .expect_block_request()
             .expect_no_blobs_request()
-            .parent_blob_response()
-            .expect_empty_beacon_processor()
-            .parent_block_response()
-            .expect_block_process()
-            .parent_block_imported()
+            .block_response_and_expect_blob_request()
             .blobs_response()
-            .expect_parent_chain_process();
+            .block_imported()
+            .expect_no_active_lookups();
     }
 
     #[test]
-    fn empty_parent_blobs_then_parent_block() {
-        let Some(tester) =
-            DenebTester::new(RequestTrigger::GossipUnknownParentBlock { num_parents: 1 })
-        else {
+    fn parent_block_then_empty_parent_blobs() {
+        let Some(tester) = DenebTester::new(RequestTrigger::GossipUnknownParentBlock(1)) else {
             return;
         };
-
         tester
-            .blobs_response()
-            .empty_parent_blobs_response()
-            .expect_no_penalty()
-            .expect_no_blobs_request()
-            .expect_no_block_request()
-            .parent_block_response()
-            .expect_penalty()
-            .expect_parent_blobs_request()
-            .parent_blob_response()
-            .expect_block_process()
-            .parent_block_imported()
-            .expect_parent_chain_process();
+            .parent_block_then_empty_parent_blobs()
+            .log("resolve original block trigger blobs request and import")
+            // Should not have block request, it is cached
+            .expect_blobs_request()
+            // TODO: Should send blobs for processing
+            .block_imported()
+            .expect_no_active_lookups();
     }
 
     #[test]
     fn parent_blob_unknown_parent() {
-        let Some(tester) =
-            DenebTester::new(RequestTrigger::GossipUnknownParentBlob { num_parents: 1 })
-        else {
+        let Some(tester) = DenebTester::new(RequestTrigger::GossipUnknownParentBlob(1)) else {
             return;
         };
-
         tester
-            .block_response()
             .expect_empty_beacon_processor()
-            .parent_block_response()
+            .parent_block_response_expect_blobs()
             .parent_blob_response()
             .expect_block_process()
             .parent_block_unknown_parent()
             .expect_parent_block_request()
-            .expect_parent_blobs_request()
             .expect_empty_beacon_processor();
     }
 
     #[test]
     fn parent_blob_invalid_parent() {
-        let Some(tester) =
-            DenebTester::new(RequestTrigger::GossipUnknownParentBlob { num_parents: 1 })
-        else {
+        let Some(tester) = DenebTester::new(RequestTrigger::GossipUnknownParentBlob(1)) else {
             return;
         };
-
         tester
-            .block_response()
             .expect_empty_beacon_processor()
-            .parent_block_response()
+            .parent_block_response_expect_blobs()
             .parent_blob_response()
             .expect_block_process()
             .invalid_parent_processed()
-            .expect_penalty()
+            .expect_penalty("lookup_block_processing_failure")
             .expect_parent_block_request()
-            .expect_parent_blobs_request()
+            // blobs are not sent until block is processed
             .expect_empty_beacon_processor();
     }
 
     #[test]
     fn parent_block_and_blob_lookup_parent_returned_first_blob_trigger() {
-        let Some(tester) =
-            DenebTester::new(RequestTrigger::GossipUnknownParentBlob { num_parents: 1 })
-        else {
-            return;
-        };
-
-        tester
-            .parent_block_response()
-            .parent_blob_response()
-            .expect_block_process()
-            .parent_block_imported()
-            .block_response()
-            .expect_parent_chain_process();
-    }
-
-    #[test]
-    fn parent_block_and_blob_lookup_child_returned_first_blob_trigger() {
-        let Some(tester) =
-            DenebTester::new(RequestTrigger::GossipUnknownParentBlob { num_parents: 1 })
-        else {
+        let Some(tester) = DenebTester::new(RequestTrigger::GossipUnknownParentBlob(1)) else {
             return;
         };
-
         tester
-            .block_response()
-            .expect_no_penalty()
-            .expect_no_block_request()
-            .expect_no_blobs_request()
             .parent_block_response()
+            .expect_parent_blobs_request()
             .parent_blob_response()
             .expect_block_process()
+            .trigger_unknown_block_from_attestation()
             .parent_block_imported()
-            .expect_parent_chain_process();
-    }
-
-    #[test]
-    fn empty_parent_block_then_parent_blob_blob_trigger() {
-        let Some(tester) =
-            DenebTester::new(RequestTrigger::GossipUnknownParentBlob { num_parents: 1 })
-        else {
-            return;
-        };
-
-        tester
-            .empty_parent_block_response()
-            .expect_penalty()
-            .expect_parent_block_request()
-            .expect_no_blobs_request()
-            .parent_blob_response()
-            .expect_empty_beacon_processor()
-            .parent_block_response()
-            .expect_block_process()
-            .parent_block_imported()
-            .block_response()
-            .expect_parent_chain_process();
+            .complete_current_block_and_blobs_lookup()
+            .expect_no_active_lookups();
     }
 
     #[test]
-    fn empty_parent_blobs_then_parent_block_blob_trigger() {
-        let Some(tester) =
-            DenebTester::new(RequestTrigger::GossipUnknownParentBlob { num_parents: 1 })
-        else {
+    fn parent_block_then_empty_parent_blobs_blob_trigger() {
+        let Some(tester) = DenebTester::new(RequestTrigger::GossipUnknownParentBlob(1)) else {
             return;
         };
-
         tester
-            .block_response()
-            .empty_parent_blobs_response()
-            .expect_no_penalty()
-            .expect_no_blobs_request()
-            .expect_no_block_request()
-            .parent_block_response()
-            .expect_penalty()
-            .expect_parent_blobs_request()
-            .parent_blob_response()
-            .expect_block_process()
-            .parent_block_imported()
-            .expect_parent_chain_process();
+            .parent_block_then_empty_parent_blobs()
+            .log("resolve original block trigger blobs request and import")
+            .complete_current_block_and_blobs_lookup()
+            .expect_no_active_lookups();
     }
 
     #[test]
     fn parent_blob_unknown_parent_chain() {
-        let Some(tester) =
-            DenebTester::new(RequestTrigger::GossipUnknownParentBlob { num_parents: 2 })
-        else {
+        let Some(tester) = DenebTester::new(RequestTrigger::GossipUnknownParentBlob(2)) else {
             return;
         };
-
         tester
-            .block_response()
             .expect_empty_beacon_processor()
-            .parent_block_response()
+            .parent_block_response_expect_blobs()
             .parent_blob_response()
             .expect_no_penalty()
             .expect_block_process()
             .parent_block_unknown_parent()
             .expect_parent_block_request()
-            .expect_parent_blobs_request()
             .expect_empty_beacon_processor()
             .parent_block_response()
+            .expect_parent_blobs_request()
             .parent_blob_response()
             .expect_no_penalty()
             .expect_block_process();
@@ -2108,12 +2249,9 @@ mod deneb_only {
 
     #[test]
     fn unknown_parent_block_dup() {
-        let Some(tester) =
-            DenebTester::new(RequestTrigger::GossipUnknownParentBlock { num_parents: 1 })
-        else {
+        let Some(tester) = DenebTester::new(RequestTrigger::GossipUnknownParentBlock(1)) else {
             return;
         };
-
         tester
             .search_parent_dup()
             .expect_no_blobs_request()
@@ -2122,15 +2260,40 @@ mod deneb_only {
 
     #[test]
     fn unknown_parent_blob_dup() {
-        let Some(tester) =
-            DenebTester::new(RequestTrigger::GossipUnknownParentBlob { num_parents: 1 })
-        else {
+        let Some(tester) = DenebTester::new(RequestTrigger::GossipUnknownParentBlob(1)) else {
             return;
         };
-
         tester
             .search_parent_dup()
             .expect_no_blobs_request()
             .expect_no_block_request();
     }
+
+    // This test no longer applies, we don't issue requests for child lookups
+    // Keep for after updating rules on fetching blocks only first
+    #[ignore]
+    #[test]
+    fn no_peer_penalty_when_rpc_response_already_known_from_gossip() {
+        let Some(mut r) = TestRig::test_setup_after_deneb() else {
+            return;
+        };
+        let (block, blobs) = r.rand_block_and_blobs(NumBlobs::Number(2));
+        let block_root = block.canonical_root();
+        let blob_0 = blobs[0].clone();
+        let blob_1 = blobs[1].clone();
+        let peer_a = r.new_connected_peer();
+        let peer_b = r.new_connected_peer();
+        // Send unknown parent block lookup
+        r.trigger_unknown_parent_block(peer_a, block.into());
+        // Expect network request for blobs
+        let id = r.expect_blob_lookup_request(block_root);
+        // Peer responses with blob 0
+        r.single_lookup_blob_response(id, peer_a, Some(blob_0.into()));
+        // Blob 1 is received via gossip unknown parent blob from a different peer
+        r.trigger_unknown_parent_blob(peer_b, blob_1.clone());
+        // Original peer sends blob 1 via RPC
+        r.single_lookup_blob_response(id, peer_a, Some(blob_1.into()));
+        // Assert no downscore event for original peer
+        r.expect_no_penalty_for(peer_a);
+    }
 }
diff --git a/beacon_node/network/src/sync/block_sidecar_coupling.rs b/beacon_node/network/src/sync/block_sidecar_coupling.rs
index 9c6e2fcf07c..d159733cbc7 100644
--- a/beacon_node/network/src/sync/block_sidecar_coupling.rs
+++ b/beacon_node/network/src/sync/block_sidecar_coupling.rs
@@ -3,7 +3,9 @@ use ssz_types::VariableList;
 use std::{collections::VecDeque, sync::Arc};
 use types::{BlobSidecar, EthSpec, SignedBeaconBlock};
 
-#[derive(Debug, Default)]
+use super::range_sync::ByRangeRequestType;
+
+#[derive(Debug)]
 pub struct BlocksAndBlobsRequestInfo<E: EthSpec> {
     /// Blocks we have received awaiting for their corresponding sidecar.
     accumulated_blocks: VecDeque<Arc<SignedBeaconBlock<E>>>,
@@ -13,9 +15,25 @@ pub struct BlocksAndBlobsRequestInfo<E: EthSpec> {
     is_blocks_stream_terminated: bool,
     /// Whether the individual RPC request for sidecars is finished or not.
     is_sidecars_stream_terminated: bool,
+    /// Used to determine if this accumulator should wait for a sidecars stream termination
+    request_type: ByRangeRequestType,
 }
 
 impl<E: EthSpec> BlocksAndBlobsRequestInfo<E> {
+    pub fn new(request_type: ByRangeRequestType) -> Self {
+        Self {
+            accumulated_blocks: <_>::default(),
+            accumulated_sidecars: <_>::default(),
+            is_blocks_stream_terminated: <_>::default(),
+            is_sidecars_stream_terminated: <_>::default(),
+            request_type,
+        }
+    }
+
+    pub fn get_request_type(&self) -> ByRangeRequestType {
+        self.request_type
+    }
+
     pub fn add_block_response(&mut self, block_opt: Option<Arc<SignedBeaconBlock<E>>>) {
         match block_opt {
             Some(block) => self.accumulated_blocks.push_back(block),
@@ -78,6 +96,64 @@ impl<E: EthSpec> BlocksAndBlobsRequestInfo<E> {
     }
 
     pub fn is_finished(&self) -> bool {
-        self.is_blocks_stream_terminated && self.is_sidecars_stream_terminated
+        let blobs_requested = match self.request_type {
+            ByRangeRequestType::Blocks => false,
+            ByRangeRequestType::BlocksAndBlobs => true,
+        };
+        self.is_blocks_stream_terminated && (!blobs_requested || self.is_sidecars_stream_terminated)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::BlocksAndBlobsRequestInfo;
+    use crate::sync::range_sync::ByRangeRequestType;
+    use beacon_chain::test_utils::{generate_rand_block_and_blobs, NumBlobs};
+    use rand::SeedableRng;
+    use types::{test_utils::XorShiftRng, ForkName, MinimalEthSpec as E};
+
+    #[test]
+    fn no_blobs_into_responses() {
+        let mut info = BlocksAndBlobsRequestInfo::<E>::new(ByRangeRequestType::Blocks);
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let blocks = (0..4)
+            .map(|_| generate_rand_block_and_blobs::<E>(ForkName::Base, NumBlobs::None, &mut rng).0)
+            .collect::<Vec<_>>();
+
+        // Send blocks and complete terminate response
+        for block in blocks {
+            info.add_block_response(Some(block.into()));
+        }
+        info.add_block_response(None);
+
+        // Assert response is finished and RpcBlocks can be constructed
+        assert!(info.is_finished());
+        info.into_responses().unwrap();
+    }
+
+    #[test]
+    fn empty_blobs_into_responses() {
+        let mut info = BlocksAndBlobsRequestInfo::<E>::new(ByRangeRequestType::BlocksAndBlobs);
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let blocks = (0..4)
+            .map(|_| {
+                // Always generate some blobs.
+                generate_rand_block_and_blobs::<E>(ForkName::Deneb, NumBlobs::Number(3), &mut rng).0
+            })
+            .collect::<Vec<_>>();
+
+        // Send blocks and complete terminate response
+        for block in blocks {
+            info.add_block_response(Some(block.into()));
+        }
+        info.add_block_response(None);
+        // Expect no blobs returned
+        info.add_sidecar_response(None);
+
+        // Assert response is finished and RpcBlocks can be constructed, even if blobs weren't returned.
+        // This makes sure we don't expect blobs here when they have expired. Checking this logic should
+        // be hendled elsewhere.
+        assert!(info.is_finished());
+        info.into_responses().unwrap();
     }
 }
diff --git a/beacon_node/network/src/sync/manager.rs b/beacon_node/network/src/sync/manager.rs
index e95649806bc..71d3113414c 100644
--- a/beacon_node/network/src/sync/manager.rs
+++ b/beacon_node/network/src/sync/manager.rs
@@ -35,19 +35,19 @@
 
 use super::backfill_sync::{BackFillSync, ProcessResult, SyncStart};
 use super::block_lookups::BlockLookups;
-use super::network_context::{BlockOrBlob, SyncNetworkContext};
+use super::network_context::{BlockOrBlob, RangeRequestId, RpcEvent, SyncNetworkContext};
 use super::peer_sync_info::{remote_sync_type, PeerSyncType};
 use super::range_sync::{RangeSync, RangeSyncType, EPOCHS_PER_BATCH};
 use crate::network_beacon_processor::{ChainSegmentProcessId, NetworkBeaconProcessor};
 use crate::service::NetworkMessage;
 use crate::status::ToStatusMessage;
-use crate::sync::block_lookups::common::{Current, Parent};
-use crate::sync::block_lookups::{BlobRequestState, BlockRequestState};
-use crate::sync::network_context::BlocksAndBlobsByRangeRequest;
-use crate::sync::range_sync::ByRangeRequestType;
+use crate::sync::block_lookups::{
+    BlobRequestState, BlockComponent, BlockRequestState, DownloadResult,
+};
+use crate::sync::block_sidecar_coupling::BlocksAndBlobsRequestInfo;
 use beacon_chain::block_verification_types::AsBlock;
 use beacon_chain::block_verification_types::RpcBlock;
-use beacon_chain::data_availability_checker::ChildComponents;
+use beacon_chain::validator_monitor::timestamp_now;
 use beacon_chain::{
     AvailabilityProcessingStatus, BeaconChain, BeaconChainTypes, BlockError, EngineState,
 };
@@ -56,13 +56,11 @@ use lighthouse_network::rpc::RPCError;
 use lighthouse_network::types::{NetworkGlobals, SyncState};
 use lighthouse_network::SyncInfo;
 use lighthouse_network::{PeerAction, PeerId};
-use slog::{crit, debug, error, info, trace, warn, Logger};
-use std::ops::IndexMut;
+use slog::{crit, debug, error, info, o, trace, warn, Logger};
 use std::ops::Sub;
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::sync::mpsc;
-use types::blob_sidecar::FixedBlobSidecarList;
 use types::{BlobSidecar, EthSpec, Hash256, SignedBeaconBlock, Slot};
 
 /// The number of slots ahead of us that is allowed before requesting a long-range (batch)  Sync
@@ -78,8 +76,8 @@ pub type Id = u32;
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
 pub struct SingleLookupReqId {
-    pub id: Id,
-    pub req_counter: Id,
+    pub lookup_id: Id,
+    pub req_id: Id,
 }
 
 /// Id of rpc requests sent by sync to the network.
@@ -89,18 +87,6 @@ pub enum RequestId {
     SingleBlock { id: SingleLookupReqId },
     /// Request searching for a set of blobs given a hash.
     SingleBlob { id: SingleLookupReqId },
-    /// Request searching for a block's parent. The id is the chain, share with the corresponding
-    /// blob id.
-    ParentLookup { id: SingleLookupReqId },
-    /// Request searching for a block's parent blobs. The id is the chain, shared with the corresponding
-    /// block id.
-    ParentLookupBlob { id: SingleLookupReqId },
-    /// Request was from the backfill sync algorithm.
-    BackFillBlocks { id: Id },
-    /// Backfill request that is composed by both a block range request and a blob range request.
-    BackFillBlockAndBlobs { id: Id },
-    /// The request was from a chain in the range sync algorithm.
-    RangeBlocks { id: Id },
     /// Range request that is composed by both a block range request and a blob range request.
     RangeBlockAndBlobs { id: Id },
 }
@@ -158,6 +144,9 @@ pub enum SyncMessage<E: EthSpec> {
         process_type: BlockProcessType,
         result: BlockProcessingResult<E>,
     },
+
+    /// A block from gossip has completed processing,
+    GossipBlockProcessResult { block_root: Hash256, imported: bool },
 }
 
 /// The type of processing specified for a received block.
@@ -165,7 +154,6 @@ pub enum SyncMessage<E: EthSpec> {
 pub enum BlockProcessType {
     SingleBlock { id: Id },
     SingleBlob { id: Id },
-    ParentLookup { chain_hash: Hash256 },
 }
 
 #[derive(Debug)]
@@ -233,24 +221,13 @@ pub fn spawn<T: BeaconChainTypes>(
     );
 
     // create an instance of the SyncManager
-    let network_globals = beacon_processor.network_globals.clone();
-    let mut sync_manager = SyncManager {
-        chain: beacon_chain.clone(),
-        input_channel: sync_recv,
-        network: SyncNetworkContext::new(
-            network_send,
-            beacon_processor.clone(),
-            beacon_chain.clone(),
-            log.clone(),
-        ),
-        range_sync: RangeSync::new(beacon_chain.clone(), log.clone()),
-        backfill_sync: BackFillSync::new(beacon_chain.clone(), network_globals, log.clone()),
-        block_lookups: BlockLookups::new(
-            beacon_chain.data_availability_checker.clone(),
-            log.clone(),
-        ),
-        log: log.clone(),
-    };
+    let mut sync_manager = SyncManager::new(
+        beacon_chain,
+        network_send,
+        beacon_processor,
+        sync_recv,
+        log.clone(),
+    );
 
     // spawn the sync manager thread
     debug!(log, "Sync Manager started");
@@ -258,6 +235,61 @@ pub fn spawn<T: BeaconChainTypes>(
 }
 
 impl<T: BeaconChainTypes> SyncManager<T> {
+    pub(crate) fn new(
+        beacon_chain: Arc<BeaconChain<T>>,
+        network_send: mpsc::UnboundedSender<NetworkMessage<T::EthSpec>>,
+        beacon_processor: Arc<NetworkBeaconProcessor<T>>,
+        sync_recv: mpsc::UnboundedReceiver<SyncMessage<T::EthSpec>>,
+        log: slog::Logger,
+    ) -> Self {
+        let network_globals = beacon_processor.network_globals.clone();
+        Self {
+            chain: beacon_chain.clone(),
+            input_channel: sync_recv,
+            network: SyncNetworkContext::new(
+                network_send,
+                beacon_processor.clone(),
+                beacon_chain.clone(),
+                log.clone(),
+            ),
+            range_sync: RangeSync::new(
+                beacon_chain.clone(),
+                log.new(o!("service" => "range_sync")),
+            ),
+            backfill_sync: BackFillSync::new(
+                beacon_chain.clone(),
+                network_globals,
+                log.new(o!("service" => "backfill_sync")),
+            ),
+            block_lookups: BlockLookups::new(log.new(o!("service"=> "lookup_sync"))),
+            log: log.clone(),
+        }
+    }
+
+    #[cfg(test)]
+    pub(crate) fn active_single_lookups(&self) -> Vec<(Id, Hash256, Option<Hash256>)> {
+        self.block_lookups.active_single_lookups()
+    }
+
+    #[cfg(test)]
+    pub(crate) fn active_parent_lookups(&self) -> Vec<Vec<Hash256>> {
+        self.block_lookups
+            .active_parent_lookups()
+            .iter()
+            .map(|c| c.chain.clone())
+            .collect()
+    }
+
+    #[cfg(test)]
+    pub(crate) fn get_failed_chains(&mut self) -> Vec<Hash256> {
+        self.block_lookups.get_failed_chains()
+    }
+
+    #[cfg(test)]
+    pub(crate) fn insert_failed_chain(&mut self, block_root: Hash256) {
+        self.block_lookups.insert_failed_chain(block_root);
+    }
+
     fn network_globals(&self) -> &NetworkGlobals<T::EthSpec> {
         self.network.network_globals()
     }
@@ -301,98 +333,32 @@ impl<T: BeaconChainTypes> SyncManager<T> {
         trace!(self.log, "Sync manager received a failed RPC");
         match request_id {
             RequestId::SingleBlock { id } => {
-                self.block_lookups
-                    .single_block_lookup_failed::<BlockRequestState<Current>>(
-                        id,
-                        &peer_id,
-                        &self.network,
-                        error,
-                    );
+                self.on_single_block_response(id, peer_id, RpcEvent::RPCError(error))
             }
             RequestId::SingleBlob { id } => {
-                self.block_lookups
-                    .single_block_lookup_failed::<BlobRequestState<Current, T::EthSpec>>(
-                        id,
-                        &peer_id,
-                        &self.network,
-                        error,
-                    );
-            }
-            RequestId::ParentLookup { id } => {
-                self.block_lookups
-                    .parent_lookup_failed::<BlockRequestState<Parent>>(
-                        id,
-                        peer_id,
-                        &self.network,
-                        error,
-                    );
-            }
-            RequestId::ParentLookupBlob { id } => {
-                self.block_lookups
-                    .parent_lookup_failed::<BlobRequestState<Parent, T::EthSpec>>(
-                        id,
-                        peer_id,
-                        &self.network,
-                        error,
-                    );
-            }
-            RequestId::BackFillBlocks { id } => {
-                if let Some(batch_id) = self
-                    .network
-                    .backfill_request_failed(id, ByRangeRequestType::Blocks)
-                {
-                    match self
-                        .backfill_sync
-                        .inject_error(&mut self.network, batch_id, &peer_id, id)
-                    {
-                        Ok(_) => {}
-                        Err(_) => self.update_sync_state(),
-                    }
-                }
-            }
-
-            RequestId::BackFillBlockAndBlobs { id } => {
-                if let Some(batch_id) = self
-                    .network
-                    .backfill_request_failed(id, ByRangeRequestType::BlocksAndBlobs)
-                {
-                    match self
-                        .backfill_sync
-                        .inject_error(&mut self.network, batch_id, &peer_id, id)
-                    {
-                        Ok(_) => {}
-                        Err(_) => self.update_sync_state(),
-                    }
-                }
-            }
-            RequestId::RangeBlocks { id } => {
-                if let Some((chain_id, batch_id)) = self
-                    .network
-                    .range_sync_request_failed(id, ByRangeRequestType::Blocks)
-                {
-                    self.range_sync.inject_error(
-                        &mut self.network,
-                        peer_id,
-                        batch_id,
-                        chain_id,
-                        id,
-                    );
-                    self.update_sync_state()
-                }
+                self.on_single_blob_response(id, peer_id, RpcEvent::RPCError(error))
             }
             RequestId::RangeBlockAndBlobs { id } => {
-                if let Some((chain_id, batch_id)) = self
-                    .network
-                    .range_sync_request_failed(id, ByRangeRequestType::BlocksAndBlobs)
-                {
-                    self.range_sync.inject_error(
-                        &mut self.network,
-                        peer_id,
-                        batch_id,
-                        chain_id,
-                        id,
-                    );
-                    self.update_sync_state()
+                if let Some(sender_id) = self.network.range_request_failed(id) {
+                    match sender_id {
+                        RangeRequestId::RangeSync { chain_id, batch_id } => {
+                            self.range_sync.inject_error(
+                                &mut self.network,
+                                peer_id,
+                                batch_id,
+                                chain_id,
+                                id,
+                            );
+                            self.update_sync_state();
+                        }
+                        RangeRequestId::BackfillSync { batch_id } => match self
+                            .backfill_sync
+                            .inject_error(&mut self.network, batch_id, &peer_id, id)
+                        {
+                            Ok(_) => {}
+                            Err(_) => self.update_sync_state(),
+                        },
+                    }
                 }
             }
         }
@@ -400,12 +366,9 @@ impl<T: BeaconChainTypes> SyncManager<T> {
 
     fn peer_disconnect(&mut self, peer_id: &PeerId) {
         self.range_sync.peer_disconnect(&mut self.network, peer_id);
-        self.block_lookups
-            .peer_disconnected(peer_id, &mut self.network);
+        self.block_lookups.peer_disconnected(peer_id);
         // Regardless of the outcome, we update the sync status.
-        let _ = self
-            .backfill_sync
-            .peer_disconnected(peer_id, &mut self.network);
+        let _ = self.backfill_sync.peer_disconnected(peer_id);
         self.update_sync_state();
     }
 
@@ -584,6 +547,10 @@ impl<T: BeaconChainTypes> SyncManager<T> {
             futures::stream::iter(ee_responsiveness_watch.await).flatten()
         };
 
+        // LOOKUP_MAX_DURATION_SECS is 60 seconds. Logging every 30 seconds allows enough timely
+        // visbility while being sparse and not increasing the debug log volume in a noticeable way
+        let mut interval = tokio::time::interval(Duration::from_secs(30));
+
         // process any inbound messages
         loop {
             tokio::select! {
@@ -593,11 +560,14 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                 Some(engine_state) = check_ee_stream.next(), if check_ee => {
                     self.handle_new_execution_engine_state(engine_state);
                 }
+                _ = interval.tick() => {
+                    self.block_lookups.log_stuck_lookups();
+                }
             }
         }
     }
 
-    fn handle_message(&mut self, sync_message: SyncMessage<T::EthSpec>) {
+    pub(crate) fn handle_message(&mut self, sync_message: SyncMessage<T::EthSpec>) {
         match sync_message {
             SyncMessage::AddPeer(peer_id, info) => {
                 self.add_peer(peer_id, info);
@@ -625,37 +595,37 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                     block_root,
                     parent_root,
                     block_slot,
-                    block.into(),
+                    BlockComponent::Block(DownloadResult {
+                        value: block.block_cloned(),
+                        block_root,
+                        seen_timestamp: timestamp_now(),
+                        peer_id,
+                    }),
                 );
             }
             SyncMessage::UnknownParentBlob(peer_id, blob) => {
                 let blob_slot = blob.slot();
                 let block_root = blob.block_root();
                 let parent_root = blob.block_parent_root();
-                let blob_index = blob.index;
-                if blob_index >= T::EthSpec::max_blobs_per_block() as u64 {
-                    warn!(self.log, "Peer sent blob with invalid index"; "index" => blob_index, "peer_id" => %peer_id);
-                    return;
-                }
-                let mut blobs = FixedBlobSidecarList::default();
-                *blobs.index_mut(blob_index as usize) = Some(blob);
                 debug!(self.log, "Received unknown parent blob message"; "block_root" => %block_root, "parent_root" => %parent_root);
                 self.handle_unknown_parent(
                     peer_id,
                     block_root,
                     parent_root,
                     blob_slot,
-                    ChildComponents::new(block_root, None, Some(blobs)),
+                    BlockComponent::Blob(DownloadResult {
+                        value: blob,
+                        block_root,
+                        seen_timestamp: timestamp_now(),
+                        peer_id,
+                    }),
                 );
             }
-            SyncMessage::UnknownBlockHashFromAttestation(peer_id, block_hash) => {
-                // If we are not synced, ignore this block.
-                if self.synced_and_connected(&peer_id) {
-                    self.block_lookups
-                        .search_block(block_hash, &[peer_id], &mut self.network);
-                }
+            SyncMessage::UnknownBlockHashFromAttestation(peer_id, block_root) => {
+                self.handle_unknown_block_root(peer_id, block_root);
             }
             SyncMessage::Disconnect(peer_id) => {
+                debug!(self.log, "Received disconnected message"; "peer_id" => %peer_id);
                 self.peer_disconnect(&peer_id);
             }
             SyncMessage::RpcError {
@@ -666,25 +636,17 @@ impl<T: BeaconChainTypes> SyncManager<T> {
             SyncMessage::BlockComponentProcessed {
                 process_type,
                 result,
-            } => match process_type {
-                BlockProcessType::SingleBlock { id } => self
-                    .block_lookups
-                    .single_block_component_processed::<BlockRequestState<Current>>(
-                        id,
-                        result,
-                        &mut self.network,
-                    ),
-                BlockProcessType::SingleBlob { id } => self
-                    .block_lookups
-                    .single_block_component_processed::<BlobRequestState<Current, T::EthSpec>>(
-                        id,
-                        result,
-                        &mut self.network,
-                    ),
-                BlockProcessType::ParentLookup { chain_hash } => self
-                    .block_lookups
-                    .parent_block_processed(chain_hash, result, &mut self.network),
-            },
+            } => self
+                .block_lookups
+                .on_processing_result(process_type, result, &mut self.network),
+            SyncMessage::GossipBlockProcessResult {
+                block_root,
+                imported,
+            } => self.block_lookups.on_external_processing_result(
+                block_root,
+                imported,
+                &mut self.network,
+            ),
             SyncMessage::BatchProcessed { sync_type, result } => match sync_type {
                 ChainSegmentProcessId::RangeBatchId(chain_id, epoch) => {
                     self.range_sync.handle_block_process_result(
@@ -710,9 +672,6 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                         }
                     }
                 }
-                ChainSegmentProcessId::ParentLookup(chain_hash) => self
-                    .block_lookups
-                    .parent_chain_processed(chain_hash, result, &self.network),
             },
         }
     }
@@ -723,23 +682,16 @@ impl<T: BeaconChainTypes> SyncManager<T> {
         block_root: Hash256,
         parent_root: Hash256,
         slot: Slot,
-        child_components: ChildComponents<T::EthSpec>,
+        block_component: BlockComponent<T::EthSpec>,
     ) {
-        match self.should_search_for_block(slot, &peer_id) {
+        match self.should_search_for_block(Some(slot), &peer_id) {
             Ok(_) => {
-                self.block_lookups.search_parent(
-                    slot,
+                self.block_lookups.search_child_and_parent(
                     block_root,
-                    parent_root,
+                    block_component,
                     peer_id,
                     &mut self.network,
                 );
-                self.block_lookups.search_child_block(
-                    block_root,
-                    child_components,
-                    &[peer_id],
-                    &mut self.network,
-                );
             }
             Err(reason) => {
                 debug!(self.log, "Ignoring unknown parent request"; "block_root" => %block_root, "parent_root" => %parent_root, "reason" => reason);
@@ -747,12 +699,28 @@ impl<T: BeaconChainTypes> SyncManager<T> {
         }
     }
 
+    fn handle_unknown_block_root(&mut self, peer_id: PeerId, block_root: Hash256) {
+        match self.should_search_for_block(None, &peer_id) {
+            Ok(_) => {
+                self.block_lookups
+                    .search_unknown_block(block_root, &[peer_id], &mut self.network);
+            }
+            Err(reason) => {
+                debug!(self.log, "Ignoring unknown block request"; "block_root" => %block_root, "reason" => reason);
+            }
+        }
+    }
+
     fn should_search_for_block(
         &mut self,
-        block_slot: Slot,
+        block_slot: Option<Slot>,
         peer_id: &PeerId,
     ) -> Result<(), &'static str> {
         if !self.network_globals().sync_state.read().is_synced() {
+            let Some(block_slot) = block_slot else {
+                return Err("not synced");
+            };
+
             let head_slot = self.chain.canonical_head.cached_head().head_slot();
 
             // if the block is far in the future, ignore it. If its within the slot tolerance of
@@ -775,15 +743,6 @@ impl<T: BeaconChainTypes> SyncManager<T> {
         Ok(())
     }
 
-    fn synced(&mut self) -> bool {
-        self.network_globals().sync_state.read().is_synced()
-            && self.network.is_execution_engine_online()
-    }
-
-    fn synced_and_connected(&mut self, peer_id: &PeerId) -> bool {
-        self.synced() && self.network_globals().peers.read().is_connected(peer_id)
-    }
-
     fn handle_new_execution_engine_state(&mut self, engine_state: EngineState) {
         self.network.update_execution_engine_state(engine_state);
 
@@ -816,11 +775,6 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                 let dropped_single_blocks_requests =
                     self.block_lookups.drop_single_block_requests();
 
-                // - Parent lookups:
-                //   Disabled while in this state. We drop current requests and don't search for new
-                //   blocks.
-                let dropped_parent_chain_requests = self.block_lookups.drop_parent_chain_requests();
-
                 // - Range:
                 //   We still send found peers to range so that it can keep track of potential chains
                 //   with respect to our current peers. Range will stop processing batches in the
@@ -829,10 +783,9 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                 // - Backfill: Not affected by ee states, nothing to do.
 
                 // Some logs.
-                if dropped_single_blocks_requests > 0 || dropped_parent_chain_requests > 0 {
+                if dropped_single_blocks_requests > 0 {
                     debug!(self.log, "Execution engine not online. Dropping active requests.";
                         "dropped_single_blocks_requests" => dropped_single_blocks_requests,
-                        "dropped_parent_chain_requests" => dropped_parent_chain_requests,
                     );
                 }
             }
@@ -847,79 +800,40 @@ impl<T: BeaconChainTypes> SyncManager<T> {
         seen_timestamp: Duration,
     ) {
         match request_id {
-            RequestId::SingleBlock { id } => self
-                .block_lookups
-                .single_lookup_response::<BlockRequestState<Current>>(
-                    id,
-                    peer_id,
-                    block,
-                    seen_timestamp,
-                    &self.network,
-                ),
+            RequestId::SingleBlock { id } => self.on_single_block_response(
+                id,
+                peer_id,
+                match block {
+                    Some(block) => RpcEvent::Response(block, seen_timestamp),
+                    None => RpcEvent::StreamTermination,
+                },
+            ),
             RequestId::SingleBlob { .. } => {
                 crit!(self.log, "Block received during blob request"; "peer_id" => %peer_id  );
             }
-            RequestId::ParentLookup { id } => self
-                .block_lookups
-                .parent_lookup_response::<BlockRequestState<Parent>>(
-                    id,
-                    peer_id,
-                    block,
-                    seen_timestamp,
-                    &self.network,
-                ),
-            RequestId::ParentLookupBlob { id: _ } => {
-                crit!(self.log, "Block received during parent blob request"; "peer_id" => %peer_id  );
-            }
-            RequestId::BackFillBlocks { id } => {
-                let is_stream_terminator = block.is_none();
-                if let Some(batch_id) = self
-                    .network
-                    .backfill_sync_only_blocks_response(id, is_stream_terminator)
-                {
-                    match self.backfill_sync.on_block_response(
-                        &mut self.network,
-                        batch_id,
-                        &peer_id,
-                        id,
-                        block.map(|b| RpcBlock::new_without_blobs(None, b)),
-                    ) {
-                        Ok(ProcessResult::SyncCompleted) => self.update_sync_state(),
-                        Ok(ProcessResult::Successful) => {}
-                        Err(_error) => {
-                            // The backfill sync has failed, errors are reported
-                            // within.
-                            self.update_sync_state();
-                        }
-                    }
-                }
-            }
-            RequestId::RangeBlocks { id } => {
-                let is_stream_terminator = block.is_none();
-                if let Some((chain_id, batch_id)) = self
-                    .network
-                    .range_sync_block_only_response(id, is_stream_terminator)
-                {
-                    self.range_sync.blocks_by_range_response(
-                        &mut self.network,
-                        peer_id,
-                        chain_id,
-                        batch_id,
-                        id,
-                        block.map(|b| RpcBlock::new_without_blobs(None, b)),
-                    );
-                    self.update_sync_state();
-                }
-            }
-            RequestId::BackFillBlockAndBlobs { id } => {
-                self.backfill_block_and_blobs_response(id, peer_id, block.into())
-            }
             RequestId::RangeBlockAndBlobs { id } => {
                 self.range_block_and_blobs_response(id, peer_id, block.into())
             }
         }
     }
 
+    fn on_single_block_response(
+        &mut self,
+        id: SingleLookupReqId,
+        peer_id: PeerId,
+        block: RpcEvent<Arc<SignedBeaconBlock<T::EthSpec>>>,
+    ) {
+        if let Some(resp) = self.network.on_single_block_response(id, peer_id, block) {
+            self.block_lookups
+                .on_download_response::<BlockRequestState<T::EthSpec>>(
+                    id,
+                    peer_id,
+                    resp,
+                    &mut self.network,
+                )
+        }
+    }
+
     fn rpc_blob_received(
         &mut self,
         request_id: RequestId,
@@ -931,107 +845,40 @@ impl<T: BeaconChainTypes> SyncManager<T> {
             RequestId::SingleBlock { .. } => {
                 crit!(self.log, "Single blob received during block request"; "peer_id" => %peer_id  );
             }
-            RequestId::SingleBlob { id } => self
-                .block_lookups
-                .single_lookup_response::<BlobRequestState<Current, T::EthSpec>>(
-                    id,
-                    peer_id,
-                    blob,
-                    seen_timestamp,
-                    &self.network,
-                ),
-
-            RequestId::ParentLookup { id: _ } => {
-                crit!(self.log, "Single blob received during parent block request"; "peer_id" => %peer_id  );
-            }
-            RequestId::ParentLookupBlob { id } => self
-                .block_lookups
-                .parent_lookup_response::<BlobRequestState<Parent, T::EthSpec>>(
-                    id,
-                    peer_id,
-                    blob,
-                    seen_timestamp,
-                    &self.network,
-                ),
-            RequestId::BackFillBlocks { id: _ } => {
-                crit!(self.log, "Blob received during backfill block request"; "peer_id" => %peer_id  );
-            }
-            RequestId::RangeBlocks { id: _ } => {
-                crit!(self.log, "Blob received during range block request"; "peer_id" => %peer_id  );
-            }
-            RequestId::BackFillBlockAndBlobs { id } => {
-                self.backfill_block_and_blobs_response(id, peer_id, blob.into())
-            }
+            RequestId::SingleBlob { id } => self.on_single_blob_response(
+                id,
+                peer_id,
+                match blob {
+                    Some(blob) => RpcEvent::Response(blob, seen_timestamp),
+                    None => RpcEvent::StreamTermination,
+                },
+            ),
             RequestId::RangeBlockAndBlobs { id } => {
                 self.range_block_and_blobs_response(id, peer_id, blob.into())
             }
         }
     }
 
-    /// Handles receiving a response for a range sync request that should have both blocks and
-    /// blobs.
-    fn range_block_and_blobs_response(
+    fn on_single_blob_response(
         &mut self,
-        id: Id,
+        id: SingleLookupReqId,
         peer_id: PeerId,
-        block_or_blob: BlockOrBlob<T::EthSpec>,
+        blob: RpcEvent<Arc<BlobSidecar<T::EthSpec>>>,
     ) {
-        if let Some((chain_id, resp)) = self
-            .network
-            .range_sync_block_and_blob_response(id, block_or_blob)
-        {
-            match resp.responses {
-                Ok(blocks) => {
-                    for block in blocks
-                        .into_iter()
-                        .map(Some)
-                        // chain the stream terminator
-                        .chain(vec![None])
-                    {
-                        self.range_sync.blocks_by_range_response(
-                            &mut self.network,
-                            peer_id,
-                            chain_id,
-                            resp.batch_id,
-                            id,
-                            block,
-                        );
-                        self.update_sync_state();
-                    }
-                }
-                Err(e) => {
-                    // Re-insert the request so we can retry
-                    let new_req = BlocksAndBlobsByRangeRequest {
-                        chain_id,
-                        batch_id: resp.batch_id,
-                        block_blob_info: <_>::default(),
-                    };
-                    self.network
-                        .insert_range_blocks_and_blobs_request(id, new_req);
-                    // inform range that the request needs to be treated as failed
-                    // With time we will want to downgrade this log
-                    warn!(
-                        self.log,
-                        "Blocks and blobs request for range received invalid data";
-                        "peer_id" => %peer_id,
-                        "batch_id" => resp.batch_id,
-                        "error" => e.clone()
-                    );
-                    let id = RequestId::RangeBlockAndBlobs { id };
-                    self.network.report_peer(
-                        peer_id,
-                        PeerAction::MidToleranceError,
-                        "block_blob_faulty_batch",
-                    );
-                    self.inject_error(peer_id, id, RPCError::InvalidData(e))
-                }
-            }
+        if let Some(resp) = self.network.on_single_blob_response(id, peer_id, blob) {
+            self.block_lookups
+                .on_download_response::<BlobRequestState<T::EthSpec>>(
+                    id,
+                    peer_id,
+                    resp,
+                    &mut self.network,
+                )
         }
     }
 
-    /// Handles receiving a response for a Backfill sync request that should have both blocks and
+    /// Handles receiving a response for a range sync request that should have both blocks and
     /// blobs.
-    fn backfill_block_and_blobs_response(
+    fn range_block_and_blobs_response(
         &mut self,
         id: Id,
         peer_id: PeerId,
@@ -1039,7 +886,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
     ) {
         if let Some(resp) = self
             .network
-            .backfill_sync_block_and_blob_response(id, block_or_blob)
+            .range_block_and_blob_response(id, block_or_blob)
         {
             match resp.responses {
                 Ok(blocks) => {
@@ -1049,42 +896,59 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                         // chain the stream terminator
                         .chain(vec![None])
                     {
-                        match self.backfill_sync.on_block_response(
-                            &mut self.network,
-                            resp.batch_id,
-                            &peer_id,
-                            id,
-                            block,
-                        ) {
-                            Ok(ProcessResult::SyncCompleted) => self.update_sync_state(),
-                            Ok(ProcessResult::Successful) => {}
-                            Err(_error) => {
-                                // The backfill sync has failed, errors are reported
-                                // within.
+                        match resp.sender_id {
+                            RangeRequestId::RangeSync { chain_id, batch_id } => {
+                                self.range_sync.blocks_by_range_response(
+                                    &mut self.network,
+                                    peer_id,
+                                    chain_id,
+                                    batch_id,
+                                    id,
+                                    block,
+                                );
                                 self.update_sync_state();
                             }
+                            RangeRequestId::BackfillSync { batch_id } => {
+                                match self.backfill_sync.on_block_response(
+                                    &mut self.network,
+                                    batch_id,
+                                    &peer_id,
+                                    id,
+                                    block,
+                                ) {
+                                    Ok(ProcessResult::SyncCompleted) => self.update_sync_state(),
+                                    Ok(ProcessResult::Successful) => {}
+                                    Err(_error) => {
+                                        // The backfill sync has failed, errors are reported
+                                        // within.
+                                        self.update_sync_state();
+                                    }
+                                }
+                            }
                         }
                     }
                 }
                 Err(e) => {
                     // Re-insert the request so we can retry
-                    self.network.insert_backfill_blocks_and_blobs_requests(
+                    self.network.insert_range_blocks_and_blobs_request(
                         id,
-                        resp.batch_id,
-                        <_>::default(),
+                        resp.sender_id,
+                        BlocksAndBlobsRequestInfo::new(resp.request_type),
                     );
-
-                    // inform backfill that the request needs to be treated as failed
+                    // inform range that the request needs to be treated as failed
                     // With time we will want to downgrade this log
                     warn!(
-                        self.log, "Blocks and blobs request for backfill received invalid data";
-                        "peer_id" => %peer_id, "batch_id" => resp.batch_id, "error" => e.clone()
+                        self.log,
+                        "Blocks and blobs request for range received invalid data";
+                        "peer_id" => %peer_id,
+                        "sender_id" => ?resp.sender_id,
+                        "error" => e.clone()
                     );
-                    let id = RequestId::BackFillBlockAndBlobs { id };
+                    let id = RequestId::RangeBlockAndBlobs { id };
                     self.network.report_peer(
                         peer_id,
                         PeerAction::MidToleranceError,
-                        "block_blob_faulty_backfill_batch",
+                        "block_blob_faulty_batch",
                     );
                     self.inject_error(peer_id, id, RPCError::InvalidData(e))
                 }
diff --git a/beacon_node/network/src/sync/network_context.rs b/beacon_node/network/src/sync/network_context.rs
index f15105781f0..8693bc0c6c4 100644
--- a/beacon_node/network/src/sync/network_context.rs
+++ b/beacon_node/network/src/sync/network_context.rs
@@ -1,35 +1,99 @@
 //! Provides network functionality for the Syncing thread. This fundamentally wraps a network
 //! channel and stores a global RPC ID to perform requests.
 
+use self::requests::{ActiveBlobsByRootRequest, ActiveBlocksByRootRequest};
+pub use self::requests::{BlobsByRootSingleBlockRequest, BlocksByRootSingleRequest};
 use super::block_sidecar_coupling::BlocksAndBlobsRequestInfo;
 use super::manager::{Id, RequestId as SyncRequestId};
 use super::range_sync::{BatchId, ByRangeRequestType, ChainId};
 use crate::network_beacon_processor::NetworkBeaconProcessor;
 use crate::service::{NetworkMessage, RequestId};
 use crate::status::ToStatusMessage;
-use crate::sync::block_lookups::common::LookupType;
-use crate::sync::manager::SingleLookupReqId;
+use crate::sync::block_lookups::SingleLookupId;
+use crate::sync::manager::{BlockProcessType, SingleLookupReqId};
 use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::{BeaconChain, BeaconChainTypes, EngineState};
 use fnv::FnvHashMap;
-use lighthouse_network::rpc::methods::{BlobsByRangeRequest, BlobsByRootRequest};
-use lighthouse_network::rpc::{BlocksByRangeRequest, BlocksByRootRequest, GoodbyeReason};
+use lighthouse_network::rpc::methods::BlobsByRangeRequest;
+use lighthouse_network::rpc::{BlocksByRangeRequest, GoodbyeReason, RPCError};
 use lighthouse_network::{Client, NetworkGlobals, PeerAction, PeerId, ReportSource, Request};
-use slog::{debug, trace, warn};
+pub use requests::LookupVerifyError;
+use slog::{debug, error, trace, warn};
 use std::collections::hash_map::Entry;
 use std::sync::Arc;
+use std::time::Duration;
 use tokio::sync::mpsc;
-use types::{BlobSidecar, EthSpec, SignedBeaconBlock};
+use types::blob_sidecar::FixedBlobSidecarList;
+use types::{BlobSidecar, EthSpec, Hash256, SignedBeaconBlock};
+
+mod requests;
 
 pub struct BlocksAndBlobsByRangeResponse<E: EthSpec> {
-    pub batch_id: BatchId,
+    pub sender_id: RangeRequestId,
     pub responses: Result<Vec<RpcBlock<E>>, String>,
+    pub request_type: ByRangeRequestType,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum RangeRequestId {
+    RangeSync {
+        chain_id: ChainId,
+        batch_id: BatchId,
+    },
+    BackfillSync {
+        batch_id: BatchId,
+    },
+}
+
+#[derive(Debug)]
+pub enum RpcEvent<T> {
+    StreamTermination,
+    Response(T, Duration),
+    RPCError(RPCError),
+}
+
+pub type RpcProcessingResult<T> = Result<(T, Duration), LookupFailure>;
+
+pub enum LookupFailure {
+    RpcError(RPCError),
+    LookupVerifyError(LookupVerifyError),
+}
+
+impl std::fmt::Display for LookupFailure {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            LookupFailure::RpcError(e) => write!(f, "RPC Error: {:?}", e),
+            LookupFailure::LookupVerifyError(e) => write!(f, "Lookup Verify Error: {:?}", e),
+        }
+    }
+}
+
+impl From<RPCError> for LookupFailure {
+    fn from(e: RPCError) -> Self {
+        LookupFailure::RpcError(e)
+    }
 }
 
-pub struct BlocksAndBlobsByRangeRequest<E: EthSpec> {
-    pub chain_id: ChainId,
-    pub batch_id: BatchId,
-    pub block_blob_info: BlocksAndBlobsRequestInfo<E>,
+impl From<LookupVerifyError> for LookupFailure {
+    fn from(e: LookupVerifyError) -> Self {
+        LookupFailure::LookupVerifyError(e)
+    }
+}
+
+/// Sequential ID that uniquely identifies ReqResp outgoing requests
+pub type ReqId = u32;
+
+pub enum LookupRequestResult {
+    /// A request is sent. Sync MUST receive an event from the network in the future for either:
+    /// completed response or failed request
+    RequestSent(ReqId),
+    /// No request is sent, and no further action is necessary to consider this request completed
+    NoRequestNeeded,
+    /// No request is sent, but the request is not completed. Sync MUST receive some future event
+    /// that makes progress on the request. For example: request is processing from a different
+    /// source (i.e. block received from gossip) and sync MUST receive an event with that processing
+    /// result.
+    Pending,
 }
 
 /// Wraps a Network channel to employ various RPC related network functionality for the Sync manager. This includes management of a global RPC request Id.
@@ -40,18 +104,15 @@ pub struct SyncNetworkContext<T: BeaconChainTypes> {
     /// A sequential ID for all RPC requests.
     request_id: Id,
 
-    /// BlocksByRange requests made by the range syncing algorithm.
-    range_requests: FnvHashMap<Id, (ChainId, BatchId)>,
+    /// A mapping of active BlocksByRoot requests, including both current slot and parent lookups.
+    blocks_by_root_requests: FnvHashMap<SingleLookupReqId, ActiveBlocksByRootRequest>,
 
-    /// BlocksByRange requests made by backfill syncing.
-    backfill_requests: FnvHashMap<Id, BatchId>,
+    /// A mapping of active BlobsByRoot requests, including both current slot and parent lookups.
+    blobs_by_root_requests: FnvHashMap<SingleLookupReqId, ActiveBlobsByRootRequest<T::EthSpec>>,
 
-    /// BlocksByRange requests paired with BlobsByRange requests made by the range.
-    range_blocks_and_blobs_requests: FnvHashMap<Id, BlocksAndBlobsByRangeRequest<T::EthSpec>>,
-
-    /// BlocksByRange requests paired with BlobsByRange requests made by the backfill sync.
-    backfill_blocks_and_blobs_requests:
-        FnvHashMap<Id, (BatchId, BlocksAndBlobsRequestInfo<T::EthSpec>)>,
+    /// BlocksByRange requests paired with BlobsByRange
+    range_blocks_and_blobs_requests:
+        FnvHashMap<Id, (RangeRequestId, BlocksAndBlobsRequestInfo<T::EthSpec>)>,
 
     /// Whether the ee is online. If it's not, we don't allow access to the
     /// `beacon_processor_send`.
@@ -95,10 +156,9 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
             network_send,
             execution_engine_state: EngineState::Online, // always assume `Online` at the start
             request_id: 1,
-            range_requests: FnvHashMap::default(),
-            backfill_requests: FnvHashMap::default(),
+            blocks_by_root_requests: <_>::default(),
+            blobs_by_root_requests: <_>::default(),
             range_blocks_and_blobs_requests: FnvHashMap::default(),
-            backfill_blocks_and_blobs_requests: FnvHashMap::default(),
             network_beacon_processor,
             chain,
             log,
@@ -149,266 +209,85 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
         peer_id: PeerId,
         batch_type: ByRangeRequestType,
         request: BlocksByRangeRequest,
-        chain_id: ChainId,
-        batch_id: BatchId,
     ) -> Result<Id, &'static str> {
-        match batch_type {
-            ByRangeRequestType::Blocks => {
-                trace!(
-                    self.log,
-                    "Sending BlocksByRange request";
-                    "method" => "BlocksByRange",
-                    "count" => request.count(),
-                    "peer" => %peer_id,
-                );
-                let request = Request::BlocksByRange(request);
-                let id = self.next_id();
-                let request_id = RequestId::Sync(SyncRequestId::RangeBlocks { id });
-                self.send_network_msg(NetworkMessage::SendRequest {
-                    peer_id,
-                    request,
-                    request_id,
-                })?;
-                self.range_requests.insert(id, (chain_id, batch_id));
-                Ok(id)
-            }
-            ByRangeRequestType::BlocksAndBlobs => {
-                debug!(
-                    self.log,
-                    "Sending BlocksByRange and BlobsByRange requests";
-                    "method" => "Mixed by range request",
-                    "count" => request.count(),
-                    "peer" => %peer_id,
-                );
-
-                // create the shared request id. This is fine since the rpc handles substream ids.
-                let id = self.next_id();
-                let request_id = RequestId::Sync(SyncRequestId::RangeBlockAndBlobs { id });
-
-                // Create the blob request based on the blob request.
-                let blobs_request = Request::BlobsByRange(BlobsByRangeRequest {
+        let id = self.next_id();
+        trace!(
+            self.log,
+            "Sending BlocksByRange request";
+            "method" => "BlocksByRange",
+            "count" => request.count(),
+            "peer" => %peer_id,
+        );
+        self.send_network_msg(NetworkMessage::SendRequest {
+            peer_id,
+            request: Request::BlocksByRange(request.clone()),
+            request_id: RequestId::Sync(SyncRequestId::RangeBlockAndBlobs { id }),
+        })?;
+
+        if matches!(batch_type, ByRangeRequestType::BlocksAndBlobs) {
+            debug!(
+                self.log,
+                "Sending BlobsByRange requests";
+                "method" => "BlobsByRange",
+                "count" => request.count(),
+                "peer" => %peer_id,
+            );
+
+            // Create the blob request based on the blocks request.
+            self.send_network_msg(NetworkMessage::SendRequest {
+                peer_id,
+                request: Request::BlobsByRange(BlobsByRangeRequest {
                     start_slot: *request.start_slot(),
                     count: *request.count(),
-                });
-                let blocks_request = Request::BlocksByRange(request);
-
-                // Send both requests. Make sure both can be sent.
-                self.send_network_msg(NetworkMessage::SendRequest {
-                    peer_id,
-                    request: blocks_request,
-                    request_id,
-                })?;
-                self.send_network_msg(NetworkMessage::SendRequest {
-                    peer_id,
-                    request: blobs_request,
-                    request_id,
-                })?;
-                let block_blob_info = BlocksAndBlobsRequestInfo::default();
-                self.range_blocks_and_blobs_requests.insert(
-                    id,
-                    BlocksAndBlobsByRangeRequest {
-                        chain_id,
-                        batch_id,
-                        block_blob_info,
-                    },
-                );
-                Ok(id)
-            }
+                }),
+                request_id: RequestId::Sync(SyncRequestId::RangeBlockAndBlobs { id }),
+            })?;
         }
+
+        Ok(id)
     }
 
-    /// A blocks by range request sent by the backfill sync algorithm
-    pub fn backfill_blocks_by_range_request(
+    /// A blocks by range request sent by the range sync algorithm
+    pub fn blocks_and_blobs_by_range_request(
         &mut self,
         peer_id: PeerId,
         batch_type: ByRangeRequestType,
         request: BlocksByRangeRequest,
-        batch_id: BatchId,
+        sender_id: RangeRequestId,
     ) -> Result<Id, &'static str> {
-        match batch_type {
-            ByRangeRequestType::Blocks => {
-                trace!(
-                    self.log,
-                    "Sending backfill BlocksByRange request";
-                    "method" => "BlocksByRange",
-                    "count" => request.count(),
-                    "peer" => %peer_id,
-                );
-                let request = Request::BlocksByRange(request);
-                let id = self.next_id();
-                let request_id = RequestId::Sync(SyncRequestId::BackFillBlocks { id });
-                self.send_network_msg(NetworkMessage::SendRequest {
-                    peer_id,
-                    request,
-                    request_id,
-                })?;
-                self.backfill_requests.insert(id, batch_id);
-                Ok(id)
-            }
-            ByRangeRequestType::BlocksAndBlobs => {
-                debug!(
-                    self.log,
-                    "Sending backfill BlocksByRange and BlobsByRange requests";
-                    "method" => "Mixed by range request",
-                    "count" => request.count(),
-                    "peer" => %peer_id,
-                );
-
-                // create the shared request id. This is fine since the rpc handles substream ids.
-                let id = self.next_id();
-                let request_id = RequestId::Sync(SyncRequestId::BackFillBlockAndBlobs { id });
-
-                // Create the blob request based on the blob request.
-                let blobs_request = Request::BlobsByRange(BlobsByRangeRequest {
-                    start_slot: *request.start_slot(),
-                    count: *request.count(),
-                });
-                let blocks_request = Request::BlocksByRange(request);
-
-                // Send both requests. Make sure both can be sent.
-                self.send_network_msg(NetworkMessage::SendRequest {
-                    peer_id,
-                    request: blocks_request,
-                    request_id,
-                })?;
-                self.send_network_msg(NetworkMessage::SendRequest {
-                    peer_id,
-                    request: blobs_request,
-                    request_id,
-                })?;
-                let block_blob_info = BlocksAndBlobsRequestInfo::default();
-                self.backfill_blocks_and_blobs_requests
-                    .insert(id, (batch_id, block_blob_info));
-                Ok(id)
-            }
-        }
-    }
-
-    /// Response for a request that is only for blocks.
-    pub fn range_sync_block_only_response(
-        &mut self,
-        request_id: Id,
-        is_stream_terminator: bool,
-    ) -> Option<(ChainId, BatchId)> {
-        if is_stream_terminator {
-            self.range_requests.remove(&request_id)
-        } else {
-            self.range_requests.get(&request_id).copied()
-        }
+        let id = self.blocks_by_range_request(peer_id, batch_type, request)?;
+        self.range_blocks_and_blobs_requests
+            .insert(id, (sender_id, BlocksAndBlobsRequestInfo::new(batch_type)));
+        Ok(id)
     }
 
-    /// Received a blocks by range response for a request that couples blocks and blobs.
-    pub fn range_sync_block_and_blob_response(
-        &mut self,
-        request_id: Id,
-        block_or_blob: BlockOrBlob<T::EthSpec>,
-    ) -> Option<(ChainId, BlocksAndBlobsByRangeResponse<T::EthSpec>)> {
-        match self.range_blocks_and_blobs_requests.entry(request_id) {
-            Entry::Occupied(mut entry) => {
-                let req = entry.get_mut();
-                let info = &mut req.block_blob_info;
-                match block_or_blob {
-                    BlockOrBlob::Block(maybe_block) => info.add_block_response(maybe_block),
-                    BlockOrBlob::Blob(maybe_sidecar) => info.add_sidecar_response(maybe_sidecar),
-                }
-                if info.is_finished() {
-                    // If the request is finished, dequeue everything
-                    let BlocksAndBlobsByRangeRequest {
-                        chain_id,
-                        batch_id,
-                        block_blob_info,
-                    } = entry.remove();
-                    Some((
-                        chain_id,
-                        BlocksAndBlobsByRangeResponse {
-                            batch_id,
-                            responses: block_blob_info.into_responses(),
-                        },
-                    ))
-                } else {
-                    None
-                }
-            }
-            Entry::Vacant(_) => None,
-        }
-    }
-
-    pub fn range_sync_request_failed(
-        &mut self,
-        request_id: Id,
-        batch_type: ByRangeRequestType,
-    ) -> Option<(ChainId, BatchId)> {
-        let req = match batch_type {
-            ByRangeRequestType::BlocksAndBlobs => self
-                .range_blocks_and_blobs_requests
-                .remove(&request_id)
-                .map(|req| (req.chain_id, req.batch_id)),
-            ByRangeRequestType::Blocks => self.range_requests.remove(&request_id),
-        };
-        if let Some(req) = req {
+    pub fn range_request_failed(&mut self, request_id: Id) -> Option<RangeRequestId> {
+        let sender_id = self
+            .range_blocks_and_blobs_requests
+            .remove(&request_id)
+            .map(|(sender_id, _info)| sender_id);
+        if let Some(sender_id) = sender_id {
             debug!(
                 self.log,
-                "Range sync request failed";
+                "Sync range request failed";
                 "request_id" => request_id,
-                "batch_type" => ?batch_type,
-                "chain_id" => ?req.0,
-                "batch_id" => ?req.1
+                "sender_id" => ?sender_id
             );
-            Some(req)
+            Some(sender_id)
         } else {
-            debug!(self.log, "Range sync request failed"; "request_id" => request_id, "batch_type" => ?batch_type);
+            debug!(self.log, "Sync range request failed"; "request_id" => request_id);
             None
         }
     }
 
-    pub fn backfill_request_failed(
-        &mut self,
-        request_id: Id,
-        batch_type: ByRangeRequestType,
-    ) -> Option<BatchId> {
-        let batch_id = match batch_type {
-            ByRangeRequestType::BlocksAndBlobs => self
-                .backfill_blocks_and_blobs_requests
-                .remove(&request_id)
-                .map(|(batch_id, _info)| batch_id),
-            ByRangeRequestType::Blocks => self.backfill_requests.remove(&request_id),
-        };
-        if let Some(batch_id) = batch_id {
-            debug!(
-                self.log,
-                "Backfill sync request failed";
-                "request_id" => request_id,
-                "batch_type" => ?batch_type,
-                "batch_id" => ?batch_id
-            );
-            Some(batch_id)
-        } else {
-            debug!(self.log, "Backfill sync request failed"; "request_id" => request_id, "batch_type" => ?batch_type);
-            None
-        }
-    }
-
-    /// Response for a request that is only for blocks.
-    pub fn backfill_sync_only_blocks_response(
-        &mut self,
-        request_id: Id,
-        is_stream_terminator: bool,
-    ) -> Option<BatchId> {
-        if is_stream_terminator {
-            self.backfill_requests.remove(&request_id)
-        } else {
-            self.backfill_requests.get(&request_id).copied()
-        }
-    }
-
     /// Received a blocks by range or blobs by range response for a request that couples blocks '
     /// and blobs.
-    pub fn backfill_sync_block_and_blob_response(
+    pub fn range_block_and_blob_response(
         &mut self,
         request_id: Id,
         block_or_blob: BlockOrBlob<T::EthSpec>,
     ) -> Option<BlocksAndBlobsByRangeResponse<T::EthSpec>> {
-        match self.backfill_blocks_and_blobs_requests.entry(request_id) {
+        match self.range_blocks_and_blobs_requests.entry(request_id) {
             Entry::Occupied(mut entry) => {
                 let (_, info) = entry.get_mut();
                 match block_or_blob {
@@ -417,12 +296,12 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
                 }
                 if info.is_finished() {
                     // If the request is finished, dequeue everything
-                    let (batch_id, info) = entry.remove();
-
-                    let responses = info.into_responses();
+                    let (sender_id, info) = entry.remove();
+                    let request_type = info.get_request_type();
                     Some(BlocksAndBlobsByRangeResponse {
-                        batch_id,
-                        responses,
+                        sender_id,
+                        request_type,
+                        responses: info.into_responses(),
                     })
                 } else {
                     None
@@ -432,78 +311,133 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
         }
     }
 
+    /// Request block of `block_root` if necessary by checking:
+    /// - If the da_checker has a pending block from gossip or a previous request
+    ///
+    /// Returns false if no request was made, because the block is already imported
     pub fn block_lookup_request(
-        &self,
-        id: SingleLookupReqId,
+        &mut self,
+        lookup_id: SingleLookupId,
         peer_id: PeerId,
-        request: BlocksByRootRequest,
-        lookup_type: LookupType,
-    ) -> Result<(), &'static str> {
-        let sync_id = match lookup_type {
-            LookupType::Current => SyncRequestId::SingleBlock { id },
-            LookupType::Parent => SyncRequestId::ParentLookup { id },
-        };
-        let request_id = RequestId::Sync(sync_id);
+        block_root: Hash256,
+    ) -> Result<LookupRequestResult, &'static str> {
+        // da_checker includes block that are execution verified, but are missing components
+        if self
+            .chain
+            .data_availability_checker
+            .has_execution_valid_block(&block_root)
+        {
+            return Ok(LookupRequestResult::NoRequestNeeded);
+        }
+
+        // reqresp_pre_import_cache includes blocks that may not be yet execution verified
+        if self
+            .chain
+            .reqresp_pre_import_cache
+            .read()
+            .contains_key(&block_root)
+        {
+            // A block is on the `reqresp_pre_import_cache` but NOT in the
+            // `data_availability_checker` only if it is actively processing. We can expect a future
+            // event with the result of processing
+            return Ok(LookupRequestResult::Pending);
+        }
+
+        let req_id = self.next_id();
+        let id = SingleLookupReqId { lookup_id, req_id };
 
         debug!(
             self.log,
             "Sending BlocksByRoot Request";
             "method" => "BlocksByRoot",
-            "block_roots" => ?request.block_roots().to_vec(),
+            "block_root" => ?block_root,
             "peer" => %peer_id,
-            "lookup_type" => ?lookup_type
+            "id" => ?id
         );
 
+        let request = BlocksByRootSingleRequest(block_root);
+
         self.send_network_msg(NetworkMessage::SendRequest {
             peer_id,
-            request: Request::BlocksByRoot(request),
-            request_id,
+            request: Request::BlocksByRoot(request.into_request(&self.chain.spec)),
+            request_id: RequestId::Sync(SyncRequestId::SingleBlock { id }),
         })?;
-        Ok(())
+
+        self.blocks_by_root_requests
+            .insert(id, ActiveBlocksByRootRequest::new(request));
+
+        Ok(LookupRequestResult::RequestSent(req_id))
     }
 
+    /// Request necessary blobs for `block_root`. Requests only the necessary blobs by checking:
+    /// - If we have a downloaded but not yet processed block
+    /// - If the da_checker has a pending block
+    /// - If the da_checker has pending blobs from gossip
+    ///
+    /// Returns false if no request was made, because we don't need to import (more) blobs.
     pub fn blob_lookup_request(
-        &self,
-        id: SingleLookupReqId,
-        blob_peer_id: PeerId,
-        blob_request: BlobsByRootRequest,
-        lookup_type: LookupType,
-    ) -> Result<(), &'static str> {
-        let sync_id = match lookup_type {
-            LookupType::Current => SyncRequestId::SingleBlob { id },
-            LookupType::Parent => SyncRequestId::ParentLookupBlob { id },
+        &mut self,
+        lookup_id: SingleLookupId,
+        peer_id: PeerId,
+        block_root: Hash256,
+        downloaded_block_expected_blobs: Option<usize>,
+    ) -> Result<LookupRequestResult, &'static str> {
+        let Some(expected_blobs) = downloaded_block_expected_blobs.or_else(|| {
+            self.chain
+                .data_availability_checker
+                .num_expected_blobs(&block_root)
+        }) else {
+            // Wait to download the block before downloading blobs. Then we can be sure that the
+            // block has data, so there's no need to do "blind" requests for all possible blobs and
+            // latter handle the case where if the peer sent no blobs, penalize.
+            // - if `downloaded_block_expected_blobs` is Some = block is downloading or processing.
+            // - if `num_expected_blobs` returns Some = block is processed.
+            return Ok(LookupRequestResult::Pending);
         };
-        let request_id = RequestId::Sync(sync_id);
 
-        if let Some(block_root) = blob_request
-            .blob_ids
-            .as_slice()
-            .first()
-            .map(|id| id.block_root)
-        {
-            let indices = blob_request
-                .blob_ids
-                .as_slice()
-                .iter()
-                .map(|id| id.index)
-                .collect::<Vec<_>>();
-            debug!(
-                self.log,
-                "Sending BlobsByRoot Request";
-                "method" => "BlobsByRoot",
-                "block_root" => ?block_root,
-                "blob_indices" => ?indices,
-                "peer" => %blob_peer_id,
-                "lookup_type" => ?lookup_type
-            );
-
-            self.send_network_msg(NetworkMessage::SendRequest {
-                peer_id: blob_peer_id,
-                request: Request::BlobsByRoot(blob_request),
-                request_id,
-            })?;
+        let imported_blob_indexes = self
+            .chain
+            .data_availability_checker
+            .imported_blob_indexes(&block_root)
+            .unwrap_or_default();
+        // Include only the blob indexes not yet imported (received through gossip)
+        let indices = (0..expected_blobs as u64)
+            .filter(|index| !imported_blob_indexes.contains(index))
+            .collect::<Vec<_>>();
+
+        if indices.is_empty() {
+            // No blobs required, do not issue any request
+            return Ok(LookupRequestResult::NoRequestNeeded);
         }
-        Ok(())
+
+        let req_id = self.next_id();
+        let id = SingleLookupReqId { lookup_id, req_id };
+
+        debug!(
+            self.log,
+            "Sending BlobsByRoot Request";
+            "method" => "BlobsByRoot",
+            "block_root" => ?block_root,
+            "blob_indices" => ?indices,
+            "peer" => %peer_id,
+            "id" => ?id
+        );
+
+        let request = BlobsByRootSingleBlockRequest {
+            block_root,
+            indices,
+        };
+
+        self.send_network_msg(NetworkMessage::SendRequest {
+            peer_id,
+            request: Request::BlobsByRoot(request.clone().into_request(&self.chain.spec)),
+            request_id: RequestId::Sync(SyncRequestId::SingleBlob { id }),
+        })?;
+
+        self.blobs_by_root_requests
+            .insert(id, ActiveBlobsByRootRequest::new(request));
+
+        Ok(LookupRequestResult::RequestSent(req_id))
     }
 
     pub fn is_execution_engine_online(&self) -> bool {
@@ -531,7 +465,7 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
 
     /// Reports to the scoring algorithm the behaviour of a peer.
     pub fn report_peer(&self, peer_id: PeerId, action: PeerAction, msg: &'static str) {
-        debug!(self.log, "Sync reporting peer"; "peer_id" => %peer_id, "action" => %action);
+        debug!(self.log, "Sync reporting peer"; "peer_id" => %peer_id, "action" => %action, "msg" => %msg);
         self.network_send
             .send(NetworkMessage::ReportPeer {
                 peer_id,
@@ -601,18 +535,177 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
     pub fn insert_range_blocks_and_blobs_request(
         &mut self,
         id: Id,
-        request: BlocksAndBlobsByRangeRequest<T::EthSpec>,
+        sender_id: RangeRequestId,
+        info: BlocksAndBlobsRequestInfo<T::EthSpec>,
     ) {
-        self.range_blocks_and_blobs_requests.insert(id, request);
+        self.range_blocks_and_blobs_requests
+            .insert(id, (sender_id, info));
+    }
+
+    // Request handlers
+
+    pub fn on_single_block_response(
+        &mut self,
+        request_id: SingleLookupReqId,
+        peer_id: PeerId,
+        block: RpcEvent<Arc<SignedBeaconBlock<T::EthSpec>>>,
+    ) -> Option<RpcProcessingResult<Arc<SignedBeaconBlock<T::EthSpec>>>> {
+        let Entry::Occupied(mut request) = self.blocks_by_root_requests.entry(request_id) else {
+            return None;
+        };
+
+        let resp = match block {
+            RpcEvent::Response(block, seen_timestamp) => {
+                match request.get_mut().add_response(block) {
+                    Ok(block) => Ok((block, seen_timestamp)),
+                    Err(e) => {
+                        // The request must be dropped after receiving an error.
+                        request.remove();
+                        Err(e.into())
+                    }
+                }
+            }
+            RpcEvent::StreamTermination => match request.remove().terminate() {
+                Ok(_) => return None,
+                Err(e) => Err(e.into()),
+            },
+            RpcEvent::RPCError(e) => {
+                request.remove();
+                Err(e.into())
+            }
+        };
+
+        if let Err(LookupFailure::LookupVerifyError(e)) = &resp {
+            self.report_peer(peer_id, PeerAction::LowToleranceError, e.into());
+        }
+        Some(resp)
     }
 
-    pub fn insert_backfill_blocks_and_blobs_requests(
+    pub fn on_single_blob_response(
         &mut self,
+        request_id: SingleLookupReqId,
+        peer_id: PeerId,
+        blob: RpcEvent<Arc<BlobSidecar<T::EthSpec>>>,
+    ) -> Option<RpcProcessingResult<FixedBlobSidecarList<T::EthSpec>>> {
+        let Entry::Occupied(mut request) = self.blobs_by_root_requests.entry(request_id) else {
+            return None;
+        };
+
+        let resp = match blob {
+            RpcEvent::Response(blob, seen_timestamp) => {
+                let request = request.get_mut();
+                match request.add_response(blob) {
+                    Ok(Some(blobs)) => to_fixed_blob_sidecar_list(blobs)
+                        .map(|blobs| (blobs, seen_timestamp))
+                        .map_err(|e| (e.into(), request.resolve())),
+                    Ok(None) => return None,
+                    Err(e) => Err((e.into(), request.resolve())),
+                }
+            }
+            RpcEvent::StreamTermination => match request.remove().terminate() {
+                Ok(_) => return None,
+                // (err, false = not resolved) because terminate returns Ok() if resolved
+                Err(e) => Err((e.into(), false)),
+            },
+            RpcEvent::RPCError(e) => Err((e.into(), request.remove().resolve())),
+        };
+
+        match resp {
+            Ok(resp) => Some(Ok(resp)),
+            // Track if this request has already returned some value downstream. Ensure that
+            // downstream code only receives a single Result per request. If the serving peer does
+            // multiple penalizable actions per request, downscore and return None. This allows to
+            // catch if a peer is returning more blobs than requested or if the excess blobs are
+            // invalid.
+            Err((e, resolved)) => {
+                if let LookupFailure::LookupVerifyError(e) = &e {
+                    self.report_peer(peer_id, PeerAction::LowToleranceError, e.into());
+                }
+                if resolved {
+                    None
+                } else {
+                    Some(Err(e))
+                }
+            }
+        }
+    }
+
+    pub fn send_block_for_processing(
+        &self,
         id: Id,
-        batch_id: BatchId,
-        request: BlocksAndBlobsRequestInfo<T::EthSpec>,
-    ) {
-        self.backfill_blocks_and_blobs_requests
-            .insert(id, (batch_id, request));
+        block_root: Hash256,
+        block: RpcBlock<T::EthSpec>,
+        duration: Duration,
+    ) -> Result<(), &'static str> {
+        match self.beacon_processor_if_enabled() {
+            Some(beacon_processor) => {
+                debug!(self.log, "Sending block for processing"; "block" => ?block_root, "id" => id);
+                if let Err(e) = beacon_processor.send_rpc_beacon_block(
+                    block_root,
+                    block,
+                    duration,
+                    BlockProcessType::SingleBlock { id },
+                ) {
+                    error!(
+                        self.log,
+                        "Failed to send sync block to processor";
+                        "error" => ?e
+                    );
+                    Err("beacon processor send failure")
+                } else {
+                    Ok(())
+                }
+            }
+            None => {
+                trace!(self.log, "Dropping block ready for processing. Beacon processor not available"; "block" => %block_root);
+                Err("beacon processor unavailable")
+            }
+        }
+    }
+
+    pub fn send_blobs_for_processing(
+        &self,
+        id: Id,
+        block_root: Hash256,
+        blobs: FixedBlobSidecarList<T::EthSpec>,
+        duration: Duration,
+    ) -> Result<(), &'static str> {
+        match self.beacon_processor_if_enabled() {
+            Some(beacon_processor) => {
+                debug!(self.log, "Sending blobs for processing"; "block" => ?block_root, "id" => id);
+                if let Err(e) = beacon_processor.send_rpc_blobs(
+                    block_root,
+                    blobs,
+                    duration,
+                    BlockProcessType::SingleBlob { id },
+                ) {
+                    error!(
+                        self.log,
+                        "Failed to send sync blobs to processor";
+                        "error" => ?e
+                    );
+                    Err("beacon processor send failure")
+                } else {
+                    Ok(())
+                }
+            }
+            None => {
+                trace!(self.log, "Dropping blobs ready for processing. Beacon processor not available"; "block_root" => %block_root);
+                Err("beacon processor unavailable")
+            }
+        }
+    }
+}
+
+fn to_fixed_blob_sidecar_list<E: EthSpec>(
+    blobs: Vec<Arc<BlobSidecar<E>>>,
+) -> Result<FixedBlobSidecarList<E>, LookupVerifyError> {
+    let mut fixed_list = FixedBlobSidecarList::default();
+    for blob in blobs.into_iter() {
+        let index = blob.index as usize;
+        *fixed_list
+            .get_mut(index)
+            .ok_or(LookupVerifyError::UnrequestedBlobIndex(index as u64))? = Some(blob)
     }
+    Ok(fixed_list)
 }
diff --git a/beacon_node/network/src/sync/network_context/requests.rs b/beacon_node/network/src/sync/network_context/requests.rs
new file mode 100644
index 00000000000..cd73b4bebab
--- /dev/null
+++ b/beacon_node/network/src/sync/network_context/requests.rs
@@ -0,0 +1,159 @@
+use beacon_chain::get_block_root;
+use lighthouse_network::rpc::{methods::BlobsByRootRequest, BlocksByRootRequest};
+use std::sync::Arc;
+use strum::IntoStaticStr;
+use types::{
+    blob_sidecar::BlobIdentifier, BlobSidecar, ChainSpec, EthSpec, Hash256, SignedBeaconBlock,
+};
+
+#[derive(Debug, PartialEq, Eq, IntoStaticStr)]
+pub enum LookupVerifyError {
+    NoResponseReturned,
+    NotEnoughResponsesReturned { expected: usize, actual: usize },
+    TooManyResponses,
+    UnrequestedBlockRoot(Hash256),
+    UnrequestedBlobIndex(u64),
+    InvalidInclusionProof,
+    DuplicateData,
+}
+
+pub struct ActiveBlocksByRootRequest {
+    request: BlocksByRootSingleRequest,
+    resolved: bool,
+}
+
+impl ActiveBlocksByRootRequest {
+    pub fn new(request: BlocksByRootSingleRequest) -> Self {
+        Self {
+            request,
+            resolved: false,
+        }
+    }
+
+    /// Append a response to the single chunk request. If the chunk is valid, the request is
+    /// resolved immediately.
+    /// The active request SHOULD be dropped after `add_response` returns an error
+    pub fn add_response<E: EthSpec>(
+        &mut self,
+        block: Arc<SignedBeaconBlock<E>>,
+    ) -> Result<Arc<SignedBeaconBlock<E>>, LookupVerifyError> {
+        if self.resolved {
+            return Err(LookupVerifyError::TooManyResponses);
+        }
+
+        let block_root = get_block_root(&block);
+        if self.request.0 != block_root {
+            return Err(LookupVerifyError::UnrequestedBlockRoot(block_root));
+        }
+
+        // Valid data, blocks by root expects a single response
+        self.resolved = true;
+        Ok(block)
+    }
+
+    pub fn terminate(self) -> Result<(), LookupVerifyError> {
+        if self.resolved {
+            Ok(())
+        } else {
+            Err(LookupVerifyError::NoResponseReturned)
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct BlocksByRootSingleRequest(pub Hash256);
+
+impl BlocksByRootSingleRequest {
+    pub fn into_request(self, spec: &ChainSpec) -> BlocksByRootRequest {
+        BlocksByRootRequest::new(vec![self.0], spec)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct BlobsByRootSingleBlockRequest {
+    pub block_root: Hash256,
+    pub indices: Vec<u64>,
+}
+
+impl BlobsByRootSingleBlockRequest {
+    pub fn into_request(self, spec: &ChainSpec) -> BlobsByRootRequest {
+        BlobsByRootRequest::new(
+            self.indices
+                .into_iter()
+                .map(|index| BlobIdentifier {
+                    block_root: self.block_root,
+                    index,
+                })
+                .collect(),
+            spec,
+        )
+    }
+}
+
+pub struct ActiveBlobsByRootRequest<E: EthSpec> {
+    request: BlobsByRootSingleBlockRequest,
+    blobs: Vec<Arc<BlobSidecar<E>>>,
+    resolved: bool,
+}
+
+impl<E: EthSpec> ActiveBlobsByRootRequest<E> {
+    pub fn new(request: BlobsByRootSingleBlockRequest) -> Self {
+        Self {
+            request,
+            blobs: vec![],
+            resolved: false,
+        }
+    }
+
+    /// Appends a chunk to this multi-item request. If all expected chunks are received, this
+    /// method returns `Some`, resolving the request before the stream terminator.
+    /// The active request SHOULD be dropped after `add_response` returns an error
+    pub fn add_response(
+        &mut self,
+        blob: Arc<BlobSidecar<E>>,
+    ) -> Result<Option<Vec<Arc<BlobSidecar<E>>>>, LookupVerifyError> {
+        if self.resolved {
+            return Err(LookupVerifyError::TooManyResponses);
+        }
+
+        let block_root = blob.block_root();
+        if self.request.block_root != block_root {
+            return Err(LookupVerifyError::UnrequestedBlockRoot(block_root));
+        }
+        if !blob.verify_blob_sidecar_inclusion_proof().unwrap_or(false) {
+            return Err(LookupVerifyError::InvalidInclusionProof);
+        }
+        if !self.request.indices.contains(&blob.index) {
+            return Err(LookupVerifyError::UnrequestedBlobIndex(blob.index));
+        }
+        if self.blobs.iter().any(|b| b.index == blob.index) {
+            return Err(LookupVerifyError::DuplicateData);
+        }
+
+        self.blobs.push(blob);
+        if self.blobs.len() >= self.request.indices.len() {
+            // All expected chunks received, return result early
+            self.resolved = true;
+            Ok(Some(std::mem::take(&mut self.blobs)))
+        } else {
+            Ok(None)
+        }
+    }
+
+    pub fn terminate(self) -> Result<(), LookupVerifyError> {
+        if self.resolved {
+            Ok(())
+        } else {
+            Err(LookupVerifyError::NotEnoughResponsesReturned {
+                expected: self.request.indices.len(),
+                actual: self.blobs.len(),
+            })
+        }
+    }
+
+    /// Mark request as resolved (= has returned something downstream) while marking this status as
+    /// true for future calls.
+    pub fn resolve(&mut self) -> bool {
+        std::mem::replace(&mut self.resolved, true)
+    }
+}
diff --git a/beacon_node/network/src/sync/range_sync/chain.rs b/beacon_node/network/src/sync/range_sync/chain.rs
index 5a77340e3b5..9a6c99ebf6c 100644
--- a/beacon_node/network/src/sync/range_sync/chain.rs
+++ b/beacon_node/network/src/sync/range_sync/chain.rs
@@ -1,5 +1,6 @@
 use super::batch::{BatchInfo, BatchProcessingResult, BatchState};
 use crate::network_beacon_processor::ChainSegmentProcessId;
+use crate::sync::network_context::RangeRequestId;
 use crate::sync::{
     manager::Id, network_context::SyncNetworkContext, BatchOperationOutcome, BatchProcessResult,
 };
@@ -173,30 +174,8 @@ impl<T: BeaconChainTypes> SyncingChain<T> {
 
     /// Removes a peer from the chain.
     /// If the peer has active batches, those are considered failed and re-requested.
-    pub fn remove_peer(
-        &mut self,
-        peer_id: &PeerId,
-        network: &mut SyncNetworkContext<T>,
-    ) -> ProcessingResult {
-        if let Some(batch_ids) = self.peers.remove(peer_id) {
-            // fail the batches
-            for id in batch_ids {
-                if let Some(batch) = self.batches.get_mut(&id) {
-                    if let BatchOperationOutcome::Failed { blacklist } =
-                        batch.download_failed(true)?
-                    {
-                        return Err(RemoveChain::ChainFailed {
-                            blacklist,
-                            failing_batch: id,
-                        });
-                    }
-                    self.retry_batch_download(network, id)?;
-                } else {
-                    debug!(self.log, "Batch not found while removing peer";
-                        "peer" => %peer_id, "batch" => id)
-                }
-            }
-        }
+    pub fn remove_peer(&mut self, peer_id: &PeerId) -> ProcessingResult {
+        self.peers.remove(peer_id);
 
         if self.peers.is_empty() {
             Err(RemoveChain::EmptyPeerPool)
@@ -905,7 +884,15 @@ impl<T: BeaconChainTypes> SyncingChain<T> {
     ) -> ProcessingResult {
         if let Some(batch) = self.batches.get_mut(&batch_id) {
             let (request, batch_type) = batch.to_blocks_by_range_request();
-            match network.blocks_by_range_request(peer, batch_type, request, self.id, batch_id) {
+            match network.blocks_and_blobs_by_range_request(
+                peer,
+                batch_type,
+                request,
+                RangeRequestId::RangeSync {
+                    chain_id: self.id,
+                    batch_id,
+                },
+            ) {
                 Ok(request_id) => {
                     // inform the batch about the new request
                     batch.start_downloading_from_peer(peer, request_id)?;
diff --git a/beacon_node/network/src/sync/range_sync/range.rs b/beacon_node/network/src/sync/range_sync/range.rs
index 8fbc186a1b7..fe48db35b45 100644
--- a/beacon_node/network/src/sync/range_sync/range.rs
+++ b/beacon_node/network/src/sync/range_sync/range.rs
@@ -278,9 +278,8 @@ where
     /// for this peer. If so we mark the batch as failed. The batch may then hit it's maximum
     /// retries. In this case, we need to remove the chain.
     fn remove_peer(&mut self, network: &mut SyncNetworkContext<T>, peer_id: &PeerId) {
-        for (removed_chain, sync_type, remove_reason) in self
-            .chains
-            .call_all(|chain| chain.remove_peer(peer_id, network))
+        for (removed_chain, sync_type, remove_reason) in
+            self.chains.call_all(|chain| chain.remove_peer(peer_id))
         {
             self.on_chain_removed(
                 removed_chain,
@@ -384,7 +383,7 @@ mod tests {
     use crate::NetworkMessage;
 
     use super::*;
-    use crate::sync::network_context::BlockOrBlob;
+    use crate::sync::network_context::{BlockOrBlob, RangeRequestId};
     use beacon_chain::builder::Witness;
     use beacon_chain::eth1_chain::CachingEth1Backend;
     use beacon_chain::parking_lot::RwLock;
@@ -548,6 +547,51 @@ mod tests {
             (block_req_id, blob_req_id)
         }
 
+        fn complete_range_block_and_blobs_response(
+            &mut self,
+            block_req: RequestId,
+            blob_req_opt: Option<RequestId>,
+        ) -> (ChainId, BatchId, Id) {
+            if blob_req_opt.is_some() {
+                match block_req {
+                    RequestId::Sync(crate::sync::manager::RequestId::RangeBlockAndBlobs { id }) => {
+                        let _ = self
+                            .cx
+                            .range_block_and_blob_response(id, BlockOrBlob::Block(None));
+                        let response = self
+                            .cx
+                            .range_block_and_blob_response(id, BlockOrBlob::Blob(None))
+                            .unwrap();
+                        let (chain_id, batch_id) =
+                            TestRig::unwrap_range_request_id(response.sender_id);
+                        (chain_id, batch_id, id)
+                    }
+                    other => panic!("unexpected request {:?}", other),
+                }
+            } else {
+                match block_req {
+                    RequestId::Sync(crate::sync::manager::RequestId::RangeBlockAndBlobs { id }) => {
+                        let response = self
+                            .cx
+                            .range_block_and_blob_response(id, BlockOrBlob::Block(None))
+                            .unwrap();
+                        let (chain_id, batch_id) =
+                            TestRig::unwrap_range_request_id(response.sender_id);
+                        (chain_id, batch_id, id)
+                    }
+                    other => panic!("unexpected request {:?}", other),
+                }
+            }
+        }
+
+        fn unwrap_range_request_id(sender_id: RangeRequestId) -> (ChainId, BatchId) {
+            if let RangeRequestId::RangeSync { chain_id, batch_id } = sender_id {
+                (chain_id, batch_id)
+            } else {
+                panic!("expected RangeSync request: {:?}", sender_id)
+            }
+        }
+
         /// Produce a head peer
         fn head_peer(
             &self,
@@ -637,7 +681,12 @@ mod tests {
         let (network_tx, network_rx) = mpsc::unbounded_channel();
         let globals = Arc::new(NetworkGlobals::new_test_globals(Vec::new(), &log));
         let (network_beacon_processor, beacon_processor_rx) =
-            NetworkBeaconProcessor::null_for_testing(globals.clone());
+            NetworkBeaconProcessor::null_for_testing(
+                globals.clone(),
+                chain.clone(),
+                harness.runtime.task_executor.clone(),
+                log.clone(),
+            );
         let cx = SyncNetworkContext::new(
             network_tx,
             Arc::new(network_beacon_processor),
@@ -739,29 +788,8 @@ mod tests {
         range.add_peer(&mut rig.cx, local_info, peer1, head_info);
         let (block_req, blob_req_opt) = rig.grab_request(&peer1, fork);
 
-        let (chain1, batch1, id1) = if blob_req_opt.is_some() {
-            match block_req {
-                RequestId::Sync(crate::sync::manager::RequestId::RangeBlockAndBlobs { id }) => {
-                    let _ = rig
-                        .cx
-                        .range_sync_block_and_blob_response(id, BlockOrBlob::Block(None));
-                    let (chain1, response) = rig
-                        .cx
-                        .range_sync_block_and_blob_response(id, BlockOrBlob::Blob(None))
-                        .unwrap();
-                    (chain1, response.batch_id, id)
-                }
-                other => panic!("unexpected request {:?}", other),
-            }
-        } else {
-            match block_req {
-                RequestId::Sync(crate::sync::manager::RequestId::RangeBlocks { id }) => {
-                    let (chain, batch) = rig.cx.range_sync_block_only_response(id, true).unwrap();
-                    (chain, batch, id)
-                }
-                other => panic!("unexpected request {:?}", other),
-            }
-        };
+        let (chain1, batch1, id1) =
+            rig.complete_range_block_and_blobs_response(block_req, blob_req_opt);
 
         // make the ee offline
         rig.cx.update_execution_engine_state(EngineState::Offline);
@@ -777,29 +805,8 @@ mod tests {
         range.add_peer(&mut rig.cx, local_info, peer2, finalized_info);
         let (block_req, blob_req_opt) = rig.grab_request(&peer2, fork);
 
-        let (chain2, batch2, id2) = if blob_req_opt.is_some() {
-            match block_req {
-                RequestId::Sync(crate::sync::manager::RequestId::RangeBlockAndBlobs { id }) => {
-                    let _ = rig
-                        .cx
-                        .range_sync_block_and_blob_response(id, BlockOrBlob::Block(None));
-                    let (chain2, response) = rig
-                        .cx
-                        .range_sync_block_and_blob_response(id, BlockOrBlob::Blob(None))
-                        .unwrap();
-                    (chain2, response.batch_id, id)
-                }
-                other => panic!("unexpected request {:?}", other),
-            }
-        } else {
-            match block_req {
-                RequestId::Sync(crate::sync::manager::RequestId::RangeBlocks { id }) => {
-                    let (chain, batch) = rig.cx.range_sync_block_only_response(id, true).unwrap();
-                    (chain, batch, id)
-                }
-                other => panic!("unexpected request {:?}", other),
-            }
-        };
+        let (chain2, batch2, id2) =
+            rig.complete_range_block_and_blobs_response(block_req, blob_req_opt);
 
         // send the response to the request
         range.blocks_by_range_response(&mut rig.cx, peer2, chain2, batch2, id2, None);
diff --git a/beacon_node/operation_pool/src/lib.rs b/beacon_node/operation_pool/src/lib.rs
index 7cd40a4bb60..6e744ccf62a 100644
--- a/beacon_node/operation_pool/src/lib.rs
+++ b/beacon_node/operation_pool/src/lib.rs
@@ -1272,7 +1272,7 @@ mod release_tests {
         // Each validator will have a multiple of 1_000_000_000 wei.
         // Safe from overflow unless there are about 18B validators (2^64 / 1_000_000_000).
         for i in 0..state.validators().len() {
-            state.validators_mut()[i].effective_balance = 1_000_000_000 * i as u64;
+            state.validators_mut().get_mut(i).unwrap().effective_balance = 1_000_000_000 * i as u64;
         }
 
         let num_validators = num_committees
@@ -1530,9 +1530,9 @@ mod release_tests {
         let spec = &harness.spec;
         let mut state = harness.get_current_state();
         let op_pool = OperationPool::<MainnetEthSpec>::new();
-        state.validators_mut()[1].effective_balance = 17_000_000_000;
-        state.validators_mut()[2].effective_balance = 17_000_000_000;
-        state.validators_mut()[3].effective_balance = 17_000_000_000;
+        state.validators_mut().get_mut(1).unwrap().effective_balance = 17_000_000_000;
+        state.validators_mut().get_mut(2).unwrap().effective_balance = 17_000_000_000;
+        state.validators_mut().get_mut(3).unwrap().effective_balance = 17_000_000_000;
 
         let slashing_1 = harness.make_attester_slashing(vec![1, 2, 3]);
         let slashing_2 = harness.make_attester_slashing(vec![4, 5, 6]);
diff --git a/beacon_node/src/cli.rs b/beacon_node/src/cli.rs
index d46eb0f403e..81c2196b754 100644
--- a/beacon_node/src/cli.rs
+++ b/beacon_node/src/cli.rs
@@ -392,9 +392,9 @@ pub fn cli_app<'a, 'b>() -> App<'a, 'b> {
                 .long("http-spec-fork")
                 .requires("enable_http")
                 .value_name("FORK")
-                .help("Serve the spec for a specific hard fork on /eth/v1/config/spec. It should \
-                       not be necessary to set this flag.")
+                .help("This flag is deprecated and has no effect.")
                 .takes_value(true)
+                .hidden(true)
         )
         .arg(
             Arg::with_name("http-enable-tls")
@@ -425,9 +425,8 @@ pub fn cli_app<'a, 'b>() -> App<'a, 'b> {
             Arg::with_name("http-allow-sync-stalled")
                 .long("http-allow-sync-stalled")
                 .requires("enable_http")
-                .help("Forces the HTTP to indicate that the node is synced when sync is actually \
-                    stalled. This is useful for very small testnets. TESTING ONLY. DO NOT USE ON \
-                    MAINNET.")
+                .help("This flag is deprecated and has no effect.")
+                .hidden(true)
         )
         .arg(
             Arg::with_name("http-sse-capacity-multiplier")
@@ -625,7 +624,7 @@ pub fn cli_app<'a, 'b>() -> App<'a, 'b> {
             Arg::with_name("state-cache-size")
                 .long("state-cache-size")
                 .value_name("STATE_CACHE_SIZE")
-                .help("Specifies the size of the snapshot cache [default: 3]")
+                .help("Specifies the size of the state cache [default: 128]")
                 .takes_value(true)
         )
         /*
diff --git a/beacon_node/src/config.rs b/beacon_node/src/config.rs
index 9b0032e3068..9a1d7df124c 100644
--- a/beacon_node/src/config.rs
+++ b/beacon_node/src/config.rs
@@ -3,6 +3,7 @@ use beacon_chain::chain_config::{
     DEFAULT_RE_ORG_HEAD_THRESHOLD, DEFAULT_RE_ORG_MAX_EPOCHS_SINCE_FINALIZATION,
     DEFAULT_RE_ORG_PARENT_THRESHOLD,
 };
+use beacon_chain::graffiti_calculator::GraffitiOrigin;
 use beacon_chain::TrustedSetup;
 use clap::ArgMatches;
 use clap_utils::flags::DISABLE_MALLOC_TUNING_FLAG;
@@ -17,7 +18,6 @@ use lighthouse_network::ListenAddress;
 use lighthouse_network::{multiaddr::Protocol, Enr, Multiaddr, NetworkConfig, PeerIdSerialized};
 use sensitive_url::SensitiveUrl;
 use slog::{info, warn, Logger};
-use std::cmp;
 use std::cmp::max;
 use std::fmt::Debug;
 use std::fs;
@@ -27,7 +27,8 @@ use std::num::NonZeroU16;
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::time::Duration;
-use types::{Checkpoint, Epoch, EthSpec, Hash256, PublicKeyBytes, GRAFFITI_BYTES_LEN};
+use types::graffiti::GraffitiString;
+use types::{Checkpoint, Epoch, EthSpec, Hash256, PublicKeyBytes};
 
 /// Gets the fully-initialized global client.
 ///
@@ -128,8 +129,12 @@ pub fn get_config<E: EthSpec>(
             client_config.http_api.allow_origin = Some(allow_origin.to_string());
         }
 
-        if let Some(fork_name) = clap_utils::parse_optional(cli_args, "http-spec-fork")? {
-            client_config.http_api.spec_fork_name = Some(fork_name);
+        if cli_args.is_present("http-spec-fork") {
+            warn!(
+                log,
+                "Ignoring --http-spec-fork";
+                "info" => "this flag is deprecated and will be removed"
+            );
         }
 
         if cli_args.is_present("http-enable-tls") {
@@ -148,7 +153,11 @@ pub fn get_config<E: EthSpec>(
         }
 
         if cli_args.is_present("http-allow-sync-stalled") {
-            client_config.http_api.allow_sync_stalled = true;
+            warn!(
+                log,
+                "Ignoring --http-allow-sync-stalled";
+                "info" => "this flag is deprecated and will be removed"
+            );
         }
 
         client_config.http_api.sse_capacity_multiplier =
@@ -171,9 +180,6 @@ pub fn get_config<E: EthSpec>(
     if let Some(cache_size) = clap_utils::parse_optional(cli_args, "shuffling-cache-size")? {
         client_config.chain.shuffling_cache_size = cache_size;
     }
-    if let Some(cache_size) = clap_utils::parse_optional(cli_args, "state-cache-size")? {
-        client_config.chain.snapshot_cache_size = cache_size;
-    }
 
     /*
      * Prometheus metrics HTTP server
@@ -340,8 +346,8 @@ pub fn get_config<E: EthSpec>(
         }
 
         // Set config values from parse values.
-        el_config.secret_files = vec![secret_file.clone()];
-        el_config.execution_endpoints = vec![execution_endpoint.clone()];
+        el_config.secret_file = Some(secret_file.clone());
+        el_config.execution_endpoint = Some(execution_endpoint.clone());
         el_config.suggested_fee_recipient =
             clap_utils::parse_optional(cli_args, "suggested-fee-recipient")?;
         el_config.jwt_id = clap_utils::parse_optional(cli_args, "execution-jwt-id")?;
@@ -400,6 +406,10 @@ pub fn get_config<E: EthSpec>(
             .map_err(|_| "block-cache-size is not a valid integer".to_string())?;
     }
 
+    if let Some(cache_size) = clap_utils::parse_optional(cli_args, "state-cache-size")? {
+        client_config.store.state_cache_size = cache_size;
+    }
+
     if let Some(historic_state_cache_size) = cli_args.value_of("historic-state-cache-size") {
         client_config.store.historic_state_cache_size = historic_state_cache_size
             .parse()
@@ -567,24 +577,16 @@ pub fn get_config<E: EthSpec>(
         client_config.chain.genesis_backfill = true;
     }
 
-    let raw_graffiti = if let Some(graffiti) = cli_args.value_of("graffiti") {
-        if graffiti.len() > GRAFFITI_BYTES_LEN {
-            return Err(format!(
-                "Your graffiti is too long! {} bytes maximum!",
-                GRAFFITI_BYTES_LEN
-            ));
-        }
-
-        graffiti.as_bytes()
+    let beacon_graffiti = if let Some(graffiti) = cli_args.value_of("graffiti") {
+        GraffitiOrigin::UserSpecified(GraffitiString::from_str(graffiti)?.into())
     } else if cli_args.is_present("private") {
-        b""
+        // When 'private' flag is present, use a zero-initialized bytes array.
+        GraffitiOrigin::UserSpecified(GraffitiString::empty().into())
     } else {
-        lighthouse_version::VERSION.as_bytes()
+        // Use the default lighthouse graffiti if no user-specified graffiti flags are present
+        GraffitiOrigin::default()
     };
-
-    let trimmed_graffiti_len = cmp::min(raw_graffiti.len(), GRAFFITI_BYTES_LEN);
-    client_config.graffiti.0[..trimmed_graffiti_len]
-        .copy_from_slice(&raw_graffiti[..trimmed_graffiti_len]);
+    client_config.beacon_graffiti = beacon_graffiti;
 
     if let Some(wss_checkpoint) = cli_args.value_of("wss-checkpoint") {
         let mut split = wss_checkpoint.split(':');
diff --git a/beacon_node/store/Cargo.toml b/beacon_node/store/Cargo.toml
index 7bf1ef76bef..b7822670078 100644
--- a/beacon_node/store/Cargo.toml
+++ b/beacon_node/store/Cargo.toml
@@ -25,3 +25,7 @@ lru = { workspace = true }
 sloggers = { workspace = true }
 directory = { workspace = true }
 strum = { workspace = true }
+safe_arith = { workspace = true }
+bls = { workspace = true }
+smallvec = { workspace = true }
+logging = { workspace = true }
diff --git a/beacon_node/store/src/chunked_vector.rs b/beacon_node/store/src/chunked_vector.rs
index a0c50e5a2b5..4450989d590 100644
--- a/beacon_node/store/src/chunked_vector.rs
+++ b/beacon_node/store/src/chunked_vector.rs
@@ -1,6 +1,6 @@
 //! Space-efficient storage for `BeaconState` vector fields.
 //!
-//! This module provides logic for splitting the `FixedVector` fields of a `BeaconState` into
+//! This module provides logic for splitting the `Vector` fields of a `BeaconState` into
 //! chunks, and storing those chunks in contiguous ranges in the on-disk database.  The motiviation
 //! for doing this is avoiding massive duplication in every on-disk state.  For example, rather than
 //! storing the whole `historical_roots` vector, which is updated once every couple of thousand
@@ -60,12 +60,13 @@ fn genesis_value_key() -> [u8; 8] {
 /// type-level. We require their value-level witnesses to be `Copy` so that we can avoid the
 /// turbofish when calling functions like `store_updated_vector`.
 pub trait Field<E: EthSpec>: Copy {
-    /// The type of value stored in this field: the `T` from `FixedVector<T, N>`.
+    /// The type of value stored in this field: the `T` from `Vector<T, N>`.
     ///
     /// The `Default` impl will be used to fill extra vector entries.
-    type Value: Decode + Encode + Default + Clone + PartialEq + std::fmt::Debug;
+    type Value: Default + std::fmt::Debug + milhouse::Value;
+    // Decode + Encode + Default + Clone + PartialEq + std::fmt::Debug
 
-    /// The length of this field: the `N` from `FixedVector<T, N>`.
+    /// The length of this field: the `N` from `Vector<T, N>`.
     type Length: Unsigned;
 
     /// The database column where the integer-indexed chunks for this field should be stored.
@@ -273,10 +274,10 @@ pub trait Field<E: EthSpec>: Copy {
     }
 }
 
-/// Marker trait for fixed-length fields (`FixedVector<T, N>`).
+/// Marker trait for fixed-length fields (`Vector<T, N>`).
 pub trait FixedLengthField<E: EthSpec>: Field<E> {}
 
-/// Marker trait for variable-length fields (`VariableList<T, N>`).
+/// Marker trait for variable-length fields (`List<T, N>`).
 pub trait VariableLengthField<E: EthSpec>: Field<E> {}
 
 /// Macro to implement the `Field` trait on a new unit struct type.
@@ -331,7 +332,7 @@ field!(
         activation_slot: Some(Slot::new(0)),
         deactivation_slot: None
     },
-    |state: &BeaconState<_>, index, _| safe_modulo_index(state.block_roots(), index)
+    |state: &BeaconState<_>, index, _| safe_modulo_vector_index(state.block_roots(), index)
 );
 
 field!(
@@ -345,7 +346,7 @@ field!(
         activation_slot: Some(Slot::new(0)),
         deactivation_slot: None,
     },
-    |state: &BeaconState<_>, index, _| safe_modulo_index(state.state_roots(), index)
+    |state: &BeaconState<_>, index, _| safe_modulo_vector_index(state.state_roots(), index)
 );
 
 field!(
@@ -361,7 +362,7 @@ field!(
             .capella_fork_epoch
             .map(|fork_epoch| fork_epoch.start_slot(E::slots_per_epoch())),
     },
-    |state: &BeaconState<_>, index, _| safe_modulo_index(state.historical_roots(), index)
+    |state: &BeaconState<_>, index, _| safe_modulo_list_index(state.historical_roots(), index)
 );
 
 field!(
@@ -371,7 +372,7 @@ field!(
     E::EpochsPerHistoricalVector,
     DBColumn::BeaconRandaoMixes,
     |_| OncePerEpoch { lag: 1 },
-    |state: &BeaconState<_>, index, _| safe_modulo_index(state.randao_mixes(), index)
+    |state: &BeaconState<_>, index, _| safe_modulo_vector_index(state.randao_mixes(), index)
 );
 
 field!(
@@ -387,7 +388,7 @@ field!(
             .map(|fork_epoch| fork_epoch.start_slot(E::slots_per_epoch())),
         deactivation_slot: None,
     },
-    |state: &BeaconState<_>, index, _| safe_modulo_index(
+    |state: &BeaconState<_>, index, _| safe_modulo_list_index(
         state
             .historical_summaries()
             .map_err(|_| ChunkError::InvalidFork)?,
@@ -565,7 +566,7 @@ pub fn load_vector_from_db<F: FixedLengthField<E>, E: EthSpec, S: KeyValueStore<
     store: &S,
     slot: Slot,
     spec: &ChainSpec,
-) -> Result<FixedVector<F::Value, F::Length>, Error> {
+) -> Result<Vector<F::Value, F::Length>, Error> {
     // Do a range query
     let chunk_size = F::chunk_size();
     let (start_vindex, end_vindex) = F::start_and_end_vindex(slot, spec);
@@ -589,7 +590,7 @@ pub fn load_vector_from_db<F: FixedLengthField<E>, E: EthSpec, S: KeyValueStore<
         default,
     )?;
 
-    Ok(result.into())
+    Ok(Vector::new(result).map_err(ChunkError::Milhouse)?)
 }
 
 /// The historical roots are stored in vector chunks, despite not actually being a vector.
@@ -597,7 +598,7 @@ pub fn load_variable_list_from_db<F: VariableLengthField<E>, E: EthSpec, S: KeyV
     store: &S,
     slot: Slot,
     spec: &ChainSpec,
-) -> Result<VariableList<F::Value, F::Length>, Error> {
+) -> Result<List<F::Value, F::Length>, Error> {
     let chunk_size = F::chunk_size();
     let (start_vindex, end_vindex) = F::start_and_end_vindex(slot, spec);
     let start_cindex = start_vindex / chunk_size;
@@ -617,15 +618,35 @@ pub fn load_variable_list_from_db<F: VariableLengthField<E>, E: EthSpec, S: KeyV
         }
     }
 
-    Ok(result.into())
+    Ok(List::new(result).map_err(ChunkError::Milhouse)?)
 }
 
-/// Index into a field of the state, avoiding out of bounds and division by 0.
-fn safe_modulo_index<T: Copy>(values: &[T], index: u64) -> Result<T, ChunkError> {
+/// Index into a `List` field of the state, avoiding out of bounds and division by 0.
+fn safe_modulo_list_index<T: milhouse::Value + Copy, N: Unsigned>(
+    values: &List<T, N>,
+    index: u64,
+) -> Result<T, ChunkError> {
+    if values.is_empty() {
+        Err(ChunkError::ZeroLengthList)
+    } else {
+        values
+            .get(index as usize % values.len())
+            .copied()
+            .ok_or(ChunkError::IndexOutOfBounds { index })
+    }
+}
+
+fn safe_modulo_vector_index<T: milhouse::Value + Copy, N: Unsigned>(
+    values: &Vector<T, N>,
+    index: u64,
+) -> Result<T, ChunkError> {
     if values.is_empty() {
         Err(ChunkError::ZeroLengthVector)
     } else {
-        Ok(values[index as usize % values.len()])
+        values
+            .get(index as usize % values.len())
+            .copied()
+            .ok_or(ChunkError::IndexOutOfBounds { index })
     }
 }
 
@@ -712,6 +733,10 @@ where
 #[derive(Debug, PartialEq)]
 pub enum ChunkError {
     ZeroLengthVector,
+    ZeroLengthList,
+    IndexOutOfBounds {
+        index: u64,
+    },
     InvalidSize {
         chunk_index: usize,
         expected: usize,
@@ -744,6 +769,13 @@ pub enum ChunkError {
         length: usize,
     },
     InvalidFork,
+    Milhouse(milhouse::Error),
+}
+
+impl From<milhouse::Error> for ChunkError {
+    fn from(e: milhouse::Error) -> ChunkError {
+        Self::Milhouse(e)
+    }
 }
 
 #[cfg(test)]
diff --git a/beacon_node/store/src/config.rs b/beacon_node/store/src/config.rs
index 681d424e282..d43999d8220 100644
--- a/beacon_node/store/src/config.rs
+++ b/beacon_node/store/src/config.rs
@@ -9,6 +9,7 @@ use types::{EthSpec, MinimalEthSpec};
 pub const PREV_DEFAULT_SLOTS_PER_RESTORE_POINT: u64 = 2048;
 pub const DEFAULT_SLOTS_PER_RESTORE_POINT: u64 = 8192;
 pub const DEFAULT_BLOCK_CACHE_SIZE: NonZeroUsize = new_non_zero_usize(5);
+pub const DEFAULT_STATE_CACHE_SIZE: NonZeroUsize = new_non_zero_usize(128);
 pub const DEFAULT_HISTORIC_STATE_CACHE_SIZE: NonZeroUsize = new_non_zero_usize(1);
 pub const DEFAULT_EPOCHS_PER_BLOB_PRUNE: u64 = 1;
 pub const DEFAULT_BLOB_PUNE_MARGIN_EPOCHS: u64 = 0;
@@ -22,6 +23,8 @@ pub struct StoreConfig {
     pub slots_per_restore_point_set_explicitly: bool,
     /// Maximum number of blocks to store in the in-memory block cache.
     pub block_cache_size: NonZeroUsize,
+    /// Maximum number of states to store in the in-memory state cache.
+    pub state_cache_size: NonZeroUsize,
     /// Maximum number of states from freezer database to store in the in-memory state cache.
     pub historic_state_cache_size: NonZeroUsize,
     /// Whether to compact the database on initialization.
@@ -57,6 +60,7 @@ impl Default for StoreConfig {
             slots_per_restore_point: MinimalEthSpec::slots_per_historical_root() as u64,
             slots_per_restore_point_set_explicitly: false,
             block_cache_size: DEFAULT_BLOCK_CACHE_SIZE,
+            state_cache_size: DEFAULT_STATE_CACHE_SIZE,
             historic_state_cache_size: DEFAULT_HISTORIC_STATE_CACHE_SIZE,
             compact_on_init: false,
             compact_on_prune: true,
diff --git a/beacon_node/store/src/consensus_context.rs b/beacon_node/store/src/consensus_context.rs
new file mode 100644
index 00000000000..08fad17b14b
--- /dev/null
+++ b/beacon_node/store/src/consensus_context.rs
@@ -0,0 +1,66 @@
+use ssz_derive::{Decode, Encode};
+use state_processing::ConsensusContext;
+use std::collections::HashMap;
+use types::{AttestationData, BitList, EthSpec, Hash256, IndexedAttestation, Slot};
+
+/// The consensus context is stored on disk as part of the data availability overflow cache.
+///
+/// We use this separate struct to keep the on-disk format stable in the presence of changes to the
+/// in-memory `ConsensusContext`. You MUST NOT change the fields of this struct without
+/// superstructing it and implementing a schema migration.
+#[derive(Debug, PartialEq, Clone, Encode, Decode)]
+pub struct OnDiskConsensusContext<E: EthSpec> {
+    /// Slot to act as an identifier/safeguard
+    slot: Slot,
+    /// Proposer index of the block at `slot`.
+    proposer_index: Option<u64>,
+    /// Block root of the block at `slot`.
+    current_block_root: Option<Hash256>,
+    /// We keep the indexed attestations in the *in-memory* version of this struct so that we don't
+    /// need to regenerate them if roundtripping via this type *without* going to disk.
+    ///
+    /// They are not part of the on-disk format.
+    #[ssz(skip_serializing, skip_deserializing)]
+    indexed_attestations:
+        HashMap<(AttestationData, BitList<E::MaxValidatorsPerCommittee>), IndexedAttestation<E>>,
+}
+
+impl<E: EthSpec> OnDiskConsensusContext<E> {
+    pub fn from_consensus_context(ctxt: ConsensusContext<E>) -> Self {
+        // Match exhaustively on fields here so we are forced to *consider* updating the on-disk
+        // format when the `ConsensusContext` fields change.
+        let ConsensusContext {
+            slot,
+            previous_epoch: _,
+            current_epoch: _,
+            proposer_index,
+            current_block_root,
+            indexed_attestations,
+        } = ctxt;
+        OnDiskConsensusContext {
+            slot,
+            proposer_index,
+            current_block_root,
+            indexed_attestations,
+        }
+    }
+
+    pub fn into_consensus_context(self) -> ConsensusContext<E> {
+        let OnDiskConsensusContext {
+            slot,
+            proposer_index,
+            current_block_root,
+            indexed_attestations,
+        } = self;
+
+        let mut ctxt = ConsensusContext::new(slot);
+
+        if let Some(proposer_index) = proposer_index {
+            ctxt = ctxt.set_proposer_index(proposer_index);
+        }
+        if let Some(block_root) = current_block_root {
+            ctxt = ctxt.set_current_block_root(block_root);
+        }
+        ctxt.set_indexed_attestations(indexed_attestations)
+    }
+}
diff --git a/beacon_node/store/src/errors.rs b/beacon_node/store/src/errors.rs
index 96e02b80ff8..91e6a920ba3 100644
--- a/beacon_node/store/src/errors.rs
+++ b/beacon_node/store/src/errors.rs
@@ -3,7 +3,7 @@ use crate::config::StoreConfigError;
 use crate::hot_cold_store::HotColdDBError;
 use ssz::DecodeError;
 use state_processing::BlockReplayError;
-use types::{BeaconStateError, Hash256, InconsistentFork, Slot};
+use types::{BeaconStateError, EpochCacheError, Hash256, InconsistentFork, Slot};
 
 pub type Result<T> = std::result::Result<T, Error>;
 
@@ -49,6 +49,14 @@ pub enum Error {
     InvalidBytes,
     UnableToDowngrade,
     InconsistentFork(InconsistentFork),
+    CacheBuildError(EpochCacheError),
+    RandaoMixOutOfBounds,
+    FinalizedStateDecreasingSlot,
+    FinalizedStateUnaligned,
+    StateForCacheHasPendingUpdates {
+        state_root: Hash256,
+        slot: Slot,
+    },
 }
 
 pub trait HandleUnavailable<T> {
@@ -113,6 +121,12 @@ impl From<InconsistentFork> for Error {
     }
 }
 
+impl From<EpochCacheError> for Error {
+    fn from(e: EpochCacheError) -> Error {
+        Error::CacheBuildError(e)
+    }
+}
+
 #[derive(Debug)]
 pub struct DBError {
     pub message: String,
diff --git a/beacon_node/store/src/hot_cold_store.rs b/beacon_node/store/src/hot_cold_store.rs
index 70e02164e08..484a1139bf9 100644
--- a/beacon_node/store/src/hot_cold_store.rs
+++ b/beacon_node/store/src/hot_cold_store.rs
@@ -17,6 +17,7 @@ use crate::metadata::{
     PRUNING_CHECKPOINT_KEY, SCHEMA_VERSION_KEY, SPLIT_KEY, STATE_UPPER_LIMIT_NO_RETAIN,
 };
 use crate::metrics;
+use crate::state_cache::{PutStateOutcome, StateCache};
 use crate::{
     get_key_for_col, ChunkWriter, DBColumn, DatabaseBlock, Error, ItemStore, KeyValueStoreOp,
     PartialBeaconState, StoreItem, StoreOp,
@@ -30,7 +31,8 @@ use slog::{debug, error, info, trace, warn, Logger};
 use ssz::{Decode, Encode};
 use ssz_derive::{Decode, Encode};
 use state_processing::{
-    BlockProcessingError, BlockReplayer, SlotProcessingError, StateProcessingStrategy,
+    block_replayer::PreSlotHook, AllCaches, BlockProcessingError, BlockReplayer,
+    SlotProcessingError,
 };
 use std::cmp::min;
 use std::marker::PhantomData;
@@ -66,12 +68,16 @@ pub struct HotColdDB<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> {
     pub hot_db: Hot,
     /// LRU cache of deserialized blocks and blobs. Updated whenever a block or blob is loaded.
     block_cache: Mutex<BlockCache<E>>,
+    /// Cache of beacon states.
+    ///
+    /// LOCK ORDERING: this lock must always be locked *after* the `split` if both are required.
+    state_cache: Mutex<StateCache<E>>,
     /// LRU cache of replayed states.
-    state_cache: Mutex<LruCache<Slot, BeaconState<E>>>,
+    historic_state_cache: Mutex<LruCache<Slot, BeaconState<E>>>,
     /// Chain spec.
     pub(crate) spec: ChainSpec,
     /// Logger.
-    pub(crate) log: Logger,
+    pub log: Logger,
     /// Mere vessel for E.
     _phantom: PhantomData<E>,
 }
@@ -178,7 +184,8 @@ impl<E: EthSpec> HotColdDB<E, MemoryStore<E>, MemoryStore<E>> {
             blobs_db: MemoryStore::open(),
             hot_db: MemoryStore::open(),
             block_cache: Mutex::new(BlockCache::new(config.block_cache_size)),
-            state_cache: Mutex::new(LruCache::new(config.historic_state_cache_size)),
+            state_cache: Mutex::new(StateCache::new(config.state_cache_size)),
+            historic_state_cache: Mutex::new(LruCache::new(config.historic_state_cache_size)),
             config,
             spec,
             log,
@@ -192,8 +199,6 @@ impl<E: EthSpec> HotColdDB<E, MemoryStore<E>, MemoryStore<E>> {
 impl<E: EthSpec> HotColdDB<E, LevelDB<E>, LevelDB<E>> {
     /// Open a new or existing database, with the given paths to the hot and cold DBs.
     ///
-    /// The `slots_per_restore_point` parameter must be a divisor of `SLOTS_PER_HISTORICAL_ROOT`.
-    ///
     /// The `migrate_schema` function is passed in so that the parent `BeaconChain` can provide
     /// context and access `BeaconChain`-level code without creating a circular dependency.
     pub fn open(
@@ -215,7 +220,8 @@ impl<E: EthSpec> HotColdDB<E, LevelDB<E>, LevelDB<E>> {
             blobs_db: LevelDB::open(blobs_db_path)?,
             hot_db: LevelDB::open(hot_path)?,
             block_cache: Mutex::new(BlockCache::new(config.block_cache_size)),
-            state_cache: Mutex::new(LruCache::new(config.historic_state_cache_size)),
+            state_cache: Mutex::new(StateCache::new(config.state_cache_size)),
+            historic_state_cache: Mutex::new(LruCache::new(config.historic_state_cache_size)),
             config,
             spec,
             log,
@@ -352,6 +358,21 @@ impl<E: EthSpec> HotColdDB<E, LevelDB<E>, LevelDB<E>> {
 }
 
 impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold> {
+    pub fn update_finalized_state(
+        &self,
+        state_root: Hash256,
+        block_root: Hash256,
+        state: BeaconState<E>,
+    ) -> Result<(), Error> {
+        self.state_cache
+            .lock()
+            .update_finalized_state(state_root, block_root, state)
+    }
+
+    pub fn state_cache_len(&self) -> usize {
+        self.state_cache.lock().len()
+    }
+
     /// Store a block and update the LRU cache.
     pub fn put_block(
         &self,
@@ -615,11 +636,26 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
 
     /// Store a state in the store.
     pub fn put_state(&self, state_root: &Hash256, state: &BeaconState<E>) -> Result<(), Error> {
+        self.put_state_possibly_temporary(state_root, state, false)
+    }
+
+    /// Store a state in the store.
+    ///
+    /// The `temporary` flag indicates whether this state should be considered canonical.
+    pub fn put_state_possibly_temporary(
+        &self,
+        state_root: &Hash256,
+        state: &BeaconState<E>,
+        temporary: bool,
+    ) -> Result<(), Error> {
         let mut ops: Vec<KeyValueStoreOp> = Vec::new();
         if state.slot() < self.get_split_slot() {
             self.store_cold_state(state_root, state, &mut ops)?;
             self.cold_db.do_atomically(ops)
         } else {
+            if temporary {
+                ops.push(TemporaryFlag.as_kv_store_op(*state_root));
+            }
             self.store_hot_state(state_root, state, &mut ops)?;
             self.hot_db.do_atomically(ops)
         }
@@ -648,45 +684,16 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
                 // chain. This way we avoid returning a state that doesn't match `state_root`.
                 self.load_cold_state(state_root)
             } else {
-                self.load_hot_state(state_root, StateProcessingStrategy::Accurate)
+                self.get_hot_state(state_root)
             }
         } else {
-            match self.load_hot_state(state_root, StateProcessingStrategy::Accurate)? {
+            match self.get_hot_state(state_root)? {
                 Some(state) => Ok(Some(state)),
                 None => self.load_cold_state(state_root),
             }
         }
     }
 
-    /// Fetch a state from the store, but don't compute all of the values when replaying blocks
-    /// upon that state (e.g., state roots). Additionally, only states from the hot store are
-    /// returned.
-    ///
-    /// See `Self::get_advanced_hot_state` for information about `max_slot`.
-    ///
-    /// ## Warning
-    ///
-    /// The returned state **is not a valid beacon state**, it can only be used for obtaining
-    /// shuffling to process attestations. At least the following components of the state will be
-    /// broken/invalid:
-    ///
-    /// - `state.state_roots`
-    /// - `state.block_roots`
-    pub fn get_inconsistent_state_for_attestation_verification_only(
-        &self,
-        block_root: &Hash256,
-        max_slot: Slot,
-        state_root: Hash256,
-    ) -> Result<Option<(Hash256, BeaconState<E>)>, Error> {
-        metrics::inc_counter(&metrics::BEACON_STATE_GET_COUNT);
-        self.get_advanced_hot_state_with_strategy(
-            *block_root,
-            max_slot,
-            state_root,
-            StateProcessingStrategy::Inconsistent,
-        )
-    }
-
     /// Get a state with `latest_block_root == block_root` advanced through to at most `max_slot`.
     ///
     /// The `state_root` argument is used to look up the block's un-advanced state in case an
@@ -697,35 +704,29 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
     /// - `result_state_root == state.canonical_root()`
     /// - `state.slot() <= max_slot`
     /// - `state.get_latest_block_root(result_state_root) == block_root`
-    ///
-    /// Presently this is only used to avoid loading the un-advanced split state, but in future will
-    /// be expanded to return states from an in-memory cache.
     pub fn get_advanced_hot_state(
         &self,
         block_root: Hash256,
         max_slot: Slot,
         state_root: Hash256,
     ) -> Result<Option<(Hash256, BeaconState<E>)>, Error> {
-        self.get_advanced_hot_state_with_strategy(
-            block_root,
-            max_slot,
-            state_root,
-            StateProcessingStrategy::Accurate,
-        )
-    }
+        if let Some(cached) = self.get_advanced_hot_state_from_cache(block_root, max_slot) {
+            return Ok(Some(cached));
+        }
 
-    /// Same as `get_advanced_hot_state` but taking a `StateProcessingStrategy`.
-    pub fn get_advanced_hot_state_with_strategy(
-        &self,
-        block_root: Hash256,
-        max_slot: Slot,
-        state_root: Hash256,
-        state_processing_strategy: StateProcessingStrategy,
-    ) -> Result<Option<(Hash256, BeaconState<E>)>, Error> {
         // Hold a read lock on the split point so it can't move while we're trying to load the
         // state.
         let split = self.split.read_recursive();
 
+        if state_root != split.state_root {
+            warn!(
+                self.log,
+                "State cache missed";
+                "state_root"  => ?state_root,
+                "block_root" => ?block_root,
+            );
+        }
+
         // Sanity check max-slot against the split slot.
         if max_slot < split.slot {
             return Err(HotColdDBError::FinalizedStateNotInHotDatabase {
@@ -741,11 +742,40 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
         } else {
             state_root
         };
-        let state = self
-            .load_hot_state(&state_root, state_processing_strategy)?
-            .map(|state| (state_root, state));
+        let mut opt_state = self
+            .load_hot_state(&state_root)?
+            .map(|(state, _block_root)| (state_root, state));
+
+        if let Some((state_root, state)) = opt_state.as_mut() {
+            state.update_tree_hash_cache()?;
+            state.build_all_caches(&self.spec)?;
+            self.state_cache
+                .lock()
+                .put_state(*state_root, block_root, state)?;
+            debug!(
+                self.log,
+                "Cached state";
+                "state_root" => ?state_root,
+                "slot" => state.slot(),
+            );
+        }
         drop(split);
-        Ok(state)
+        Ok(opt_state)
+    }
+
+    /// Same as `get_advanced_hot_state` but will return `None` if no compatible state is cached.
+    ///
+    /// If this function returns `Some(state)` then that `state` will always have
+    /// `latest_block_header` matching `block_root` but may not be advanced all the way through to
+    /// `max_slot`.
+    pub fn get_advanced_hot_state_from_cache(
+        &self,
+        block_root: Hash256,
+        max_slot: Slot,
+    ) -> Option<(Hash256, BeaconState<E>)> {
+        self.state_cache
+            .lock()
+            .get_by_block_root(block_root, max_slot)
     }
 
     /// Delete a state, ensuring it is removed from the LRU cache, as well as from on-disk.
@@ -755,17 +785,10 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
     /// (which are frozen, and won't be deleted), or valid descendents of the finalized checkpoint
     /// (which will be deleted by this function but shouldn't be).
     pub fn delete_state(&self, state_root: &Hash256, slot: Slot) -> Result<(), Error> {
-        // Delete the state summary.
-        self.hot_db
-            .key_delete(DBColumn::BeaconStateSummary.into(), state_root.as_bytes())?;
-
-        // Delete the full state if it lies on an epoch boundary.
-        if slot % E::slots_per_epoch() == 0 {
-            self.hot_db
-                .key_delete(DBColumn::BeaconState.into(), state_root.as_bytes())?;
-        }
-
-        Ok(())
+        self.do_atomically_with_block_and_blobs_cache(vec![StoreOp::DeleteState(
+            *state_root,
+            Some(slot),
+        )])
     }
 
     pub fn forwards_block_roots_iterator(
@@ -833,17 +856,9 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
         }) = self.load_hot_state_summary(state_root)?
         {
             // NOTE: minor inefficiency here because we load an unnecessary hot state summary
-            //
-            // `StateProcessingStrategy` should be irrelevant here since we never replay blocks for an epoch
-            // boundary state in the hot DB.
-            let state = self
-                .load_hot_state(
-                    &epoch_boundary_state_root,
-                    StateProcessingStrategy::Accurate,
-                )?
-                .ok_or(HotColdDBError::MissingEpochBoundaryState(
-                    epoch_boundary_state_root,
-                ))?;
+            let (state, _) = self.load_hot_state(&epoch_boundary_state_root)?.ok_or(
+                HotColdDBError::MissingEpochBoundaryState(epoch_boundary_state_root),
+            )?;
             Ok(Some(state))
         } else {
             // Try the cold DB
@@ -1029,11 +1044,14 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
 
                 StoreOp::DeleteBlock(block_root) => {
                     guard.delete_block(&block_root);
+                    self.state_cache.lock().delete_block_states(&block_root);
                 }
 
-                StoreOp::DeleteBlobs(_) => (),
+                StoreOp::DeleteState(state_root, _) => {
+                    self.state_cache.lock().delete_state(&state_root)
+                }
 
-                StoreOp::DeleteState(_, _) => (),
+                StoreOp::DeleteBlobs(_) => (),
 
                 StoreOp::DeleteExecutionPayload(_) => (),
 
@@ -1070,6 +1088,26 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
         state: &BeaconState<E>,
         ops: &mut Vec<KeyValueStoreOp>,
     ) -> Result<(), Error> {
+        // Put the state in the cache.
+        let block_root = state.get_latest_block_root(*state_root);
+
+        // Avoid storing states in the database if they already exist in the state cache.
+        // The exception to this is the finalized state, which must exist in the cache before it
+        // is stored on disk.
+        if let PutStateOutcome::Duplicate =
+            self.state_cache
+                .lock()
+                .put_state(*state_root, block_root, state)?
+        {
+            debug!(
+                self.log,
+                "Skipping storage of cached state";
+                "slot" => state.slot(),
+                "state_root" => ?state_root
+            );
+            return Ok(());
+        }
+
         // On the epoch boundary, store the full state.
         if state.slot() % E::slots_per_epoch() == 0 {
             trace!(
@@ -1091,14 +1129,51 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
         Ok(())
     }
 
+    /// Get a post-finalization state from the database or store.
+    pub fn get_hot_state(&self, state_root: &Hash256) -> Result<Option<BeaconState<E>>, Error> {
+        if let Some(state) = self.state_cache.lock().get_by_state_root(*state_root) {
+            return Ok(Some(state));
+        }
+
+        if *state_root != self.get_split_info().state_root {
+            // Do not warn on start up when loading the split state.
+            warn!(
+                self.log,
+                "State cache missed";
+                "state_root" => ?state_root,
+            );
+        }
+
+        let state_from_disk = self.load_hot_state(state_root)?;
+
+        if let Some((mut state, block_root)) = state_from_disk {
+            state.update_tree_hash_cache()?;
+            state.build_all_caches(&self.spec)?;
+            self.state_cache
+                .lock()
+                .put_state(*state_root, block_root, &state)?;
+            debug!(
+                self.log,
+                "Cached state";
+                "state_root" => ?state_root,
+                "slot" => state.slot(),
+            );
+            Ok(Some(state))
+        } else {
+            Ok(None)
+        }
+    }
+
     /// Load a post-finalization state from the hot database.
     ///
     /// Will replay blocks from the nearest epoch boundary.
+    ///
+    /// Return the `(state, latest_block_root)` where `latest_block_root` is the root of the last
+    /// block applied to `state`.
     pub fn load_hot_state(
         &self,
         state_root: &Hash256,
-        state_processing_strategy: StateProcessingStrategy,
-    ) -> Result<Option<BeaconState<E>>, Error> {
+    ) -> Result<Option<(BeaconState<E>, Hash256)>, Error> {
         metrics::inc_counter(&metrics::BEACON_STATE_HOT_GET_COUNT);
 
         // If the state is marked as temporary, do not return it. It will become visible
@@ -1113,16 +1188,47 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
             epoch_boundary_state_root,
         }) = self.load_hot_state_summary(state_root)?
         {
-            let boundary_state =
+            let mut boundary_state =
                 get_full_state(&self.hot_db, &epoch_boundary_state_root, &self.spec)?.ok_or(
                     HotColdDBError::MissingEpochBoundaryState(epoch_boundary_state_root),
                 )?;
 
+            // Immediately rebase the state from disk on the finalized state so that we can reuse
+            // parts of the tree for state root calculation in `replay_blocks`.
+            self.state_cache
+                .lock()
+                .rebase_on_finalized(&mut boundary_state, &self.spec)?;
+
             // Optimization to avoid even *thinking* about replaying blocks if we're already
             // on an epoch boundary.
-            let state = if slot % E::slots_per_epoch() == 0 {
+            let mut state = if slot % E::slots_per_epoch() == 0 {
                 boundary_state
             } else {
+                // Cache ALL intermediate states that are reached during block replay. We may want
+                // to restrict this in future to only cache epoch boundary states. At worst we will
+                // cache up to 32 states for each state loaded, which should not flush out the cache
+                // entirely.
+                let state_cache_hook = |state_root, state: &mut BeaconState<E>| {
+                    // Ensure all caches are built before attempting to cache.
+                    state.update_tree_hash_cache()?;
+                    state.build_all_caches(&self.spec)?;
+
+                    let latest_block_root = state.get_latest_block_root(state_root);
+                    let state_slot = state.slot();
+                    if let PutStateOutcome::New =
+                        self.state_cache
+                            .lock()
+                            .put_state(state_root, latest_block_root, state)?
+                    {
+                        debug!(
+                            self.log,
+                            "Cached ancestor state";
+                            "state_root" => ?state_root,
+                            "slot" => state_slot,
+                        );
+                    }
+                    Ok(())
+                };
                 let blocks =
                     self.load_blocks_to_replay(boundary_state.slot(), slot, latest_block_root)?;
                 self.replay_blocks(
@@ -1130,11 +1236,12 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
                     blocks,
                     slot,
                     no_state_root_iter(),
-                    state_processing_strategy,
+                    Some(Box::new(state_cache_hook)),
                 )?
             };
+            state.apply_pending_mutations()?;
 
-            Ok(Some(state))
+            Ok(Some((state, latest_block_root)))
         } else {
             Ok(None)
         }
@@ -1233,7 +1340,9 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
         partial_state.load_randao_mixes(&self.cold_db, &self.spec)?;
         partial_state.load_historical_summaries(&self.cold_db, &self.spec)?;
 
-        partial_state.try_into()
+        let mut state: BeaconState<E> = partial_state.try_into()?;
+        state.apply_pending_mutations()?;
+        Ok(state)
     }
 
     /// Load a restore point state by its `restore_point_index`.
@@ -1247,7 +1356,7 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
 
     /// Load a frozen state that lies between restore points.
     fn load_cold_intermediate_state(&self, slot: Slot) -> Result<BeaconState<E>, Error> {
-        if let Some(state) = self.state_cache.lock().get(&slot) {
+        if let Some(state) = self.historic_state_cache.lock().get(&slot) {
             return Ok(state.clone());
         }
 
@@ -1261,7 +1370,7 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
         let mut low_state: Option<BeaconState<E>> = None;
 
         // Try to get a more recent state from the cache to avoid massive blocks replay.
-        for (s, state) in self.state_cache.lock().iter() {
+        for (s, state) in self.historic_state_cache.lock().iter() {
             if s.as_u64() / self.config.slots_per_restore_point == low_restore_point_idx
                 && *s < slot
                 && low_slot < *s
@@ -1299,16 +1408,11 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
             &self.spec,
         )?;
 
-        let state = self.replay_blocks(
-            low_state,
-            blocks,
-            slot,
-            Some(state_root_iter),
-            StateProcessingStrategy::Accurate,
-        )?;
+        let mut state = self.replay_blocks(low_state, blocks, slot, Some(state_root_iter), None)?;
+        state.apply_pending_mutations()?;
 
         // If state is not error, put it in the cache.
-        self.state_cache.lock().put(slot, state.clone());
+        self.historic_state_cache.lock().put(slot, state.clone());
 
         Ok(state)
     }
@@ -1390,16 +1494,15 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
     ///
     /// Will skip slots as necessary. The returned state is not guaranteed
     /// to have any caches built, beyond those immediately required by block processing.
-    fn replay_blocks(
+    pub fn replay_blocks(
         &self,
         state: BeaconState<E>,
         blocks: Vec<SignedBeaconBlock<E, BlindedPayload<E>>>,
         target_slot: Slot,
         state_root_iter: Option<impl Iterator<Item = Result<(Hash256, Slot), Error>>>,
-        state_processing_strategy: StateProcessingStrategy,
+        pre_slot_hook: Option<PreSlotHook<E, Error>>,
     ) -> Result<BeaconState<E>, Error> {
         let mut block_replayer = BlockReplayer::new(state, &self.spec)
-            .state_processing_strategy(state_processing_strategy)
             .no_signature_verification()
             .minimal_block_root_verification();
 
@@ -1408,17 +1511,20 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
             block_replayer = block_replayer.state_root_iter(state_root_iter);
         }
 
+        if let Some(pre_slot_hook) = pre_slot_hook {
+            block_replayer = block_replayer.pre_slot_hook(pre_slot_hook);
+        }
+
         block_replayer
             .apply_blocks(blocks, Some(target_slot))
             .map(|block_replayer| {
                 if have_state_root_iterator && block_replayer.state_root_miss() {
                     warn!(
                         self.log,
-                        "State root iterator miss";
+                        "State root cache miss during block replay";
                         "slot" => target_slot,
                     );
                 }
-
                 block_replayer.into_state()
             })
     }
@@ -2213,7 +2319,7 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
     }
 
     /// This function fills in missing block roots between last restore point slot and split
-    /// slot, if any.  
+    /// slot, if any.
     pub fn heal_freezer_block_roots_at_split(&self) -> Result<(), Error> {
         let split = self.get_split_info();
         let last_restore_point_slot = (split.slot - 1) / self.config.slots_per_restore_point
@@ -2528,15 +2634,22 @@ pub fn migrate_database<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>>(
         };
         store.hot_db.put_sync(&SPLIT_KEY, &split)?;
 
-        // Split point is now persisted in the hot database on disk.  The in-memory split point
-        // hasn't been modified elsewhere since we keep a write lock on it.  It's safe to update
+        // Split point is now persisted in the hot database on disk. The in-memory split point
+        // hasn't been modified elsewhere since we keep a write lock on it. It's safe to update
         // the in-memory split point now.
         *split_guard = split;
     }
 
-    // Delete the states from the hot database if we got this far.
+    // Delete the blocks and states from the hot database if we got this far.
     store.do_atomically_with_block_and_blobs_cache(hot_db_ops)?;
 
+    // Update the cache's view of the finalized state.
+    store.update_finalized_state(
+        finalized_state_root,
+        finalized_block_root,
+        finalized_state.clone(),
+    )?;
+
     debug!(
         store.log,
         "Freezer migration complete";
diff --git a/beacon_node/store/src/impls/beacon_state.rs b/beacon_node/store/src/impls/beacon_state.rs
index d08bf564927..f752bf39795 100644
--- a/beacon_node/store/src/impls/beacon_state.rs
+++ b/beacon_node/store/src/impls/beacon_state.rs
@@ -46,14 +46,14 @@ pub fn get_full_state<KV: KeyValueStore<E>, E: EthSpec>(
 #[derive(Encode)]
 pub struct StorageContainer<E: EthSpec> {
     state: BeaconState<E>,
-    committee_caches: Vec<CommitteeCache>,
+    committee_caches: Vec<Arc<CommitteeCache>>,
 }
 
 impl<E: EthSpec> StorageContainer<E> {
     /// Create a new instance for storing a `BeaconState`.
     pub fn new(state: &BeaconState<E>) -> Self {
         Self {
-            state: state.clone_with(CloneConfig::none()),
+            state: state.clone(),
             committee_caches: state.committee_caches().to_vec(),
         }
     }
diff --git a/beacon_node/store/src/impls/execution_payload.rs b/beacon_node/store/src/impls/execution_payload.rs
index a874031ca27..14fc10ad6de 100644
--- a/beacon_node/store/src/impls/execution_payload.rs
+++ b/beacon_node/store/src/impls/execution_payload.rs
@@ -1,8 +1,8 @@
 use crate::{DBColumn, Error, StoreItem};
 use ssz::{Decode, Encode};
 use types::{
-    BlobSidecarList, EthSpec, ExecutionPayload, ExecutionPayloadCapella, ExecutionPayloadDeneb,
-    ExecutionPayloadElectra, ExecutionPayloadMerge,
+    BlobSidecarList, EthSpec, ExecutionPayload, ExecutionPayloadBellatrix, ExecutionPayloadCapella,
+    ExecutionPayloadDeneb, ExecutionPayloadElectra,
 };
 
 macro_rules! impl_store_item {
@@ -22,7 +22,7 @@ macro_rules! impl_store_item {
         }
     };
 }
-impl_store_item!(ExecutionPayloadMerge);
+impl_store_item!(ExecutionPayloadBellatrix);
 impl_store_item!(ExecutionPayloadCapella);
 impl_store_item!(ExecutionPayloadDeneb);
 impl_store_item!(ExecutionPayloadElectra);
@@ -51,7 +51,8 @@ impl<E: EthSpec> StoreItem for ExecutionPayload<E> {
                         ExecutionPayloadCapella::from_ssz_bytes(bytes)
                             .map(Self::Capella)
                             .or_else(|_| {
-                                ExecutionPayloadMerge::from_ssz_bytes(bytes).map(Self::Merge)
+                                ExecutionPayloadBellatrix::from_ssz_bytes(bytes)
+                                    .map(Self::Bellatrix)
                             })
                     })
             })
diff --git a/beacon_node/store/src/iter.rs b/beacon_node/store/src/iter.rs
index e459c1c3575..03090ca14c5 100644
--- a/beacon_node/store/src/iter.rs
+++ b/beacon_node/store/src/iter.rs
@@ -412,15 +412,16 @@ mod test {
         let mut hashes = (0..).map(Hash256::from_low_u64_be);
         let roots_a = state_a.block_roots_mut();
         for i in 0..roots_a.len() {
-            roots_a[i] = hashes.next().unwrap()
+            *roots_a.get_mut(i).unwrap() = hashes.next().unwrap();
         }
         let roots_b = state_b.block_roots_mut();
         for i in 0..roots_b.len() {
-            roots_b[i] = hashes.next().unwrap()
+            *roots_b.get_mut(i).unwrap() = hashes.next().unwrap();
         }
 
         let state_a_root = hashes.next().unwrap();
-        state_b.state_roots_mut()[0] = state_a_root;
+        *state_b.state_roots_mut().get_mut(0).unwrap() = state_a_root;
+        state_a.apply_pending_mutations().unwrap();
         store.put_state(&state_a_root, &state_a).unwrap();
 
         let iter = BlockRootsIterator::new(&store, &state_b);
@@ -472,6 +473,9 @@ mod test {
         let state_a_root = Hash256::from_low_u64_be(slots_per_historical_root as u64);
         let state_b_root = Hash256::from_low_u64_be(slots_per_historical_root as u64 * 2);
 
+        state_a.apply_pending_mutations().unwrap();
+        state_b.apply_pending_mutations().unwrap();
+
         store.put_state(&state_a_root, &state_a).unwrap();
         store.put_state(&state_b_root, &state_b).unwrap();
 
diff --git a/beacon_node/store/src/lib.rs b/beacon_node/store/src/lib.rs
index e86689b0cf1..66032d89c52 100644
--- a/beacon_node/store/src/lib.rs
+++ b/beacon_node/store/src/lib.rs
@@ -14,6 +14,7 @@ mod chunk_writer;
 pub mod chunked_iter;
 pub mod chunked_vector;
 pub mod config;
+pub mod consensus_context;
 pub mod errors;
 mod forwards_iter;
 mod garbage_collection;
@@ -25,11 +26,13 @@ pub mod metadata;
 pub mod metrics;
 mod partial_beacon_state;
 pub mod reconstruct;
+pub mod state_cache;
 
 pub mod iter;
 
 pub use self::chunk_writer::ChunkWriter;
 pub use self::config::StoreConfig;
+pub use self::consensus_context::OnDiskConsensusContext;
 pub use self::hot_cold_store::{HotColdDB, HotStateSummary, Split};
 pub use self::leveldb_store::LevelDB;
 pub use self::memory_store::MemoryStore;
diff --git a/beacon_node/store/src/partial_beacon_state.rs b/beacon_node/store/src/partial_beacon_state.rs
index 4e5a2b8e64b..e56d0580ac2 100644
--- a/beacon_node/store/src/partial_beacon_state.rs
+++ b/beacon_node/store/src/partial_beacon_state.rs
@@ -14,7 +14,7 @@ use types::*;
 ///
 /// Utilises lazy-loading from separate storage for its vector fields.
 #[superstruct(
-    variants(Base, Altair, Merge, Capella, Deneb, Electra),
+    variants(Base, Altair, Bellatrix, Capella, Deneb, Electra),
     variant_attributes(derive(Debug, PartialEq, Clone, Encode, Decode))
 )]
 #[derive(Debug, PartialEq, Clone, Encode)]
@@ -34,42 +34,42 @@ where
     pub latest_block_header: BeaconBlockHeader,
 
     #[ssz(skip_serializing, skip_deserializing)]
-    pub block_roots: Option<FixedVector<Hash256, E::SlotsPerHistoricalRoot>>,
+    pub block_roots: Option<Vector<Hash256, E::SlotsPerHistoricalRoot>>,
     #[ssz(skip_serializing, skip_deserializing)]
-    pub state_roots: Option<FixedVector<Hash256, E::SlotsPerHistoricalRoot>>,
+    pub state_roots: Option<Vector<Hash256, E::SlotsPerHistoricalRoot>>,
 
     #[ssz(skip_serializing, skip_deserializing)]
-    pub historical_roots: Option<VariableList<Hash256, E::HistoricalRootsLimit>>,
+    pub historical_roots: Option<List<Hash256, E::HistoricalRootsLimit>>,
 
     // Ethereum 1.0 chain data
     pub eth1_data: Eth1Data,
-    pub eth1_data_votes: VariableList<Eth1Data, E::SlotsPerEth1VotingPeriod>,
+    pub eth1_data_votes: List<Eth1Data, E::SlotsPerEth1VotingPeriod>,
     pub eth1_deposit_index: u64,
 
     // Registry
-    pub validators: VariableList<Validator, E::ValidatorRegistryLimit>,
-    pub balances: VariableList<u64, E::ValidatorRegistryLimit>,
+    pub validators: List<Validator, E::ValidatorRegistryLimit>,
+    pub balances: List<u64, E::ValidatorRegistryLimit>,
 
     // Shuffling
     /// Randao value from the current slot, for patching into the per-epoch randao vector.
     pub latest_randao_value: Hash256,
     #[ssz(skip_serializing, skip_deserializing)]
-    pub randao_mixes: Option<FixedVector<Hash256, E::EpochsPerHistoricalVector>>,
+    pub randao_mixes: Option<Vector<Hash256, E::EpochsPerHistoricalVector>>,
 
     // Slashings
-    slashings: FixedVector<u64, E::EpochsPerSlashingsVector>,
+    slashings: Vector<u64, E::EpochsPerSlashingsVector>,
 
     // Attestations (genesis fork only)
     #[superstruct(only(Base))]
-    pub previous_epoch_attestations: VariableList<PendingAttestation<E>, E::MaxPendingAttestations>,
+    pub previous_epoch_attestations: List<PendingAttestation<E>, E::MaxPendingAttestations>,
     #[superstruct(only(Base))]
-    pub current_epoch_attestations: VariableList<PendingAttestation<E>, E::MaxPendingAttestations>,
+    pub current_epoch_attestations: List<PendingAttestation<E>, E::MaxPendingAttestations>,
 
     // Participation (Altair and later)
-    #[superstruct(only(Altair, Merge, Capella, Deneb, Electra))]
-    pub previous_epoch_participation: VariableList<ParticipationFlags, E::ValidatorRegistryLimit>,
-    #[superstruct(only(Altair, Merge, Capella, Deneb, Electra))]
-    pub current_epoch_participation: VariableList<ParticipationFlags, E::ValidatorRegistryLimit>,
+    #[superstruct(only(Altair, Bellatrix, Capella, Deneb, Electra))]
+    pub previous_epoch_participation: List<ParticipationFlags, E::ValidatorRegistryLimit>,
+    #[superstruct(only(Altair, Bellatrix, Capella, Deneb, Electra))]
+    pub current_epoch_participation: List<ParticipationFlags, E::ValidatorRegistryLimit>,
 
     // Finality
     pub justification_bits: BitVector<E::JustificationBitsLength>,
@@ -78,21 +78,21 @@ where
     pub finalized_checkpoint: Checkpoint,
 
     // Inactivity
-    #[superstruct(only(Altair, Merge, Capella, Deneb, Electra))]
-    pub inactivity_scores: VariableList<u64, E::ValidatorRegistryLimit>,
+    #[superstruct(only(Altair, Bellatrix, Capella, Deneb, Electra))]
+    pub inactivity_scores: List<u64, E::ValidatorRegistryLimit>,
 
     // Light-client sync committees
-    #[superstruct(only(Altair, Merge, Capella, Deneb, Electra))]
+    #[superstruct(only(Altair, Bellatrix, Capella, Deneb, Electra))]
     pub current_sync_committee: Arc<SyncCommittee<E>>,
-    #[superstruct(only(Altair, Merge, Capella, Deneb, Electra))]
+    #[superstruct(only(Altair, Bellatrix, Capella, Deneb, Electra))]
     pub next_sync_committee: Arc<SyncCommittee<E>>,
 
     // Execution
     #[superstruct(
-        only(Merge),
-        partial_getter(rename = "latest_execution_payload_header_merge")
+        only(Bellatrix),
+        partial_getter(rename = "latest_execution_payload_header_bellatrix")
     )]
-    pub latest_execution_payload_header: ExecutionPayloadHeaderMerge<E>,
+    pub latest_execution_payload_header: ExecutionPayloadHeaderBellatrix<E>,
     #[superstruct(
         only(Capella),
         partial_getter(rename = "latest_execution_payload_header_capella")
@@ -117,7 +117,30 @@ where
 
     #[ssz(skip_serializing, skip_deserializing)]
     #[superstruct(only(Capella, Deneb, Electra))]
-    pub historical_summaries: Option<VariableList<HistoricalSummary, E::HistoricalRootsLimit>>,
+    pub historical_summaries: Option<List<HistoricalSummary, E::HistoricalRootsLimit>>,
+
+    // Electra
+    #[superstruct(only(Electra))]
+    pub deposit_receipts_start_index: u64,
+    #[superstruct(only(Electra))]
+    pub deposit_balance_to_consume: u64,
+    #[superstruct(only(Electra))]
+    pub exit_balance_to_consume: u64,
+    #[superstruct(only(Electra))]
+    pub earliest_exit_epoch: Epoch,
+    #[superstruct(only(Electra))]
+    pub consolidation_balance_to_consume: u64,
+    #[superstruct(only(Electra))]
+    pub earliest_consolidation_epoch: Epoch,
+
+    // TODO(electra) should these be optional?
+    #[superstruct(only(Electra))]
+    pub pending_balance_deposits: List<PendingBalanceDeposit, E::PendingBalanceDepositsLimit>,
+    #[superstruct(only(Electra))]
+    pub pending_partial_withdrawals:
+        List<PendingPartialWithdrawal, E::PendingPartialWithdrawalsLimit>,
+    #[superstruct(only(Electra))]
+    pub pending_consolidations: List<PendingConsolidation, E::PendingConsolidationsLimit>,
 }
 
 /// Implement the conversion function from BeaconState -> PartialBeaconState.
@@ -199,11 +222,11 @@ impl<E: EthSpec> PartialBeaconState<E> {
                 ],
                 []
             ),
-            BeaconState::Merge(s) => impl_from_state_forgetful!(
+            BeaconState::Bellatrix(s) => impl_from_state_forgetful!(
                 s,
                 outer,
-                Merge,
-                PartialBeaconStateMerge,
+                Bellatrix,
+                PartialBeaconStateBellatrix,
                 [
                     previous_epoch_participation,
                     current_epoch_participation,
@@ -261,7 +284,16 @@ impl<E: EthSpec> PartialBeaconState<E> {
                     inactivity_scores,
                     latest_execution_payload_header,
                     next_withdrawal_index,
-                    next_withdrawal_validator_index
+                    next_withdrawal_validator_index,
+                    deposit_receipts_start_index,
+                    deposit_balance_to_consume,
+                    exit_balance_to_consume,
+                    earliest_exit_epoch,
+                    consolidation_balance_to_consume,
+                    earliest_consolidation_epoch,
+                    pending_balance_deposits,
+                    pending_partial_withdrawals,
+                    pending_consolidations
                 ],
                 [historical_summaries]
             ),
@@ -369,7 +401,9 @@ impl<E: EthSpec> PartialBeaconState<E> {
             // Patch the value for the current slot into the index for the current epoch
             let current_epoch = self.slot().epoch(E::slots_per_epoch());
             let len = randao_mixes.len();
-            randao_mixes[current_epoch.as_usize() % len] = *self.latest_randao_value();
+            *randao_mixes
+                .get_mut(current_epoch.as_usize() % len)
+                .ok_or(Error::RandaoMixOutOfBounds)? = *self.latest_randao_value();
 
             *self.randao_mixes_mut() = Some(randao_mixes)
         }
@@ -422,7 +456,6 @@ macro_rules! impl_try_into_beacon_state {
             exit_cache: <_>::default(),
             slashings_cache: <_>::default(),
             epoch_cache: <_>::default(),
-            tree_hash_cache: <_>::default(),
 
             // Variant-specific fields
             $(
@@ -466,10 +499,10 @@ impl<E: EthSpec> TryInto<BeaconState<E>> for PartialBeaconState<E> {
                 ],
                 []
             ),
-            PartialBeaconState::Merge(inner) => impl_try_into_beacon_state!(
+            PartialBeaconState::Bellatrix(inner) => impl_try_into_beacon_state!(
                 inner,
-                Merge,
-                BeaconStateMerge,
+                Bellatrix,
+                BeaconStateBellatrix,
                 [
                     previous_epoch_participation,
                     current_epoch_participation,
@@ -524,7 +557,16 @@ impl<E: EthSpec> TryInto<BeaconState<E>> for PartialBeaconState<E> {
                     inactivity_scores,
                     latest_execution_payload_header,
                     next_withdrawal_index,
-                    next_withdrawal_validator_index
+                    next_withdrawal_validator_index,
+                    deposit_receipts_start_index,
+                    deposit_balance_to_consume,
+                    exit_balance_to_consume,
+                    earliest_exit_epoch,
+                    consolidation_balance_to_consume,
+                    earliest_consolidation_epoch,
+                    pending_balance_deposits,
+                    pending_partial_withdrawals,
+                    pending_consolidations
                 ],
                 [historical_summaries]
             ),
diff --git a/beacon_node/store/src/reconstruct.rs b/beacon_node/store/src/reconstruct.rs
index 8fe13777ac4..8ef4886565c 100644
--- a/beacon_node/store/src/reconstruct.rs
+++ b/beacon_node/store/src/reconstruct.rs
@@ -5,7 +5,7 @@ use itertools::{process_results, Itertools};
 use slog::info;
 use state_processing::{
     per_block_processing, per_slot_processing, BlockSignatureStrategy, ConsensusContext,
-    StateProcessingStrategy, VerifyBlockRoot,
+    VerifyBlockRoot,
 };
 use std::sync::Arc;
 use types::{EthSpec, Hash256};
@@ -94,7 +94,6 @@ where
                         &mut state,
                         &block,
                         BlockSignatureStrategy::NoVerification,
-                        StateProcessingStrategy::Accurate,
                         VerifyBlockRoot::True,
                         &mut ctxt,
                         &self.spec,
diff --git a/beacon_node/store/src/state_cache.rs b/beacon_node/store/src/state_cache.rs
new file mode 100644
index 00000000000..5c1faa7f2fd
--- /dev/null
+++ b/beacon_node/store/src/state_cache.rs
@@ -0,0 +1,303 @@
+use crate::Error;
+use lru::LruCache;
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::num::NonZeroUsize;
+use types::{BeaconState, ChainSpec, Epoch, EthSpec, Hash256, Slot};
+
+/// Fraction of the LRU cache to leave intact during culling.
+const CULL_EXEMPT_NUMERATOR: usize = 1;
+const CULL_EXEMPT_DENOMINATOR: usize = 10;
+
+/// States that are less than or equal to this many epochs old *could* become finalized and will not
+/// be culled from the cache.
+const EPOCH_FINALIZATION_LIMIT: u64 = 4;
+
+#[derive(Debug)]
+pub struct FinalizedState<E: EthSpec> {
+    state_root: Hash256,
+    state: BeaconState<E>,
+}
+
+/// Map from block_root -> slot -> state_root.
+#[derive(Debug, Default)]
+pub struct BlockMap {
+    blocks: HashMap<Hash256, SlotMap>,
+}
+
+/// Map from slot -> state_root.
+#[derive(Debug, Default)]
+pub struct SlotMap {
+    slots: BTreeMap<Slot, Hash256>,
+}
+
+#[derive(Debug)]
+pub struct StateCache<E: EthSpec> {
+    finalized_state: Option<FinalizedState<E>>,
+    states: LruCache<Hash256, BeaconState<E>>,
+    block_map: BlockMap,
+    max_epoch: Epoch,
+}
+
+#[derive(Debug)]
+pub enum PutStateOutcome {
+    Finalized,
+    Duplicate,
+    New,
+}
+
+#[allow(clippy::len_without_is_empty)]
+impl<E: EthSpec> StateCache<E> {
+    pub fn new(capacity: NonZeroUsize) -> Self {
+        StateCache {
+            finalized_state: None,
+            states: LruCache::new(capacity),
+            block_map: BlockMap::default(),
+            max_epoch: Epoch::new(0),
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.states.len()
+    }
+
+    pub fn capacity(&self) -> usize {
+        self.states.cap().get()
+    }
+
+    pub fn update_finalized_state(
+        &mut self,
+        state_root: Hash256,
+        block_root: Hash256,
+        state: BeaconState<E>,
+    ) -> Result<(), Error> {
+        if state.slot() % E::slots_per_epoch() != 0 {
+            return Err(Error::FinalizedStateUnaligned);
+        }
+
+        if self
+            .finalized_state
+            .as_ref()
+            .map_or(false, |finalized_state| {
+                state.slot() < finalized_state.state.slot()
+            })
+        {
+            return Err(Error::FinalizedStateDecreasingSlot);
+        }
+
+        // Add to block map.
+        self.block_map.insert(block_root, state.slot(), state_root);
+
+        // Prune block map.
+        let state_roots_to_prune = self.block_map.prune(state.slot());
+
+        // Delete states.
+        for state_root in state_roots_to_prune {
+            self.states.pop(&state_root);
+        }
+
+        // Update finalized state.
+        self.finalized_state = Some(FinalizedState { state_root, state });
+        Ok(())
+    }
+
+    /// Rebase the given state on the finalized state in order to reduce its memory consumption.
+    ///
+    /// This function should only be called on states that are likely not to already share tree
+    /// nodes with the finalized state, e.g. states loaded from disk.
+    ///
+    /// If the finalized state is not initialized this function is a no-op.
+    pub fn rebase_on_finalized(
+        &self,
+        state: &mut BeaconState<E>,
+        spec: &ChainSpec,
+    ) -> Result<(), Error> {
+        if let Some(finalized_state) = &self.finalized_state {
+            state.rebase_on(&finalized_state.state, spec)?;
+        }
+        Ok(())
+    }
+
+    /// Return a status indicating whether the state already existed in the cache.
+    pub fn put_state(
+        &mut self,
+        state_root: Hash256,
+        block_root: Hash256,
+        state: &BeaconState<E>,
+    ) -> Result<PutStateOutcome, Error> {
+        if self
+            .finalized_state
+            .as_ref()
+            .map_or(false, |finalized_state| {
+                finalized_state.state_root == state_root
+            })
+        {
+            return Ok(PutStateOutcome::Finalized);
+        }
+
+        if self.states.peek(&state_root).is_some() {
+            return Ok(PutStateOutcome::Duplicate);
+        }
+
+        // Refuse states with pending mutations: we want cached states to be as small as possible
+        // i.e. stored entirely as a binary merkle tree with no updates overlaid.
+        if state.has_pending_mutations() {
+            return Err(Error::StateForCacheHasPendingUpdates {
+                state_root,
+                slot: state.slot(),
+            });
+        }
+
+        // Update the cache's idea of the max epoch.
+        self.max_epoch = std::cmp::max(state.current_epoch(), self.max_epoch);
+
+        // If the cache is full, use the custom cull routine to make room.
+        if let Some(over_capacity) = self.len().checked_sub(self.capacity()) {
+            self.cull(over_capacity + 1);
+        }
+
+        // Insert the full state into the cache.
+        self.states.put(state_root, state.clone());
+
+        // Record the connection from block root and slot to this state.
+        let slot = state.slot();
+        self.block_map.insert(block_root, slot, state_root);
+
+        Ok(PutStateOutcome::New)
+    }
+
+    pub fn get_by_state_root(&mut self, state_root: Hash256) -> Option<BeaconState<E>> {
+        if let Some(ref finalized_state) = self.finalized_state {
+            if state_root == finalized_state.state_root {
+                return Some(finalized_state.state.clone());
+            }
+        }
+        self.states.get(&state_root).cloned()
+    }
+
+    pub fn get_by_block_root(
+        &mut self,
+        block_root: Hash256,
+        slot: Slot,
+    ) -> Option<(Hash256, BeaconState<E>)> {
+        let slot_map = self.block_map.blocks.get(&block_root)?;
+
+        // Find the state at `slot`, or failing that the most recent ancestor.
+        let state_root = slot_map
+            .slots
+            .iter()
+            .rev()
+            .find_map(|(ancestor_slot, state_root)| {
+                (*ancestor_slot <= slot).then_some(*state_root)
+            })?;
+
+        let state = self.get_by_state_root(state_root)?;
+        Some((state_root, state))
+    }
+
+    pub fn delete_state(&mut self, state_root: &Hash256) {
+        self.states.pop(state_root);
+        self.block_map.delete(state_root);
+    }
+
+    pub fn delete_block_states(&mut self, block_root: &Hash256) {
+        if let Some(slot_map) = self.block_map.delete_block_states(block_root) {
+            for state_root in slot_map.slots.values() {
+                self.states.pop(state_root);
+            }
+        }
+    }
+
+    /// Cull approximately `count` states from the cache.
+    ///
+    /// States are culled LRU, with the following extra order imposed:
+    ///
+    /// - Advanced states.
+    /// - Mid-epoch unadvanced states.
+    /// - Epoch-boundary states that are too old to be finalized.
+    /// - Epoch-boundary states that could be finalized.
+    pub fn cull(&mut self, count: usize) {
+        let cull_exempt = std::cmp::max(
+            1,
+            self.len() * CULL_EXEMPT_NUMERATOR / CULL_EXEMPT_DENOMINATOR,
+        );
+
+        // Stage 1: gather states to cull.
+        let mut advanced_state_roots = vec![];
+        let mut mid_epoch_state_roots = vec![];
+        let mut old_boundary_state_roots = vec![];
+        let mut good_boundary_state_roots = vec![];
+        for (&state_root, state) in self.states.iter().skip(cull_exempt) {
+            let is_advanced = state.slot() > state.latest_block_header().slot;
+            let is_boundary = state.slot() % E::slots_per_epoch() == 0;
+            let could_finalize =
+                (self.max_epoch - state.current_epoch()) <= EPOCH_FINALIZATION_LIMIT;
+
+            if is_boundary {
+                if could_finalize {
+                    good_boundary_state_roots.push(state_root);
+                } else {
+                    old_boundary_state_roots.push(state_root);
+                }
+            } else if is_advanced {
+                advanced_state_roots.push(state_root);
+            } else {
+                mid_epoch_state_roots.push(state_root);
+            }
+
+            // Terminate early in the common case where we've already found enough junk to cull.
+            if advanced_state_roots.len() == count {
+                break;
+            }
+        }
+
+        // Stage 2: delete.
+        // This could probably be more efficient in how it interacts with the block map.
+        for state_root in advanced_state_roots
+            .iter()
+            .chain(mid_epoch_state_roots.iter())
+            .chain(old_boundary_state_roots.iter())
+            .chain(good_boundary_state_roots.iter())
+            .take(count)
+        {
+            self.delete_state(state_root);
+        }
+    }
+}
+
+impl BlockMap {
+    fn insert(&mut self, block_root: Hash256, slot: Slot, state_root: Hash256) {
+        let slot_map = self.blocks.entry(block_root).or_default();
+        slot_map.slots.insert(slot, state_root);
+    }
+
+    fn prune(&mut self, finalized_slot: Slot) -> HashSet<Hash256> {
+        let mut pruned_states = HashSet::new();
+
+        self.blocks.retain(|_, slot_map| {
+            slot_map.slots.retain(|slot, state_root| {
+                let keep = *slot >= finalized_slot;
+                if !keep {
+                    pruned_states.insert(*state_root);
+                }
+                keep
+            });
+
+            !slot_map.slots.is_empty()
+        });
+
+        pruned_states
+    }
+
+    fn delete(&mut self, state_root_to_delete: &Hash256) {
+        self.blocks.retain(|_, slot_map| {
+            slot_map
+                .slots
+                .retain(|_, state_root| state_root != state_root_to_delete);
+            !slot_map.slots.is_empty()
+        });
+    }
+
+    fn delete_block_states(&mut self, block_root: &Hash256) -> Option<SlotMap> {
+        self.blocks.remove(block_root)
+    }
+}
diff --git a/book/src/help_bn.md b/book/src/help_bn.md
index 996642f0fc7..efdc7114b79 100644
--- a/book/src/help_bn.md
+++ b/book/src/help_bn.md
@@ -70,9 +70,6 @@ FLAGS:
                                                enables --http and --validator-monitor-auto and enables SSE logging.
     -h, --help                                 Prints help information
         --http                                 Enable the RESTful HTTP API server. Disabled by default.
-        --http-allow-sync-stalled              Forces the HTTP to indicate that the node is synced when sync is actually
-                                               stalled. This is useful for very small testnets. TESTING ONLY. DO NOT USE
-                                               ON MAINNET.
         --http-enable-tls                      Serves the RESTful HTTP API server over TLS. This feature is currently
                                                experimental.
         --import-all-attestations              Import and aggregate all attestations, regardless of validator
@@ -280,9 +277,6 @@ OPTIONS:
         --http-port <PORT>
             Set the listen TCP port for the RESTful HTTP API server.
 
-        --http-spec-fork <FORK>
-            Serve the spec for a specific hard fork on /eth/v1/config/spec. It should not be necessary to set this flag.
-
         --http-sse-capacity-multiplier <N>
             Multiplier to apply to the length of HTTP server-sent-event (SSE) channels. Increasing this value can
             prevent messages from being dropped.
@@ -444,7 +438,7 @@ OPTIONS:
             Specifies how often a freezer DB restore point should be stored. Cannot be changed after initialization.
             [default: 8192 (mainnet) or 64 (minimal)]
         --state-cache-size <STATE_CACHE_SIZE>
-            Specifies the size of the snapshot cache [default: 3]
+            Specifies the size of the state cache [default: 128]
 
         --suggested-fee-recipient <SUGGESTED-FEE-RECIPIENT>
             Emergency fallback fee recipient for use in case the validator client does not have one configured. You
diff --git a/book/src/help_vc.md b/book/src/help_vc.md
index fb963f87cc5..1b7e7f2b0af 100644
--- a/book/src/help_vc.md
+++ b/book/src/help_vc.md
@@ -218,7 +218,7 @@ OPTIONS:
             The directory which contains the validator keystores, deposit data for each validator along with the common
             slashing protection database and the validator_definitions.yml
         --web3-signer-keep-alive-timeout <MILLIS>
-            Keep-alive timeout for each web3signer connection. Set to 'null' to never timeout [default: 90000]
+            Keep-alive timeout for each web3signer connection. Set to 'null' to never timeout [default: 20000]
 
         --web3-signer-max-idle-connections <COUNT>
             Maximum number of idle connections to maintain per web3signer host. Default is unlimited.
diff --git a/book/src/validator-management.md b/book/src/validator-management.md
index df7c2ac4760..bc6aba3c4f9 100644
--- a/book/src/validator-management.md
+++ b/book/src/validator-management.md
@@ -59,7 +59,9 @@ Each permitted field of the file is listed below for reference:
 - `voting_keystore_password`: The password to the EIP-2335 keystore.
 
 > **Note**: Either `voting_keystore_password_path` or `voting_keystore_password` *must* be
-> supplied. If both are supplied, `voting_keystore_password_path` is ignored.
+> supplied. If both are supplied, `voting_keystore_password_path` is ignored. 
+
+>If you do not wish to have  `voting_keystore_password` being stored in the `validator_definitions.yml` file, you can add the field `voting_keystore_password_path` and point it to a file containing the password. The file can be, e.g., on a mounted portable drive that contains the password so that no password is stored on the validating node. 
 
 ## Populating the `validator_definitions.yml` file
 
@@ -75,6 +77,7 @@ recap:
 
 ### Automatic validator discovery
 
+
 When the `--disable-auto-discover` flag is **not** provided, the validator client will search the
 `validator-dir` for validators and add any *new* validators to the
 `validator_definitions.yml` with `enabled: true`.
diff --git a/common/eth2/src/types.rs b/common/eth2/src/types.rs
index feff1d391a9..b15246e7fdb 100644
--- a/common/eth2/src/types.rs
+++ b/common/eth2/src/types.rs
@@ -1023,7 +1023,7 @@ impl ForkVersionDeserialize for SsePayloadAttributes {
         fork_name: ForkName,
     ) -> Result<Self, D::Error> {
         match fork_name {
-            ForkName::Merge => serde_json::from_value(value)
+            ForkName::Bellatrix => serde_json::from_value(value)
                 .map(Self::V1)
                 .map_err(serde::de::Error::custom),
             ForkName::Capella => serde_json::from_value(value)
@@ -1080,6 +1080,8 @@ pub enum EventKind<E: EthSpec> {
     #[cfg(feature = "lighthouse")]
     BlockReward(BlockReward),
     PayloadAttributes(VersionedSsePayloadAttributes),
+    ProposerSlashing(Box<ProposerSlashing>),
+    AttesterSlashing(Box<AttesterSlashing<E>>),
 }
 
 impl<E: EthSpec> EventKind<E> {
@@ -1099,6 +1101,8 @@ impl<E: EthSpec> EventKind<E> {
             EventKind::LightClientOptimisticUpdate(_) => "light_client_optimistic_update",
             #[cfg(feature = "lighthouse")]
             EventKind::BlockReward(_) => "block_reward",
+            EventKind::ProposerSlashing(_) => "proposer_slashing",
+            EventKind::AttesterSlashing(_) => "attester_slashing",
         }
     }
 
@@ -1179,6 +1183,16 @@ impl<E: EthSpec> EventKind<E> {
             "block_reward" => Ok(EventKind::BlockReward(serde_json::from_str(data).map_err(
                 |e| ServerError::InvalidServerSentEvent(format!("Block Reward: {:?}", e)),
             )?)),
+            "attester_slashing" => Ok(EventKind::AttesterSlashing(
+                serde_json::from_str(data).map_err(|e| {
+                    ServerError::InvalidServerSentEvent(format!("Attester Slashing: {:?}", e))
+                })?,
+            )),
+            "proposer_slashing" => Ok(EventKind::ProposerSlashing(
+                serde_json::from_str(data).map_err(|e| {
+                    ServerError::InvalidServerSentEvent(format!("Proposer Slashing: {:?}", e))
+                })?,
+            )),
             _ => Err(ServerError::InvalidServerSentEvent(
                 "Could not parse event tag".to_string(),
             )),
@@ -1210,6 +1224,8 @@ pub enum EventTopic {
     LightClientOptimisticUpdate,
     #[cfg(feature = "lighthouse")]
     BlockReward,
+    AttesterSlashing,
+    ProposerSlashing,
 }
 
 impl FromStr for EventTopic {
@@ -1231,6 +1247,8 @@ impl FromStr for EventTopic {
             "light_client_optimistic_update" => Ok(EventTopic::LightClientOptimisticUpdate),
             #[cfg(feature = "lighthouse")]
             "block_reward" => Ok(EventTopic::BlockReward),
+            "attester_slashing" => Ok(EventTopic::AttesterSlashing),
+            "proposer_slashing" => Ok(EventTopic::ProposerSlashing),
             _ => Err("event topic cannot be parsed.".to_string()),
         }
     }
@@ -1253,6 +1271,8 @@ impl fmt::Display for EventTopic {
             EventTopic::LightClientOptimisticUpdate => write!(f, "light_client_optimistic_update"),
             #[cfg(feature = "lighthouse")]
             EventTopic::BlockReward => write!(f, "block_reward"),
+            EventTopic::AttesterSlashing => write!(f, "attester_slashing"),
+            EventTopic::ProposerSlashing => write!(f, "proposer_slashing"),
         }
     }
 }
@@ -1598,7 +1618,7 @@ impl<E: EthSpec> FullBlockContents<E> {
         fork_name: ForkName,
     ) -> Result<Self, ssz::DecodeError> {
         match fork_name {
-            ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => {
+            ForkName::Base | ForkName::Altair | ForkName::Bellatrix | ForkName::Capella => {
                 BeaconBlock::from_ssz_bytes_for_fork(bytes, fork_name)
                     .map(|block| FullBlockContents::Block(block))
             }
@@ -1658,7 +1678,7 @@ impl<E: EthSpec> ForkVersionDeserialize for FullBlockContents<E> {
         fork_name: ForkName,
     ) -> Result<Self, D::Error> {
         match fork_name {
-            ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => {
+            ForkName::Base | ForkName::Altair | ForkName::Bellatrix | ForkName::Capella => {
                 Ok(FullBlockContents::Block(
                     BeaconBlock::deserialize_by_fork::<'de, D>(value, fork_name)?,
                 ))
@@ -1758,7 +1778,7 @@ impl<E: EthSpec> PublishBlockRequest<E> {
     /// SSZ decode with fork variant determined by `fork_name`.
     pub fn from_ssz_bytes(bytes: &[u8], fork_name: ForkName) -> Result<Self, ssz::DecodeError> {
         match fork_name {
-            ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => {
+            ForkName::Base | ForkName::Altair | ForkName::Bellatrix | ForkName::Capella => {
                 SignedBeaconBlock::from_ssz_bytes_for_fork(bytes, fork_name)
                     .map(|block| PublishBlockRequest::Block(Arc::new(block)))
             }
@@ -1844,7 +1864,7 @@ impl<E: EthSpec> TryFrom<Arc<SignedBeaconBlock<E>>> for PublishBlockRequest<E> {
         match *block {
             SignedBeaconBlock::Base(_)
             | SignedBeaconBlock::Altair(_)
-            | SignedBeaconBlock::Merge(_)
+            | SignedBeaconBlock::Bellatrix(_)
             | SignedBeaconBlock::Capella(_) => Ok(PublishBlockRequest::Block(block)),
             SignedBeaconBlock::Deneb(_) | SignedBeaconBlock::Electra(_) => Err(
                 "post-Deneb block contents cannot be fully constructed from just the signed block",
@@ -1953,7 +1973,7 @@ impl<E: EthSpec> ForkVersionDeserialize for FullPayloadContents<E> {
         fork_name: ForkName,
     ) -> Result<Self, D::Error> {
         match fork_name {
-            ForkName::Merge | ForkName::Capella => serde_json::from_value(value)
+            ForkName::Bellatrix | ForkName::Capella => serde_json::from_value(value)
                 .map(Self::Payload)
                 .map_err(serde::de::Error::custom),
             ForkName::Deneb | ForkName::Electra => serde_json::from_value(value)
diff --git a/common/eth2_network_config/built_in_network_configs/gnosis/config.yaml b/common/eth2_network_config/built_in_network_configs/gnosis/config.yaml
index 27fb81a5139..50a5fcc3a50 100644
--- a/common/eth2_network_config/built_in_network_configs/gnosis/config.yaml
+++ b/common/eth2_network_config/built_in_network_configs/gnosis/config.yaml
@@ -33,7 +33,7 @@ GENESIS_DELAY: 6000
 # Altair
 ALTAIR_FORK_VERSION: 0x01000064
 ALTAIR_FORK_EPOCH: 512
-# Merge
+# Bellatrix
 BELLATRIX_FORK_VERSION: 0x02000064
 BELLATRIX_FORK_EPOCH: 385536
 # Capella
diff --git a/common/eth2_network_config/built_in_network_configs/holesky/config.yaml b/common/eth2_network_config/built_in_network_configs/holesky/config.yaml
index bd384cfe497..6a399b957d2 100644
--- a/common/eth2_network_config/built_in_network_configs/holesky/config.yaml
+++ b/common/eth2_network_config/built_in_network_configs/holesky/config.yaml
@@ -22,7 +22,7 @@ GENESIS_DELAY: 300
 # Altair
 ALTAIR_FORK_VERSION: 0x02017000
 ALTAIR_FORK_EPOCH: 0
-# Merge
+# Bellatrix
 BELLATRIX_FORK_VERSION: 0x03017000
 BELLATRIX_FORK_EPOCH: 0
 TERMINAL_TOTAL_DIFFICULTY: 0
diff --git a/common/eth2_network_config/built_in_network_configs/sepolia/config.yaml b/common/eth2_network_config/built_in_network_configs/sepolia/config.yaml
index 2df40798c11..72a48679118 100644
--- a/common/eth2_network_config/built_in_network_configs/sepolia/config.yaml
+++ b/common/eth2_network_config/built_in_network_configs/sepolia/config.yaml
@@ -21,7 +21,7 @@ GENESIS_DELAY: 86400
 ALTAIR_FORK_VERSION: 0x90000070
 ALTAIR_FORK_EPOCH: 50
 
-# Merge
+# Bellatrix
 BELLATRIX_FORK_VERSION: 0x90000071
 BELLATRIX_FORK_EPOCH: 100
 TERMINAL_TOTAL_DIFFICULTY: 17000000000000000
diff --git a/common/lighthouse_version/src/lib.rs b/common/lighthouse_version/src/lib.rs
index 5387d322e96..985eaff1b59 100644
--- a/common/lighthouse_version/src/lib.rs
+++ b/common/lighthouse_version/src/lib.rs
@@ -21,6 +21,24 @@ pub const VERSION: &str = git_version!(
     fallback = "Lighthouse/v5.1.3"
 );
 
+/// Returns the first eight characters of the latest commit hash for this build.
+///
+/// No indication is given if the tree is dirty. This is part of the standard
+/// for reporting the client version to the execution engine.
+pub const COMMIT_PREFIX: &str = git_version!(
+    args = [
+        "--always",
+        "--abbrev=8",
+        // NOTE: using --match instead of --exclude for compatibility with old Git
+        "--match=thiswillnevermatchlol"
+    ],
+    prefix = "",
+    suffix = "",
+    cargo_prefix = "",
+    cargo_suffix = "",
+    fallback = "00000000"
+);
+
 /// Returns `VERSION`, but with platform information appended to the end.
 ///
 /// ## Example
diff --git a/common/logging/src/lib.rs b/common/logging/src/lib.rs
index 3a5a5209b02..b0e1da00e97 100644
--- a/common/logging/src/lib.rs
+++ b/common/logging/src/lib.rs
@@ -256,14 +256,14 @@ pub fn create_tracing_layer(base_tracing_log_path: PathBuf) {
         return;
     };
 
-    let (libp2p_non_blocking_writer, libp2p_guard) = NonBlocking::new(libp2p_writer);
-    let (discv5_non_blocking_writer, discv5_guard) = NonBlocking::new(discv5_writer);
+    let (libp2p_non_blocking_writer, _libp2p_guard) = NonBlocking::new(libp2p_writer);
+    let (discv5_non_blocking_writer, _discv5_guard) = NonBlocking::new(discv5_writer);
 
     let custom_layer = LoggingLayer {
         libp2p_non_blocking_writer,
-        libp2p_guard,
+        _libp2p_guard,
         discv5_non_blocking_writer,
-        discv5_guard,
+        _discv5_guard,
     };
 
     if let Err(e) = tracing_subscriber::fmt()
diff --git a/common/logging/src/tracing_logging_layer.rs b/common/logging/src/tracing_logging_layer.rs
index aabb6ddd0c9..a9ddae828ae 100644
--- a/common/logging/src/tracing_logging_layer.rs
+++ b/common/logging/src/tracing_logging_layer.rs
@@ -7,9 +7,9 @@ use tracing_subscriber::Layer;
 
 pub struct LoggingLayer {
     pub libp2p_non_blocking_writer: NonBlocking,
-    pub libp2p_guard: WorkerGuard,
+    pub _libp2p_guard: WorkerGuard,
     pub discv5_non_blocking_writer: NonBlocking,
-    pub discv5_guard: WorkerGuard,
+    pub _discv5_guard: WorkerGuard,
 }
 
 impl<S> Layer<S> for LoggingLayer
diff --git a/common/lru_cache/src/time.rs b/common/lru_cache/src/time.rs
index 0b2fd835687..890bf47eb44 100644
--- a/common/lru_cache/src/time.rs
+++ b/common/lru_cache/src/time.rs
@@ -166,6 +166,12 @@ where
         self.map.contains(key)
     }
 
+    /// List known keys
+    pub fn keys(&mut self) -> impl Iterator<Item = &Key> {
+        self.update();
+        self.map.iter()
+    }
+
     /// Shrink the mappings to fit the current size.
     pub fn shrink_to_fit(&mut self) {
         self.map.shrink_to_fit();
diff --git a/common/slot_clock/src/lib.rs b/common/slot_clock/src/lib.rs
index 6bf74645000..4f54b2ee76b 100644
--- a/common/slot_clock/src/lib.rs
+++ b/common/slot_clock/src/lib.rs
@@ -11,7 +11,7 @@ pub use crate::manual_slot_clock::ManualSlotClock as TestingSlotClock;
 pub use crate::manual_slot_clock::ManualSlotClock;
 pub use crate::system_time_slot_clock::SystemTimeSlotClock;
 pub use metrics::scrape_for_metrics;
-use types::consts::merge::INTERVALS_PER_SLOT;
+use types::consts::bellatrix::INTERVALS_PER_SLOT;
 pub use types::Slot;
 
 /// A clock that reports the current slot.
diff --git a/common/slot_clock/src/manual_slot_clock.rs b/common/slot_clock/src/manual_slot_clock.rs
index 7b42fa9062d..1d71533de15 100644
--- a/common/slot_clock/src/manual_slot_clock.rs
+++ b/common/slot_clock/src/manual_slot_clock.rs
@@ -1,5 +1,6 @@
 use super::SlotClock;
 use parking_lot::RwLock;
+use std::ops::Add;
 use std::sync::Arc;
 use std::time::Duration;
 use types::Slot;
@@ -41,6 +42,11 @@ impl ManualSlotClock {
         *self.current_time.write() = duration;
     }
 
+    pub fn advance_time(&self, duration: Duration) {
+        let current_time = *self.current_time.read();
+        *self.current_time.write() = current_time.add(duration);
+    }
+
     pub fn advance_slot(&self) {
         self.set_slot(self.now().unwrap().as_u64() + 1)
     }
diff --git a/common/task_executor/Cargo.toml b/common/task_executor/Cargo.toml
index b3d58fa5ea8..cc9a2c5097b 100644
--- a/common/task_executor/Cargo.toml
+++ b/common/task_executor/Cargo.toml
@@ -12,3 +12,4 @@ futures = { workspace = true }
 lazy_static = { workspace = true }
 lighthouse_metrics = { workspace = true }
 sloggers = { workspace = true }
+logging = { workspace = true }
diff --git a/common/task_executor/src/test_utils.rs b/common/task_executor/src/test_utils.rs
index 6e372d97575..ec8f45d850e 100644
--- a/common/task_executor/src/test_utils.rs
+++ b/common/task_executor/src/test_utils.rs
@@ -1,4 +1,5 @@
 use crate::TaskExecutor;
+use logging::test_logger;
 use slog::Logger;
 use sloggers::{null::NullLoggerBuilder, Build};
 use std::sync::Arc;
@@ -26,7 +27,7 @@ impl Default for TestRuntime {
     fn default() -> Self {
         let (runtime_shutdown, exit) = async_channel::bounded(1);
         let (shutdown_tx, _) = futures::channel::mpsc::channel(1);
-        let log = null_logger().unwrap();
+        let log = test_logger();
 
         let (runtime, handle) = if let Ok(handle) = runtime::Handle::try_current() {
             (None, handle)
diff --git a/consensus/fork_choice/src/fork_choice.rs b/consensus/fork_choice/src/fork_choice.rs
index 6e3f6717ede..2846a0112cd 100644
--- a/consensus/fork_choice/src/fork_choice.rs
+++ b/consensus/fork_choice/src/fork_choice.rs
@@ -13,7 +13,7 @@ use std::collections::BTreeSet;
 use std::marker::PhantomData;
 use std::time::Duration;
 use types::{
-    consts::merge::INTERVALS_PER_SLOT, AbstractExecPayload, AttestationShufflingId,
+    consts::bellatrix::INTERVALS_PER_SLOT, AbstractExecPayload, AttestationShufflingId,
     AttesterSlashing, BeaconBlockRef, BeaconState, BeaconStateError, ChainSpec, Checkpoint, Epoch,
     EthSpec, ExecPayload, ExecutionBlockHash, Hash256, IndexedAttestation, RelativeEpoch,
     SignedBeaconBlock, Slot,
@@ -751,7 +751,7 @@ where
                     BeaconBlockRef::Electra(_)
                     | BeaconBlockRef::Deneb(_)
                     | BeaconBlockRef::Capella(_)
-                    | BeaconBlockRef::Merge(_)
+                    | BeaconBlockRef::Bellatrix(_)
                     | BeaconBlockRef::Altair(_) => {
                         // NOTE: Processing justification & finalization requires the progressive
                         // balances cache, but we cannot initialize it here as we only have an
diff --git a/consensus/int_to_bytes/Cargo.toml b/consensus/int_to_bytes/Cargo.toml
index 03bec9d3801..e99d1af8e56 100644
--- a/consensus/int_to_bytes/Cargo.toml
+++ b/consensus/int_to_bytes/Cargo.toml
@@ -8,5 +8,5 @@ edition = { workspace = true }
 bytes = { workspace = true }
 
 [dev-dependencies]
-yaml-rust = "0.4.4"
+yaml-rust2 = "0.8"
 hex = { workspace = true }
diff --git a/consensus/int_to_bytes/src/lib.rs b/consensus/int_to_bytes/src/lib.rs
index 589c72d249d..7a1fff7ccd3 100644
--- a/consensus/int_to_bytes/src/lib.rs
+++ b/consensus/int_to_bytes/src/lib.rs
@@ -79,7 +79,7 @@ pub fn int_to_bytes96(int: u64) -> Vec<u8> {
 mod tests {
     use super::*;
     use std::{fs::File, io::prelude::*, path::PathBuf};
-    use yaml_rust::yaml;
+    use yaml_rust2::yaml;
 
     #[test]
     fn fixed_bytes32() {
diff --git a/consensus/state_processing/src/all_caches.rs b/consensus/state_processing/src/all_caches.rs
index 106692c63aa..b915091405b 100644
--- a/consensus/state_processing/src/all_caches.rs
+++ b/consensus/state_processing/src/all_caches.rs
@@ -9,12 +9,14 @@ use types::{BeaconState, ChainSpec, EpochCacheError, EthSpec, Hash256, RelativeE
 pub trait AllCaches {
     /// Build all caches.
     ///
-    /// Note that this excludes the tree-hash cache. That needs to be managed separately.
+    /// Note that this excludes milhouse's intrinsic tree-hash cache. That needs to be managed
+    /// separately.
     fn build_all_caches(&mut self, spec: &ChainSpec) -> Result<(), EpochCacheError>;
 
     /// Return true if all caches are built.
     ///
-    /// Note that this excludes the tree-hash cache. That needs to be managed separately.
+    /// Note that this excludes milhouse's intrinsic tree-hash cache. That needs to be managed
+    /// separately.
     fn all_caches_built(&self) -> bool;
 }
 
diff --git a/consensus/state_processing/src/block_replayer.rs b/consensus/state_processing/src/block_replayer.rs
index f502d7f692c..d7621ebf18b 100644
--- a/consensus/state_processing/src/block_replayer.rs
+++ b/consensus/state_processing/src/block_replayer.rs
@@ -6,19 +6,23 @@ use crate::{
 use itertools::Itertools;
 use std::iter::Peekable;
 use std::marker::PhantomData;
-use types::{BeaconState, BlindedPayload, ChainSpec, EthSpec, Hash256, SignedBeaconBlock, Slot};
+use types::{
+    BeaconState, BeaconStateError, BlindedPayload, ChainSpec, EthSpec, Hash256, SignedBeaconBlock,
+    Slot,
+};
 
-type PreBlockHook<'a, E, Error> = Box<
+pub type PreBlockHook<'a, E, Error> = Box<
     dyn FnMut(&mut BeaconState<E>, &SignedBeaconBlock<E, BlindedPayload<E>>) -> Result<(), Error>
         + 'a,
 >;
-type PostBlockHook<'a, E, Error> = PreBlockHook<'a, E, Error>;
-type PreSlotHook<'a, E, Error> = Box<dyn FnMut(&mut BeaconState<E>) -> Result<(), Error> + 'a>;
-type PostSlotHook<'a, E, Error> = Box<
+pub type PostBlockHook<'a, E, Error> = PreBlockHook<'a, E, Error>;
+pub type PreSlotHook<'a, E, Error> =
+    Box<dyn FnMut(Hash256, &mut BeaconState<E>) -> Result<(), Error> + 'a>;
+pub type PostSlotHook<'a, E, Error> = Box<
     dyn FnMut(&mut BeaconState<E>, Option<EpochProcessingSummary<E>>, bool) -> Result<(), Error>
         + 'a,
 >;
-type StateRootIterDefault<Error> = std::iter::Empty<Result<(Hash256, Slot), Error>>;
+pub type StateRootIterDefault<Error> = std::iter::Empty<Result<(Hash256, Slot), Error>>;
 
 /// Efficiently apply blocks to a state while configuring various parameters.
 ///
@@ -31,7 +35,6 @@ pub struct BlockReplayer<
 > {
     state: BeaconState<Spec>,
     spec: &'a ChainSpec,
-    state_processing_strategy: StateProcessingStrategy,
     block_sig_strategy: BlockSignatureStrategy,
     verify_block_root: Option<VerifyBlockRoot>,
     pre_block_hook: Option<PreBlockHook<'a, Spec, Error>>,
@@ -45,9 +48,9 @@ pub struct BlockReplayer<
 
 #[derive(Debug)]
 pub enum BlockReplayError {
-    NoBlocks,
     SlotProcessing(SlotProcessingError),
     BlockProcessing(BlockProcessingError),
+    BeaconState(BeaconStateError),
 }
 
 impl From<SlotProcessingError> for BlockReplayError {
@@ -62,14 +65,10 @@ impl From<BlockProcessingError> for BlockReplayError {
     }
 }
 
-/// Defines how state roots should be computed and whether to perform all state transitions during block replay.
-#[derive(PartialEq, Clone, Copy)]
-pub enum StateProcessingStrategy {
-    /// Perform all transitions faithfully to the specification.
-    Accurate,
-    /// Don't compute state roots and process withdrawals, eventually computing an invalid beacon
-    /// state that can only be used for obtaining shuffling.
-    Inconsistent,
+impl From<BeaconStateError> for BlockReplayError {
+    fn from(e: BeaconStateError) -> Self {
+        Self::BeaconState(e)
+    }
 }
 
 impl<'a, E, Error, StateRootIter> BlockReplayer<'a, E, Error, StateRootIter>
@@ -89,7 +88,6 @@ where
         Self {
             state,
             spec,
-            state_processing_strategy: StateProcessingStrategy::Accurate,
             block_sig_strategy: BlockSignatureStrategy::VerifyBulk,
             verify_block_root: Some(VerifyBlockRoot::True),
             pre_block_hook: None,
@@ -102,18 +100,6 @@ where
         }
     }
 
-    /// Set the replayer's state processing strategy different from the default.
-    pub fn state_processing_strategy(
-        mut self,
-        state_processing_strategy: StateProcessingStrategy,
-    ) -> Self {
-        if state_processing_strategy == StateProcessingStrategy::Inconsistent {
-            self.verify_block_root = None;
-        }
-        self.state_processing_strategy = state_processing_strategy;
-        self
-    }
-
     /// Set the replayer's block signature verification strategy.
     pub fn block_signature_strategy(mut self, block_sig_strategy: BlockSignatureStrategy) -> Self {
         self.block_sig_strategy = block_sig_strategy;
@@ -175,21 +161,24 @@ where
         self
     }
 
-    /// Compute the state root for `slot` as efficiently as possible.
+    /// Compute the state root for `self.state` as efficiently as possible.
+    ///
+    /// This function MUST only be called when `self.state` is a post-state, i.e. it MUST not be
+    /// called between advancing a state with `per_slot_processing` and applying the block for that
+    /// slot.
     ///
     /// The `blocks` should be the full list of blocks being applied and `i` should be the index of
     /// the next block that will be applied, or `blocks.len()` if all blocks have already been
     /// applied.
+    ///
+    /// If the state root is not available from the state root iterator or the blocks then it will
+    /// be computed from `self.state` and a state root iterator miss will be recorded.
     fn get_state_root(
         &mut self,
-        slot: Slot,
         blocks: &[SignedBeaconBlock<E, BlindedPayload<E>>],
         i: usize,
-    ) -> Result<Option<Hash256>, Error> {
-        // If we don't care about state roots then return immediately.
-        if self.state_processing_strategy == StateProcessingStrategy::Inconsistent {
-            return Ok(Some(Hash256::zero()));
-        }
+    ) -> Result<Hash256, Error> {
+        let slot = self.state.slot();
 
         // If a state root iterator is configured, use it to find the root.
         if let Some(ref mut state_root_iter) = self.state_root_iter {
@@ -199,7 +188,7 @@ where
                 .transpose()?;
 
             if let Some((root, _)) = opt_root {
-                return Ok(Some(root));
+                return Ok(root);
             }
         }
 
@@ -207,13 +196,17 @@ where
         if let Some(prev_i) = i.checked_sub(1) {
             if let Some(prev_block) = blocks.get(prev_i) {
                 if prev_block.slot() == slot {
-                    return Ok(Some(prev_block.state_root()));
+                    return Ok(prev_block.state_root());
                 }
             }
         }
 
         self.state_root_miss = true;
-        Ok(None)
+        let state_root = self
+            .state
+            .update_tree_hash_cache()
+            .map_err(BlockReplayError::from)?;
+        Ok(state_root)
     }
 
     /// Apply `blocks` atop `self.state`, taking care of slot processing.
@@ -232,12 +225,13 @@ where
             }
 
             while self.state.slot() < block.slot() {
+                let state_root = self.get_state_root(&blocks, i)?;
+
                 if let Some(ref mut pre_slot_hook) = self.pre_slot_hook {
-                    pre_slot_hook(&mut self.state)?;
+                    pre_slot_hook(state_root, &mut self.state)?;
                 }
 
-                let state_root = self.get_state_root(self.state.slot(), &blocks, i)?;
-                let summary = per_slot_processing(&mut self.state, state_root, self.spec)
+                let summary = per_slot_processing(&mut self.state, Some(state_root), self.spec)
                     .map_err(BlockReplayError::from)?;
 
                 if let Some(ref mut post_slot_hook) = self.post_slot_hook {
@@ -250,15 +244,11 @@ where
                 pre_block_hook(&mut self.state, block)?;
             }
 
-            let verify_block_root = self.verify_block_root.unwrap_or_else(|| {
-                // If no explicit policy is set, verify only the first 1 or 2 block roots if using
-                // accurate state roots. Inaccurate state roots require block root verification to
-                // be off.
-                if i <= 1 && self.state_processing_strategy == StateProcessingStrategy::Accurate {
-                    VerifyBlockRoot::True
-                } else {
-                    VerifyBlockRoot::False
-                }
+            // If no explicit policy is set, verify only the first 1 or 2 block roots.
+            let verify_block_root = self.verify_block_root.unwrap_or(if i <= 1 {
+                VerifyBlockRoot::True
+            } else {
+                VerifyBlockRoot::False
             });
             // Proposer index was already checked when this block was originally processed, we
             // can omit recomputing it during replay.
@@ -268,7 +258,6 @@ where
                 &mut self.state,
                 block,
                 self.block_sig_strategy,
-                self.state_processing_strategy,
                 verify_block_root,
                 &mut ctxt,
                 self.spec,
@@ -282,12 +271,13 @@ where
 
         if let Some(target_slot) = target_slot {
             while self.state.slot() < target_slot {
+                let state_root = self.get_state_root(&blocks, blocks.len())?;
+
                 if let Some(ref mut pre_slot_hook) = self.pre_slot_hook {
-                    pre_slot_hook(&mut self.state)?;
+                    pre_slot_hook(state_root, &mut self.state)?;
                 }
 
-                let state_root = self.get_state_root(self.state.slot(), &blocks, blocks.len())?;
-                let summary = per_slot_processing(&mut self.state, state_root, self.spec)
+                let summary = per_slot_processing(&mut self.state, Some(state_root), self.spec)
                     .map_err(BlockReplayError::from)?;
 
                 if let Some(ref mut post_slot_hook) = self.post_slot_hook {
diff --git a/consensus/state_processing/src/common/get_attestation_participation.rs b/consensus/state_processing/src/common/get_attestation_participation.rs
index d27a00c3826..fc09dad1f4e 100644
--- a/consensus/state_processing/src/common/get_attestation_participation.rs
+++ b/consensus/state_processing/src/common/get_attestation_participation.rs
@@ -47,7 +47,7 @@ pub fn get_attestation_participation_flag_indices<E: EthSpec>(
     match state {
         &BeaconState::Base(_)
         | &BeaconState::Altair(_)
-        | &BeaconState::Merge(_)
+        | &BeaconState::Bellatrix(_)
         | &BeaconState::Capella(_) => {
             if is_matching_target && inclusion_delay <= E::slots_per_epoch() {
                 participation_flag_indices.push(TIMELY_TARGET_FLAG_INDEX);
diff --git a/consensus/state_processing/src/common/initiate_validator_exit.rs b/consensus/state_processing/src/common/initiate_validator_exit.rs
index c527807df89..a40a9dfd398 100644
--- a/consensus/state_processing/src/common/initiate_validator_exit.rs
+++ b/consensus/state_processing/src/common/initiate_validator_exit.rs
@@ -26,17 +26,18 @@ pub fn initiate_validator_exit<E: EthSpec>(
         .map_or(delayed_epoch, |epoch| max(epoch, delayed_epoch));
     let exit_queue_churn = state.exit_cache().get_churn_at(exit_queue_epoch)?;
 
-    if exit_queue_churn >= state.get_churn_limit(spec)? {
+    if exit_queue_churn >= state.get_validator_churn_limit(spec)? {
         exit_queue_epoch.safe_add_assign(1)?;
     }
 
-    let validator = state.get_validator_mut(index)?;
+    let validator = state.get_validator_cow(index)?;
 
     // Return if the validator already initiated exit
     if validator.exit_epoch != spec.far_future_epoch {
         return Ok(());
     }
 
+    let validator = validator.into_mut()?;
     validator.exit_epoch = exit_queue_epoch;
     validator.withdrawable_epoch =
         exit_queue_epoch.safe_add(spec.min_validator_withdrawability_delay)?;
diff --git a/consensus/state_processing/src/common/slash_validator.rs b/consensus/state_processing/src/common/slash_validator.rs
index 16b4e74ece9..520b58a8af3 100644
--- a/consensus/state_processing/src/common/slash_validator.rs
+++ b/consensus/state_processing/src/common/slash_validator.rs
@@ -58,7 +58,7 @@ pub fn slash_validator<E: EthSpec>(
     let proposer_reward = match state {
         BeaconState::Base(_) => whistleblower_reward.safe_div(spec.proposer_reward_quotient)?,
         BeaconState::Altair(_)
-        | BeaconState::Merge(_)
+        | BeaconState::Bellatrix(_)
         | BeaconState::Capella(_)
         | BeaconState::Deneb(_)
         | BeaconState::Electra(_) => whistleblower_reward
diff --git a/consensus/state_processing/src/consensus_context.rs b/consensus/state_processing/src/consensus_context.rs
index 263539fa429..073d87be85b 100644
--- a/consensus/state_processing/src/consensus_context.rs
+++ b/consensus/state_processing/src/consensus_context.rs
@@ -1,7 +1,6 @@
 use crate::common::get_indexed_attestation;
 use crate::per_block_processing::errors::{AttestationInvalid, BlockOperationError};
 use crate::EpochCacheError;
-use ssz_derive::{Decode, Encode};
 use std::collections::{hash_map::Entry, HashMap};
 use tree_hash::TreeHash;
 use types::{
@@ -9,22 +8,20 @@ use types::{
     ChainSpec, Epoch, EthSpec, Hash256, IndexedAttestation, SignedBeaconBlock, Slot,
 };
 
-#[derive(Debug, PartialEq, Clone, Encode, Decode)]
+#[derive(Debug, PartialEq, Clone)]
 pub struct ConsensusContext<E: EthSpec> {
     /// Slot to act as an identifier/safeguard
-    slot: Slot,
+    pub slot: Slot,
     /// Previous epoch of the `slot` precomputed for optimization purpose.
-    pub(crate) previous_epoch: Epoch,
+    pub previous_epoch: Epoch,
     /// Current epoch of the `slot` precomputed for optimization purpose.
-    pub(crate) current_epoch: Epoch,
+    pub current_epoch: Epoch,
     /// Proposer index of the block at `slot`.
-    proposer_index: Option<u64>,
+    pub proposer_index: Option<u64>,
     /// Block root of the block at `slot`.
-    current_block_root: Option<Hash256>,
+    pub current_block_root: Option<Hash256>,
     /// Cache of indexed attestations constructed during block processing.
-    /// We can skip serializing / deserializing this as the cache will just be rebuilt
-    #[ssz(skip_serializing, skip_deserializing)]
-    indexed_attestations:
+    pub indexed_attestations:
         HashMap<(AttestationData, BitList<E::MaxValidatorsPerCommittee>), IndexedAttestation<E>>,
 }
 
@@ -62,6 +59,7 @@ impl<E: EthSpec> ConsensusContext<E> {
         }
     }
 
+    #[must_use]
     pub fn set_proposer_index(mut self, proposer_index: u64) -> Self {
         self.proposer_index = Some(proposer_index);
         self
@@ -109,6 +107,7 @@ impl<E: EthSpec> ConsensusContext<E> {
         Ok(proposer_index)
     }
 
+    #[must_use]
     pub fn set_current_block_root(mut self, block_root: Hash256) -> Self {
         self.current_block_root = Some(block_root);
         self
@@ -174,4 +173,16 @@ impl<E: EthSpec> ConsensusContext<E> {
     pub fn num_cached_indexed_attestations(&self) -> usize {
         self.indexed_attestations.len()
     }
+
+    #[must_use]
+    pub fn set_indexed_attestations(
+        mut self,
+        attestations: HashMap<
+            (AttestationData, BitList<E::MaxValidatorsPerCommittee>),
+            IndexedAttestation<E>,
+        >,
+    ) -> Self {
+        self.indexed_attestations = attestations;
+        self
+    }
 }
diff --git a/consensus/state_processing/src/genesis.rs b/consensus/state_processing/src/genesis.rs
index b225923b418..a84f359389c 100644
--- a/consensus/state_processing/src/genesis.rs
+++ b/consensus/state_processing/src/genesis.rs
@@ -1,5 +1,5 @@
 use super::per_block_processing::{
-    errors::BlockProcessingError, process_operations::process_deposit,
+    errors::BlockProcessingError, process_operations::apply_deposit,
 };
 use crate::common::DepositDataTree;
 use crate::upgrade::{
@@ -28,7 +28,7 @@ pub fn initialize_beacon_state_from_eth1<E: EthSpec>(
     let mut state = BeaconState::new(genesis_time, eth1_data, spec);
 
     // Seed RANDAO with Eth1 entropy
-    state.fill_randao_mixes_with(eth1_block_hash);
+    state.fill_randao_mixes_with(eth1_block_hash)?;
 
     let mut deposit_tree = DepositDataTree::create(&[], 0, DEPOSIT_TREE_DEPTH);
 
@@ -37,7 +37,7 @@ pub fn initialize_beacon_state_from_eth1<E: EthSpec>(
             .push_leaf(deposit.data.tree_hash_root())
             .map_err(BlockProcessingError::MerkleTreeError)?;
         state.eth1_data_mut().deposit_root = deposit_tree.root();
-        process_deposit(&mut state, deposit, spec, true)?;
+        apply_deposit(&mut state, deposit, spec, true)?;
     }
 
     process_activations(&mut state, spec)?;
@@ -63,7 +63,7 @@ pub fn initialize_beacon_state_from_eth1<E: EthSpec>(
         .bellatrix_fork_epoch
         .map_or(false, |fork_epoch| fork_epoch == E::genesis_epoch())
     {
-        // this will set state.latest_execution_payload_header = ExecutionPayloadHeaderMerge::default()
+        // this will set state.latest_execution_payload_header = ExecutionPayloadHeaderBellatrix::default()
         upgrade_to_bellatrix(&mut state, spec)?;
 
         // Remove intermediate Altair fork from `state.fork`.
@@ -71,8 +71,8 @@ pub fn initialize_beacon_state_from_eth1<E: EthSpec>(
 
         // Override latest execution payload header.
         // See https://github.com/ethereum/consensus-specs/blob/v1.1.0/specs/bellatrix/beacon-chain.md#testing
-        if let Some(ExecutionPayloadHeader::Merge(ref header)) = execution_payload_header {
-            *state.latest_execution_payload_header_merge_mut()? = header.clone();
+        if let Some(ExecutionPayloadHeader::Bellatrix(ref header)) = execution_payload_header {
+            *state.latest_execution_payload_header_bellatrix_mut()? = header.clone();
         }
     }
 
@@ -152,7 +152,9 @@ pub fn process_activations<E: EthSpec>(
     spec: &ChainSpec,
 ) -> Result<(), Error> {
     let (validators, balances, _) = state.validators_and_balances_and_progressive_balances_mut();
-    for (index, validator) in validators.iter_mut().enumerate() {
+    let mut validators_iter = validators.iter_cow();
+    while let Some((index, validator)) = validators_iter.next_cow() {
+        let validator = validator.into_mut()?;
         let balance = balances
             .get(index)
             .copied()
diff --git a/consensus/state_processing/src/lib.rs b/consensus/state_processing/src/lib.rs
index 7d84c426e8c..74f9d84bb11 100644
--- a/consensus/state_processing/src/lib.rs
+++ b/consensus/state_processing/src/lib.rs
@@ -30,7 +30,7 @@ pub mod upgrade;
 pub mod verify_operation;
 
 pub use all_caches::AllCaches;
-pub use block_replayer::{BlockReplayError, BlockReplayer, StateProcessingStrategy};
+pub use block_replayer::{BlockReplayError, BlockReplayer};
 pub use consensus_context::{ConsensusContext, ContextError};
 pub use genesis::{
     eth2_genesis_time, initialize_beacon_state_from_eth1, is_valid_genesis_state,
diff --git a/consensus/state_processing/src/metrics.rs b/consensus/state_processing/src/metrics.rs
index e163f3b76b8..ac5c0f659cd 100644
--- a/consensus/state_processing/src/metrics.rs
+++ b/consensus/state_processing/src/metrics.rs
@@ -17,6 +17,10 @@ lazy_static! {
         "beacon_participation_prev_epoch_source_attesting_gwei_total",
         "Total effective balance (gwei) of validators who attested to the source in the previous epoch"
     );
+    pub static ref PARTICIPATION_CURRENT_EPOCH_TOTAL_ACTIVE_GWEI_TOTAL: Result<IntGauge> = try_create_int_gauge(
+        "beacon_participation_current_epoch_active_gwei_total",
+        "Total effective balance (gwei) of validators who are active in the current epoch"
+    );
     /*
      * Processing metrics
      */
diff --git a/consensus/state_processing/src/per_block_processing.rs b/consensus/state_processing/src/per_block_processing.rs
index b370ec6216b..98671f82b9f 100644
--- a/consensus/state_processing/src/per_block_processing.rs
+++ b/consensus/state_processing/src/per_block_processing.rs
@@ -40,7 +40,6 @@ mod verify_exit;
 mod verify_proposer_slashing;
 
 use crate::common::decrease_balance;
-use crate::StateProcessingStrategy;
 
 use crate::common::update_progressive_balances_cache::{
     initialize_progressive_balances_cache, update_progressive_balances_metrics,
@@ -102,7 +101,6 @@ pub fn per_block_processing<E: EthSpec, Payload: AbstractExecPayload<E>>(
     state: &mut BeaconState<E>,
     signed_block: &SignedBeaconBlock<E, Payload>,
     block_signature_strategy: BlockSignatureStrategy,
-    state_processing_strategy: StateProcessingStrategy,
     verify_block_root: VerifyBlockRoot,
     ctxt: &mut ConsensusContext<E>,
     spec: &ChainSpec,
@@ -172,9 +170,7 @@ pub fn per_block_processing<E: EthSpec, Payload: AbstractExecPayload<E>>(
     // previous block.
     if is_execution_enabled(state, block.body()) {
         let body = block.body();
-        if state_processing_strategy == StateProcessingStrategy::Accurate {
-            process_withdrawals::<E, Payload>(state, body.execution_payload()?, spec)?;
-        }
+        process_withdrawals::<E, Payload>(state, body.execution_payload()?, spec)?;
         process_execution_payload::<E, Payload>(state, body, spec)?;
     }
 
@@ -422,9 +418,9 @@ pub fn process_execution_payload<E: EthSpec, Payload: AbstractExecPayload<E>>(
     partially_verify_execution_payload::<E, Payload>(state, state.slot(), body, spec)?;
     let payload = body.execution_payload()?;
     match state.latest_execution_payload_header_mut()? {
-        ExecutionPayloadHeaderRefMut::Merge(header_mut) => {
+        ExecutionPayloadHeaderRefMut::Bellatrix(header_mut) => {
             match payload.to_execution_payload_header() {
-                ExecutionPayloadHeader::Merge(header) => *header_mut = header,
+                ExecutionPayloadHeader::Bellatrix(header) => *header_mut = header,
                 _ => return Err(BlockProcessingError::IncorrectStateType),
             }
         }
@@ -453,14 +449,14 @@ pub fn process_execution_payload<E: EthSpec, Payload: AbstractExecPayload<E>>(
 
 /// These functions will definitely be called before the merge. Their entire purpose is to check if
 /// the merge has happened or if we're on the transition block. Thus we don't want to propagate
-/// errors from the `BeaconState` being an earlier variant than `BeaconStateMerge` as we'd have to
+/// errors from the `BeaconState` being an earlier variant than `BeaconStateBellatrix` as we'd have to
 /// repeatedly write code to treat these errors as false.
 /// https://github.com/ethereum/consensus-specs/blob/dev/specs/bellatrix/beacon-chain.md#is_merge_transition_complete
 pub fn is_merge_transition_complete<E: EthSpec>(state: &BeaconState<E>) -> bool {
     match state {
         // We must check defaultness against the payload header with 0x0 roots, as that's what's meant
         // by `ExecutionPayloadHeader()` in the spec.
-        BeaconState::Merge(_) => state
+        BeaconState::Bellatrix(_) => state
             .latest_execution_payload_header()
             .map(|header| !header.is_default_with_zero_roots())
             .unwrap_or(false),
@@ -512,6 +508,7 @@ pub fn get_expected_withdrawals<E: EthSpec>(
     let mut withdrawal_index = state.next_withdrawal_index()?;
     let mut validator_index = state.next_withdrawal_validator_index()?;
     let mut withdrawals = vec![];
+    let fork_name = state.fork_name_unchecked();
 
     let bound = std::cmp::min(
         state.validators().len() as u64,
@@ -522,7 +519,7 @@ pub fn get_expected_withdrawals<E: EthSpec>(
         let balance = *state.balances().get(validator_index as usize).ok_or(
             BeaconStateError::BalancesOutOfBounds(validator_index as usize),
         )?;
-        if validator.is_fully_withdrawable_at(balance, epoch, spec) {
+        if validator.is_fully_withdrawable_at(balance, epoch, spec, fork_name) {
             withdrawals.push(Withdrawal {
                 index: withdrawal_index,
                 validator_index,
@@ -532,7 +529,7 @@ pub fn get_expected_withdrawals<E: EthSpec>(
                 amount: balance,
             });
             withdrawal_index.safe_add_assign(1)?;
-        } else if validator.is_partially_withdrawable_validator(balance, spec) {
+        } else if validator.is_partially_withdrawable_validator(balance, spec, fork_name) {
             withdrawals.push(Withdrawal {
                 index: withdrawal_index,
                 validator_index,
@@ -561,7 +558,7 @@ pub fn process_withdrawals<E: EthSpec, Payload: AbstractExecPayload<E>>(
     spec: &ChainSpec,
 ) -> Result<(), BlockProcessingError> {
     match state {
-        BeaconState::Merge(_) => Ok(()),
+        BeaconState::Bellatrix(_) => Ok(()),
         BeaconState::Capella(_) | BeaconState::Deneb(_) | BeaconState::Electra(_) => {
             let expected_withdrawals = get_expected_withdrawals(state, spec)?;
             let expected_root = expected_withdrawals.tree_hash_root();
diff --git a/consensus/state_processing/src/per_block_processing/errors.rs b/consensus/state_processing/src/per_block_processing/errors.rs
index 28d36dbc518..336895514f9 100644
--- a/consensus/state_processing/src/per_block_processing/errors.rs
+++ b/consensus/state_processing/src/per_block_processing/errors.rs
@@ -82,6 +82,7 @@ pub enum BlockProcessingError {
     },
     ExecutionInvalid,
     ConsensusContext(ContextError),
+    MilhouseError(milhouse::Error),
     EpochCacheError(EpochCacheError),
     WithdrawalsRootMismatch {
         expected: Hash256,
@@ -138,6 +139,12 @@ impl From<EpochCacheError> for BlockProcessingError {
     }
 }
 
+impl From<milhouse::Error> for BlockProcessingError {
+    fn from(e: milhouse::Error) -> Self {
+        Self::MilhouseError(e)
+    }
+}
+
 impl From<BlockOperationError<HeaderInvalid>> for BlockProcessingError {
     fn from(e: BlockOperationError<HeaderInvalid>) -> BlockProcessingError {
         match e {
diff --git a/consensus/state_processing/src/per_block_processing/process_operations.rs b/consensus/state_processing/src/per_block_processing/process_operations.rs
index af9b7938132..3aefcf8a9c5 100644
--- a/consensus/state_processing/src/per_block_processing/process_operations.rs
+++ b/consensus/state_processing/src/per_block_processing/process_operations.rs
@@ -128,7 +128,7 @@ pub mod altair_deneb {
         let previous_epoch = ctxt.previous_epoch;
         let current_epoch = ctxt.current_epoch;
 
-        let attesting_indices = &verify_attestation_for_block_inclusion(
+        let attesting_indices = verify_attestation_for_block_inclusion(
             state,
             attestation,
             ctxt,
@@ -136,7 +136,8 @@ pub mod altair_deneb {
             spec,
         )
         .map_err(|e| e.into_with_index(att_index))?
-        .attesting_indices;
+        .attesting_indices
+        .clone();
 
         // Matching roots, participation flag indices
         let data = &attestation.data;
@@ -146,7 +147,7 @@ pub mod altair_deneb {
 
         // Update epoch participation flags.
         let mut proposer_reward_numerator = 0;
-        for index in attesting_indices {
+        for index in &attesting_indices {
             let index = *index as usize;
 
             let validator_effective_balance = state.epoch_cache().get_effective_balance(index)?;
@@ -272,7 +273,7 @@ pub fn process_attestations<E: EthSpec, Payload: AbstractExecPayload<E>>(
             )?;
         }
         BeaconBlockBodyRef::Altair(_)
-        | BeaconBlockBodyRef::Merge(_)
+        | BeaconBlockBodyRef::Bellatrix(_)
         | BeaconBlockBodyRef::Capella(_)
         | BeaconBlockBodyRef::Deneb(_)
         | BeaconBlockBodyRef::Electra(_) => {
@@ -371,14 +372,14 @@ pub fn process_deposits<E: EthSpec>(
 
     // Update the state in series.
     for deposit in deposits {
-        process_deposit(state, deposit, spec, false)?;
+        apply_deposit(state, deposit, spec, false)?;
     }
 
     Ok(())
 }
 
 /// Process a single deposit, optionally verifying its merkle proof.
-pub fn process_deposit<E: EthSpec>(
+pub fn apply_deposit<E: EthSpec>(
     state: &mut BeaconState<E>,
     deposit: &Deposit,
     spec: &ChainSpec,
diff --git a/consensus/state_processing/src/per_block_processing/signature_sets.rs b/consensus/state_processing/src/per_block_processing/signature_sets.rs
index 163b2cff7a9..9468893f762 100644
--- a/consensus/state_processing/src/per_block_processing/signature_sets.rs
+++ b/consensus/state_processing/src/per_block_processing/signature_sets.rs
@@ -390,7 +390,7 @@ where
     let domain = match state {
         BeaconState::Base(_)
         | BeaconState::Altair(_)
-        | BeaconState::Merge(_)
+        | BeaconState::Bellatrix(_)
         | BeaconState::Capella(_) => spec.get_domain(
             exit.epoch,
             Domain::VoluntaryExit,
diff --git a/consensus/state_processing/src/per_block_processing/tests.rs b/consensus/state_processing/src/per_block_processing/tests.rs
index 2a2b67e30da..f0055fa80dd 100644
--- a/consensus/state_processing/src/per_block_processing/tests.rs
+++ b/consensus/state_processing/src/per_block_processing/tests.rs
@@ -5,7 +5,7 @@ use crate::per_block_processing::errors::{
     DepositInvalid, HeaderInvalid, IndexedAttestationInvalid, IntoWithIndex,
     ProposerSlashingInvalid,
 };
-use crate::{per_block_processing, BlockReplayError, BlockReplayer, StateProcessingStrategy};
+use crate::{per_block_processing, BlockReplayError, BlockReplayer};
 use crate::{
     per_block_processing::{process_operations, verify_exit::verify_exit},
     BlockSignatureStrategy, ConsensusContext, VerifyBlockRoot, VerifySignatures,
@@ -72,7 +72,6 @@ async fn valid_block_ok() {
         &mut state,
         &block,
         BlockSignatureStrategy::VerifyIndividual,
-        StateProcessingStrategy::Accurate,
         VerifyBlockRoot::True,
         &mut ctxt,
         &spec,
@@ -98,7 +97,6 @@ async fn invalid_block_header_state_slot() {
         &mut state,
         &SignedBeaconBlock::from_block(block, signature),
         BlockSignatureStrategy::VerifyIndividual,
-        StateProcessingStrategy::Accurate,
         VerifyBlockRoot::True,
         &mut ctxt,
         &spec,
@@ -131,7 +129,6 @@ async fn invalid_parent_block_root() {
         &mut state,
         &SignedBeaconBlock::from_block(block, signature),
         BlockSignatureStrategy::VerifyIndividual,
-        StateProcessingStrategy::Accurate,
         VerifyBlockRoot::True,
         &mut ctxt,
         &spec,
@@ -165,7 +162,6 @@ async fn invalid_block_signature() {
         &mut state,
         &SignedBeaconBlock::from_block(block, Signature::empty()),
         BlockSignatureStrategy::VerifyIndividual,
-        StateProcessingStrategy::Accurate,
         VerifyBlockRoot::True,
         &mut ctxt,
         &spec,
@@ -199,7 +195,6 @@ async fn invalid_randao_reveal_signature() {
         &mut state,
         &signed_block,
         BlockSignatureStrategy::VerifyIndividual,
-        StateProcessingStrategy::Accurate,
         VerifyBlockRoot::True,
         &mut ctxt,
         &spec,
diff --git a/consensus/state_processing/src/per_block_processing/verify_attestation.rs b/consensus/state_processing/src/per_block_processing/verify_attestation.rs
index 73454559dfd..c904ba55f0a 100644
--- a/consensus/state_processing/src/per_block_processing/verify_attestation.rs
+++ b/consensus/state_processing/src/per_block_processing/verify_attestation.rs
@@ -35,7 +35,7 @@ pub fn verify_attestation_for_block_inclusion<'ctxt, E: EthSpec>(
     match state {
         BeaconState::Base(_)
         | BeaconState::Altair(_)
-        | BeaconState::Merge(_)
+        | BeaconState::Bellatrix(_)
         | BeaconState::Capella(_) => {
             verify!(
                 state.slot() <= data.slot.safe_add(E::slots_per_epoch())?,
diff --git a/consensus/state_processing/src/per_epoch_processing.rs b/consensus/state_processing/src/per_epoch_processing.rs
index b51aa23f370..55e8853f3f8 100644
--- a/consensus/state_processing/src/per_epoch_processing.rs
+++ b/consensus/state_processing/src/per_epoch_processing.rs
@@ -44,7 +44,7 @@ pub fn process_epoch<E: EthSpec>(
     match state {
         BeaconState::Base(_) => base::process_epoch(state, spec),
         BeaconState::Altair(_)
-        | BeaconState::Merge(_)
+        | BeaconState::Bellatrix(_)
         | BeaconState::Capella(_)
         | BeaconState::Deneb(_)
         | BeaconState::Electra(_) => altair::process_epoch(state, spec),
diff --git a/consensus/state_processing/src/per_epoch_processing/altair/participation_flag_updates.rs b/consensus/state_processing/src/per_epoch_processing/altair/participation_flag_updates.rs
index dd1b2dfcd86..fc55fb11144 100644
--- a/consensus/state_processing/src/per_epoch_processing/altair/participation_flag_updates.rs
+++ b/consensus/state_processing/src/per_epoch_processing/altair/participation_flag_updates.rs
@@ -2,17 +2,14 @@ use crate::EpochProcessingError;
 use types::beacon_state::BeaconState;
 use types::eth_spec::EthSpec;
 use types::participation_flags::ParticipationFlags;
-use types::VariableList;
+use types::List;
 
 pub fn process_participation_flag_updates<E: EthSpec>(
     state: &mut BeaconState<E>,
 ) -> Result<(), EpochProcessingError> {
     *state.previous_epoch_participation_mut()? =
         std::mem::take(state.current_epoch_participation_mut()?);
-    *state.current_epoch_participation_mut()? = VariableList::new(vec![
-        ParticipationFlags::default(
-        );
-        state.validators().len()
-    ])?;
+    *state.current_epoch_participation_mut()? =
+        List::repeat(ParticipationFlags::default(), state.validators().len())?;
     Ok(())
 }
diff --git a/consensus/state_processing/src/per_epoch_processing/capella/historical_summaries_update.rs b/consensus/state_processing/src/per_epoch_processing/capella/historical_summaries_update.rs
index 7490f276567..00adabdcfe9 100644
--- a/consensus/state_processing/src/per_epoch_processing/capella/historical_summaries_update.rs
+++ b/consensus/state_processing/src/per_epoch_processing/capella/historical_summaries_update.rs
@@ -13,6 +13,9 @@ pub fn process_historical_summaries_update<E: EthSpec>(
         .safe_rem((E::slots_per_historical_root() as u64).safe_div(E::slots_per_epoch())?)?
         == 0
     {
+        // We need to flush any pending mutations before hashing.
+        state.block_roots_mut().apply_updates()?;
+        state.state_roots_mut().apply_updates()?;
         let summary = HistoricalSummary::new(state);
         return state
             .historical_summaries_mut()?
diff --git a/consensus/state_processing/src/per_epoch_processing/effective_balance_updates.rs b/consensus/state_processing/src/per_epoch_processing/effective_balance_updates.rs
index 7bd62c40816..73881e932b7 100644
--- a/consensus/state_processing/src/per_epoch_processing/effective_balance_updates.rs
+++ b/consensus/state_processing/src/per_epoch_processing/effective_balance_updates.rs
@@ -21,7 +21,9 @@ pub fn process_effective_balance_updates<E: EthSpec>(
     let downward_threshold = hysteresis_increment.safe_mul(spec.hysteresis_downward_multiplier)?;
     let upward_threshold = hysteresis_increment.safe_mul(spec.hysteresis_upward_multiplier)?;
     let (validators, balances, _) = state.validators_and_balances_and_progressive_balances_mut();
-    for (index, validator) in validators.iter_mut().enumerate() {
+    let mut validators_iter = validators.iter_cow();
+
+    while let Some((index, validator)) = validators_iter.next_cow() {
         let balance = balances
             .get(index)
             .copied()
@@ -44,7 +46,7 @@ pub fn process_effective_balance_updates<E: EthSpec>(
         }
 
         if new_effective_balance != validator.effective_balance {
-            validator.effective_balance = new_effective_balance;
+            validator.into_mut()?.effective_balance = new_effective_balance;
         }
     }
 
diff --git a/consensus/state_processing/src/per_epoch_processing/epoch_processing_summary.rs b/consensus/state_processing/src/per_epoch_processing/epoch_processing_summary.rs
index 65a946e7bff..952ab3f6498 100644
--- a/consensus/state_processing/src/per_epoch_processing/epoch_processing_summary.rs
+++ b/consensus/state_processing/src/per_epoch_processing/epoch_processing_summary.rs
@@ -3,8 +3,8 @@ use crate::metrics;
 use std::sync::Arc;
 use types::{
     consts::altair::{TIMELY_HEAD_FLAG_INDEX, TIMELY_SOURCE_FLAG_INDEX, TIMELY_TARGET_FLAG_INDEX},
-    BeaconStateError, Epoch, EthSpec, ParticipationFlags, ProgressiveBalancesCache, SyncCommittee,
-    Validator, VariableList,
+    BeaconStateError, Epoch, EthSpec, List, ParticipationFlags, ProgressiveBalancesCache,
+    SyncCommittee, Validator,
 };
 
 /// Provides a summary of validator participation during the epoch.
@@ -25,20 +25,20 @@ pub enum EpochProcessingSummary<E: EthSpec> {
 #[derive(PartialEq, Debug)]
 pub struct ParticipationEpochSummary<E: EthSpec> {
     /// Copy of the validator registry prior to mutation.
-    validators: VariableList<Validator, E::ValidatorRegistryLimit>,
+    validators: List<Validator, E::ValidatorRegistryLimit>,
     /// Copy of the participation flags for the previous epoch.
-    previous_epoch_participation: VariableList<ParticipationFlags, E::ValidatorRegistryLimit>,
+    previous_epoch_participation: List<ParticipationFlags, E::ValidatorRegistryLimit>,
     /// Copy of the participation flags for the current epoch.
-    current_epoch_participation: VariableList<ParticipationFlags, E::ValidatorRegistryLimit>,
+    current_epoch_participation: List<ParticipationFlags, E::ValidatorRegistryLimit>,
     previous_epoch: Epoch,
     current_epoch: Epoch,
 }
 
 impl<E: EthSpec> ParticipationEpochSummary<E> {
     pub fn new(
-        validators: VariableList<Validator, E::ValidatorRegistryLimit>,
-        previous_epoch_participation: VariableList<ParticipationFlags, E::ValidatorRegistryLimit>,
-        current_epoch_participation: VariableList<ParticipationFlags, E::ValidatorRegistryLimit>,
+        validators: List<Validator, E::ValidatorRegistryLimit>,
+        previous_epoch_participation: List<ParticipationFlags, E::ValidatorRegistryLimit>,
+        current_epoch_participation: List<ParticipationFlags, E::ValidatorRegistryLimit>,
         previous_epoch: Epoch,
         current_epoch: Epoch,
     ) -> Self {
@@ -100,6 +100,10 @@ impl<E: EthSpec> EpochProcessingSummary<E> {
             &metrics::PARTICIPATION_PREV_EPOCH_SOURCE_ATTESTING_GWEI_TOTAL,
             self.previous_epoch_source_attesting_balance()? as i64,
         );
+        metrics::set_gauge(
+            &metrics::PARTICIPATION_CURRENT_EPOCH_TOTAL_ACTIVE_GWEI_TOTAL,
+            self.current_epoch_total_active_balance() as i64,
+        );
 
         Ok(())
     }
diff --git a/consensus/state_processing/src/per_epoch_processing/errors.rs b/consensus/state_processing/src/per_epoch_processing/errors.rs
index c18e1303b26..de481ec6767 100644
--- a/consensus/state_processing/src/per_epoch_processing/errors.rs
+++ b/consensus/state_processing/src/per_epoch_processing/errors.rs
@@ -1,4 +1,4 @@
-use types::{BeaconStateError, EpochCacheError, InconsistentFork};
+use types::{milhouse, BeaconStateError, EpochCacheError, InconsistentFork};
 
 #[derive(Debug, PartialEq)]
 pub enum EpochProcessingError {
@@ -23,6 +23,7 @@ pub enum EpochProcessingError {
     InconsistentStateFork(InconsistentFork),
     InvalidJustificationBit(ssz_types::Error),
     InvalidFlagIndex(usize),
+    MilhouseError(milhouse::Error),
     EpochCache(EpochCacheError),
 }
 
@@ -50,6 +51,12 @@ impl From<safe_arith::ArithError> for EpochProcessingError {
     }
 }
 
+impl From<milhouse::Error> for EpochProcessingError {
+    fn from(e: milhouse::Error) -> Self {
+        Self::MilhouseError(e)
+    }
+}
+
 impl From<EpochCacheError> for EpochProcessingError {
     fn from(e: EpochCacheError) -> Self {
         EpochProcessingError::EpochCache(e)
diff --git a/consensus/state_processing/src/per_epoch_processing/historical_roots_update.rs b/consensus/state_processing/src/per_epoch_processing/historical_roots_update.rs
index 6d06b4d7ca5..7686932192f 100644
--- a/consensus/state_processing/src/per_epoch_processing/historical_roots_update.rs
+++ b/consensus/state_processing/src/per_epoch_processing/historical_roots_update.rs
@@ -14,7 +14,7 @@ pub fn process_historical_roots_update<E: EthSpec>(
         .safe_rem(E::SlotsPerHistoricalRoot::to_u64().safe_div(E::slots_per_epoch())?)?
         == 0
     {
-        let historical_batch = state.historical_batch();
+        let historical_batch = state.historical_batch()?;
         state
             .historical_roots_mut()
             .push(historical_batch.tree_hash_root())?;
diff --git a/consensus/state_processing/src/per_epoch_processing/registry_updates.rs b/consensus/state_processing/src/per_epoch_processing/registry_updates.rs
index 4b2f940e5f8..3d02d797366 100644
--- a/consensus/state_processing/src/per_epoch_processing/registry_updates.rs
+++ b/consensus/state_processing/src/per_epoch_processing/registry_updates.rs
@@ -19,19 +19,20 @@ pub fn process_registry_updates<E: EthSpec>(
         validator.is_active_at(current_epoch)
             && validator.effective_balance <= spec.ejection_balance
     };
+    let fork_name = state.fork_name_unchecked();
     let indices_to_update: Vec<_> = state
         .validators()
         .iter()
         .enumerate()
         .filter(|(_, validator)| {
-            validator.is_eligible_for_activation_queue(spec) || is_ejectable(validator)
+            validator.is_eligible_for_activation_queue(spec, fork_name) || is_ejectable(validator)
         })
         .map(|(idx, _)| idx)
         .collect();
 
     for index in indices_to_update {
         let validator = state.get_validator_mut(index)?;
-        if validator.is_eligible_for_activation_queue(spec) {
+        if validator.is_eligible_for_activation_queue(spec, fork_name) {
             validator.activation_eligibility_epoch = current_epoch.safe_add(1)?;
         }
         if is_ejectable(validator) {
diff --git a/consensus/state_processing/src/per_epoch_processing/resets.rs b/consensus/state_processing/src/per_epoch_processing/resets.rs
index d577c52e6a5..c9f69c3c95e 100644
--- a/consensus/state_processing/src/per_epoch_processing/resets.rs
+++ b/consensus/state_processing/src/per_epoch_processing/resets.rs
@@ -2,7 +2,7 @@ use super::errors::EpochProcessingError;
 use safe_arith::SafeArith;
 use types::beacon_state::BeaconState;
 use types::eth_spec::EthSpec;
-use types::{Unsigned, VariableList};
+use types::{List, Unsigned};
 
 pub fn process_eth1_data_reset<E: EthSpec>(
     state: &mut BeaconState<E>,
@@ -13,7 +13,7 @@ pub fn process_eth1_data_reset<E: EthSpec>(
         .safe_rem(E::SlotsPerEth1VotingPeriod::to_u64())?
         == 0
     {
-        *state.eth1_data_votes_mut() = VariableList::empty();
+        *state.eth1_data_votes_mut() = List::empty();
     }
     Ok(())
 }
diff --git a/consensus/state_processing/src/per_epoch_processing/single_pass.rs b/consensus/state_processing/src/per_epoch_processing/single_pass.rs
index 9319d2941b5..a9629e73e40 100644
--- a/consensus/state_processing/src/per_epoch_processing/single_pass.rs
+++ b/consensus/state_processing/src/per_epoch_processing/single_pass.rs
@@ -12,6 +12,7 @@ use types::{
         NUM_FLAG_INDICES, PARTICIPATION_FLAG_WEIGHTS, TIMELY_HEAD_FLAG_INDEX,
         TIMELY_TARGET_FLAG_INDEX, WEIGHT_DENOMINATOR,
     },
+    milhouse::Cow,
     ActivationQueue, BeaconState, BeaconStateError, ChainSpec, Epoch, EthSpec, ExitCache, ForkName,
     ParticipationFlags, ProgressiveBalancesCache, RelativeEpoch, Unsigned, Validator,
 };
@@ -120,7 +121,7 @@ pub fn process_epoch_single_pass<E: EthSpec>(
     let next_epoch = state.next_epoch()?;
     let is_in_inactivity_leak = state.is_in_inactivity_leak(previous_epoch, spec)?;
     let total_active_balance = state.get_total_active_balance()?;
-    let churn_limit = state.get_churn_limit(spec)?;
+    let churn_limit = state.get_validator_churn_limit(spec)?;
     let activation_churn_limit = state.get_activation_churn_limit(spec)?;
     let finalized_checkpoint = state.finalized_checkpoint();
     let fork_name = state.fork_name_unchecked();
@@ -173,9 +174,9 @@ pub fn process_epoch_single_pass<E: EthSpec>(
     let effective_balances_ctxt = &EffectiveBalancesContext::new(spec)?;
 
     // Iterate over the validators and related fields in one pass.
-    let mut validators_iter = validators.iter_mut();
-    let mut balances_iter = balances.iter_mut();
-    let mut inactivity_scores_iter = inactivity_scores.iter_mut();
+    let mut validators_iter = validators.iter_cow();
+    let mut balances_iter = balances.iter_cow();
+    let mut inactivity_scores_iter = inactivity_scores.iter_cow();
 
     // Values computed for the next epoch transition.
     let mut next_epoch_total_active_balance = 0;
@@ -186,14 +187,14 @@ pub fn process_epoch_single_pass<E: EthSpec>(
         previous_epoch_participation.iter(),
         current_epoch_participation.iter(),
     ) {
-        let validator = validators_iter
-            .next()
+        let (_, mut validator) = validators_iter
+            .next_cow()
             .ok_or(BeaconStateError::UnknownValidator(index))?;
-        let balance = balances_iter
-            .next()
+        let (_, mut balance) = balances_iter
+            .next_cow()
             .ok_or(BeaconStateError::UnknownValidator(index))?;
-        let inactivity_score = inactivity_scores_iter
-            .next()
+        let (_, mut inactivity_score) = inactivity_scores_iter
+            .next_cow()
             .ok_or(BeaconStateError::UnknownValidator(index))?;
 
         let is_active_current_epoch = validator.is_active_at(current_epoch);
@@ -223,7 +224,7 @@ pub fn process_epoch_single_pass<E: EthSpec>(
             // `process_inactivity_updates`
             if conf.inactivity_updates {
                 process_single_inactivity_update(
-                    inactivity_score,
+                    &mut inactivity_score,
                     validator_info,
                     state_ctxt,
                     spec,
@@ -233,8 +234,8 @@ pub fn process_epoch_single_pass<E: EthSpec>(
             // `process_rewards_and_penalties`
             if conf.rewards_and_penalties {
                 process_single_reward_and_penalty(
-                    balance,
-                    inactivity_score,
+                    &mut balance,
+                    &inactivity_score,
                     validator_info,
                     rewards_ctxt,
                     state_ctxt,
@@ -246,7 +247,7 @@ pub fn process_epoch_single_pass<E: EthSpec>(
         // `process_registry_updates`
         if conf.registry_updates {
             process_single_registry_update(
-                validator,
+                &mut validator,
                 validator_info,
                 exit_cache,
                 activation_queue,
@@ -258,14 +259,14 @@ pub fn process_epoch_single_pass<E: EthSpec>(
 
         // `process_slashings`
         if conf.slashings {
-            process_single_slashing(balance, validator, slashings_ctxt, state_ctxt, spec)?;
+            process_single_slashing(&mut balance, &validator, slashings_ctxt, state_ctxt, spec)?;
         }
 
         // `process_effective_balance_updates`
         if conf.effective_balance_updates {
             process_single_effective_balance_update(
                 *balance,
-                validator,
+                &mut validator,
                 validator_info,
                 &mut next_epoch_total_active_balance,
                 &mut next_epoch_cache,
@@ -290,7 +291,7 @@ pub fn process_epoch_single_pass<E: EthSpec>(
 }
 
 fn process_single_inactivity_update(
-    inactivity_score: &mut u64,
+    inactivity_score: &mut Cow<u64>,
     validator_info: &ValidatorInfo,
     state_ctxt: &StateContext,
     spec: &ChainSpec,
@@ -303,25 +304,27 @@ fn process_single_inactivity_update(
     if validator_info.is_unslashed_participating_index(TIMELY_TARGET_FLAG_INDEX)? {
         // Avoid mutating when the inactivity score is 0 and can't go any lower -- the common
         // case.
-        if *inactivity_score == 0 {
+        if **inactivity_score == 0 {
             return Ok(());
         }
-        inactivity_score.safe_sub_assign(1)?;
+        inactivity_score.make_mut()?.safe_sub_assign(1)?;
     } else {
-        inactivity_score.safe_add_assign(spec.inactivity_score_bias)?;
+        inactivity_score
+            .make_mut()?
+            .safe_add_assign(spec.inactivity_score_bias)?;
     }
 
     // Decrease the score of all validators for forgiveness when not during a leak
     if !state_ctxt.is_in_inactivity_leak {
-        let deduction = min(spec.inactivity_score_recovery_rate, *inactivity_score);
-        inactivity_score.safe_sub_assign(deduction)?;
+        let deduction = min(spec.inactivity_score_recovery_rate, **inactivity_score);
+        inactivity_score.make_mut()?.safe_sub_assign(deduction)?;
     }
 
     Ok(())
 }
 
 fn process_single_reward_and_penalty(
-    balance: &mut u64,
+    balance: &mut Cow<u64>,
     inactivity_score: &u64,
     validator_info: &ValidatorInfo,
     rewards_ctxt: &RewardsAndPenaltiesContext,
@@ -351,6 +354,7 @@ fn process_single_reward_and_penalty(
     )?;
 
     if delta.rewards != 0 || delta.penalties != 0 {
+        let balance = balance.make_mut()?;
         balance.safe_add_assign(delta.rewards)?;
         *balance = balance.saturating_sub(delta.penalties);
     }
@@ -452,7 +456,7 @@ impl RewardsAndPenaltiesContext {
 }
 
 fn process_single_registry_update(
-    validator: &mut Validator,
+    validator: &mut Cow<Validator>,
     validator_info: &ValidatorInfo,
     exit_cache: &mut ExitCache,
     activation_queue: &BTreeSet<usize>,
@@ -462,8 +466,8 @@ fn process_single_registry_update(
 ) -> Result<(), Error> {
     let current_epoch = state_ctxt.current_epoch;
 
-    if validator.is_eligible_for_activation_queue(spec) {
-        validator.activation_eligibility_epoch = current_epoch.safe_add(1)?;
+    if validator.is_eligible_for_activation_queue(spec, state_ctxt.fork_name) {
+        validator.make_mut()?.activation_eligibility_epoch = current_epoch.safe_add(1)?;
     }
 
     if validator.is_active_at(current_epoch) && validator.effective_balance <= spec.ejection_balance
@@ -472,7 +476,8 @@ fn process_single_registry_update(
     }
 
     if activation_queue.contains(&validator_info.index) {
-        validator.activation_epoch = spec.compute_activation_exit_epoch(current_epoch)?;
+        validator.make_mut()?.activation_epoch =
+            spec.compute_activation_exit_epoch(current_epoch)?;
     }
 
     // Caching: add to speculative activation queue for next epoch.
@@ -487,7 +492,7 @@ fn process_single_registry_update(
 }
 
 fn initiate_validator_exit(
-    validator: &mut Validator,
+    validator: &mut Cow<Validator>,
     exit_cache: &mut ExitCache,
     state_ctxt: &StateContext,
     spec: &ChainSpec,
@@ -508,6 +513,7 @@ fn initiate_validator_exit(
         exit_queue_epoch.safe_add_assign(1)?;
     }
 
+    let validator = validator.make_mut()?;
     validator.exit_epoch = exit_queue_epoch;
     validator.withdrawable_epoch =
         exit_queue_epoch.safe_add(spec.min_validator_withdrawability_delay)?;
@@ -540,7 +546,7 @@ impl SlashingsContext {
 }
 
 fn process_single_slashing(
-    balance: &mut u64,
+    balance: &mut Cow<u64>,
     validator: &Validator,
     slashings_ctxt: &SlashingsContext,
     state_ctxt: &StateContext,
@@ -557,7 +563,7 @@ fn process_single_slashing(
             .safe_div(state_ctxt.total_active_balance)?
             .safe_mul(increment)?;
 
-        *balance = balance.saturating_sub(penalty);
+        *balance.make_mut()? = balance.saturating_sub(penalty);
     }
     Ok(())
 }
@@ -581,7 +587,7 @@ impl EffectiveBalancesContext {
 #[allow(clippy::too_many_arguments)]
 fn process_single_effective_balance_update(
     balance: u64,
-    validator: &mut Validator,
+    validator: &mut Cow<Validator>,
     validator_info: &ValidatorInfo,
     next_epoch_total_active_balance: &mut u64,
     next_epoch_cache: &mut PreEpochCache,
@@ -611,7 +617,7 @@ fn process_single_effective_balance_update(
     }
 
     if new_effective_balance != old_effective_balance {
-        validator.effective_balance = new_effective_balance;
+        validator.make_mut()?.effective_balance = new_effective_balance;
 
         // Update progressive balances cache for the *current* epoch, which will soon become the
         // previous epoch once the epoch transition completes.
diff --git a/consensus/state_processing/src/per_slot_processing.rs b/consensus/state_processing/src/per_slot_processing.rs
index cc28340962a..6554423199f 100644
--- a/consensus/state_processing/src/per_slot_processing.rs
+++ b/consensus/state_processing/src/per_slot_processing.rs
@@ -54,7 +54,7 @@ pub fn per_slot_processing<E: EthSpec>(
         if spec.altair_fork_epoch == Some(state.current_epoch()) {
             upgrade_to_altair(state, spec)?;
         }
-        // If the Merge fork epoch is reached, perform an irregular state upgrade.
+        // If the Bellatrix fork epoch is reached, perform an irregular state upgrade.
         if spec.bellatrix_fork_epoch == Some(state.current_epoch()) {
             upgrade_to_bellatrix(state, spec)?;
         }
diff --git a/consensus/state_processing/src/upgrade.rs b/consensus/state_processing/src/upgrade.rs
index 98602c66ba3..93cafa73d03 100644
--- a/consensus/state_processing/src/upgrade.rs
+++ b/consensus/state_processing/src/upgrade.rs
@@ -1,11 +1,11 @@
 pub mod altair;
+pub mod bellatrix;
 pub mod capella;
 pub mod deneb;
 pub mod electra;
-pub mod merge;
 
 pub use altair::upgrade_to_altair;
+pub use bellatrix::upgrade_to_bellatrix;
 pub use capella::upgrade_to_capella;
 pub use deneb::upgrade_to_deneb;
 pub use electra::upgrade_to_electra;
-pub use merge::upgrade_to_bellatrix;
diff --git a/consensus/state_processing/src/upgrade/altair.rs b/consensus/state_processing/src/upgrade/altair.rs
index cfbc6eba9e9..872560db3df 100644
--- a/consensus/state_processing/src/upgrade/altair.rs
+++ b/consensus/state_processing/src/upgrade/altair.rs
@@ -4,13 +4,13 @@ use std::mem;
 use std::sync::Arc;
 use types::{
     BeaconState, BeaconStateAltair, BeaconStateError as Error, ChainSpec, EpochCache, EthSpec,
-    Fork, ParticipationFlags, PendingAttestation, RelativeEpoch, SyncCommittee, VariableList,
+    Fork, List, ParticipationFlags, PendingAttestation, RelativeEpoch, SyncCommittee,
 };
 
 /// Translate the participation information from the epoch prior to the fork into Altair's format.
 pub fn translate_participation<E: EthSpec>(
     state: &mut BeaconState<E>,
-    pending_attestations: &VariableList<PendingAttestation<E>, E::MaxPendingAttestations>,
+    pending_attestations: &List<PendingAttestation<E>, E::MaxPendingAttestations>,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
     // Previous epoch committee cache is required for `get_attesting_indices`.
@@ -51,8 +51,8 @@ pub fn upgrade_to_altair<E: EthSpec>(
     let pre = pre_state.as_base_mut()?;
 
     let default_epoch_participation =
-        VariableList::new(vec![ParticipationFlags::default(); pre.validators.len()])?;
-    let inactivity_scores = VariableList::new(vec![0; pre.validators.len()])?;
+        List::new(vec![ParticipationFlags::default(); pre.validators.len()])?;
+    let inactivity_scores = List::new(vec![0; pre.validators.len()])?;
 
     let temp_sync_committee = Arc::new(SyncCommittee::temporary());
 
@@ -108,7 +108,6 @@ pub fn upgrade_to_altair<E: EthSpec>(
         exit_cache: mem::take(&mut pre.exit_cache),
         slashings_cache: mem::take(&mut pre.slashings_cache),
         epoch_cache: EpochCache::default(),
-        tree_hash_cache: mem::take(&mut pre.tree_hash_cache),
     });
 
     // Fill in previous epoch participation from the pre state's pending attestations.
diff --git a/consensus/state_processing/src/upgrade/merge.rs b/consensus/state_processing/src/upgrade/bellatrix.rs
similarity index 89%
rename from consensus/state_processing/src/upgrade/merge.rs
rename to consensus/state_processing/src/upgrade/bellatrix.rs
index 147c97ac29e..f23e571cd12 100644
--- a/consensus/state_processing/src/upgrade/merge.rs
+++ b/consensus/state_processing/src/upgrade/bellatrix.rs
@@ -1,10 +1,10 @@
 use std::mem;
 use types::{
-    BeaconState, BeaconStateError as Error, BeaconStateMerge, ChainSpec, EpochCache, EthSpec,
-    ExecutionPayloadHeaderMerge, Fork,
+    BeaconState, BeaconStateBellatrix, BeaconStateError as Error, ChainSpec, EpochCache, EthSpec,
+    ExecutionPayloadHeaderBellatrix, Fork,
 };
 
-/// Transform a `Altair` state into an `Merge` state.
+/// Transform a `Altair` state into an `Bellatrix` state.
 pub fn upgrade_to_bellatrix<E: EthSpec>(
     pre_state: &mut BeaconState<E>,
     spec: &ChainSpec,
@@ -17,7 +17,7 @@ pub fn upgrade_to_bellatrix<E: EthSpec>(
     //
     // Fixed size vectors get cloned because replacing them would require the same size
     // allocation as cloning.
-    let post = BeaconState::Merge(BeaconStateMerge {
+    let post = BeaconState::Bellatrix(BeaconStateBellatrix {
         // Versioning
         genesis_time: pre.genesis_time,
         genesis_validators_root: pre.genesis_validators_root,
@@ -57,7 +57,7 @@ pub fn upgrade_to_bellatrix<E: EthSpec>(
         current_sync_committee: pre.current_sync_committee.clone(),
         next_sync_committee: pre.next_sync_committee.clone(),
         // Execution
-        latest_execution_payload_header: <ExecutionPayloadHeaderMerge<E>>::default(),
+        latest_execution_payload_header: <ExecutionPayloadHeaderBellatrix<E>>::default(),
         // Caches
         total_active_balance: pre.total_active_balance,
         progressive_balances_cache: mem::take(&mut pre.progressive_balances_cache),
@@ -66,7 +66,6 @@ pub fn upgrade_to_bellatrix<E: EthSpec>(
         exit_cache: mem::take(&mut pre.exit_cache),
         slashings_cache: mem::take(&mut pre.slashings_cache),
         epoch_cache: EpochCache::default(),
-        tree_hash_cache: mem::take(&mut pre.tree_hash_cache),
     });
 
     *pre_state = post;
diff --git a/consensus/state_processing/src/upgrade/capella.rs b/consensus/state_processing/src/upgrade/capella.rs
index 87b40abebdd..ae0dbde7678 100644
--- a/consensus/state_processing/src/upgrade/capella.rs
+++ b/consensus/state_processing/src/upgrade/capella.rs
@@ -1,16 +1,16 @@
 use std::mem;
 use types::{
     BeaconState, BeaconStateCapella, BeaconStateError as Error, ChainSpec, EpochCache, EthSpec,
-    Fork, VariableList,
+    Fork, List,
 };
 
-/// Transform a `Merge` state into an `Capella` state.
+/// Transform a `Bellatrix` state into an `Capella` state.
 pub fn upgrade_to_capella<E: EthSpec>(
     pre_state: &mut BeaconState<E>,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
     let epoch = pre_state.current_epoch();
-    let pre = pre_state.as_merge_mut()?;
+    let pre = pre_state.as_bellatrix_mut()?;
 
     // Where possible, use something like `mem::take` to move fields from behind the &mut
     // reference. For other fields that don't have a good default value, use `clone`.
@@ -61,7 +61,7 @@ pub fn upgrade_to_capella<E: EthSpec>(
         // Capella
         next_withdrawal_index: 0,
         next_withdrawal_validator_index: 0,
-        historical_summaries: VariableList::default(),
+        historical_summaries: List::default(),
         // Caches
         total_active_balance: pre.total_active_balance,
         progressive_balances_cache: mem::take(&mut pre.progressive_balances_cache),
@@ -70,7 +70,6 @@ pub fn upgrade_to_capella<E: EthSpec>(
         exit_cache: mem::take(&mut pre.exit_cache),
         slashings_cache: mem::take(&mut pre.slashings_cache),
         epoch_cache: EpochCache::default(),
-        tree_hash_cache: mem::take(&mut pre.tree_hash_cache),
     });
 
     *pre_state = post;
diff --git a/consensus/state_processing/src/upgrade/deneb.rs b/consensus/state_processing/src/upgrade/deneb.rs
index 43fe5d9dc3d..c21e1361a5a 100644
--- a/consensus/state_processing/src/upgrade/deneb.rs
+++ b/consensus/state_processing/src/upgrade/deneb.rs
@@ -71,7 +71,6 @@ pub fn upgrade_to_deneb<E: EthSpec>(
         exit_cache: mem::take(&mut pre.exit_cache),
         slashings_cache: mem::take(&mut pre.slashings_cache),
         epoch_cache: EpochCache::default(),
-        tree_hash_cache: mem::take(&mut pre.tree_hash_cache),
     });
 
     *pre_state = post;
diff --git a/consensus/state_processing/src/upgrade/electra.rs b/consensus/state_processing/src/upgrade/electra.rs
index a37d0fc3beb..1e60bf488db 100644
--- a/consensus/state_processing/src/upgrade/electra.rs
+++ b/consensus/state_processing/src/upgrade/electra.rs
@@ -1,3 +1,4 @@
+use safe_arith::SafeArith;
 use std::mem;
 use types::{
     BeaconState, BeaconStateElectra, BeaconStateError as Error, ChainSpec, EpochCache, EthSpec,
@@ -10,14 +11,28 @@ pub fn upgrade_to_electra<E: EthSpec>(
     spec: &ChainSpec,
 ) -> Result<(), Error> {
     let epoch = pre_state.current_epoch();
-    let pre = pre_state.as_deneb_mut()?;
 
+    let earliest_exit_epoch = pre_state
+        .validators()
+        .iter()
+        .filter(|v| v.exit_epoch != spec.far_future_epoch)
+        .map(|v| v.exit_epoch)
+        .max()
+        .unwrap_or(epoch)
+        .safe_add(1)?;
+
+    // The total active balance cache must be built before the consolidation churn limit
+    // is calculated.
+    pre_state.build_total_active_balance_cache(spec)?;
+    let earliest_consolidation_epoch = spec.compute_activation_exit_epoch(epoch)?;
+
+    let pre = pre_state.as_deneb_mut()?;
     // Where possible, use something like `mem::take` to move fields from behind the &mut
     // reference. For other fields that don't have a good default value, use `clone`.
     //
     // Fixed size vectors get cloned because replacing them would require the same size
     // allocation as cloning.
-    let post = BeaconState::Electra(BeaconStateElectra {
+    let mut post = BeaconState::Electra(BeaconStateElectra {
         // Versioning
         genesis_time: pre.genesis_time,
         genesis_validators_root: pre.genesis_validators_root,
@@ -62,6 +77,16 @@ pub fn upgrade_to_electra<E: EthSpec>(
         next_withdrawal_index: pre.next_withdrawal_index,
         next_withdrawal_validator_index: pre.next_withdrawal_validator_index,
         historical_summaries: pre.historical_summaries.clone(),
+        // Electra
+        deposit_receipts_start_index: spec.unset_deposit_receipts_start_index,
+        deposit_balance_to_consume: 0,
+        exit_balance_to_consume: 0,
+        earliest_exit_epoch,
+        consolidation_balance_to_consume: 0,
+        earliest_consolidation_epoch,
+        pending_balance_deposits: Default::default(),
+        pending_partial_withdrawals: Default::default(),
+        pending_consolidations: Default::default(),
         // Caches
         total_active_balance: pre.total_active_balance,
         progressive_balances_cache: mem::take(&mut pre.progressive_balances_cache),
@@ -70,8 +95,40 @@ pub fn upgrade_to_electra<E: EthSpec>(
         exit_cache: mem::take(&mut pre.exit_cache),
         slashings_cache: mem::take(&mut pre.slashings_cache),
         epoch_cache: EpochCache::default(),
-        tree_hash_cache: mem::take(&mut pre.tree_hash_cache),
     });
+    *post.exit_balance_to_consume_mut()? = post.get_activation_exit_churn_limit(spec)?;
+    *post.consolidation_balance_to_consume_mut()? = post.get_consolidation_churn_limit(spec)?;
+
+    // Add validators that are not yet active to pending balance deposits
+    let validators = post.validators().clone();
+    let mut pre_activation = validators
+        .iter()
+        .enumerate()
+        .filter(|(_, validator)| validator.activation_epoch == spec.far_future_epoch)
+        .collect::<Vec<_>>();
+
+    // Sort the indices by activation_eligibility_epoch and then by index
+    pre_activation.sort_by(|(index_a, val_a), (index_b, val_b)| {
+        if val_a.activation_eligibility_epoch == val_b.activation_eligibility_epoch {
+            index_a.cmp(index_b)
+        } else {
+            val_a
+                .activation_eligibility_epoch
+                .cmp(&val_b.activation_eligibility_epoch)
+        }
+    });
+
+    // Process validators to queue entire balance and reset them
+    for (index, _) in pre_activation {
+        post.queue_entire_balance_and_reset_validator(index, spec)?;
+    }
+
+    // Ensure early adopters of compounding credentials go through the activation churn
+    for (index, validator) in validators.iter().enumerate() {
+        if validator.has_compounding_withdrawal_credential(spec) {
+            post.queue_excess_active_balance(index, spec)?;
+        }
+    }
 
     *pre_state = post;
 
diff --git a/consensus/types/Cargo.toml b/consensus/types/Cargo.toml
index db15f53537e..4b7d9f2b98d 100644
--- a/consensus/types/Cargo.toml
+++ b/consensus/types/Cargo.toml
@@ -52,6 +52,8 @@ serde_json = { workspace = true }
 smallvec = { workspace = true }
 maplit = { workspace = true }
 strum = { workspace = true }
+milhouse = { workspace = true }
+rpds = { workspace = true }
 
 [dev-dependencies]
 criterion = { workspace = true }
@@ -68,4 +70,4 @@ sqlite = []
 # The `arbitrary-fuzz` feature is a no-op provided for backwards compatibility.
 # For simplicity `Arbitrary` is now derived regardless of the feature's presence.
 arbitrary-fuzz = []
-portable = ["bls/supranational-portable"]
\ No newline at end of file
+portable = ["bls/supranational-portable"]
diff --git a/consensus/types/benches/benches.rs b/consensus/types/benches/benches.rs
index bb2b527109f..5c1036a4c5a 100644
--- a/consensus/types/benches/benches.rs
+++ b/consensus/types/benches/benches.rs
@@ -2,6 +2,7 @@
 
 use criterion::Criterion;
 use criterion::{black_box, criterion_group, criterion_main, Benchmark};
+use milhouse::List;
 use rayon::prelude::*;
 use ssz::Encode;
 use std::sync::Arc;
@@ -27,21 +28,23 @@ fn get_state<E: EthSpec>(validator_count: usize) -> BeaconState<E> {
             .expect("should add balance");
     }
 
-    *state.validators_mut() = (0..validator_count)
-        .collect::<Vec<_>>()
-        .par_iter()
-        .map(|&i| Validator {
-            pubkey: generate_deterministic_keypair(i).pk.into(),
-            withdrawal_credentials: Hash256::from_low_u64_le(i as u64),
-            effective_balance: spec.max_effective_balance,
-            slashed: false,
-            activation_eligibility_epoch: Epoch::new(0),
-            activation_epoch: Epoch::new(0),
-            exit_epoch: Epoch::from(u64::max_value()),
-            withdrawable_epoch: Epoch::from(u64::max_value()),
-        })
-        .collect::<Vec<_>>()
-        .into();
+    *state.validators_mut() = List::new(
+        (0..validator_count)
+            .collect::<Vec<_>>()
+            .par_iter()
+            .map(|&i| Validator {
+                pubkey: generate_deterministic_keypair(i).pk.compress(),
+                withdrawal_credentials: Hash256::from_low_u64_le(i as u64),
+                effective_balance: spec.max_effective_balance,
+                slashed: false,
+                activation_eligibility_epoch: Epoch::new(0),
+                activation_epoch: Epoch::new(0),
+                exit_epoch: Epoch::from(u64::max_value()),
+                withdrawable_epoch: Epoch::from(u64::max_value()),
+            })
+            .collect(),
+    )
+    .unwrap();
 
     state
 }
@@ -96,19 +99,6 @@ fn all_benches(c: &mut Criterion) {
         .sample_size(10),
     );
 
-    let inner_state = state.clone();
-    c.bench(
-        &format!("{}_validators", validator_count),
-        Benchmark::new("clone/tree_hash_cache", move |b| {
-            b.iter_batched_ref(
-                || inner_state.clone(),
-                |state| black_box(state.tree_hash_cache().clone()),
-                criterion::BatchSize::SmallInput,
-            )
-        })
-        .sample_size(10),
-    );
-
     let inner_state = state.clone();
     c.bench(
         &format!("{}_validators", validator_count),
diff --git a/consensus/types/examples/clone_state.rs b/consensus/types/examples/clone_state.rs
deleted file mode 100644
index a7e80cf4078..00000000000
--- a/consensus/types/examples/clone_state.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-//! These examples only really exist so we can use them for flamegraph. If they get annoying to
-//! maintain, feel free to delete.
-
-use types::{
-    test_utils::generate_deterministic_keypair, BeaconState, Eth1Data, EthSpec, Hash256,
-    MinimalEthSpec, Validator,
-};
-
-type E = MinimalEthSpec;
-
-fn get_state(validator_count: usize) -> BeaconState<E> {
-    let spec = &E::default_spec();
-    let eth1_data = Eth1Data {
-        deposit_root: Hash256::zero(),
-        deposit_count: 0,
-        block_hash: Hash256::zero(),
-    };
-
-    let mut state = BeaconState::new(0, eth1_data, spec);
-
-    for i in 0..validator_count {
-        state
-            .balances_mut()
-            .push(i as u64)
-            .expect("should add balance");
-        state
-            .validators_mut()
-            .push(Validator {
-                pubkey: generate_deterministic_keypair(i).pk.into(),
-                withdrawal_credentials: Hash256::from_low_u64_le(i as u64),
-                effective_balance: i as u64,
-                slashed: i % 2 == 0,
-                activation_eligibility_epoch: i.into(),
-                activation_epoch: i.into(),
-                exit_epoch: i.into(),
-                withdrawable_epoch: i.into(),
-            })
-            .expect("should add validator");
-    }
-
-    state
-}
-
-fn main() {
-    let validator_count = 1_024;
-    let state = get_state(validator_count);
-
-    for _ in 0..100_000 {
-        let _ = state.clone();
-    }
-}
diff --git a/consensus/types/examples/ssz_encode_state.rs b/consensus/types/examples/ssz_encode_state.rs
deleted file mode 100644
index 5d0a2db17c7..00000000000
--- a/consensus/types/examples/ssz_encode_state.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-//! These examples only really exist so we can use them for flamegraph. If they get annoying to
-//! maintain, feel free to delete.
-
-use ssz::Encode;
-use types::{
-    test_utils::generate_deterministic_keypair, BeaconState, Eth1Data, EthSpec, Hash256,
-    MinimalEthSpec, Validator,
-};
-
-type E = MinimalEthSpec;
-
-fn get_state(validator_count: usize) -> BeaconState<E> {
-    let spec = &E::default_spec();
-    let eth1_data = Eth1Data {
-        deposit_root: Hash256::zero(),
-        deposit_count: 0,
-        block_hash: Hash256::zero(),
-    };
-
-    let mut state = BeaconState::new(0, eth1_data, spec);
-
-    for i in 0..validator_count {
-        state
-            .balances_mut()
-            .push(i as u64)
-            .expect("should add balance");
-        state
-            .validators_mut()
-            .push(Validator {
-                pubkey: generate_deterministic_keypair(i).pk.into(),
-                withdrawal_credentials: Hash256::from_low_u64_le(i as u64),
-                effective_balance: i as u64,
-                slashed: i % 2 == 0,
-                activation_eligibility_epoch: i.into(),
-                activation_epoch: i.into(),
-                exit_epoch: i.into(),
-                withdrawable_epoch: i.into(),
-            })
-            .expect("should add validator");
-    }
-
-    state
-}
-
-fn main() {
-    let validator_count = 1_024;
-    let state = get_state(validator_count);
-
-    for _ in 0..1_024 {
-        let state_bytes = state.as_ssz_bytes();
-        let _: BeaconState<E> =
-            BeaconState::from_ssz_bytes(&state_bytes, &E::default_spec()).expect("should decode");
-    }
-}
diff --git a/consensus/types/examples/tree_hash_state.rs b/consensus/types/examples/tree_hash_state.rs
deleted file mode 100644
index 26777b25912..00000000000
--- a/consensus/types/examples/tree_hash_state.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-//! These examples only really exist so we can use them for flamegraph. If they get annoying to
-//! maintain, feel free to delete.
-
-use types::{
-    test_utils::generate_deterministic_keypair, BeaconState, Eth1Data, EthSpec, Hash256,
-    MinimalEthSpec, Validator,
-};
-
-type E = MinimalEthSpec;
-
-fn get_state(validator_count: usize) -> BeaconState<E> {
-    let spec = &E::default_spec();
-    let eth1_data = Eth1Data {
-        deposit_root: Hash256::zero(),
-        deposit_count: 0,
-        block_hash: Hash256::zero(),
-    };
-
-    let mut state = BeaconState::new(0, eth1_data, spec);
-
-    for i in 0..validator_count {
-        state
-            .balances_mut()
-            .push(i as u64)
-            .expect("should add balance");
-        state
-            .validators_mut()
-            .push(Validator {
-                pubkey: generate_deterministic_keypair(i).pk.into(),
-                withdrawal_credentials: Hash256::from_low_u64_le(i as u64),
-                effective_balance: i as u64,
-                slashed: i % 2 == 0,
-                activation_eligibility_epoch: i.into(),
-                activation_epoch: i.into(),
-                exit_epoch: i.into(),
-                withdrawable_epoch: i.into(),
-            })
-            .expect("should add validator");
-    }
-
-    state
-}
-
-fn main() {
-    let validator_count = 1_024;
-    let mut state = get_state(validator_count);
-    state.update_tree_hash_cache().expect("should update cache");
-
-    actual_thing::<E>(&mut state);
-}
-
-fn actual_thing<E: EthSpec>(state: &mut BeaconState<E>) {
-    for _ in 0..200_024 {
-        let _ = state.update_tree_hash_cache().expect("should update cache");
-    }
-}
diff --git a/consensus/types/presets/gnosis/electra.yaml b/consensus/types/presets/gnosis/electra.yaml
index cafdcbbf8d3..72c626ded2f 100644
--- a/consensus/types/presets/gnosis/electra.yaml
+++ b/consensus/types/presets/gnosis/electra.yaml
@@ -1,3 +1,45 @@
-# Gnosis preset - Electra
+# Mainnet preset - Electra
 
-ELECTRA_PLACEHOLDER: 0
+# Gwei values
+# ---------------------------------------------------------------
+# 2**5 * 10**9 (= 32,000,000,000) Gwei
+MIN_ACTIVATION_BALANCE: 32000000000
+# 2**11 * 10**9 (= 2,048,000,000,000) Gwei
+MAX_EFFECTIVE_BALANCE_ELECTRA: 2048000000000
+
+# State list lengths
+# ---------------------------------------------------------------
+# `uint64(2**27)` (= 134,217,728)
+PENDING_BALANCE_DEPOSITS_LIMIT: 134217728
+# `uint64(2**27)` (= 134,217,728)
+PENDING_PARTIAL_WITHDRAWALS_LIMIT: 134217728
+# `uint64(2**18)` (= 262,144)
+PENDING_CONSOLIDATIONS_LIMIT: 262144
+
+# Reward and penalty quotients
+# ---------------------------------------------------------------
+# `uint64(2**12)` (= 4,096)
+MIN_SLASHING_PENALTY_QUOTIENT_ELECTRA: 4096
+# `uint64(2**12)` (= 4,096)
+WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA: 4096
+
+# # Max operations per block
+# ---------------------------------------------------------------
+# `uint64(2**0)` (= 1)
+MAX_ATTESTER_SLASHINGS_ELECTRA: 1
+# `uint64(2**3)` (= 8)
+MAX_ATTESTATIONS_ELECTRA: 8
+# `uint64(2**0)` (= 1)
+MAX_CONSOLIDATIONS: 1
+
+# Execution
+# ---------------------------------------------------------------
+# 2**13 (= 8192) receipts
+MAX_DEPOSIT_RECEIPTS_PER_PAYLOAD: 8192
+# 2**4 (= 16) withdrawal requests
+MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD: 16
+
+# Withdrawals processing
+# ---------------------------------------------------------------
+# 2**3 ( = 8) pending withdrawals
+MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP: 8
diff --git a/consensus/types/presets/mainnet/electra.yaml b/consensus/types/presets/mainnet/electra.yaml
index 64d8b97b631..72c626ded2f 100644
--- a/consensus/types/presets/mainnet/electra.yaml
+++ b/consensus/types/presets/mainnet/electra.yaml
@@ -1,3 +1,45 @@
 # Mainnet preset - Electra
 
-ELECTRA_PLACEHOLDER: 0
+# Gwei values
+# ---------------------------------------------------------------
+# 2**5 * 10**9 (= 32,000,000,000) Gwei
+MIN_ACTIVATION_BALANCE: 32000000000
+# 2**11 * 10**9 (= 2,048,000,000,000) Gwei
+MAX_EFFECTIVE_BALANCE_ELECTRA: 2048000000000
+
+# State list lengths
+# ---------------------------------------------------------------
+# `uint64(2**27)` (= 134,217,728)
+PENDING_BALANCE_DEPOSITS_LIMIT: 134217728
+# `uint64(2**27)` (= 134,217,728)
+PENDING_PARTIAL_WITHDRAWALS_LIMIT: 134217728
+# `uint64(2**18)` (= 262,144)
+PENDING_CONSOLIDATIONS_LIMIT: 262144
+
+# Reward and penalty quotients
+# ---------------------------------------------------------------
+# `uint64(2**12)` (= 4,096)
+MIN_SLASHING_PENALTY_QUOTIENT_ELECTRA: 4096
+# `uint64(2**12)` (= 4,096)
+WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA: 4096
+
+# # Max operations per block
+# ---------------------------------------------------------------
+# `uint64(2**0)` (= 1)
+MAX_ATTESTER_SLASHINGS_ELECTRA: 1
+# `uint64(2**3)` (= 8)
+MAX_ATTESTATIONS_ELECTRA: 8
+# `uint64(2**0)` (= 1)
+MAX_CONSOLIDATIONS: 1
+
+# Execution
+# ---------------------------------------------------------------
+# 2**13 (= 8192) receipts
+MAX_DEPOSIT_RECEIPTS_PER_PAYLOAD: 8192
+# 2**4 (= 16) withdrawal requests
+MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD: 16
+
+# Withdrawals processing
+# ---------------------------------------------------------------
+# 2**3 ( = 8) pending withdrawals
+MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP: 8
diff --git a/consensus/types/presets/minimal/electra.yaml b/consensus/types/presets/minimal/electra.yaml
index 3baa7fa8161..11aa5e1f50e 100644
--- a/consensus/types/presets/minimal/electra.yaml
+++ b/consensus/types/presets/minimal/electra.yaml
@@ -1,3 +1,45 @@
 # Minimal preset - Electra
 
-ELECTRA_PLACEHOLDER: 0
+# Gwei values
+# ---------------------------------------------------------------
+# 2**5 * 10**9 (= 32,000,000,000) Gwei
+MIN_ACTIVATION_BALANCE: 32000000000
+# 2**11 * 10**9 (= 2,048,000,000,000) Gwei
+MAX_EFFECTIVE_BALANCE_ELECTRA: 2048000000000
+
+# State list lengths
+# ---------------------------------------------------------------
+# `uint64(2**27)` (= 134,217,728)
+PENDING_BALANCE_DEPOSITS_LIMIT: 134217728
+# [customized] `uint64(2**6)` (= 64)
+PENDING_PARTIAL_WITHDRAWALS_LIMIT: 64
+# [customized] `uint64(2**6)` (= 64)
+PENDING_CONSOLIDATIONS_LIMIT: 64
+
+# Reward and penalty quotients
+# ---------------------------------------------------------------
+# `uint64(2**12)` (= 4,096)
+MIN_SLASHING_PENALTY_QUOTIENT_ELECTRA: 4096
+# `uint64(2**12)` (= 4,096)
+WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA: 4096
+
+# # Max operations per block
+# ---------------------------------------------------------------
+# `uint64(2**0)` (= 1)
+MAX_ATTESTER_SLASHINGS_ELECTRA: 1
+# `uint64(2**3)` (= 8)
+MAX_ATTESTATIONS_ELECTRA: 8
+# `uint64(2**0)` (= 1)
+MAX_CONSOLIDATIONS: 1
+
+# Execution
+# ---------------------------------------------------------------
+# [customized]
+MAX_DEPOSIT_RECEIPTS_PER_PAYLOAD: 4
+# [customized] 2**1 (= 2) withdrawal requests
+MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD: 2
+
+# Withdrawals processing
+# ---------------------------------------------------------------
+# 2**0 ( = 1) pending withdrawals
+MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP: 1
diff --git a/consensus/types/src/beacon_block.rs b/consensus/types/src/beacon_block.rs
index 14874f0204f..ed3d1827725 100644
--- a/consensus/types/src/beacon_block.rs
+++ b/consensus/types/src/beacon_block.rs
@@ -4,6 +4,7 @@ use derivative::Derivative;
 use serde::{Deserialize, Serialize};
 use ssz::{Decode, DecodeError};
 use ssz_derive::{Decode, Encode};
+use std::fmt;
 use std::marker::PhantomData;
 use superstruct::superstruct;
 use test_random_derive::TestRandom;
@@ -12,7 +13,7 @@ use tree_hash_derive::TreeHash;
 
 /// A block of the `BeaconChain`.
 #[superstruct(
-    variants(Base, Altair, Merge, Capella, Deneb, Electra),
+    variants(Base, Altair, Bellatrix, Capella, Deneb, Electra),
     variant_attributes(
         derive(
             Debug,
@@ -63,8 +64,8 @@ pub struct BeaconBlock<E: EthSpec, Payload: AbstractExecPayload<E> = FullPayload
     pub body: BeaconBlockBodyBase<E, Payload>,
     #[superstruct(only(Altair), partial_getter(rename = "body_altair"))]
     pub body: BeaconBlockBodyAltair<E, Payload>,
-    #[superstruct(only(Merge), partial_getter(rename = "body_merge"))]
-    pub body: BeaconBlockBodyMerge<E, Payload>,
+    #[superstruct(only(Bellatrix), partial_getter(rename = "body_bellatrix"))]
+    pub body: BeaconBlockBodyBellatrix<E, Payload>,
     #[superstruct(only(Capella), partial_getter(rename = "body_capella"))]
     pub body: BeaconBlockBodyCapella<E, Payload>,
     #[superstruct(only(Deneb), partial_getter(rename = "body_deneb"))]
@@ -130,7 +131,7 @@ impl<E: EthSpec, Payload: AbstractExecPayload<E>> BeaconBlock<E, Payload> {
             .map(BeaconBlock::Electra)
             .or_else(|_| BeaconBlockDeneb::from_ssz_bytes(bytes).map(BeaconBlock::Deneb))
             .or_else(|_| BeaconBlockCapella::from_ssz_bytes(bytes).map(BeaconBlock::Capella))
-            .or_else(|_| BeaconBlockMerge::from_ssz_bytes(bytes).map(BeaconBlock::Merge))
+            .or_else(|_| BeaconBlockBellatrix::from_ssz_bytes(bytes).map(BeaconBlock::Bellatrix))
             .or_else(|_| BeaconBlockAltair::from_ssz_bytes(bytes).map(BeaconBlock::Altair))
             .or_else(|_| BeaconBlockBase::from_ssz_bytes(bytes).map(BeaconBlock::Base))
     }
@@ -221,7 +222,7 @@ impl<'a, E: EthSpec, Payload: AbstractExecPayload<E>> BeaconBlockRef<'a, E, Payl
         match self {
             BeaconBlockRef::Base { .. } => ForkName::Base,
             BeaconBlockRef::Altair { .. } => ForkName::Altair,
-            BeaconBlockRef::Merge { .. } => ForkName::Merge,
+            BeaconBlockRef::Bellatrix { .. } => ForkName::Bellatrix,
             BeaconBlockRef::Capella { .. } => ForkName::Capella,
             BeaconBlockRef::Deneb { .. } => ForkName::Deneb,
             BeaconBlockRef::Electra { .. } => ForkName::Electra,
@@ -466,15 +467,15 @@ impl<E: EthSpec, Payload: AbstractExecPayload<E>> BeaconBlockAltair<E, Payload>
     }
 }
 
-impl<E: EthSpec, Payload: AbstractExecPayload<E>> EmptyBlock for BeaconBlockMerge<E, Payload> {
-    /// Returns an empty Merge block to be used during genesis.
+impl<E: EthSpec, Payload: AbstractExecPayload<E>> EmptyBlock for BeaconBlockBellatrix<E, Payload> {
+    /// Returns an empty Bellatrix block to be used during genesis.
     fn empty(spec: &ChainSpec) -> Self {
-        BeaconBlockMerge {
+        BeaconBlockBellatrix {
             slot: spec.genesis_slot,
             proposer_index: 0,
             parent_root: Hash256::zero(),
             state_root: Hash256::zero(),
-            body: BeaconBlockBodyMerge {
+            body: BeaconBlockBodyBellatrix {
                 randao_reveal: Signature::empty(),
                 eth1_data: Eth1Data {
                     deposit_root: Hash256::zero(),
@@ -488,7 +489,7 @@ impl<E: EthSpec, Payload: AbstractExecPayload<E>> EmptyBlock for BeaconBlockMerg
                 deposits: VariableList::empty(),
                 voluntary_exits: VariableList::empty(),
                 sync_aggregate: SyncAggregate::empty(),
-                execution_payload: Payload::Merge::default(),
+                execution_payload: Payload::Bellatrix::default(),
             },
         }
     }
@@ -753,7 +754,7 @@ macro_rules! impl_from {
 
 impl_from!(BeaconBlockBase, <E, FullPayload<E>>, <E, BlindedPayload<E>>, |body: BeaconBlockBodyBase<_, _>| body.into());
 impl_from!(BeaconBlockAltair, <E, FullPayload<E>>, <E, BlindedPayload<E>>, |body: BeaconBlockBodyAltair<_, _>| body.into());
-impl_from!(BeaconBlockMerge, <E, FullPayload<E>>, <E, BlindedPayload<E>>, |body: BeaconBlockBodyMerge<_, _>| body.into());
+impl_from!(BeaconBlockBellatrix, <E, FullPayload<E>>, <E, BlindedPayload<E>>, |body: BeaconBlockBodyBellatrix<_, _>| body.into());
 impl_from!(BeaconBlockCapella, <E, FullPayload<E>>, <E, BlindedPayload<E>>, |body: BeaconBlockBodyCapella<_, _>| body.into());
 impl_from!(BeaconBlockDeneb, <E, FullPayload<E>>, <E, BlindedPayload<E>>, |body: BeaconBlockBodyDeneb<_, _>| body.into());
 impl_from!(BeaconBlockElectra, <E, FullPayload<E>>, <E, BlindedPayload<E>>, |body: BeaconBlockBodyElectra<_, _>| body.into());
@@ -786,7 +787,7 @@ macro_rules! impl_clone_as_blinded {
 
 impl_clone_as_blinded!(BeaconBlockBase, <E, FullPayload<E>>, <E, BlindedPayload<E>>);
 impl_clone_as_blinded!(BeaconBlockAltair, <E, FullPayload<E>>, <E, BlindedPayload<E>>);
-impl_clone_as_blinded!(BeaconBlockMerge, <E, FullPayload<E>>, <E, BlindedPayload<E>>);
+impl_clone_as_blinded!(BeaconBlockBellatrix, <E, FullPayload<E>>, <E, BlindedPayload<E>>);
 impl_clone_as_blinded!(BeaconBlockCapella, <E, FullPayload<E>>, <E, BlindedPayload<E>>);
 impl_clone_as_blinded!(BeaconBlockDeneb, <E, FullPayload<E>>, <E, BlindedPayload<E>>);
 impl_clone_as_blinded!(BeaconBlockElectra, <E, FullPayload<E>>, <E, BlindedPayload<E>>);
@@ -836,6 +837,23 @@ impl<E: EthSpec, Payload: AbstractExecPayload<E>> ForkVersionDeserialize
         ))
     }
 }
+pub enum BlockImportSource {
+    Gossip,
+    Lookup,
+    RangeSync,
+    HttpApi,
+}
+
+impl fmt::Display for BlockImportSource {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            BlockImportSource::Gossip => write!(f, "gossip"),
+            BlockImportSource::Lookup => write!(f, "lookup"),
+            BlockImportSource::RangeSync => write!(f, "range_sync"),
+            BlockImportSource::HttpApi => write!(f, "http_api"),
+        }
+    }
+}
 
 #[cfg(test)]
 mod tests {
@@ -1074,9 +1092,8 @@ mod tests {
                     .expect("good electra block can be decoded"),
                 good_block
             );
-            // TODO(electra): once the Electra block is changed from Deneb, update this to match
-            // the other forks.
-            assert!(BeaconBlock::from_ssz_bytes(&bad_block.as_ssz_bytes(), &spec).is_ok());
+            BeaconBlock::from_ssz_bytes(&bad_block.as_ssz_bytes(), &spec)
+                .expect_err("bad electra block cannot be decoded");
         }
     }
 }
diff --git a/consensus/types/src/beacon_block_body.rs b/consensus/types/src/beacon_block_body.rs
index a55c16b80d5..c3077c4ab68 100644
--- a/consensus/types/src/beacon_block_body.rs
+++ b/consensus/types/src/beacon_block_body.rs
@@ -29,7 +29,7 @@ pub const BLOB_KZG_COMMITMENTS_INDEX: usize = 11;
 ///
 /// This *superstruct* abstracts over the hard-fork.
 #[superstruct(
-    variants(Base, Altair, Merge, Capella, Deneb, Electra),
+    variants(Base, Altair, Bellatrix, Capella, Deneb, Electra),
     variant_attributes(
         derive(
             Debug,
@@ -67,14 +67,17 @@ pub struct BeaconBlockBody<E: EthSpec, Payload: AbstractExecPayload<E> = FullPay
     pub attestations: VariableList<Attestation<E>, E::MaxAttestations>,
     pub deposits: VariableList<Deposit, E::MaxDeposits>,
     pub voluntary_exits: VariableList<SignedVoluntaryExit, E::MaxVoluntaryExits>,
-    #[superstruct(only(Altair, Merge, Capella, Deneb, Electra))]
+    #[superstruct(only(Altair, Bellatrix, Capella, Deneb, Electra))]
     pub sync_aggregate: SyncAggregate<E>,
     // We flatten the execution payload so that serde can use the name of the inner type,
     // either `execution_payload` for full payloads, or `execution_payload_header` for blinded
     // payloads.
-    #[superstruct(only(Merge), partial_getter(rename = "execution_payload_merge"))]
+    #[superstruct(
+        only(Bellatrix),
+        partial_getter(rename = "execution_payload_bellatrix")
+    )]
     #[serde(flatten)]
-    pub execution_payload: Payload::Merge,
+    pub execution_payload: Payload::Bellatrix,
     #[superstruct(only(Capella), partial_getter(rename = "execution_payload_capella"))]
     #[serde(flatten)]
     pub execution_payload: Payload::Capella,
@@ -107,7 +110,7 @@ impl<'a, E: EthSpec, Payload: AbstractExecPayload<E>> BeaconBlockBodyRef<'a, E,
     pub fn execution_payload(&self) -> Result<Payload::Ref<'a>, Error> {
         match self {
             Self::Base(_) | Self::Altair(_) => Err(Error::IncorrectStateVariant),
-            Self::Merge(body) => Ok(Payload::Ref::from(&body.execution_payload)),
+            Self::Bellatrix(body) => Ok(Payload::Ref::from(&body.execution_payload)),
             Self::Capella(body) => Ok(Payload::Ref::from(&body.execution_payload)),
             Self::Deneb(body) => Ok(Payload::Ref::from(&body.execution_payload)),
             Self::Electra(body) => Ok(Payload::Ref::from(&body.execution_payload)),
@@ -121,7 +124,7 @@ impl<'a, E: EthSpec, Payload: AbstractExecPayload<E>> BeaconBlockBodyRef<'a, E,
         index: usize,
     ) -> Result<FixedVector<Hash256, E::KzgCommitmentInclusionProofDepth>, Error> {
         match self {
-            Self::Base(_) | Self::Altair(_) | Self::Merge(_) | Self::Capella(_) => {
+            Self::Base(_) | Self::Altair(_) | Self::Bellatrix(_) | Self::Capella(_) => {
                 Err(Error::IncorrectStateVariant)
             }
             Self::Deneb(body) => {
@@ -261,7 +264,7 @@ impl<'a, E: EthSpec, Payload: AbstractExecPayload<E>> BeaconBlockBodyRef<'a, E,
         match self {
             BeaconBlockBodyRef::Base { .. } => ForkName::Base,
             BeaconBlockBodyRef::Altair { .. } => ForkName::Altair,
-            BeaconBlockBodyRef::Merge { .. } => ForkName::Merge,
+            BeaconBlockBodyRef::Bellatrix { .. } => ForkName::Bellatrix,
             BeaconBlockBodyRef::Capella { .. } => ForkName::Capella,
             BeaconBlockBodyRef::Deneb { .. } => ForkName::Deneb,
             BeaconBlockBodyRef::Electra { .. } => ForkName::Electra,
@@ -407,14 +410,14 @@ impl<E: EthSpec> From<BeaconBlockBodyAltair<E, FullPayload<E>>>
     }
 }
 
-impl<E: EthSpec> From<BeaconBlockBodyMerge<E, FullPayload<E>>>
+impl<E: EthSpec> From<BeaconBlockBodyBellatrix<E, FullPayload<E>>>
     for (
-        BeaconBlockBodyMerge<E, BlindedPayload<E>>,
-        Option<ExecutionPayloadMerge<E>>,
+        BeaconBlockBodyBellatrix<E, BlindedPayload<E>>,
+        Option<ExecutionPayloadBellatrix<E>>,
     )
 {
-    fn from(body: BeaconBlockBodyMerge<E, FullPayload<E>>) -> Self {
-        let BeaconBlockBodyMerge {
+    fn from(body: BeaconBlockBodyBellatrix<E, FullPayload<E>>) -> Self {
+        let BeaconBlockBodyBellatrix {
             randao_reveal,
             eth1_data,
             graffiti,
@@ -424,11 +427,11 @@ impl<E: EthSpec> From<BeaconBlockBodyMerge<E, FullPayload<E>>>
             deposits,
             voluntary_exits,
             sync_aggregate,
-            execution_payload: FullPayloadMerge { execution_payload },
+            execution_payload: FullPayloadBellatrix { execution_payload },
         } = body;
 
         (
-            BeaconBlockBodyMerge {
+            BeaconBlockBodyBellatrix {
                 randao_reveal,
                 eth1_data,
                 graffiti,
@@ -438,7 +441,7 @@ impl<E: EthSpec> From<BeaconBlockBodyMerge<E, FullPayload<E>>>
                 deposits,
                 voluntary_exits,
                 sync_aggregate,
-                execution_payload: BlindedPayloadMerge {
+                execution_payload: BlindedPayloadBellatrix {
                     execution_payload_header: From::from(&execution_payload),
                 },
             },
@@ -592,9 +595,9 @@ impl<E: EthSpec> BeaconBlockBodyAltair<E, FullPayload<E>> {
     }
 }
 
-impl<E: EthSpec> BeaconBlockBodyMerge<E, FullPayload<E>> {
-    pub fn clone_as_blinded(&self) -> BeaconBlockBodyMerge<E, BlindedPayload<E>> {
-        let BeaconBlockBodyMerge {
+impl<E: EthSpec> BeaconBlockBodyBellatrix<E, FullPayload<E>> {
+    pub fn clone_as_blinded(&self) -> BeaconBlockBodyBellatrix<E, BlindedPayload<E>> {
+        let BeaconBlockBodyBellatrix {
             randao_reveal,
             eth1_data,
             graffiti,
@@ -604,10 +607,10 @@ impl<E: EthSpec> BeaconBlockBodyMerge<E, FullPayload<E>> {
             deposits,
             voluntary_exits,
             sync_aggregate,
-            execution_payload: FullPayloadMerge { execution_payload },
+            execution_payload: FullPayloadBellatrix { execution_payload },
         } = self;
 
-        BeaconBlockBodyMerge {
+        BeaconBlockBodyBellatrix {
             randao_reveal: randao_reveal.clone(),
             eth1_data: eth1_data.clone(),
             graffiti: *graffiti,
@@ -617,7 +620,7 @@ impl<E: EthSpec> BeaconBlockBodyMerge<E, FullPayload<E>> {
             deposits: deposits.clone(),
             voluntary_exits: voluntary_exits.clone(),
             sync_aggregate: sync_aggregate.clone(),
-            execution_payload: BlindedPayloadMerge {
+            execution_payload: BlindedPayloadBellatrix {
                 execution_payload_header: execution_payload.into(),
             },
         }
diff --git a/consensus/types/src/beacon_state.rs b/consensus/types/src/beacon_state.rs
index ba11c9c4cce..577f282a556 100644
--- a/consensus/types/src/beacon_state.rs
+++ b/consensus/types/src/beacon_state.rs
@@ -7,6 +7,7 @@ use compare_fields_derive::CompareFields;
 use derivative::Derivative;
 use ethereum_hashing::hash;
 use int_to_bytes::{int_to_bytes4, int_to_bytes8};
+use metastruct::{metastruct, NumFields};
 pub use pubkey_cache::PubkeyCache;
 use safe_arith::{ArithError, SafeArith};
 use serde::{Deserialize, Serialize};
@@ -28,28 +29,25 @@ pub use crate::beacon_state::balance::Balance;
 pub use crate::beacon_state::exit_cache::ExitCache;
 pub use crate::beacon_state::progressive_balances_cache::*;
 pub use crate::beacon_state::slashings_cache::SlashingsCache;
-pub use clone_config::CloneConfig;
 pub use eth_spec::*;
 pub use iter::BlockRootsIter;
-pub use tree_hash_cache::BeaconTreeHashCache;
+pub use milhouse::{interface::Interface, List, Vector};
 
 #[macro_use]
 mod committee_cache;
 mod balance;
-mod clone_config;
 mod exit_cache;
 mod iter;
 mod progressive_balances_cache;
 mod pubkey_cache;
 mod slashings_cache;
 mod tests;
-mod tree_hash_cache;
 
 pub const CACHED_EPOCHS: usize = 3;
 const MAX_RANDOM_BYTE: u64 = (1 << 8) - 1;
 
-pub type Validators<T> = VariableList<Validator, <T as EthSpec>::ValidatorRegistryLimit>;
-pub type Balances<T> = VariableList<u64, <T as EthSpec>::ValidatorRegistryLimit>;
+pub type Validators<E> = List<Validator, <E as EthSpec>::ValidatorRegistryLimit>;
+pub type Balances<E> = List<u64, <E as EthSpec>::ValidatorRegistryLimit>;
 
 #[derive(Debug, PartialEq, Clone)]
 pub enum Error {
@@ -144,6 +142,20 @@ pub enum Error {
         current_epoch: Epoch,
         epoch: Epoch,
     },
+    MilhouseError(milhouse::Error),
+    CommitteeCacheDiffInvalidEpoch {
+        prev_current_epoch: Epoch,
+        current_epoch: Epoch,
+    },
+    CommitteeCacheDiffUninitialized {
+        expected_epoch: Epoch,
+    },
+    DiffAcrossFork {
+        prev_fork: ForkName,
+        current_fork: ForkName,
+    },
+    TotalActiveBalanceDiffUninitialized,
+    MissingImmutableValidator(usize),
     IndexNotSupported(usize),
     InvalidFlagIndex(usize),
     MerkleTreeError(merkle_proof::MerkleTreeError),
@@ -194,7 +206,7 @@ impl From<BeaconStateHash> for Hash256 {
 
 /// The state of the `BeaconChain` at some slot.
 #[superstruct(
-    variants(Base, Altair, Merge, Capella, Deneb, Electra),
+    variants(Base, Altair, Bellatrix, Capella, Deneb, Electra),
     variant_attributes(
         derive(
             Derivative,
@@ -207,16 +219,105 @@ impl From<BeaconStateHash> for Hash256 {
             TreeHash,
             TestRandom,
             CompareFields,
-            arbitrary::Arbitrary
+            arbitrary::Arbitrary,
         ),
         serde(bound = "E: EthSpec", deny_unknown_fields),
         arbitrary(bound = "E: EthSpec"),
         derivative(Clone),
     ),
+    specific_variant_attributes(
+        Base(metastruct(
+            mappings(
+                map_beacon_state_base_fields(),
+                map_beacon_state_base_tree_list_fields(mutable, fallible, groups(tree_lists)),
+                map_beacon_state_base_tree_list_fields_immutable(groups(tree_lists)),
+            ),
+            bimappings(bimap_beacon_state_base_tree_list_fields(
+                other_type = "BeaconStateBase",
+                self_mutable,
+                fallible,
+                groups(tree_lists)
+            )),
+            num_fields(all()),
+        )),
+        Altair(metastruct(
+            mappings(
+                map_beacon_state_altair_fields(),
+                map_beacon_state_altair_tree_list_fields(mutable, fallible, groups(tree_lists)),
+                map_beacon_state_altair_tree_list_fields_immutable(groups(tree_lists)),
+            ),
+            bimappings(bimap_beacon_state_altair_tree_list_fields(
+                other_type = "BeaconStateAltair",
+                self_mutable,
+                fallible,
+                groups(tree_lists)
+            )),
+            num_fields(all()),
+        )),
+        Bellatrix(metastruct(
+            mappings(
+                map_beacon_state_bellatrix_fields(),
+                map_beacon_state_bellatrix_tree_list_fields(mutable, fallible, groups(tree_lists)),
+                map_beacon_state_bellatrix_tree_list_fields_immutable(groups(tree_lists)),
+            ),
+            bimappings(bimap_beacon_state_bellatrix_tree_list_fields(
+                other_type = "BeaconStateBellatrix",
+                self_mutable,
+                fallible,
+                groups(tree_lists)
+            )),
+            num_fields(all()),
+        )),
+        Capella(metastruct(
+            mappings(
+                map_beacon_state_capella_fields(),
+                map_beacon_state_capella_tree_list_fields(mutable, fallible, groups(tree_lists)),
+                map_beacon_state_capella_tree_list_fields_immutable(groups(tree_lists)),
+            ),
+            bimappings(bimap_beacon_state_capella_tree_list_fields(
+                other_type = "BeaconStateCapella",
+                self_mutable,
+                fallible,
+                groups(tree_lists)
+            )),
+            num_fields(all()),
+        )),
+        Deneb(metastruct(
+            mappings(
+                map_beacon_state_deneb_fields(),
+                map_beacon_state_deneb_tree_list_fields(mutable, fallible, groups(tree_lists)),
+                map_beacon_state_deneb_tree_list_fields_immutable(groups(tree_lists)),
+            ),
+            bimappings(bimap_beacon_state_deneb_tree_list_fields(
+                other_type = "BeaconStateDeneb",
+                self_mutable,
+                fallible,
+                groups(tree_lists)
+            )),
+            num_fields(all()),
+        )),
+        Electra(metastruct(
+            mappings(
+                map_beacon_state_electra_fields(),
+                map_beacon_state_electra_tree_list_fields(mutable, fallible, groups(tree_lists)),
+                map_beacon_state_electra_tree_list_fields_immutable(groups(tree_lists)),
+            ),
+            bimappings(bimap_beacon_state_electra_tree_list_fields(
+                other_type = "BeaconStateElectra",
+                self_mutable,
+                fallible,
+                groups(tree_lists)
+            )),
+            num_fields(all()),
+        ))
+    ),
     cast_error(ty = "Error", expr = "Error::IncorrectStateVariant"),
-    partial_getter_error(ty = "Error", expr = "Error::IncorrectStateVariant")
+    partial_getter_error(ty = "Error", expr = "Error::IncorrectStateVariant"),
+    map_ref_mut_into(BeaconStateRef)
+)]
+#[derive(
+    Debug, PartialEq, Clone, Serialize, Deserialize, Encode, TreeHash, arbitrary::Arbitrary,
 )]
-#[derive(Debug, PartialEq, Serialize, Deserialize, Encode, TreeHash, arbitrary::Arbitrary)]
 #[serde(untagged)]
 #[serde(bound = "E: EthSpec")]
 #[arbitrary(bound = "E: EthSpec")]
@@ -228,166 +329,222 @@ where
 {
     // Versioning
     #[superstruct(getter(copy))]
+    #[metastruct(exclude_from(tree_lists))]
     #[serde(with = "serde_utils::quoted_u64")]
     pub genesis_time: u64,
     #[superstruct(getter(copy))]
+    #[metastruct(exclude_from(tree_lists))]
     pub genesis_validators_root: Hash256,
     #[superstruct(getter(copy))]
+    #[metastruct(exclude_from(tree_lists))]
     pub slot: Slot,
     #[superstruct(getter(copy))]
+    #[metastruct(exclude_from(tree_lists))]
     pub fork: Fork,
 
     // History
+    #[metastruct(exclude_from(tree_lists))]
     pub latest_block_header: BeaconBlockHeader,
-    #[compare_fields(as_slice)]
-    pub block_roots: FixedVector<Hash256, E::SlotsPerHistoricalRoot>,
-    #[compare_fields(as_slice)]
-    pub state_roots: FixedVector<Hash256, E::SlotsPerHistoricalRoot>,
+    #[test_random(default)]
+    #[compare_fields(as_iter)]
+    pub block_roots: Vector<Hash256, E::SlotsPerHistoricalRoot>,
+    #[test_random(default)]
+    #[compare_fields(as_iter)]
+    pub state_roots: Vector<Hash256, E::SlotsPerHistoricalRoot>,
     // Frozen in Capella, replaced by historical_summaries
-    pub historical_roots: VariableList<Hash256, E::HistoricalRootsLimit>,
+    #[test_random(default)]
+    #[compare_fields(as_iter)]
+    pub historical_roots: List<Hash256, E::HistoricalRootsLimit>,
 
     // Ethereum 1.0 chain data
+    #[metastruct(exclude_from(tree_lists))]
     pub eth1_data: Eth1Data,
-    pub eth1_data_votes: VariableList<Eth1Data, E::SlotsPerEth1VotingPeriod>,
+    #[test_random(default)]
+    pub eth1_data_votes: List<Eth1Data, E::SlotsPerEth1VotingPeriod>,
     #[superstruct(getter(copy))]
+    #[metastruct(exclude_from(tree_lists))]
     #[serde(with = "serde_utils::quoted_u64")]
     pub eth1_deposit_index: u64,
 
     // Registry
-    #[compare_fields(as_slice)]
-    pub validators: VariableList<Validator, E::ValidatorRegistryLimit>,
-    #[compare_fields(as_slice)]
+    #[test_random(default)]
+    pub validators: List<Validator, E::ValidatorRegistryLimit>,
     #[serde(with = "ssz_types::serde_utils::quoted_u64_var_list")]
-    pub balances: VariableList<u64, E::ValidatorRegistryLimit>,
+    #[compare_fields(as_iter)]
+    #[test_random(default)]
+    pub balances: List<u64, E::ValidatorRegistryLimit>,
 
     // Randomness
-    pub randao_mixes: FixedVector<Hash256, E::EpochsPerHistoricalVector>,
+    #[test_random(default)]
+    pub randao_mixes: Vector<Hash256, E::EpochsPerHistoricalVector>,
 
     // Slashings
+    #[test_random(default)]
     #[serde(with = "ssz_types::serde_utils::quoted_u64_fixed_vec")]
-    pub slashings: FixedVector<u64, E::EpochsPerSlashingsVector>,
+    pub slashings: Vector<u64, E::EpochsPerSlashingsVector>,
 
     // Attestations (genesis fork only)
     #[superstruct(only(Base))]
-    pub previous_epoch_attestations: VariableList<PendingAttestation<E>, E::MaxPendingAttestations>,
+    #[test_random(default)]
+    pub previous_epoch_attestations: List<PendingAttestation<E>, E::MaxPendingAttestations>,
     #[superstruct(only(Base))]
-    pub current_epoch_attestations: VariableList<PendingAttestation<E>, E::MaxPendingAttestations>,
+    #[test_random(default)]
+    pub current_epoch_attestations: List<PendingAttestation<E>, E::MaxPendingAttestations>,
 
     // Participation (Altair and later)
-    #[superstruct(only(Altair, Merge, Capella, Deneb, Electra))]
-    pub previous_epoch_participation: VariableList<ParticipationFlags, E::ValidatorRegistryLimit>,
-    #[superstruct(only(Altair, Merge, Capella, Deneb, Electra))]
-    pub current_epoch_participation: VariableList<ParticipationFlags, E::ValidatorRegistryLimit>,
+    #[superstruct(only(Altair, Bellatrix, Capella, Deneb, Electra))]
+    #[test_random(default)]
+    pub previous_epoch_participation: List<ParticipationFlags, E::ValidatorRegistryLimit>,
+    #[superstruct(only(Altair, Bellatrix, Capella, Deneb, Electra))]
+    #[test_random(default)]
+    pub current_epoch_participation: List<ParticipationFlags, E::ValidatorRegistryLimit>,
 
     // Finality
     #[test_random(default)]
+    #[metastruct(exclude_from(tree_lists))]
     pub justification_bits: BitVector<E::JustificationBitsLength>,
     #[superstruct(getter(copy))]
+    #[metastruct(exclude_from(tree_lists))]
     pub previous_justified_checkpoint: Checkpoint,
     #[superstruct(getter(copy))]
+    #[metastruct(exclude_from(tree_lists))]
     pub current_justified_checkpoint: Checkpoint,
     #[superstruct(getter(copy))]
+    #[metastruct(exclude_from(tree_lists))]
     pub finalized_checkpoint: Checkpoint,
 
     // Inactivity
     #[serde(with = "ssz_types::serde_utils::quoted_u64_var_list")]
-    #[superstruct(only(Altair, Merge, Capella, Deneb, Electra))]
-    pub inactivity_scores: VariableList<u64, E::ValidatorRegistryLimit>,
+    #[superstruct(only(Altair, Bellatrix, Capella, Deneb, Electra))]
+    #[test_random(default)]
+    pub inactivity_scores: List<u64, E::ValidatorRegistryLimit>,
 
     // Light-client sync committees
-    #[superstruct(only(Altair, Merge, Capella, Deneb, Electra))]
+    #[superstruct(only(Altair, Bellatrix, Capella, Deneb, Electra))]
+    #[metastruct(exclude_from(tree_lists))]
     pub current_sync_committee: Arc<SyncCommittee<E>>,
-    #[superstruct(only(Altair, Merge, Capella, Deneb, Electra))]
+    #[superstruct(only(Altair, Bellatrix, Capella, Deneb, Electra))]
+    #[metastruct(exclude_from(tree_lists))]
     pub next_sync_committee: Arc<SyncCommittee<E>>,
 
     // Execution
     #[superstruct(
-        only(Merge),
-        partial_getter(rename = "latest_execution_payload_header_merge")
+        only(Bellatrix),
+        partial_getter(rename = "latest_execution_payload_header_bellatrix")
     )]
-    pub latest_execution_payload_header: ExecutionPayloadHeaderMerge<E>,
+    #[metastruct(exclude_from(tree_lists))]
+    pub latest_execution_payload_header: ExecutionPayloadHeaderBellatrix<E>,
     #[superstruct(
         only(Capella),
         partial_getter(rename = "latest_execution_payload_header_capella")
     )]
+    #[metastruct(exclude_from(tree_lists))]
     pub latest_execution_payload_header: ExecutionPayloadHeaderCapella<E>,
     #[superstruct(
         only(Deneb),
         partial_getter(rename = "latest_execution_payload_header_deneb")
     )]
+    #[metastruct(exclude_from(tree_lists))]
     pub latest_execution_payload_header: ExecutionPayloadHeaderDeneb<E>,
     #[superstruct(
         only(Electra),
         partial_getter(rename = "latest_execution_payload_header_electra")
     )]
+    #[metastruct(exclude_from(tree_lists))]
     pub latest_execution_payload_header: ExecutionPayloadHeaderElectra<E>,
 
     // Capella
     #[superstruct(only(Capella, Deneb, Electra), partial_getter(copy))]
     #[serde(with = "serde_utils::quoted_u64")]
+    #[metastruct(exclude_from(tree_lists))]
     pub next_withdrawal_index: u64,
     #[superstruct(only(Capella, Deneb, Electra), partial_getter(copy))]
     #[serde(with = "serde_utils::quoted_u64")]
+    #[metastruct(exclude_from(tree_lists))]
     pub next_withdrawal_validator_index: u64,
     // Deep history valid from Capella onwards.
     #[superstruct(only(Capella, Deneb, Electra))]
-    pub historical_summaries: VariableList<HistoricalSummary, E::HistoricalRootsLimit>,
+    #[test_random(default)]
+    pub historical_summaries: List<HistoricalSummary, E::HistoricalRootsLimit>,
+
+    // Electra
+    #[superstruct(only(Electra), partial_getter(copy))]
+    #[metastruct(exclude_from(tree_lists))]
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub deposit_receipts_start_index: u64,
+    #[superstruct(only(Electra), partial_getter(copy))]
+    #[metastruct(exclude_from(tree_lists))]
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub deposit_balance_to_consume: u64,
+    #[superstruct(only(Electra), partial_getter(copy))]
+    #[metastruct(exclude_from(tree_lists))]
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub exit_balance_to_consume: u64,
+    #[superstruct(only(Electra), partial_getter(copy))]
+    #[metastruct(exclude_from(tree_lists))]
+    pub earliest_exit_epoch: Epoch,
+    #[superstruct(only(Electra), partial_getter(copy))]
+    #[metastruct(exclude_from(tree_lists))]
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub consolidation_balance_to_consume: u64,
+    #[superstruct(only(Electra), partial_getter(copy))]
+    #[metastruct(exclude_from(tree_lists))]
+    pub earliest_consolidation_epoch: Epoch,
+    #[test_random(default)]
+    #[superstruct(only(Electra))]
+    pub pending_balance_deposits: List<PendingBalanceDeposit, E::PendingBalanceDepositsLimit>,
+    #[test_random(default)]
+    #[superstruct(only(Electra))]
+    pub pending_partial_withdrawals:
+        List<PendingPartialWithdrawal, E::PendingPartialWithdrawalsLimit>,
+    #[test_random(default)]
+    #[superstruct(only(Electra))]
+    pub pending_consolidations: List<PendingConsolidation, E::PendingConsolidationsLimit>,
 
     // Caching (not in the spec)
     #[serde(skip_serializing, skip_deserializing)]
     #[ssz(skip_serializing, skip_deserializing)]
     #[tree_hash(skip_hashing)]
     #[test_random(default)]
-    #[derivative(Clone(clone_with = "clone_default"))]
+    #[metastruct(exclude)]
     pub total_active_balance: Option<(Epoch, u64)>,
     #[serde(skip_serializing, skip_deserializing)]
     #[ssz(skip_serializing, skip_deserializing)]
     #[tree_hash(skip_hashing)]
     #[test_random(default)]
-    #[derivative(Clone(clone_with = "clone_default"))]
-    pub progressive_balances_cache: ProgressiveBalancesCache,
+    #[metastruct(exclude)]
+    pub committee_caches: [Arc<CommitteeCache>; CACHED_EPOCHS],
     #[serde(skip_serializing, skip_deserializing)]
     #[ssz(skip_serializing, skip_deserializing)]
     #[tree_hash(skip_hashing)]
     #[test_random(default)]
-    #[derivative(Clone(clone_with = "clone_default"))]
-    pub committee_caches: [CommitteeCache; CACHED_EPOCHS],
+    #[metastruct(exclude)]
+    pub progressive_balances_cache: ProgressiveBalancesCache,
     #[serde(skip_serializing, skip_deserializing)]
     #[ssz(skip_serializing, skip_deserializing)]
     #[tree_hash(skip_hashing)]
     #[test_random(default)]
-    #[derivative(Clone(clone_with = "clone_default"))]
+    #[metastruct(exclude)]
     pub pubkey_cache: PubkeyCache,
     #[serde(skip_serializing, skip_deserializing)]
     #[ssz(skip_serializing, skip_deserializing)]
     #[tree_hash(skip_hashing)]
     #[test_random(default)]
-    #[derivative(Clone(clone_with = "clone_default"))]
+    #[metastruct(exclude)]
     pub exit_cache: ExitCache,
     #[serde(skip_serializing, skip_deserializing)]
     #[ssz(skip_serializing, skip_deserializing)]
     #[tree_hash(skip_hashing)]
     #[test_random(default)]
-    #[derivative(Clone(clone_with = "clone_default"))]
+    #[metastruct(exclude)]
     pub slashings_cache: SlashingsCache,
     /// Epoch cache of values that are useful for block processing that are static over an epoch.
     #[serde(skip_serializing, skip_deserializing)]
     #[ssz(skip_serializing, skip_deserializing)]
     #[tree_hash(skip_hashing)]
     #[test_random(default)]
+    #[metastruct(exclude)]
     pub epoch_cache: EpochCache,
-    #[serde(skip_serializing, skip_deserializing)]
-    #[ssz(skip_serializing, skip_deserializing)]
-    #[tree_hash(skip_hashing)]
-    #[test_random(default)]
-    #[derivative(Clone(clone_with = "clone_default"))]
-    pub tree_hash_cache: BeaconTreeHashCache<E>,
-}
-
-impl<E: EthSpec> Clone for BeaconState<E> {
-    fn clone(&self) -> Self {
-        self.clone_with(CloneConfig::all())
-    }
 }
 
 impl<E: EthSpec> BeaconState<E> {
@@ -395,6 +552,7 @@ impl<E: EthSpec> BeaconState<E> {
     ///
     /// Not a complete genesis state, see `initialize_beacon_state_from_eth1`.
     pub fn new(genesis_time: u64, eth1_data: Eth1Data, spec: &ChainSpec) -> Self {
+        let default_committee_cache = Arc::new(CommitteeCache::default());
         BeaconState::Base(BeaconStateBase {
             // Versioning
             genesis_time,
@@ -408,28 +566,28 @@ impl<E: EthSpec> BeaconState<E> {
 
             // History
             latest_block_header: BeaconBlock::<E>::empty(spec).temporary_block_header(),
-            block_roots: FixedVector::from_elem(Hash256::zero()),
-            state_roots: FixedVector::from_elem(Hash256::zero()),
-            historical_roots: VariableList::empty(),
+            block_roots: Vector::default(),
+            state_roots: Vector::default(),
+            historical_roots: List::default(),
 
             // Eth1
             eth1_data,
-            eth1_data_votes: VariableList::empty(),
+            eth1_data_votes: List::default(),
             eth1_deposit_index: 0,
 
             // Validator registry
-            validators: VariableList::empty(), // Set later.
-            balances: VariableList::empty(),   // Set later.
+            validators: List::default(), // Set later.
+            balances: List::default(),   // Set later.
 
             // Randomness
-            randao_mixes: FixedVector::from_elem(Hash256::zero()),
+            randao_mixes: Vector::default(),
 
             // Slashings
-            slashings: FixedVector::from_elem(0),
+            slashings: Vector::default(),
 
             // Attestations
-            previous_epoch_attestations: VariableList::empty(),
-            current_epoch_attestations: VariableList::empty(),
+            previous_epoch_attestations: List::default(),
+            current_epoch_attestations: List::default(),
 
             // Finality
             justification_bits: BitVector::new(),
@@ -441,15 +599,14 @@ impl<E: EthSpec> BeaconState<E> {
             total_active_balance: None,
             progressive_balances_cache: <_>::default(),
             committee_caches: [
-                CommitteeCache::default(),
-                CommitteeCache::default(),
-                CommitteeCache::default(),
+                default_committee_cache.clone(),
+                default_committee_cache.clone(),
+                default_committee_cache,
             ],
             pubkey_cache: PubkeyCache::default(),
             exit_cache: ExitCache::default(),
             slashings_cache: SlashingsCache::default(),
             epoch_cache: EpochCache::default(),
-            tree_hash_cache: <_>::default(),
         })
     }
 
@@ -478,37 +635,13 @@ impl<E: EthSpec> BeaconState<E> {
         match self {
             BeaconState::Base { .. } => ForkName::Base,
             BeaconState::Altair { .. } => ForkName::Altair,
-            BeaconState::Merge { .. } => ForkName::Merge,
+            BeaconState::Bellatrix { .. } => ForkName::Bellatrix,
             BeaconState::Capella { .. } => ForkName::Capella,
             BeaconState::Deneb { .. } => ForkName::Deneb,
             BeaconState::Electra { .. } => ForkName::Electra,
         }
     }
 
-    /// Specialised deserialisation method that uses the `ChainSpec` as context.
-    #[allow(clippy::arithmetic_side_effects)]
-    pub fn from_ssz_bytes(bytes: &[u8], spec: &ChainSpec) -> Result<Self, ssz::DecodeError> {
-        // Slot is after genesis_time (u64) and genesis_validators_root (Hash256).
-        let slot_start = <u64 as Decode>::ssz_fixed_len() + <Hash256 as Decode>::ssz_fixed_len();
-        let slot_end = slot_start + <Slot as Decode>::ssz_fixed_len();
-
-        let slot_bytes = bytes
-            .get(slot_start..slot_end)
-            .ok_or(DecodeError::InvalidByteLength {
-                len: bytes.len(),
-                expected: slot_end,
-            })?;
-
-        let slot = Slot::from_ssz_bytes(slot_bytes)?;
-        let fork_at_slot = spec.fork_name_at_slot::<E>(slot);
-
-        Ok(map_fork_name!(
-            fork_at_slot,
-            Self,
-            <_>::from_ssz_bytes(bytes)?
-        ))
-    }
-
     /// Returns the `tree_hash_root` of the state.
     ///
     /// Spec v0.12.1
@@ -516,11 +649,15 @@ impl<E: EthSpec> BeaconState<E> {
         Hash256::from_slice(&self.tree_hash_root()[..])
     }
 
-    pub fn historical_batch(&self) -> HistoricalBatch<E> {
-        HistoricalBatch {
+    pub fn historical_batch(&mut self) -> Result<HistoricalBatch<E>, Error> {
+        // Updating before cloning makes the clone cheap and saves repeated hashing.
+        self.block_roots_mut().apply_updates()?;
+        self.state_roots_mut().apply_updates()?;
+
+        Ok(HistoricalBatch {
             block_roots: self.block_roots().clone(),
             state_roots: self.state_roots().clone(),
-        }
+        })
     }
 
     /// This method ensures the state's pubkey cache is fully up-to-date before checking if the validator
@@ -781,7 +918,7 @@ impl<E: EthSpec> BeaconState<E> {
     pub fn latest_execution_payload_header(&self) -> Result<ExecutionPayloadHeaderRef<E>, Error> {
         match self {
             BeaconState::Base(_) | BeaconState::Altair(_) => Err(Error::IncorrectStateVariant),
-            BeaconState::Merge(state) => Ok(ExecutionPayloadHeaderRef::Merge(
+            BeaconState::Bellatrix(state) => Ok(ExecutionPayloadHeaderRef::Bellatrix(
                 &state.latest_execution_payload_header,
             )),
             BeaconState::Capella(state) => Ok(ExecutionPayloadHeaderRef::Capella(
@@ -801,7 +938,7 @@ impl<E: EthSpec> BeaconState<E> {
     ) -> Result<ExecutionPayloadHeaderRefMut<E>, Error> {
         match self {
             BeaconState::Base(_) | BeaconState::Altair(_) => Err(Error::IncorrectStateVariant),
-            BeaconState::Merge(state) => Ok(ExecutionPayloadHeaderRefMut::Merge(
+            BeaconState::Bellatrix(state) => Ok(ExecutionPayloadHeaderRefMut::Bellatrix(
                 &mut state.latest_execution_payload_header,
             )),
             BeaconState::Capella(state) => Ok(ExecutionPayloadHeaderRefMut::Capella(
@@ -1079,8 +1216,9 @@ impl<E: EthSpec> BeaconState<E> {
     }
 
     /// Fill `randao_mixes` with
-    pub fn fill_randao_mixes_with(&mut self, index_root: Hash256) {
-        *self.randao_mixes_mut() = FixedVector::from_elem(index_root);
+    pub fn fill_randao_mixes_with(&mut self, index_root: Hash256) -> Result<(), Error> {
+        *self.randao_mixes_mut() = Vector::from_elem(index_root)?;
+        Ok(())
     }
 
     /// Safely obtains the index for `randao_mixes`
@@ -1213,7 +1351,7 @@ impl<E: EthSpec> BeaconState<E> {
     }
 
     /// Get a reference to the entire `slashings` vector.
-    pub fn get_all_slashings(&self) -> &[u64] {
+    pub fn get_all_slashings(&self) -> &Vector<u64, E::EpochsPerSlashingsVector> {
         self.slashings()
     }
 
@@ -1237,45 +1375,25 @@ impl<E: EthSpec> BeaconState<E> {
     }
 
     /// Convenience accessor for validators and balances simultaneously.
-    pub fn validators_and_balances_and_progressive_balances_mut(
-        &mut self,
+    pub fn validators_and_balances_and_progressive_balances_mut<'a>(
+        &'a mut self,
     ) -> (
-        &mut Validators<E>,
-        &mut Balances<E>,
-        &mut ProgressiveBalancesCache,
+        &'a mut Validators<E>,
+        &'a mut Balances<E>,
+        &'a mut ProgressiveBalancesCache,
     ) {
-        match self {
-            BeaconState::Base(state) => (
-                &mut state.validators,
-                &mut state.balances,
-                &mut state.progressive_balances_cache,
-            ),
-            BeaconState::Altair(state) => (
-                &mut state.validators,
-                &mut state.balances,
-                &mut state.progressive_balances_cache,
-            ),
-            BeaconState::Merge(state) => (
-                &mut state.validators,
-                &mut state.balances,
-                &mut state.progressive_balances_cache,
-            ),
-            BeaconState::Capella(state) => (
-                &mut state.validators,
-                &mut state.balances,
-                &mut state.progressive_balances_cache,
-            ),
-            BeaconState::Deneb(state) => (
-                &mut state.validators,
-                &mut state.balances,
-                &mut state.progressive_balances_cache,
-            ),
-            BeaconState::Electra(state) => (
-                &mut state.validators,
-                &mut state.balances,
-                &mut state.progressive_balances_cache,
-            ),
-        }
+        map_beacon_state_ref_mut_into_beacon_state_ref!(&'a _, self.to_mut(), |inner, cons| {
+            if false {
+                cons(&*inner);
+                unreachable!()
+            } else {
+                (
+                    &mut inner.validators,
+                    &mut inner.balances,
+                    &mut inner.progressive_balances_cache,
+                )
+            }
+        })
     }
 
     #[allow(clippy::type_complexity)]
@@ -1285,9 +1403,9 @@ impl<E: EthSpec> BeaconState<E> {
         (
             &mut Validators<E>,
             &mut Balances<E>,
-            &VariableList<ParticipationFlags, E::ValidatorRegistryLimit>,
-            &VariableList<ParticipationFlags, E::ValidatorRegistryLimit>,
-            &mut VariableList<u64, E::ValidatorRegistryLimit>,
+            &List<ParticipationFlags, E::ValidatorRegistryLimit>,
+            &List<ParticipationFlags, E::ValidatorRegistryLimit>,
+            &mut List<u64, E::ValidatorRegistryLimit>,
             &mut ProgressiveBalancesCache,
             &mut ExitCache,
             &mut EpochCache,
@@ -1306,7 +1424,7 @@ impl<E: EthSpec> BeaconState<E> {
                 &mut state.exit_cache,
                 &mut state.epoch_cache,
             )),
-            BeaconState::Merge(state) => Ok((
+            BeaconState::Bellatrix(state) => Ok((
                 &mut state.validators,
                 &mut state.balances,
                 &state.previous_epoch_participation,
@@ -1349,6 +1467,13 @@ impl<E: EthSpec> BeaconState<E> {
         }
     }
 
+    /// Get a mutable reference to the balance of a single validator.
+    pub fn get_balance_mut(&mut self, validator_index: usize) -> Result<&mut u64, Error> {
+        self.balances_mut()
+            .get_mut(validator_index)
+            .ok_or(Error::BalancesOutOfBounds(validator_index))
+    }
+
     /// Generate a seed for the given `epoch`.
     pub fn get_seed(
         &self,
@@ -1398,6 +1523,16 @@ impl<E: EthSpec> BeaconState<E> {
             .ok_or(Error::UnknownValidator(validator_index))
     }
 
+    /// Safe copy-on-write accessor for the `validators` list.
+    pub fn get_validator_cow(
+        &mut self,
+        validator_index: usize,
+    ) -> Result<milhouse::Cow<Validator>, Error> {
+        self.validators_mut()
+            .get_cow(validator_index)
+            .ok_or(Error::UnknownValidator(validator_index))
+    }
+
     /// Return the effective balance for a validator with the given `validator_index`.
     pub fn get_effective_balance(&self, validator_index: usize) -> Result<u64, Error> {
         self.get_validator(validator_index)
@@ -1423,13 +1558,6 @@ impl<E: EthSpec> BeaconState<E> {
             .ok_or(Error::InactivityScoresOutOfBounds(validator_index))
     }
 
-    /// Get a mutable reference to the balance of a single validator.
-    pub fn get_balance_mut(&mut self, validator_index: usize) -> Result<&mut u64, Error> {
-        self.balances_mut()
-            .get_mut(validator_index)
-            .ok_or(Error::BalancesOutOfBounds(validator_index))
-    }
-
     ///  Return the epoch at which an activation or exit triggered in ``epoch`` takes effect.
     ///
     ///  Spec v0.12.1
@@ -1444,7 +1572,7 @@ impl<E: EthSpec> BeaconState<E> {
     /// Return the churn limit for the current epoch (number of validators who can leave per epoch).
     ///
     /// Uses the current epoch committee cache, and will error if it isn't initialized.
-    pub fn get_churn_limit(&self, spec: &ChainSpec) -> Result<u64, Error> {
+    pub fn get_validator_churn_limit(&self, spec: &ChainSpec) -> Result<u64, Error> {
         Ok(std::cmp::max(
             spec.min_per_epoch_churn_limit,
             (self
@@ -1461,11 +1589,11 @@ impl<E: EthSpec> BeaconState<E> {
         Ok(match self {
             BeaconState::Base(_)
             | BeaconState::Altair(_)
-            | BeaconState::Merge(_)
-            | BeaconState::Capella(_) => self.get_churn_limit(spec)?,
+            | BeaconState::Bellatrix(_)
+            | BeaconState::Capella(_) => self.get_validator_churn_limit(spec)?,
             BeaconState::Deneb(_) | BeaconState::Electra(_) => std::cmp::min(
                 spec.max_per_epoch_activation_churn_limit,
-                self.get_churn_limit(spec)?,
+                self.get_validator_churn_limit(spec)?,
             ),
         })
     }
@@ -1575,12 +1703,12 @@ impl<E: EthSpec> BeaconState<E> {
         epoch: Epoch,
         previous_epoch: Epoch,
         current_epoch: Epoch,
-    ) -> Result<&mut VariableList<ParticipationFlags, E::ValidatorRegistryLimit>, Error> {
+    ) -> Result<&mut List<ParticipationFlags, E::ValidatorRegistryLimit>, Error> {
         if epoch == current_epoch {
             match self {
                 BeaconState::Base(_) => Err(BeaconStateError::IncorrectStateVariant),
                 BeaconState::Altair(state) => Ok(&mut state.current_epoch_participation),
-                BeaconState::Merge(state) => Ok(&mut state.current_epoch_participation),
+                BeaconState::Bellatrix(state) => Ok(&mut state.current_epoch_participation),
                 BeaconState::Capella(state) => Ok(&mut state.current_epoch_participation),
                 BeaconState::Deneb(state) => Ok(&mut state.current_epoch_participation),
                 BeaconState::Electra(state) => Ok(&mut state.current_epoch_participation),
@@ -1589,7 +1717,7 @@ impl<E: EthSpec> BeaconState<E> {
             match self {
                 BeaconState::Base(_) => Err(BeaconStateError::IncorrectStateVariant),
                 BeaconState::Altair(state) => Ok(&mut state.previous_epoch_participation),
-                BeaconState::Merge(state) => Ok(&mut state.previous_epoch_participation),
+                BeaconState::Bellatrix(state) => Ok(&mut state.previous_epoch_participation),
                 BeaconState::Capella(state) => Ok(&mut state.previous_epoch_participation),
                 BeaconState::Deneb(state) => Ok(&mut state.previous_epoch_participation),
                 BeaconState::Electra(state) => Ok(&mut state.previous_epoch_participation),
@@ -1659,7 +1787,6 @@ impl<E: EthSpec> BeaconState<E> {
         self.drop_committee_cache(RelativeEpoch::Current)?;
         self.drop_committee_cache(RelativeEpoch::Next)?;
         self.drop_pubkey_cache();
-        self.drop_tree_hash_cache();
         self.drop_progressive_balances_cache();
         *self.exit_cache_mut() = ExitCache::default();
         *self.slashings_cache_mut() = SlashingsCache::default();
@@ -1718,7 +1845,7 @@ impl<E: EthSpec> BeaconState<E> {
         &self,
         epoch: Epoch,
         spec: &ChainSpec,
-    ) -> Result<CommitteeCache, Error> {
+    ) -> Result<Arc<CommitteeCache>, Error> {
         CommitteeCache::initialized(self, epoch, spec)
     }
 
@@ -1732,7 +1859,7 @@ impl<E: EthSpec> BeaconState<E> {
         self.committee_caches_mut().rotate_left(1);
 
         let next = Self::committee_cache_index(RelativeEpoch::Next);
-        *self.committee_cache_at_index_mut(next)? = CommitteeCache::default();
+        *self.committee_cache_at_index_mut(next)? = Arc::new(CommitteeCache::default());
         Ok(())
     }
 
@@ -1747,21 +1874,24 @@ impl<E: EthSpec> BeaconState<E> {
     /// Get the committee cache for some `slot`.
     ///
     /// Return an error if the cache for the slot's epoch is not initialized.
-    fn committee_cache_at_slot(&self, slot: Slot) -> Result<&CommitteeCache, Error> {
+    fn committee_cache_at_slot(&self, slot: Slot) -> Result<&Arc<CommitteeCache>, Error> {
         let epoch = slot.epoch(E::slots_per_epoch());
         let relative_epoch = RelativeEpoch::from_epoch(self.current_epoch(), epoch)?;
         self.committee_cache(relative_epoch)
     }
 
     /// Get the committee cache at a given index.
-    fn committee_cache_at_index(&self, index: usize) -> Result<&CommitteeCache, Error> {
+    fn committee_cache_at_index(&self, index: usize) -> Result<&Arc<CommitteeCache>, Error> {
         self.committee_caches()
             .get(index)
             .ok_or(Error::CommitteeCachesOutOfBounds(index))
     }
 
     /// Get a mutable reference to the committee cache at a given index.
-    fn committee_cache_at_index_mut(&mut self, index: usize) -> Result<&mut CommitteeCache, Error> {
+    fn committee_cache_at_index_mut(
+        &mut self,
+        index: usize,
+    ) -> Result<&mut Arc<CommitteeCache>, Error> {
         self.committee_caches_mut()
             .get_mut(index)
             .ok_or(Error::CommitteeCachesOutOfBounds(index))
@@ -1769,7 +1899,10 @@ impl<E: EthSpec> BeaconState<E> {
 
     /// Returns the cache for some `RelativeEpoch`. Returns an error if the cache has not been
     /// initialized.
-    pub fn committee_cache(&self, relative_epoch: RelativeEpoch) -> Result<&CommitteeCache, Error> {
+    pub fn committee_cache(
+        &self,
+        relative_epoch: RelativeEpoch,
+    ) -> Result<&Arc<CommitteeCache>, Error> {
         let i = Self::committee_cache_index(relative_epoch);
         let cache = self.committee_cache_at_index(i)?;
 
@@ -1780,30 +1913,10 @@ impl<E: EthSpec> BeaconState<E> {
         }
     }
 
-    /// Returns the cache for some `RelativeEpoch`, replacing the existing cache with an
-    /// un-initialized cache. Returns an error if the existing cache has not been initialized.
-    pub fn take_committee_cache(
-        &mut self,
-        relative_epoch: RelativeEpoch,
-    ) -> Result<CommitteeCache, Error> {
-        let i = Self::committee_cache_index(relative_epoch);
-        let current_epoch = self.current_epoch();
-        let cache = self
-            .committee_caches_mut()
-            .get_mut(i)
-            .ok_or(Error::CommitteeCachesOutOfBounds(i))?;
-
-        if cache.is_initialized_at(relative_epoch.into_epoch(current_epoch)) {
-            Ok(mem::take(cache))
-        } else {
-            Err(Error::CommitteeCacheUninitialized(Some(relative_epoch)))
-        }
-    }
-
     /// Drops the cache, leaving it in an uninitialized state.
     pub fn drop_committee_cache(&mut self, relative_epoch: RelativeEpoch) -> Result<(), Error> {
         *self.committee_cache_at_index_mut(Self::committee_cache_index(relative_epoch))? =
-            CommitteeCache::default();
+            Arc::new(CommitteeCache::default());
         Ok(())
     }
 
@@ -1813,13 +1926,11 @@ impl<E: EthSpec> BeaconState<E> {
     /// never re-add a pubkey.
     pub fn update_pubkey_cache(&mut self) -> Result<(), Error> {
         let mut pubkey_cache = mem::take(self.pubkey_cache_mut());
-        for (i, validator) in self
-            .validators()
-            .iter()
-            .enumerate()
-            .skip(pubkey_cache.len())
-        {
-            let success = pubkey_cache.insert(validator.pubkey, i);
+        let start_index = pubkey_cache.len();
+
+        for (i, validator) in self.validators().iter_from(start_index)?.enumerate() {
+            let index = start_index.safe_add(i)?;
+            let success = pubkey_cache.insert(validator.pubkey, index);
             if !success {
                 return Err(Error::PubkeyCacheInconsistent);
             }
@@ -1834,96 +1945,71 @@ impl<E: EthSpec> BeaconState<E> {
         *self.pubkey_cache_mut() = PubkeyCache::default()
     }
 
+    pub fn has_pending_mutations(&self) -> bool {
+        let mut any_pending_mutations = false;
+        match &self {
+            Self::Base(self_inner) => {
+                map_beacon_state_base_tree_list_fields_immutable!(self_inner, |_, self_field| {
+                    any_pending_mutations |= self_field.has_pending_updates();
+                });
+            }
+            Self::Altair(self_inner) => {
+                map_beacon_state_altair_tree_list_fields_immutable!(self_inner, |_, self_field| {
+                    any_pending_mutations |= self_field.has_pending_updates();
+                });
+            }
+            Self::Bellatrix(self_inner) => {
+                map_beacon_state_bellatrix_tree_list_fields_immutable!(
+                    self_inner,
+                    |_, self_field| {
+                        any_pending_mutations |= self_field.has_pending_updates();
+                    }
+                );
+            }
+            Self::Capella(self_inner) => {
+                map_beacon_state_capella_tree_list_fields_immutable!(
+                    self_inner,
+                    |_, self_field| {
+                        any_pending_mutations |= self_field.has_pending_updates();
+                    }
+                );
+            }
+            Self::Deneb(self_inner) => {
+                map_beacon_state_deneb_tree_list_fields_immutable!(self_inner, |_, self_field| {
+                    any_pending_mutations |= self_field.has_pending_updates();
+                });
+            }
+            Self::Electra(self_inner) => {
+                map_beacon_state_electra_tree_list_fields_immutable!(
+                    self_inner,
+                    |_, self_field| {
+                        any_pending_mutations |= self_field.has_pending_updates();
+                    }
+                );
+            }
+        };
+        any_pending_mutations
+    }
+
     /// Completely drops the `progressive_balances_cache` cache, replacing it with a new, empty cache.
     fn drop_progressive_balances_cache(&mut self) {
         *self.progressive_balances_cache_mut() = ProgressiveBalancesCache::default();
     }
 
-    /// Initialize but don't fill the tree hash cache, if it isn't already initialized.
-    pub fn initialize_tree_hash_cache(&mut self) {
-        if !self.tree_hash_cache().is_initialized() {
-            *self.tree_hash_cache_mut() = BeaconTreeHashCache::new(self)
-        }
-    }
-
     /// Compute the tree hash root of the state using the tree hash cache.
     ///
     /// Initialize the tree hash cache if it isn't already initialized.
     pub fn update_tree_hash_cache(&mut self) -> Result<Hash256, Error> {
-        self.initialize_tree_hash_cache();
-
-        let cache = self.tree_hash_cache_mut().take();
-
-        if let Some(mut cache) = cache {
-            // Note: we return early if the tree hash fails, leaving `self.tree_hash_cache` as
-            // None. There's no need to keep a cache that fails.
-            let root = cache.recalculate_tree_hash_root(self)?;
-            self.tree_hash_cache_mut().restore(cache);
-            Ok(root)
-        } else {
-            Err(Error::TreeHashCacheNotInitialized)
-        }
+        self.apply_pending_mutations()?;
+        Ok(self.tree_hash_root())
     }
 
     /// Compute the tree hash root of the validators using the tree hash cache.
     ///
     /// Initialize the tree hash cache if it isn't already initialized.
     pub fn update_validators_tree_hash_cache(&mut self) -> Result<Hash256, Error> {
-        self.initialize_tree_hash_cache();
-
-        let cache = self.tree_hash_cache_mut().take();
-
-        if let Some(mut cache) = cache {
-            // Note: we return early if the tree hash fails, leaving `self.tree_hash_cache` as
-            // None. There's no need to keep a cache that fails.
-            let root = cache.recalculate_validators_tree_hash_root(self.validators())?;
-            self.tree_hash_cache_mut().restore(cache);
-            Ok(root)
-        } else {
-            Err(Error::TreeHashCacheNotInitialized)
-        }
-    }
-
-    /// Completely drops the tree hash cache, replacing it with a new, empty cache.
-    pub fn drop_tree_hash_cache(&mut self) {
-        self.tree_hash_cache_mut().uninitialize();
-    }
-
-    /// Clone the state whilst preserving only the selected caches.
-    pub fn clone_with(&self, config: CloneConfig) -> Self {
-        let mut res = match self {
-            BeaconState::Base(inner) => BeaconState::Base(inner.clone()),
-            BeaconState::Altair(inner) => BeaconState::Altair(inner.clone()),
-            BeaconState::Merge(inner) => BeaconState::Merge(inner.clone()),
-            BeaconState::Capella(inner) => BeaconState::Capella(inner.clone()),
-            BeaconState::Deneb(inner) => BeaconState::Deneb(inner.clone()),
-            BeaconState::Electra(inner) => BeaconState::Electra(inner.clone()),
-        };
-        if config.committee_caches {
-            res.committee_caches_mut()
-                .clone_from(self.committee_caches());
-            *res.total_active_balance_mut() = *self.total_active_balance();
-        }
-        if config.pubkey_cache {
-            *res.pubkey_cache_mut() = self.pubkey_cache().clone();
-        }
-        if config.exit_cache {
-            *res.exit_cache_mut() = self.exit_cache().clone();
-        }
-        if config.slashings_cache {
-            *res.slashings_cache_mut() = self.slashings_cache().clone();
-        }
-        if config.tree_hash_cache {
-            *res.tree_hash_cache_mut() = self.tree_hash_cache().clone();
-        }
-        if config.progressive_balances_cache {
-            *res.progressive_balances_cache_mut() = self.progressive_balances_cache().clone();
-        }
-        res
-    }
-
-    pub fn clone_with_only_committee_caches(&self) -> Self {
-        self.clone_with(CloneConfig::committee_caches_only())
+        self.validators_mut().apply_updates()?;
+        Ok(self.validators().tree_hash_root())
     }
 
     /// Passing `previous_epoch` to this function rather than computing it internally provides
@@ -1979,10 +2065,388 @@ impl<E: EthSpec> BeaconState<E> {
         self.epoch_cache().get_base_reward(validator_index)
     }
 
-    pub fn compute_merkle_proof(
+    // ******* Electra accessors *******
+
+    /// Return the churn limit for the current epoch.
+    pub fn get_balance_churn_limit(&self, spec: &ChainSpec) -> Result<u64, Error> {
+        let total_active_balance = self.get_total_active_balance()?;
+        let churn = std::cmp::max(
+            spec.min_per_epoch_churn_limit_electra,
+            total_active_balance.safe_div(spec.churn_limit_quotient)?,
+        );
+
+        Ok(churn.safe_sub(churn.safe_rem(spec.effective_balance_increment)?)?)
+    }
+
+    /// Return the churn limit for the current epoch dedicated to activations and exits.
+    pub fn get_activation_exit_churn_limit(&self, spec: &ChainSpec) -> Result<u64, Error> {
+        Ok(std::cmp::min(
+            spec.max_per_epoch_activation_exit_churn_limit,
+            self.get_balance_churn_limit(spec)?,
+        ))
+    }
+
+    pub fn get_consolidation_churn_limit(&self, spec: &ChainSpec) -> Result<u64, Error> {
+        self.get_balance_churn_limit(spec)?
+            .safe_sub(self.get_activation_exit_churn_limit(spec)?)
+            .map_err(Into::into)
+    }
+
+    /// Get active balance for the given `validator_index`.
+    pub fn get_active_balance(
+        &self,
+        validator_index: usize,
+        spec: &ChainSpec,
+    ) -> Result<u64, Error> {
+        let max_effective_balance = self
+            .validators()
+            .get(validator_index)
+            .map(|validator| validator.get_validator_max_effective_balance(spec))
+            .ok_or(Error::UnknownValidator(validator_index))?;
+        Ok(std::cmp::min(
+            *self
+                .balances()
+                .get(validator_index)
+                .ok_or(Error::UnknownValidator(validator_index))?,
+            max_effective_balance,
+        ))
+    }
+
+    pub fn get_pending_balance_to_withdraw(&self, validator_index: usize) -> Result<u64, Error> {
+        let mut pending_balance = 0;
+        for withdrawal in self
+            .pending_partial_withdrawals()?
+            .iter()
+            .filter(|withdrawal| withdrawal.index as usize == validator_index)
+        {
+            pending_balance.safe_add_assign(withdrawal.amount)?;
+        }
+        Ok(pending_balance)
+    }
+
+    // ******* Electra mutators *******
+
+    pub fn queue_excess_active_balance(
+        &mut self,
+        validator_index: usize,
+        spec: &ChainSpec,
+    ) -> Result<(), Error> {
+        let balance = self
+            .balances_mut()
+            .get_mut(validator_index)
+            .ok_or(Error::UnknownValidator(validator_index))?;
+        if *balance > spec.min_activation_balance {
+            let excess_balance = balance.safe_sub(spec.min_activation_balance)?;
+            *balance = spec.min_activation_balance;
+            self.pending_balance_deposits_mut()?
+                .push(PendingBalanceDeposit {
+                    index: validator_index as u64,
+                    amount: excess_balance,
+                })?;
+        }
+        Ok(())
+    }
+
+    pub fn queue_entire_balance_and_reset_validator(
         &mut self,
-        generalized_index: usize,
-    ) -> Result<Vec<Hash256>, Error> {
+        validator_index: usize,
+        spec: &ChainSpec,
+    ) -> Result<(), Error> {
+        let balance = self
+            .balances_mut()
+            .get_mut(validator_index)
+            .ok_or(Error::UnknownValidator(validator_index))?;
+        let balance_copy = *balance;
+        *balance = 0_u64;
+
+        let validator = self
+            .validators_mut()
+            .get_mut(validator_index)
+            .ok_or(Error::UnknownValidator(validator_index))?;
+        validator.effective_balance = 0;
+        validator.activation_eligibility_epoch = spec.far_future_epoch;
+
+        self.pending_balance_deposits_mut()?
+            .push(PendingBalanceDeposit {
+                index: validator_index as u64,
+                amount: balance_copy,
+            })
+            .map_err(Into::into)
+    }
+
+    /// Change the withdrawal prefix of the given `validator_index` to the compounding withdrawal validator prefix.
+    pub fn switch_to_compounding_validator(
+        &mut self,
+        validator_index: usize,
+        spec: &ChainSpec,
+    ) -> Result<(), Error> {
+        let validator = self
+            .validators_mut()
+            .get_mut(validator_index)
+            .ok_or(Error::UnknownValidator(validator_index))?;
+        if validator.has_eth1_withdrawal_credential(spec) {
+            validator.withdrawal_credentials.as_fixed_bytes_mut()[0] =
+                spec.compounding_withdrawal_prefix_byte;
+            self.queue_excess_active_balance(validator_index, spec)?;
+        }
+        Ok(())
+    }
+
+    pub fn compute_exit_epoch_and_update_churn(
+        &mut self,
+        exit_balance: u64,
+        spec: &ChainSpec,
+    ) -> Result<Epoch, Error> {
+        let mut earliest_exit_epoch = std::cmp::max(
+            self.earliest_exit_epoch()?,
+            self.compute_activation_exit_epoch(self.current_epoch(), spec)?,
+        );
+
+        let per_epoch_churn = self.get_activation_exit_churn_limit(spec)?;
+        // New epoch for exits
+        let mut exit_balance_to_consume = if self.earliest_exit_epoch()? < earliest_exit_epoch {
+            per_epoch_churn
+        } else {
+            self.exit_balance_to_consume()?
+        };
+
+        // Exit doesn't fit in the current earliest epoch
+        if exit_balance > exit_balance_to_consume {
+            let balance_to_process = exit_balance.safe_sub(exit_balance_to_consume)?;
+            let additional_epochs = balance_to_process
+                .safe_sub(1)?
+                .safe_div(per_epoch_churn)?
+                .safe_add(1)?;
+            earliest_exit_epoch.safe_add_assign(additional_epochs)?;
+            exit_balance_to_consume
+                .safe_add_assign(additional_epochs.safe_mul(per_epoch_churn)?)?;
+        }
+        let state = self.as_electra_mut()?;
+        // Consume the balance and update state variables
+        state.exit_balance_to_consume = exit_balance_to_consume.safe_sub(exit_balance)?;
+        state.earliest_exit_epoch = earliest_exit_epoch;
+
+        Ok(state.earliest_exit_epoch)
+    }
+
+    pub fn compute_consolidation_epoch_and_update_churn(
+        &mut self,
+        consolidation_balance: u64,
+        spec: &ChainSpec,
+    ) -> Result<Epoch, Error> {
+        let mut earliest_consolidation_epoch = std::cmp::max(
+            self.earliest_consolidation_epoch()?,
+            self.compute_activation_exit_epoch(self.current_epoch(), spec)?,
+        );
+
+        let per_epoch_consolidation_churn = self.get_consolidation_churn_limit(spec)?;
+
+        // New epoch for consolidations
+        let mut consolidation_balance_to_consume =
+            if self.earliest_consolidation_epoch()? < earliest_consolidation_epoch {
+                per_epoch_consolidation_churn
+            } else {
+                self.consolidation_balance_to_consume()?
+            };
+        // Consolidation doesn't fit in the current earliest epoch
+        if consolidation_balance > consolidation_balance_to_consume {
+            let balance_to_process =
+                consolidation_balance.safe_sub(consolidation_balance_to_consume)?;
+            let additional_epochs = balance_to_process
+                .safe_sub(1)?
+                .safe_div(per_epoch_consolidation_churn)?
+                .safe_add(1)?;
+            earliest_consolidation_epoch.safe_add_assign(additional_epochs)?;
+            consolidation_balance_to_consume
+                .safe_add_assign(additional_epochs.safe_mul(per_epoch_consolidation_churn)?)?;
+        }
+        // Consume the balance and update state variables
+        let state = self.as_electra_mut()?;
+        state.consolidation_balance_to_consume =
+            consolidation_balance_to_consume.safe_sub(consolidation_balance)?;
+        state.earliest_consolidation_epoch = earliest_consolidation_epoch;
+
+        Ok(state.earliest_consolidation_epoch)
+    }
+
+    #[allow(clippy::arithmetic_side_effects)]
+    pub fn rebase_on(&mut self, base: &Self, spec: &ChainSpec) -> Result<(), Error> {
+        // Required for macros (which use type-hints internally).
+
+        match (&mut *self, base) {
+            (Self::Base(self_inner), Self::Base(base_inner)) => {
+                bimap_beacon_state_base_tree_list_fields!(
+                    self_inner,
+                    base_inner,
+                    |_, self_field, base_field| { self_field.rebase_on(base_field) }
+                );
+            }
+            (Self::Base(_), _) => (),
+            (Self::Altair(self_inner), Self::Altair(base_inner)) => {
+                bimap_beacon_state_altair_tree_list_fields!(
+                    self_inner,
+                    base_inner,
+                    |_, self_field, base_field| { self_field.rebase_on(base_field) }
+                );
+            }
+            (Self::Altair(_), _) => (),
+            (Self::Bellatrix(self_inner), Self::Bellatrix(base_inner)) => {
+                bimap_beacon_state_bellatrix_tree_list_fields!(
+                    self_inner,
+                    base_inner,
+                    |_, self_field, base_field| { self_field.rebase_on(base_field) }
+                );
+            }
+            (Self::Bellatrix(_), _) => (),
+            (Self::Capella(self_inner), Self::Capella(base_inner)) => {
+                bimap_beacon_state_capella_tree_list_fields!(
+                    self_inner,
+                    base_inner,
+                    |_, self_field, base_field| { self_field.rebase_on(base_field) }
+                );
+            }
+            (Self::Capella(_), _) => (),
+            (Self::Deneb(self_inner), Self::Deneb(base_inner)) => {
+                bimap_beacon_state_deneb_tree_list_fields!(
+                    self_inner,
+                    base_inner,
+                    |_, self_field, base_field| { self_field.rebase_on(base_field) }
+                );
+            }
+            (Self::Deneb(_), _) => (),
+            (Self::Electra(self_inner), Self::Electra(base_inner)) => {
+                bimap_beacon_state_electra_tree_list_fields!(
+                    self_inner,
+                    base_inner,
+                    |_, self_field, base_field| { self_field.rebase_on(base_field) }
+                );
+            }
+            (Self::Electra(_), _) => (),
+        }
+
+        // Use sync committees from `base` if they are equal.
+        if let Ok(current_sync_committee) = self.current_sync_committee_mut() {
+            if let Ok(base_sync_committee) = base.current_sync_committee() {
+                if current_sync_committee == base_sync_committee {
+                    *current_sync_committee = base_sync_committee.clone();
+                }
+            }
+        }
+        if let Ok(next_sync_committee) = self.next_sync_committee_mut() {
+            if let Ok(base_sync_committee) = base.next_sync_committee() {
+                if next_sync_committee == base_sync_committee {
+                    *next_sync_committee = base_sync_committee.clone();
+                }
+            }
+        }
+
+        // Rebase caches like the committee caches and the pubkey cache, which are expensive to
+        // rebuild and likely to be re-usable from the base state.
+        self.rebase_caches_on(base, spec)?;
+
+        Ok(())
+    }
+
+    pub fn rebase_caches_on(&mut self, base: &Self, spec: &ChainSpec) -> Result<(), Error> {
+        // Use pubkey cache from `base` if it contains superior information (likely if our cache is
+        // uninitialized).
+        let num_validators = self.validators().len();
+        let pubkey_cache = self.pubkey_cache_mut();
+        let base_pubkey_cache = base.pubkey_cache();
+        if pubkey_cache.len() < base_pubkey_cache.len() && pubkey_cache.len() < num_validators {
+            *pubkey_cache = base_pubkey_cache.clone();
+        }
+
+        // Use committee caches from `base` if they are relevant.
+        let epochs = [
+            self.previous_epoch(),
+            self.current_epoch(),
+            self.next_epoch()?,
+        ];
+        for (index, epoch) in epochs.into_iter().enumerate() {
+            if let Ok(base_relative_epoch) = RelativeEpoch::from_epoch(base.current_epoch(), epoch)
+            {
+                *self.committee_cache_at_index_mut(index)? =
+                    base.committee_cache(base_relative_epoch)?.clone();
+
+                // Ensure total active balance cache remains built whenever current committee
+                // cache is built.
+                if epoch == self.current_epoch() {
+                    self.build_total_active_balance_cache(spec)?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl<E: EthSpec> BeaconState<E> {
+    /// The number of fields of the `BeaconState` rounded up to the nearest power of two.
+    ///
+    /// This is relevant to tree-hashing of the `BeaconState`.
+    pub fn num_fields_pow2(&self) -> usize {
+        let fork_name = self.fork_name_unchecked();
+        match fork_name {
+            ForkName::Base => BeaconStateBase::<E>::NUM_FIELDS.next_power_of_two(),
+            ForkName::Altair => BeaconStateAltair::<E>::NUM_FIELDS.next_power_of_two(),
+            ForkName::Bellatrix => BeaconStateBellatrix::<E>::NUM_FIELDS.next_power_of_two(),
+            ForkName::Capella => BeaconStateCapella::<E>::NUM_FIELDS.next_power_of_two(),
+            ForkName::Deneb => BeaconStateDeneb::<E>::NUM_FIELDS.next_power_of_two(),
+            ForkName::Electra => BeaconStateElectra::<E>::NUM_FIELDS.next_power_of_two(),
+        }
+    }
+
+    /// Specialised deserialisation method that uses the `ChainSpec` as context.
+    #[allow(clippy::arithmetic_side_effects)]
+    pub fn from_ssz_bytes(bytes: &[u8], spec: &ChainSpec) -> Result<Self, ssz::DecodeError> {
+        // Slot is after genesis_time (u64) and genesis_validators_root (Hash256).
+        let slot_start = <u64 as Decode>::ssz_fixed_len() + <Hash256 as Decode>::ssz_fixed_len();
+        let slot_end = slot_start + <Slot as Decode>::ssz_fixed_len();
+
+        let slot_bytes = bytes
+            .get(slot_start..slot_end)
+            .ok_or(DecodeError::InvalidByteLength {
+                len: bytes.len(),
+                expected: slot_end,
+            })?;
+
+        let slot = Slot::from_ssz_bytes(slot_bytes)?;
+        let fork_at_slot = spec.fork_name_at_slot::<E>(slot);
+
+        Ok(map_fork_name!(
+            fork_at_slot,
+            Self,
+            <_>::from_ssz_bytes(bytes)?
+        ))
+    }
+
+    #[allow(clippy::arithmetic_side_effects)]
+    pub fn apply_pending_mutations(&mut self) -> Result<(), Error> {
+        match self {
+            Self::Base(inner) => {
+                map_beacon_state_base_tree_list_fields!(inner, |_, x| { x.apply_updates() })
+            }
+            Self::Altair(inner) => {
+                map_beacon_state_altair_tree_list_fields!(inner, |_, x| { x.apply_updates() })
+            }
+            Self::Bellatrix(inner) => {
+                map_beacon_state_bellatrix_tree_list_fields!(inner, |_, x| { x.apply_updates() })
+            }
+            Self::Capella(inner) => {
+                map_beacon_state_capella_tree_list_fields!(inner, |_, x| { x.apply_updates() })
+            }
+            Self::Deneb(inner) => {
+                map_beacon_state_deneb_tree_list_fields!(inner, |_, x| { x.apply_updates() })
+            }
+            Self::Electra(inner) => {
+                map_beacon_state_electra_tree_list_fields!(inner, |_, x| { x.apply_updates() })
+            }
+        }
+        Ok(())
+    }
+
+    pub fn compute_merkle_proof(&self, generalized_index: usize) -> Result<Vec<Hash256>, Error> {
         // 1. Convert generalized index to field index.
         let field_index = match generalized_index {
             light_client_update::CURRENT_SYNC_COMMITTEE_INDEX
@@ -1992,7 +2456,7 @@ impl<E: EthSpec> BeaconState<E> {
                 // in the `BeaconState`:
                 // https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/beacon-chain.md#beaconstate
                 generalized_index
-                    .checked_sub(tree_hash_cache::NUM_BEACON_STATE_HASH_TREE_ROOT_LEAVES)
+                    .checked_sub(self.num_fields_pow2())
                     .ok_or(Error::IndexNotSupported(generalized_index))?
             }
             light_client_update::FINALIZED_ROOT_INDEX => {
@@ -2002,20 +2466,47 @@ impl<E: EthSpec> BeaconState<E> {
                 // Subtract off the internal nodes. Result should be 105/2 - 32 = 20 which matches
                 // position of `finalized_checkpoint` in `BeaconState`.
                 finalized_checkpoint_generalized_index
-                    .checked_sub(tree_hash_cache::NUM_BEACON_STATE_HASH_TREE_ROOT_LEAVES)
+                    .checked_sub(self.num_fields_pow2())
                     .ok_or(Error::IndexNotSupported(generalized_index))?
             }
             _ => return Err(Error::IndexNotSupported(generalized_index)),
         };
 
         // 2. Get all `BeaconState` leaves.
-        self.initialize_tree_hash_cache();
-        let mut cache = self
-            .tree_hash_cache_mut()
-            .take()
-            .ok_or(Error::TreeHashCacheNotInitialized)?;
-        let leaves = cache.recalculate_tree_hash_leaves(self)?;
-        self.tree_hash_cache_mut().restore(cache);
+        let mut leaves = vec![];
+        #[allow(clippy::arithmetic_side_effects)]
+        match self {
+            BeaconState::Base(state) => {
+                map_beacon_state_base_fields!(state, |_, field| {
+                    leaves.push(field.tree_hash_root());
+                });
+            }
+            BeaconState::Altair(state) => {
+                map_beacon_state_altair_fields!(state, |_, field| {
+                    leaves.push(field.tree_hash_root());
+                });
+            }
+            BeaconState::Bellatrix(state) => {
+                map_beacon_state_bellatrix_fields!(state, |_, field| {
+                    leaves.push(field.tree_hash_root());
+                });
+            }
+            BeaconState::Capella(state) => {
+                map_beacon_state_capella_fields!(state, |_, field| {
+                    leaves.push(field.tree_hash_root());
+                });
+            }
+            BeaconState::Deneb(state) => {
+                map_beacon_state_deneb_fields!(state, |_, field| {
+                    leaves.push(field.tree_hash_root());
+                });
+            }
+            BeaconState::Electra(state) => {
+                map_beacon_state_electra_fields!(state, |_, field| {
+                    leaves.push(field.tree_hash_root());
+                });
+            }
+        };
 
         // 3. Make deposit tree.
         // Use the depth of the `BeaconState` fields (i.e. `log2(32) = 5`).
@@ -2074,9 +2565,10 @@ impl From<ArithError> for Error {
     }
 }
 
-/// Helper function for "cloning" a field by using its default value.
-fn clone_default<T: Default>(_value: &T) -> T {
-    T::default()
+impl From<milhouse::Error> for Error {
+    fn from(e: milhouse::Error) -> Self {
+        Self::MilhouseError(e)
+    }
 }
 
 impl<E: EthSpec> CompareFields for BeaconState<E> {
@@ -2084,7 +2576,7 @@ impl<E: EthSpec> CompareFields for BeaconState<E> {
         match (self, other) {
             (BeaconState::Base(x), BeaconState::Base(y)) => x.compare_fields(y),
             (BeaconState::Altair(x), BeaconState::Altair(y)) => x.compare_fields(y),
-            (BeaconState::Merge(x), BeaconState::Merge(y)) => x.compare_fields(y),
+            (BeaconState::Bellatrix(x), BeaconState::Bellatrix(y)) => x.compare_fields(y),
             (BeaconState::Capella(x), BeaconState::Capella(y)) => x.compare_fields(y),
             (BeaconState::Deneb(x), BeaconState::Deneb(y)) => x.compare_fields(y),
             (BeaconState::Electra(x), BeaconState::Electra(y)) => x.compare_fields(y),
diff --git a/consensus/types/src/beacon_state/clone_config.rs b/consensus/types/src/beacon_state/clone_config.rs
deleted file mode 100644
index 27e066d5db6..00000000000
--- a/consensus/types/src/beacon_state/clone_config.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-/// Configuration struct for controlling which caches of a `BeaconState` should be cloned.
-#[derive(Debug, Default, PartialEq, Eq, Clone, Copy)]
-pub struct CloneConfig {
-    pub committee_caches: bool,
-    pub pubkey_cache: bool,
-    pub exit_cache: bool,
-    pub slashings_cache: bool,
-    pub tree_hash_cache: bool,
-    pub progressive_balances_cache: bool,
-}
-
-impl CloneConfig {
-    pub fn all() -> Self {
-        Self {
-            committee_caches: true,
-            pubkey_cache: true,
-            exit_cache: true,
-            slashings_cache: true,
-            tree_hash_cache: true,
-            progressive_balances_cache: true,
-        }
-    }
-
-    pub fn none() -> Self {
-        Self::default()
-    }
-
-    pub fn committee_caches_only() -> Self {
-        Self {
-            committee_caches: true,
-            ..Self::none()
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn sanity() {
-        assert!(CloneConfig::all().pubkey_cache);
-        assert!(!CloneConfig::none().tree_hash_cache);
-        assert!(CloneConfig::committee_caches_only().committee_caches);
-        assert!(!CloneConfig::committee_caches_only().exit_cache);
-    }
-}
diff --git a/consensus/types/src/beacon_state/committee_cache.rs b/consensus/types/src/beacon_state/committee_cache.rs
index a6b12cf5af3..7913df8e00e 100644
--- a/consensus/types/src/beacon_state/committee_cache.rs
+++ b/consensus/types/src/beacon_state/committee_cache.rs
@@ -8,6 +8,7 @@ use serde::{Deserialize, Serialize};
 use ssz::{four_byte_option_impl, Decode, DecodeError, Encode};
 use ssz_derive::{Decode, Encode};
 use std::ops::Range;
+use std::sync::Arc;
 use swap_or_not_shuffle::shuffle_list;
 
 mod tests;
@@ -65,7 +66,7 @@ impl CommitteeCache {
         state: &BeaconState<E>,
         epoch: Epoch,
         spec: &ChainSpec,
-    ) -> Result<CommitteeCache, Error> {
+    ) -> Result<Arc<CommitteeCache>, Error> {
         // Check that the cache is being built for an in-range epoch.
         //
         // We allow caches to be constructed for historic epochs, per:
@@ -115,13 +116,13 @@ impl CommitteeCache {
                 .ok_or(Error::ShuffleIndexOutOfBounds(v))? = NonZeroUsize::new(i + 1).into();
         }
 
-        Ok(CommitteeCache {
+        Ok(Arc::new(CommitteeCache {
             initialized_epoch: Some(epoch),
             shuffling,
             shuffling_positions,
             committees_per_slot,
             slots_per_epoch: E::slots_per_epoch(),
-        })
+        }))
     }
 
     /// Returns `true` if the cache has been initialized at the supplied `epoch`.
diff --git a/consensus/types/src/beacon_state/committee_cache/tests.rs b/consensus/types/src/beacon_state/committee_cache/tests.rs
index a5effb9363b..a2274765691 100644
--- a/consensus/types/src/beacon_state/committee_cache/tests.rs
+++ b/consensus/types/src/beacon_state/committee_cache/tests.rs
@@ -92,7 +92,7 @@ async fn shuffles_for_the_right_epoch() {
         .map(|i| Hash256::from_low_u64_be(i as u64))
         .collect();
 
-    *state.randao_mixes_mut() = FixedVector::from(distinct_hashes);
+    *state.randao_mixes_mut() = Vector::try_from_iter(distinct_hashes).unwrap();
 
     let previous_seed = state
         .get_seed(state.previous_epoch(), Domain::BeaconAttester, spec)
diff --git a/consensus/types/src/beacon_state/exit_cache.rs b/consensus/types/src/beacon_state/exit_cache.rs
index bda788e63b9..0bb984b6676 100644
--- a/consensus/types/src/beacon_state/exit_cache.rs
+++ b/consensus/types/src/beacon_state/exit_cache.rs
@@ -1,10 +1,9 @@
 use super::{BeaconStateError, ChainSpec, Epoch, Validator};
 use safe_arith::SafeArith;
-use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
 
 /// Map from exit epoch to the number of validators with that exit epoch.
-#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Default, Clone, PartialEq)]
 pub struct ExitCache {
     /// True if the cache has been initialized.
     initialized: bool,
@@ -16,7 +15,11 @@ pub struct ExitCache {
 
 impl ExitCache {
     /// Initialize a new cache for the given list of validators.
-    pub fn new(validators: &[Validator], spec: &ChainSpec) -> Result<Self, BeaconStateError> {
+    pub fn new<'a, V, I>(validators: V, spec: &ChainSpec) -> Result<Self, BeaconStateError>
+    where
+        V: IntoIterator<Item = &'a Validator, IntoIter = I>,
+        I: ExactSizeIterator + Iterator<Item = &'a Validator>,
+    {
         let mut exit_cache = ExitCache {
             initialized: true,
             max_exit_epoch: Epoch::new(0),
@@ -24,7 +27,7 @@ impl ExitCache {
         };
         // Add all validators with a non-default exit epoch to the cache.
         validators
-            .iter()
+            .into_iter()
             .filter(|validator| validator.exit_epoch != spec.far_future_epoch)
             .try_for_each(|validator| exit_cache.record_validator_exit(validator.exit_epoch))?;
         Ok(exit_cache)
diff --git a/consensus/types/src/beacon_state/iter.rs b/consensus/types/src/beacon_state/iter.rs
index 2d3ad02c836..2caa0365e01 100644
--- a/consensus/types/src/beacon_state/iter.rs
+++ b/consensus/types/src/beacon_state/iter.rs
@@ -74,7 +74,7 @@ mod test {
         let mut state: BeaconState<E> = BeaconState::new(0, <_>::default(), &spec);
 
         for i in 0..state.block_roots().len() {
-            state.block_roots_mut()[i] = root_slot(i).1;
+            *state.block_roots_mut().get_mut(i).unwrap() = root_slot(i).1;
         }
 
         assert_eq!(
@@ -122,7 +122,7 @@ mod test {
         let mut state: BeaconState<E> = BeaconState::new(0, <_>::default(), &spec);
 
         for i in 0..state.block_roots().len() {
-            state.block_roots_mut()[i] = root_slot(i).1;
+            *state.block_roots_mut().get_mut(i).unwrap() = root_slot(i).1;
         }
 
         assert_eq!(
diff --git a/consensus/types/src/beacon_state/progressive_balances_cache.rs b/consensus/types/src/beacon_state/progressive_balances_cache.rs
index 523c94cf57e..fd5e51313f7 100644
--- a/consensus/types/src/beacon_state/progressive_balances_cache.rs
+++ b/consensus/types/src/beacon_state/progressive_balances_cache.rs
@@ -288,7 +288,7 @@ pub fn is_progressive_balances_enabled<E: EthSpec>(state: &BeaconState<E>) -> bo
     match state {
         BeaconState::Base(_) => false,
         BeaconState::Altair(_)
-        | BeaconState::Merge(_)
+        | BeaconState::Bellatrix(_)
         | BeaconState::Capella(_)
         | BeaconState::Deneb(_)
         | BeaconState::Electra(_) => true,
diff --git a/consensus/types/src/beacon_state/pubkey_cache.rs b/consensus/types/src/beacon_state/pubkey_cache.rs
index 0b61ea3c5f8..d58dd7bc1dd 100644
--- a/consensus/types/src/beacon_state/pubkey_cache.rs
+++ b/consensus/types/src/beacon_state/pubkey_cache.rs
@@ -1,21 +1,21 @@
 use crate::*;
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
+use rpds::HashTrieMapSync as HashTrieMap;
 
 type ValidatorIndex = usize;
 
 #[allow(clippy::len_without_is_empty)]
-#[derive(Debug, PartialEq, Clone, Default, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Clone, Default)]
 pub struct PubkeyCache {
-    /// Maintain the number of keys added to the map. It is not sufficient to just use the HashMap
-    /// len, as it does not increase when duplicate keys are added. Duplicate keys are used during
-    /// testing.
+    /// Maintain the number of keys added to the map. It is not sufficient to just use the
+    /// HashTrieMap len, as it does not increase when duplicate keys are added. Duplicate keys are
+    /// used during testing.
     len: usize,
-    map: HashMap<PublicKeyBytes, ValidatorIndex>,
+    map: HashTrieMap<PublicKeyBytes, ValidatorIndex>,
 }
 
 impl PubkeyCache {
     /// Returns the number of validator indices added to the map so far.
+    #[allow(clippy::len_without_is_empty)]
     pub fn len(&self) -> ValidatorIndex {
         self.len
     }
@@ -26,7 +26,7 @@ impl PubkeyCache {
     /// that an index is never skipped.
     pub fn insert(&mut self, pubkey: PublicKeyBytes, index: ValidatorIndex) -> bool {
         if index == self.len {
-            self.map.insert(pubkey, index);
+            self.map.insert_mut(pubkey, index);
             self.len = self
                 .len
                 .checked_add(1)
diff --git a/consensus/types/src/beacon_state/slashings_cache.rs b/consensus/types/src/beacon_state/slashings_cache.rs
index cfdc349f86c..45d8f7e2129 100644
--- a/consensus/types/src/beacon_state/slashings_cache.rs
+++ b/consensus/types/src/beacon_state/slashings_cache.rs
@@ -1,13 +1,13 @@
 use crate::{BeaconStateError, Slot, Validator};
 use arbitrary::Arbitrary;
-use std::collections::HashSet;
+use rpds::HashTrieSetSync as HashTrieSet;
 
 /// Persistent (cheap to clone) cache of all slashed validator indices.
 #[derive(Debug, Default, Clone, PartialEq, Arbitrary)]
 pub struct SlashingsCache {
     latest_block_slot: Option<Slot>,
     #[arbitrary(default)]
-    slashed_validators: HashSet<usize>,
+    slashed_validators: HashTrieSet<usize>,
 }
 
 impl SlashingsCache {
@@ -49,7 +49,7 @@ impl SlashingsCache {
         validator_index: usize,
     ) -> Result<(), BeaconStateError> {
         self.check_initialized(block_slot)?;
-        self.slashed_validators.insert(validator_index);
+        self.slashed_validators.insert_mut(validator_index);
         Ok(())
     }
 
diff --git a/consensus/types/src/beacon_state/tests.rs b/consensus/types/src/beacon_state/tests.rs
index 00625a1788e..38a76e44c50 100644
--- a/consensus/types/src/beacon_state/tests.rs
+++ b/consensus/types/src/beacon_state/tests.rs
@@ -1,20 +1,14 @@
 #![cfg(test)]
 use crate::test_utils::*;
-use beacon_chain::test_utils::{
-    interop_genesis_state_with_eth1, test_spec, BeaconChainHarness, EphemeralHarnessType,
-    DEFAULT_ETH1_BLOCK_HASH,
-};
+use beacon_chain::test_utils::{BeaconChainHarness, EphemeralHarnessType};
 use beacon_chain::types::{
     test_utils::TestRandom, BeaconState, BeaconStateAltair, BeaconStateBase, BeaconStateError,
-    ChainSpec, CloneConfig, Domain, Epoch, EthSpec, FixedVector, Hash256, Keypair, MainnetEthSpec,
-    MinimalEthSpec, RelativeEpoch, Slot,
+    ChainSpec, Domain, Epoch, EthSpec, Hash256, Keypair, MainnetEthSpec, MinimalEthSpec,
+    RelativeEpoch, Slot, Vector,
 };
-use safe_arith::SafeArith;
 use ssz::Encode;
-use state_processing::per_slot_processing;
 use std::ops::Mul;
 use swap_or_not_shuffle::compute_shuffled_index;
-use tree_hash::TreeHash;
 
 pub const MAX_VALIDATOR_COUNT: usize = 129;
 pub const SLOT_OFFSET: Slot = Slot::new(1);
@@ -101,7 +95,11 @@ async fn test_beacon_proposer_index<E: EthSpec>() {
     // Test with two validators per slot, first validator has zero balance.
     let mut state = build_state::<E>((E::slots_per_epoch() as usize).mul(2)).await;
     let slot0_candidate0 = ith_candidate(&state, Slot::new(0), 0, &spec);
-    state.validators_mut()[slot0_candidate0].effective_balance = 0;
+    state
+        .validators_mut()
+        .get_mut(slot0_candidate0)
+        .unwrap()
+        .effective_balance = 0;
     test(&state, Slot::new(0), 1);
     for i in 1..E::slots_per_epoch() {
         test(&state, Slot::from(i), 0);
@@ -159,85 +157,6 @@ async fn cache_initialization() {
     test_cache_initialization(&mut state, RelativeEpoch::Next, &spec);
 }
 
-fn test_clone_config<E: EthSpec>(base_state: &BeaconState<E>, clone_config: CloneConfig) {
-    let state = base_state.clone_with(clone_config);
-    if clone_config.committee_caches {
-        state
-            .committee_cache(RelativeEpoch::Previous)
-            .expect("committee cache exists");
-        state
-            .committee_cache(RelativeEpoch::Current)
-            .expect("committee cache exists");
-        state
-            .committee_cache(RelativeEpoch::Next)
-            .expect("committee cache exists");
-        state
-            .total_active_balance()
-            .expect("total active balance exists");
-    } else {
-        state
-            .committee_cache(RelativeEpoch::Previous)
-            .expect_err("shouldn't exist");
-        state
-            .committee_cache(RelativeEpoch::Current)
-            .expect_err("shouldn't exist");
-        state
-            .committee_cache(RelativeEpoch::Next)
-            .expect_err("shouldn't exist");
-    }
-    if clone_config.pubkey_cache {
-        assert_ne!(state.pubkey_cache().len(), 0);
-    } else {
-        assert_eq!(state.pubkey_cache().len(), 0);
-    }
-    if clone_config.exit_cache {
-        state
-            .exit_cache()
-            .check_initialized()
-            .expect("exit cache exists");
-    } else {
-        state
-            .exit_cache()
-            .check_initialized()
-            .expect_err("exit cache doesn't exist");
-    }
-    if clone_config.tree_hash_cache {
-        assert!(state.tree_hash_cache().is_initialized());
-    } else {
-        assert!(
-            !state.tree_hash_cache().is_initialized(),
-            "{:?}",
-            clone_config
-        );
-    }
-}
-
-#[tokio::test]
-async fn clone_config() {
-    let spec = MinimalEthSpec::default_spec();
-
-    let mut state = build_state::<MinimalEthSpec>(16).await;
-
-    state.build_caches(&spec).unwrap();
-    state
-        .update_tree_hash_cache()
-        .expect("should update tree hash cache");
-
-    let num_caches = 6;
-    let all_configs = (0..2u8.pow(num_caches)).map(|i| CloneConfig {
-        committee_caches: (i & 1) != 0,
-        pubkey_cache: ((i >> 1) & 1) != 0,
-        exit_cache: ((i >> 2) & 1) != 0,
-        slashings_cache: ((i >> 3) & 1) != 0,
-        tree_hash_cache: ((i >> 4) & 1) != 0,
-        progressive_balances_cache: ((i >> 5) & 1) != 0,
-    });
-
-    for config in all_configs {
-        test_clone_config(&state, config);
-    }
-}
-
 /// Tests committee-specific components
 #[cfg(test)]
 mod committees {
@@ -328,10 +247,9 @@ mod committees {
         let harness = get_harness::<E>(validator_count, slot).await;
         let mut new_head_state = harness.get_current_state();
 
-        let distinct_hashes: Vec<Hash256> = (0..E::epochs_per_historical_vector())
-            .map(|i| Hash256::from_low_u64_be(i as u64))
-            .collect();
-        *new_head_state.randao_mixes_mut() = FixedVector::from(distinct_hashes);
+        let distinct_hashes =
+            (0..E::epochs_per_historical_vector()).map(|i| Hash256::from_low_u64_be(i as u64));
+        *new_head_state.randao_mixes_mut() = Vector::try_from_iter(distinct_hashes).unwrap();
 
         new_head_state
             .force_build_committee_cache(RelativeEpoch::Previous, spec)
@@ -485,122 +403,3 @@ fn decode_base_and_altair() {
             .expect_err("bad altair state cannot be decoded");
     }
 }
-
-#[test]
-fn tree_hash_cache_linear_history() {
-    let mut rng = XorShiftRng::from_seed([42; 16]);
-
-    let mut state: BeaconState<MainnetEthSpec> =
-        BeaconState::Base(BeaconStateBase::random_for_test(&mut rng));
-
-    let root = state.update_tree_hash_cache().unwrap();
-
-    assert_eq!(root.as_bytes(), &state.tree_hash_root()[..]);
-
-    /*
-     * A cache should hash twice without updating the slot.
-     */
-
-    assert_eq!(
-        state.update_tree_hash_cache().unwrap(),
-        root,
-        "tree hash result should be identical on the same slot"
-    );
-
-    /*
-     * A cache should not hash after updating the slot but not updating the state roots.
-     */
-
-    // The tree hash cache needs to be rebuilt since it was dropped when it failed.
-    state
-        .update_tree_hash_cache()
-        .expect("should rebuild cache");
-
-    *state.slot_mut() += 1;
-
-    assert_eq!(
-        state.update_tree_hash_cache(),
-        Err(BeaconStateError::NonLinearTreeHashCacheHistory),
-        "should not build hash without updating the state root"
-    );
-
-    /*
-     * The cache should update if the slot and state root are updated.
-     */
-
-    // The tree hash cache needs to be rebuilt since it was dropped when it failed.
-    let root = state
-        .update_tree_hash_cache()
-        .expect("should rebuild cache");
-
-    *state.slot_mut() += 1;
-    state
-        .set_state_root(state.slot() - 1, root)
-        .expect("should set state root");
-
-    let root = state.update_tree_hash_cache().unwrap();
-    assert_eq!(root.as_bytes(), &state.tree_hash_root()[..]);
-}
-
-// Check how the cache behaves when there's a distance larger than `SLOTS_PER_HISTORICAL_ROOT`
-// since its last update.
-#[test]
-fn tree_hash_cache_linear_history_long_skip() {
-    let validator_count = 128;
-    let keypairs = generate_deterministic_keypairs(validator_count);
-
-    let spec = &test_spec::<MinimalEthSpec>();
-
-    // This state has a cache that advances normally each slot.
-    let mut state: BeaconState<MinimalEthSpec> = interop_genesis_state_with_eth1(
-        &keypairs,
-        0,
-        Hash256::from_slice(DEFAULT_ETH1_BLOCK_HASH),
-        None,
-        spec,
-    )
-    .unwrap();
-
-    state.update_tree_hash_cache().unwrap();
-
-    // This state retains its original cache until it is updated after a long skip.
-    let mut original_cache_state = state.clone();
-    assert!(original_cache_state.tree_hash_cache().is_initialized());
-
-    // Advance the states to a slot beyond the historical state root limit, using the state root
-    // from the first state to avoid touching the original state's cache.
-    let start_slot = state.slot();
-    let target_slot = start_slot
-        .safe_add(MinimalEthSpec::slots_per_historical_root() as u64 + 1)
-        .unwrap();
-
-    let mut prev_state_root;
-    while state.slot() < target_slot {
-        prev_state_root = state.update_tree_hash_cache().unwrap();
-        per_slot_processing(&mut state, None, spec).unwrap();
-        per_slot_processing(&mut original_cache_state, Some(prev_state_root), spec).unwrap();
-    }
-
-    // The state with the original cache should still be initialized at the starting slot.
-    assert_eq!(
-        original_cache_state
-            .tree_hash_cache()
-            .initialized_slot()
-            .unwrap(),
-        start_slot
-    );
-
-    // Updating the tree hash cache should be successful despite the long skip.
-    assert_eq!(
-        original_cache_state.update_tree_hash_cache().unwrap(),
-        state.update_tree_hash_cache().unwrap()
-    );
-
-    assert_eq!(
-        original_cache_state
-            .tree_hash_cache()
-            .initialized_slot()
-            .unwrap(),
-        target_slot
-    );
-}
diff --git a/consensus/types/src/beacon_state/tree_hash_cache.rs b/consensus/types/src/beacon_state/tree_hash_cache.rs
deleted file mode 100644
index 290020b1b35..00000000000
--- a/consensus/types/src/beacon_state/tree_hash_cache.rs
+++ /dev/null
@@ -1,645 +0,0 @@
-#![allow(clippy::arithmetic_side_effects)]
-#![allow(clippy::disallowed_methods)]
-#![allow(clippy::indexing_slicing)]
-
-use super::Error;
-use crate::historical_summary::HistoricalSummaryCache;
-use crate::{BeaconState, EthSpec, Hash256, ParticipationList, Slot, Unsigned, Validator};
-use cached_tree_hash::{int_log, CacheArena, CachedTreeHash, TreeHashCache};
-use rayon::prelude::*;
-use ssz_derive::{Decode, Encode};
-use ssz_types::VariableList;
-use std::cmp::Ordering;
-use tree_hash::{mix_in_length, MerkleHasher, TreeHash};
-
-/// The number of leaves (including padding) on the `BeaconState` Merkle tree.
-///
-/// ## Note
-///
-/// This constant is set with the assumption that there are `> 16` and `<= 32` fields on the
-/// `BeaconState`. **Tree hashing will fail if this value is set incorrectly.**
-pub const NUM_BEACON_STATE_HASH_TREE_ROOT_LEAVES: usize = 32;
-
-/// The number of nodes in the Merkle tree of a validator record.
-const NODES_PER_VALIDATOR: usize = 15;
-
-/// The number of validator record tree hash caches stored in each arena.
-///
-/// This is primarily used for concurrency; if we have 16 validators and set `VALIDATORS_PER_ARENA
-/// == 8` then it is possible to do a 2-core concurrent hash.
-///
-/// Do not set to 0.
-const VALIDATORS_PER_ARENA: usize = 4_096;
-
-#[derive(Debug, PartialEq, Clone, Encode, Decode)]
-pub struct Eth1DataVotesTreeHashCache<E: EthSpec> {
-    arena: CacheArena,
-    tree_hash_cache: TreeHashCache,
-    voting_period: u64,
-    roots: VariableList<Hash256, E::SlotsPerEth1VotingPeriod>,
-}
-
-impl<E: EthSpec> Eth1DataVotesTreeHashCache<E> {
-    /// Instantiates a new cache.
-    ///
-    /// Allocates the necessary memory to store all of the cached Merkle trees. Only the leaves are
-    /// hashed, leaving the internal nodes as all-zeros.
-    pub fn new(state: &BeaconState<E>) -> Self {
-        let mut arena = CacheArena::default();
-        let roots: VariableList<_, _> = state
-            .eth1_data_votes()
-            .iter()
-            .map(|eth1_data| eth1_data.tree_hash_root())
-            .collect::<Vec<_>>()
-            .into();
-        let tree_hash_cache = roots.new_tree_hash_cache(&mut arena);
-
-        Self {
-            arena,
-            tree_hash_cache,
-            voting_period: Self::voting_period(state.slot()),
-            roots,
-        }
-    }
-
-    fn voting_period(slot: Slot) -> u64 {
-        slot.as_u64() / E::SlotsPerEth1VotingPeriod::to_u64()
-    }
-
-    pub fn recalculate_tree_hash_root(&mut self, state: &BeaconState<E>) -> Result<Hash256, Error> {
-        if state.eth1_data_votes().len() < self.roots.len()
-            || Self::voting_period(state.slot()) != self.voting_period
-        {
-            *self = Self::new(state);
-        }
-
-        state
-            .eth1_data_votes()
-            .iter()
-            .skip(self.roots.len())
-            .try_for_each(|eth1_data| self.roots.push(eth1_data.tree_hash_root()))?;
-
-        self.roots
-            .recalculate_tree_hash_root(&mut self.arena, &mut self.tree_hash_cache)
-            .map_err(Into::into)
-    }
-}
-
-/// A cache that performs a caching tree hash of the entire `BeaconState` struct.
-///
-/// This type is a wrapper around the inner cache, which does all the work.
-#[derive(Debug, Default, PartialEq, Clone)]
-pub struct BeaconTreeHashCache<E: EthSpec> {
-    inner: Option<BeaconTreeHashCacheInner<E>>,
-}
-
-impl<E: EthSpec> BeaconTreeHashCache<E> {
-    pub fn new(state: &BeaconState<E>) -> Self {
-        Self {
-            inner: Some(BeaconTreeHashCacheInner::new(state)),
-        }
-    }
-
-    pub fn is_initialized(&self) -> bool {
-        self.inner.is_some()
-    }
-
-    /// Move the inner cache out so that the containing `BeaconState` can be borrowed.
-    pub fn take(&mut self) -> Option<BeaconTreeHashCacheInner<E>> {
-        self.inner.take()
-    }
-
-    /// Restore the inner cache after using `take`.
-    pub fn restore(&mut self, inner: BeaconTreeHashCacheInner<E>) {
-        self.inner = Some(inner);
-    }
-
-    /// Make the cache empty.
-    pub fn uninitialize(&mut self) {
-        self.inner = None;
-    }
-
-    /// Return the slot at which the cache was last updated.
-    ///
-    /// This should probably only be used during testing.
-    pub fn initialized_slot(&self) -> Option<Slot> {
-        Some(self.inner.as_ref()?.previous_state?.1)
-    }
-}
-
-#[derive(Debug, PartialEq, Clone)]
-pub struct BeaconTreeHashCacheInner<E: EthSpec> {
-    /// Tracks the previously generated state root to ensure the next state root provided descends
-    /// directly from this state.
-    previous_state: Option<(Hash256, Slot)>,
-    // Validators cache
-    validators: ValidatorsListTreeHashCache,
-    // Arenas
-    fixed_arena: CacheArena,
-    balances_arena: CacheArena,
-    slashings_arena: CacheArena,
-    // Caches
-    block_roots: TreeHashCache,
-    state_roots: TreeHashCache,
-    historical_roots: TreeHashCache,
-    historical_summaries: OptionalTreeHashCache,
-    balances: TreeHashCache,
-    randao_mixes: TreeHashCache,
-    slashings: TreeHashCache,
-    eth1_data_votes: Eth1DataVotesTreeHashCache<E>,
-    inactivity_scores: OptionalTreeHashCache,
-    // Participation caches
-    previous_epoch_participation: OptionalTreeHashCache,
-    current_epoch_participation: OptionalTreeHashCache,
-}
-
-impl<E: EthSpec> BeaconTreeHashCacheInner<E> {
-    /// Instantiates a new cache.
-    ///
-    /// Allocates the necessary memory to store all of the cached Merkle trees. Only the leaves are
-    /// hashed, leaving the internal nodes as all-zeros.
-    pub fn new(state: &BeaconState<E>) -> Self {
-        let mut fixed_arena = CacheArena::default();
-        let block_roots = state.block_roots().new_tree_hash_cache(&mut fixed_arena);
-        let state_roots = state.state_roots().new_tree_hash_cache(&mut fixed_arena);
-        let historical_roots = state
-            .historical_roots()
-            .new_tree_hash_cache(&mut fixed_arena);
-        let historical_summaries = OptionalTreeHashCache::new(
-            state
-                .historical_summaries()
-                .ok()
-                .map(HistoricalSummaryCache::new)
-                .as_ref(),
-        );
-
-        let randao_mixes = state.randao_mixes().new_tree_hash_cache(&mut fixed_arena);
-
-        let validators = ValidatorsListTreeHashCache::new::<E>(state.validators());
-
-        let mut balances_arena = CacheArena::default();
-        let balances = state.balances().new_tree_hash_cache(&mut balances_arena);
-
-        let mut slashings_arena = CacheArena::default();
-        let slashings = state.slashings().new_tree_hash_cache(&mut slashings_arena);
-
-        let inactivity_scores = OptionalTreeHashCache::new(state.inactivity_scores().ok());
-
-        let previous_epoch_participation = OptionalTreeHashCache::new(
-            state
-                .previous_epoch_participation()
-                .ok()
-                .map(ParticipationList::new)
-                .as_ref(),
-        );
-        let current_epoch_participation = OptionalTreeHashCache::new(
-            state
-                .current_epoch_participation()
-                .ok()
-                .map(ParticipationList::new)
-                .as_ref(),
-        );
-
-        Self {
-            previous_state: None,
-            validators,
-            fixed_arena,
-            balances_arena,
-            slashings_arena,
-            block_roots,
-            state_roots,
-            historical_roots,
-            historical_summaries,
-            balances,
-            randao_mixes,
-            slashings,
-            inactivity_scores,
-            eth1_data_votes: Eth1DataVotesTreeHashCache::new(state),
-            previous_epoch_participation,
-            current_epoch_participation,
-        }
-    }
-
-    pub fn recalculate_tree_hash_leaves(
-        &mut self,
-        state: &BeaconState<E>,
-    ) -> Result<Vec<Hash256>, Error> {
-        let mut leaves = vec![
-            // Genesis data leaves.
-            state.genesis_time().tree_hash_root(),
-            state.genesis_validators_root().tree_hash_root(),
-            // Current fork data leaves.
-            state.slot().tree_hash_root(),
-            state.fork().tree_hash_root(),
-            state.latest_block_header().tree_hash_root(),
-            // Roots leaves.
-            state
-                .block_roots()
-                .recalculate_tree_hash_root(&mut self.fixed_arena, &mut self.block_roots)?,
-            state
-                .state_roots()
-                .recalculate_tree_hash_root(&mut self.fixed_arena, &mut self.state_roots)?,
-            state
-                .historical_roots()
-                .recalculate_tree_hash_root(&mut self.fixed_arena, &mut self.historical_roots)?,
-            // Eth1 Data leaves.
-            state.eth1_data().tree_hash_root(),
-            self.eth1_data_votes.recalculate_tree_hash_root(state)?,
-            state.eth1_deposit_index().tree_hash_root(),
-            // Validator leaves.
-            self.validators
-                .recalculate_tree_hash_root(state.validators())?,
-            state
-                .balances()
-                .recalculate_tree_hash_root(&mut self.balances_arena, &mut self.balances)?,
-            state
-                .randao_mixes()
-                .recalculate_tree_hash_root(&mut self.fixed_arena, &mut self.randao_mixes)?,
-            state
-                .slashings()
-                .recalculate_tree_hash_root(&mut self.slashings_arena, &mut self.slashings)?,
-        ];
-
-        // Participation
-        if let BeaconState::Base(state) = state {
-            leaves.push(state.previous_epoch_attestations.tree_hash_root());
-            leaves.push(state.current_epoch_attestations.tree_hash_root());
-        } else {
-            leaves.push(
-                self.previous_epoch_participation
-                    .recalculate_tree_hash_root(&ParticipationList::new(
-                        state.previous_epoch_participation()?,
-                    ))?,
-            );
-            leaves.push(
-                self.current_epoch_participation
-                    .recalculate_tree_hash_root(&ParticipationList::new(
-                        state.current_epoch_participation()?,
-                    ))?,
-            );
-        }
-        // Checkpoint leaves
-        leaves.push(state.justification_bits().tree_hash_root());
-        leaves.push(state.previous_justified_checkpoint().tree_hash_root());
-        leaves.push(state.current_justified_checkpoint().tree_hash_root());
-        leaves.push(state.finalized_checkpoint().tree_hash_root());
-        // Inactivity & light-client sync committees (Altair and later).
-        if let Ok(inactivity_scores) = state.inactivity_scores() {
-            leaves.push(
-                self.inactivity_scores
-                    .recalculate_tree_hash_root(inactivity_scores)?,
-            );
-        }
-        if let Ok(current_sync_committee) = state.current_sync_committee() {
-            leaves.push(current_sync_committee.tree_hash_root());
-        }
-
-        if let Ok(next_sync_committee) = state.next_sync_committee() {
-            leaves.push(next_sync_committee.tree_hash_root());
-        }
-
-        // Execution payload (merge and later).
-        if let Ok(payload_header) = state.latest_execution_payload_header() {
-            leaves.push(payload_header.tree_hash_root());
-        }
-
-        // Withdrawal indices (Capella and later).
-        if let Ok(next_withdrawal_index) = state.next_withdrawal_index() {
-            leaves.push(next_withdrawal_index.tree_hash_root());
-        }
-        if let Ok(next_withdrawal_validator_index) = state.next_withdrawal_validator_index() {
-            leaves.push(next_withdrawal_validator_index.tree_hash_root());
-        }
-
-        // Historical roots/summaries (Capella and later).
-        if let Ok(historical_summaries) = state.historical_summaries() {
-            leaves.push(
-                self.historical_summaries.recalculate_tree_hash_root(
-                    &HistoricalSummaryCache::new(historical_summaries),
-                )?,
-            );
-        }
-
-        Ok(leaves)
-    }
-
-    /// Updates the cache and returns the tree hash root for the given `state`.
-    ///
-    /// The provided `state` should be a descendant of the last `state` given to this function, or
-    /// the `Self::new` function. If the state is more than `SLOTS_PER_HISTORICAL_ROOT` slots
-    /// after `self.previous_state` then the whole cache will be re-initialized.
-    pub fn recalculate_tree_hash_root(&mut self, state: &BeaconState<E>) -> Result<Hash256, Error> {
-        // If this cache has previously produced a root, ensure that it is in the state root
-        // history of this state.
-        //
-        // This ensures that the states applied have a linear history, this
-        // allows us to make assumptions about how the state changes over times and produce a more
-        // efficient algorithm.
-        if let Some((previous_root, previous_slot)) = self.previous_state {
-            // The previously-hashed state must not be newer than `state`.
-            if previous_slot > state.slot() {
-                return Err(Error::TreeHashCacheSkippedSlot {
-                    cache: previous_slot,
-                    state: state.slot(),
-                });
-            }
-
-            // If the state is newer, the previous root must be in the history of the given state.
-            // If the previous slot is out of range of the `state_roots` array (indicating a long
-            // gap between the cache's last use and the current state) then we re-initialize.
-            match state.get_state_root(previous_slot) {
-                Ok(state_previous_root) if *state_previous_root == previous_root => {}
-                Ok(_) => return Err(Error::NonLinearTreeHashCacheHistory),
-                Err(Error::SlotOutOfBounds) => {
-                    *self = Self::new(state);
-                }
-                Err(e) => return Err(e),
-            }
-        }
-
-        let mut hasher = MerkleHasher::with_leaves(NUM_BEACON_STATE_HASH_TREE_ROOT_LEAVES);
-
-        let leaves = self.recalculate_tree_hash_leaves(state)?;
-        for leaf in leaves {
-            hasher.write(leaf.as_bytes())?;
-        }
-
-        let root = hasher.finish()?;
-
-        self.previous_state = Some((root, state.slot()));
-
-        Ok(root)
-    }
-
-    /// Updates the cache and provides the root of the given `validators`.
-    pub fn recalculate_validators_tree_hash_root(
-        &mut self,
-        validators: &[Validator],
-    ) -> Result<Hash256, Error> {
-        self.validators.recalculate_tree_hash_root(validators)
-    }
-}
-
-/// A specialized cache for computing the tree hash root of `state.validators`.
-#[derive(Debug, PartialEq, Clone, Default, Encode, Decode)]
-struct ValidatorsListTreeHashCache {
-    list_arena: CacheArena,
-    list_cache: TreeHashCache,
-    values: ParallelValidatorTreeHash,
-}
-
-impl ValidatorsListTreeHashCache {
-    /// Instantiates a new cache.
-    ///
-    /// Allocates the necessary memory to store all of the cached Merkle trees but does perform any
-    /// hashing.
-    fn new<E: EthSpec>(validators: &[Validator]) -> Self {
-        let mut list_arena = CacheArena::default();
-        Self {
-            list_cache: TreeHashCache::new(
-                &mut list_arena,
-                int_log(E::ValidatorRegistryLimit::to_usize()),
-                validators.len(),
-            ),
-            list_arena,
-            values: ParallelValidatorTreeHash::new(validators),
-        }
-    }
-
-    /// Updates the cache and returns the tree hash root for the given `state`.
-    ///
-    /// This function makes assumptions that the `validators` list will only change in accordance
-    /// with valid per-block/per-slot state transitions.
-    fn recalculate_tree_hash_root(&mut self, validators: &[Validator]) -> Result<Hash256, Error> {
-        let mut list_arena = std::mem::take(&mut self.list_arena);
-
-        let leaves = self.values.leaves(validators)?;
-        let num_leaves = leaves.iter().map(|arena| arena.len()).sum();
-
-        let leaves_iter = ForcedExactSizeIterator {
-            iter: leaves.into_iter().flatten().map(|h| h.to_fixed_bytes()),
-            len: num_leaves,
-        };
-
-        let list_root = self
-            .list_cache
-            .recalculate_merkle_root(&mut list_arena, leaves_iter)?;
-
-        self.list_arena = list_arena;
-
-        Ok(mix_in_length(&list_root, validators.len()))
-    }
-}
-
-/// Provides a wrapper around some `iter` if the number of items in the iterator is known to the
-/// programmer but not the compiler. This allows use of `ExactSizeIterator` in some occasions.
-///
-/// Care should be taken to ensure `len` is accurate.
-struct ForcedExactSizeIterator<I> {
-    iter: I,
-    len: usize,
-}
-
-impl<V, I: Iterator<Item = V>> Iterator for ForcedExactSizeIterator<I> {
-    type Item = V;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.iter.next()
-    }
-}
-
-impl<V, I: Iterator<Item = V>> ExactSizeIterator for ForcedExactSizeIterator<I> {
-    fn len(&self) -> usize {
-        self.len
-    }
-}
-
-/// Provides a cache for each of the `Validator` objects in `state.validators` and computes the
-/// roots of these using Rayon parallelization.
-#[derive(Debug, PartialEq, Clone, Default, Encode, Decode)]
-pub struct ParallelValidatorTreeHash {
-    /// Each arena and its associated sub-trees.
-    arenas: Vec<(CacheArena, Vec<TreeHashCache>)>,
-}
-
-impl ParallelValidatorTreeHash {
-    /// Instantiates a new cache.
-    ///
-    /// Allocates the necessary memory to store all of the cached Merkle trees but does perform any
-    /// hashing.
-    fn new(validators: &[Validator]) -> Self {
-        let num_arenas = std::cmp::max(
-            1,
-            (validators.len() + VALIDATORS_PER_ARENA - 1) / VALIDATORS_PER_ARENA,
-        );
-
-        let mut arenas = (1..=num_arenas)
-            .map(|i| {
-                let num_validators = if i == num_arenas {
-                    validators.len() % VALIDATORS_PER_ARENA
-                } else {
-                    VALIDATORS_PER_ARENA
-                };
-                NODES_PER_VALIDATOR * num_validators
-            })
-            .map(|capacity| (CacheArena::with_capacity(capacity), vec![]))
-            .collect::<Vec<_>>();
-
-        validators.iter().enumerate().for_each(|(i, v)| {
-            let (arena, caches) = &mut arenas[i / VALIDATORS_PER_ARENA];
-            caches.push(v.new_tree_hash_cache(arena))
-        });
-
-        Self { arenas }
-    }
-
-    /// Returns the number of validators stored in self.
-    fn len(&self) -> usize {
-        self.arenas.last().map_or(0, |last| {
-            // Subtraction cannot underflow because `.last()` ensures the `.len() > 0`.
-            (self.arenas.len() - 1) * VALIDATORS_PER_ARENA + last.1.len()
-        })
-    }
-
-    /// Updates the caches for each `Validator` in `validators` and returns a list that maps 1:1
-    /// with `validators` to the hash of each validator.
-    ///
-    /// This function makes assumptions that the `validators` list will only change in accordance
-    /// with valid per-block/per-slot state transitions.
-    fn leaves(&mut self, validators: &[Validator]) -> Result<Vec<Vec<Hash256>>, Error> {
-        match self.len().cmp(&validators.len()) {
-            Ordering::Less => validators.iter().skip(self.len()).for_each(|v| {
-                if self
-                    .arenas
-                    .last()
-                    .map_or(true, |last| last.1.len() >= VALIDATORS_PER_ARENA)
-                {
-                    let mut arena = CacheArena::default();
-                    let cache = v.new_tree_hash_cache(&mut arena);
-                    self.arenas.push((arena, vec![cache]))
-                } else {
-                    let (arena, caches) = &mut self
-                        .arenas
-                        .last_mut()
-                        .expect("Cannot reach this block if arenas is empty.");
-                    caches.push(v.new_tree_hash_cache(arena))
-                }
-            }),
-            Ordering::Greater => {
-                return Err(Error::ValidatorRegistryShrunk);
-            }
-            Ordering::Equal => (),
-        }
-
-        self.arenas
-            .par_iter_mut()
-            .enumerate()
-            .map(|(arena_index, (arena, caches))| {
-                caches
-                    .iter_mut()
-                    .enumerate()
-                    .map(move |(cache_index, cache)| {
-                        let val_index = (arena_index * VALIDATORS_PER_ARENA) + cache_index;
-
-                        let validator = validators
-                            .get(val_index)
-                            .ok_or(Error::TreeHashCacheInconsistent)?;
-
-                        validator
-                            .recalculate_tree_hash_root(arena, cache)
-                            .map_err(Error::CachedTreeHashError)
-                    })
-                    .collect()
-            })
-            .collect()
-    }
-}
-
-#[derive(Debug, PartialEq, Clone)]
-pub struct OptionalTreeHashCache {
-    inner: Option<OptionalTreeHashCacheInner>,
-}
-
-#[derive(Debug, PartialEq, Clone)]
-pub struct OptionalTreeHashCacheInner {
-    arena: CacheArena,
-    tree_hash_cache: TreeHashCache,
-}
-
-impl OptionalTreeHashCache {
-    /// Initialize a new cache if `item.is_some()`.
-    fn new<C: CachedTreeHash<TreeHashCache>>(item: Option<&C>) -> Self {
-        let inner = item.map(OptionalTreeHashCacheInner::new);
-        Self { inner }
-    }
-
-    /// Compute the tree hash root for the given `item`.
-    ///
-    /// This function will initialize the inner cache if necessary (e.g. when crossing the fork).
-    fn recalculate_tree_hash_root<C: CachedTreeHash<TreeHashCache>>(
-        &mut self,
-        item: &C,
-    ) -> Result<Hash256, Error> {
-        let cache = self
-            .inner
-            .get_or_insert_with(|| OptionalTreeHashCacheInner::new(item));
-        item.recalculate_tree_hash_root(&mut cache.arena, &mut cache.tree_hash_cache)
-            .map_err(Into::into)
-    }
-}
-
-impl OptionalTreeHashCacheInner {
-    fn new<C: CachedTreeHash<TreeHashCache>>(item: &C) -> Self {
-        let mut arena = CacheArena::default();
-        let tree_hash_cache = item.new_tree_hash_cache(&mut arena);
-        OptionalTreeHashCacheInner {
-            arena,
-            tree_hash_cache,
-        }
-    }
-}
-
-impl<E: EthSpec> arbitrary::Arbitrary<'_> for BeaconTreeHashCache<E> {
-    fn arbitrary(_u: &mut arbitrary::Unstructured<'_>) -> arbitrary::Result<Self> {
-        Ok(Self::default())
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::{MainnetEthSpec, ParticipationFlags};
-
-    #[test]
-    fn validator_node_count() {
-        let mut arena = CacheArena::default();
-        let v = Validator::default();
-        let _cache = v.new_tree_hash_cache(&mut arena);
-        assert_eq!(arena.backing_len(), NODES_PER_VALIDATOR);
-    }
-
-    #[test]
-    fn participation_flags() {
-        type N = <MainnetEthSpec as EthSpec>::ValidatorRegistryLimit;
-        let len = 65;
-        let mut test_flag = ParticipationFlags::default();
-        test_flag.add_flag(0).unwrap();
-        let epoch_participation = VariableList::<_, N>::new(vec![test_flag; len]).unwrap();
-
-        let mut cache = OptionalTreeHashCache { inner: None };
-
-        let cache_root = cache
-            .recalculate_tree_hash_root(&ParticipationList::new(&epoch_participation))
-            .unwrap();
-        let recalc_root = cache
-            .recalculate_tree_hash_root(&ParticipationList::new(&epoch_participation))
-            .unwrap();
-
-        assert_eq!(cache_root, recalc_root, "recalculated root should match");
-        assert_eq!(
-            cache_root,
-            epoch_participation.tree_hash_root(),
-            "cached root should match uncached"
-        );
-    }
-}
diff --git a/consensus/types/src/blob_sidecar.rs b/consensus/types/src/blob_sidecar.rs
index 31b1307aa7f..e54bc2f4f97 100644
--- a/consensus/types/src/blob_sidecar.rs
+++ b/consensus/types/src/blob_sidecar.rs
@@ -1,7 +1,7 @@
 use crate::test_utils::TestRandom;
 use crate::{
     beacon_block_body::BLOB_KZG_COMMITMENTS_INDEX, BeaconBlockHeader, BeaconStateError, Blob,
-    EthSpec, Hash256, SignedBeaconBlockHeader, Slot,
+    EthSpec, FixedVector, Hash256, SignedBeaconBlockHeader, Slot, VariableList,
 };
 use crate::{KzgProofs, SignedBeaconBlock};
 use bls::Signature;
@@ -16,7 +16,6 @@ use safe_arith::{ArithError, SafeArith};
 use serde::{Deserialize, Serialize};
 use ssz::Encode;
 use ssz_derive::{Decode, Encode};
-use ssz_types::{FixedVector, VariableList};
 use std::fmt::Debug;
 use std::hash::Hash;
 use std::sync::Arc;
diff --git a/consensus/types/src/builder_bid.rs b/consensus/types/src/builder_bid.rs
index 121d3f84277..9885f78474f 100644
--- a/consensus/types/src/builder_bid.rs
+++ b/consensus/types/src/builder_bid.rs
@@ -1,7 +1,7 @@
 use crate::beacon_block_body::KzgCommitments;
 use crate::{
-    ChainSpec, EthSpec, ExecutionPayloadHeaderCapella, ExecutionPayloadHeaderDeneb,
-    ExecutionPayloadHeaderElectra, ExecutionPayloadHeaderMerge, ExecutionPayloadHeaderRef,
+    ChainSpec, EthSpec, ExecutionPayloadHeaderBellatrix, ExecutionPayloadHeaderCapella,
+    ExecutionPayloadHeaderDeneb, ExecutionPayloadHeaderElectra, ExecutionPayloadHeaderRef,
     ExecutionPayloadHeaderRefMut, ForkName, ForkVersionDeserialize, SignedRoot, Uint256,
 };
 use bls::PublicKeyBytes;
@@ -11,7 +11,7 @@ use superstruct::superstruct;
 use tree_hash_derive::TreeHash;
 
 #[superstruct(
-    variants(Merge, Capella, Deneb, Electra),
+    variants(Bellatrix, Capella, Deneb, Electra),
     variant_attributes(
         derive(PartialEq, Debug, Serialize, Deserialize, TreeHash, Clone),
         serde(bound = "E: EthSpec", deny_unknown_fields)
@@ -23,8 +23,8 @@ use tree_hash_derive::TreeHash;
 #[serde(bound = "E: EthSpec", deny_unknown_fields, untagged)]
 #[tree_hash(enum_behaviour = "transparent")]
 pub struct BuilderBid<E: EthSpec> {
-    #[superstruct(only(Merge), partial_getter(rename = "header_merge"))]
-    pub header: ExecutionPayloadHeaderMerge<E>,
+    #[superstruct(only(Bellatrix), partial_getter(rename = "header_bellatrix"))]
+    pub header: ExecutionPayloadHeaderBellatrix<E>,
     #[superstruct(only(Capella), partial_getter(rename = "header_capella"))]
     pub header: ExecutionPayloadHeaderCapella<E>,
     #[superstruct(only(Deneb), partial_getter(rename = "header_deneb"))]
@@ -79,7 +79,9 @@ impl<E: EthSpec> ForkVersionDeserialize for BuilderBid<E> {
             |e| serde::de::Error::custom(format!("BuilderBid failed to deserialize: {:?}", e));
 
         Ok(match fork_name {
-            ForkName::Merge => Self::Merge(serde_json::from_value(value).map_err(convert_err)?),
+            ForkName::Bellatrix => {
+                Self::Bellatrix(serde_json::from_value(value).map_err(convert_err)?)
+            }
             ForkName::Capella => Self::Capella(serde_json::from_value(value).map_err(convert_err)?),
             ForkName::Deneb => Self::Deneb(serde_json::from_value(value).map_err(convert_err)?),
             ForkName::Electra => Self::Electra(serde_json::from_value(value).map_err(convert_err)?),
diff --git a/consensus/types/src/chain_spec.rs b/consensus/types/src/chain_spec.rs
index e9345ab14ea..b0346a14ef8 100644
--- a/consensus/types/src/chain_spec.rs
+++ b/consensus/types/src/chain_spec.rs
@@ -25,6 +25,7 @@ pub enum Domain {
     SyncCommittee,
     ContributionAndProof,
     SyncCommitteeSelectionProof,
+    Consolidation,
     ApplicationMask(ApplicationDomain),
 }
 
@@ -76,6 +77,7 @@ pub struct ChainSpec {
     pub genesis_fork_version: [u8; 4],
     pub bls_withdrawal_prefix_byte: u8,
     pub eth1_address_withdrawal_prefix_byte: u8,
+    pub compounding_withdrawal_prefix_byte: u8,
 
     /*
      * Time parameters
@@ -108,6 +110,7 @@ pub struct ChainSpec {
     pub(crate) domain_voluntary_exit: u32,
     pub(crate) domain_selection_proof: u32,
     pub(crate) domain_aggregate_and_proof: u32,
+    pub(crate) domain_consolidation: u32,
 
     /*
      * Fork choice
@@ -144,13 +147,13 @@ pub struct ChainSpec {
     pub altair_fork_epoch: Option<Epoch>,
 
     /*
-     * Merge hard fork params
+     * Bellatrix hard fork params
      */
     pub inactivity_penalty_quotient_bellatrix: u64,
     pub min_slashing_penalty_quotient_bellatrix: u64,
     pub proportional_slashing_multiplier_bellatrix: u64,
     pub bellatrix_fork_version: [u8; 4],
-    /// The Merge fork epoch is optional, with `None` representing "Merge never happens".
+    /// The Bellatrix fork epoch is optional, with `None` representing "Bellatrix never happens".
     pub bellatrix_fork_epoch: Option<Epoch>,
     pub terminal_total_difficulty: Uint256,
     pub terminal_block_hash: ExecutionBlockHash,
@@ -177,6 +180,15 @@ pub struct ChainSpec {
     pub electra_fork_version: [u8; 4],
     /// The Electra fork epoch is optional, with `None` representing "Electra never happens".
     pub electra_fork_epoch: Option<Epoch>,
+    pub unset_deposit_receipts_start_index: u64,
+    pub full_exit_request_amount: u64,
+    pub min_activation_balance: u64,
+    pub max_effective_balance_electra: u64,
+    pub min_slashing_penalty_quotient_electra: u64,
+    pub whistleblower_reward_quotient_electra: u64,
+    pub max_pending_partials_per_withdrawals_sweep: u64,
+    pub min_per_epoch_churn_limit_electra: u64,
+    pub max_per_epoch_activation_exit_churn_limit: u64,
 
     /*
      * Networking
@@ -298,7 +310,7 @@ impl ChainSpec {
                 _ => match self.capella_fork_epoch {
                     Some(fork_epoch) if epoch >= fork_epoch => ForkName::Capella,
                     _ => match self.bellatrix_fork_epoch {
-                        Some(fork_epoch) if epoch >= fork_epoch => ForkName::Merge,
+                        Some(fork_epoch) if epoch >= fork_epoch => ForkName::Bellatrix,
                         _ => match self.altair_fork_epoch {
                             Some(fork_epoch) if epoch >= fork_epoch => ForkName::Altair,
                             _ => ForkName::Base,
@@ -314,7 +326,7 @@ impl ChainSpec {
         match fork_name {
             ForkName::Base => self.genesis_fork_version,
             ForkName::Altair => self.altair_fork_version,
-            ForkName::Merge => self.bellatrix_fork_version,
+            ForkName::Bellatrix => self.bellatrix_fork_version,
             ForkName::Capella => self.capella_fork_version,
             ForkName::Deneb => self.deneb_fork_version,
             ForkName::Electra => self.electra_fork_version,
@@ -326,7 +338,7 @@ impl ChainSpec {
         match fork_name {
             ForkName::Base => Some(Epoch::new(0)),
             ForkName::Altair => self.altair_fork_epoch,
-            ForkName::Merge => self.bellatrix_fork_epoch,
+            ForkName::Bellatrix => self.bellatrix_fork_epoch,
             ForkName::Capella => self.capella_fork_epoch,
             ForkName::Deneb => self.deneb_fork_epoch,
             ForkName::Electra => self.electra_fork_epoch,
@@ -334,7 +346,7 @@ impl ChainSpec {
     }
 
     pub fn inactivity_penalty_quotient_for_fork(&self, fork_name: ForkName) -> u64 {
-        if fork_name >= ForkName::Merge {
+        if fork_name >= ForkName::Bellatrix {
             self.inactivity_penalty_quotient_bellatrix
         } else if fork_name >= ForkName::Altair {
             self.inactivity_penalty_quotient_altair
@@ -349,7 +361,7 @@ impl ChainSpec {
         state: &BeaconState<E>,
     ) -> u64 {
         let fork_name = state.fork_name_unchecked();
-        if fork_name >= ForkName::Merge {
+        if fork_name >= ForkName::Bellatrix {
             self.proportional_slashing_multiplier_bellatrix
         } else if fork_name >= ForkName::Altair {
             self.proportional_slashing_multiplier_altair
@@ -364,7 +376,9 @@ impl ChainSpec {
         state: &BeaconState<E>,
     ) -> u64 {
         let fork_name = state.fork_name_unchecked();
-        if fork_name >= ForkName::Merge {
+        if fork_name >= ForkName::Electra {
+            self.min_slashing_penalty_quotient_electra
+        } else if fork_name >= ForkName::Bellatrix {
             self.min_slashing_penalty_quotient_bellatrix
         } else if fork_name >= ForkName::Altair {
             self.min_slashing_penalty_quotient_altair
@@ -418,6 +432,7 @@ impl ChainSpec {
             Domain::SyncCommitteeSelectionProof => self.domain_sync_committee_selection_proof,
             Domain::ApplicationMask(application_domain) => application_domain.get_domain_constant(),
             Domain::BlsToExecutionChange => self.domain_bls_to_execution_change,
+            Domain::Consolidation => self.domain_consolidation,
         }
     }
 
@@ -602,6 +617,7 @@ impl ChainSpec {
             genesis_fork_version: [0; 4],
             bls_withdrawal_prefix_byte: 0x00,
             eth1_address_withdrawal_prefix_byte: 0x01,
+            compounding_withdrawal_prefix_byte: 0x02,
 
             /*
              * Time parameters
@@ -635,6 +651,7 @@ impl ChainSpec {
             domain_voluntary_exit: 4,
             domain_selection_proof: 5,
             domain_aggregate_and_proof: 6,
+            domain_consolidation: 0x0B,
 
             /*
              * Fork choice
@@ -676,7 +693,7 @@ impl ChainSpec {
             altair_fork_epoch: Some(Epoch::new(74240)),
 
             /*
-             * Merge hard fork params
+             * Bellatrix hard fork params
              */
             inactivity_penalty_quotient_bellatrix: u64::checked_pow(2, 24)
                 .expect("pow does not overflow"),
@@ -709,6 +726,30 @@ impl ChainSpec {
              */
             electra_fork_version: [0x05, 00, 00, 00],
             electra_fork_epoch: None,
+            unset_deposit_receipts_start_index: u64::MAX,
+            full_exit_request_amount: 0,
+            min_activation_balance: option_wrapper(|| {
+                u64::checked_pow(2, 5)?.checked_mul(u64::checked_pow(10, 9)?)
+            })
+            .expect("calculation does not overflow"),
+            max_effective_balance_electra: option_wrapper(|| {
+                u64::checked_pow(2, 11)?.checked_mul(u64::checked_pow(10, 9)?)
+            })
+            .expect("calculation does not overflow"),
+            min_slashing_penalty_quotient_electra: u64::checked_pow(2, 12)
+                .expect("pow does not overflow"),
+            whistleblower_reward_quotient_electra: u64::checked_pow(2, 12)
+                .expect("pow does not overflow"),
+            max_pending_partials_per_withdrawals_sweep: u64::checked_pow(2, 3)
+                .expect("pow does not overflow"),
+            min_per_epoch_churn_limit_electra: option_wrapper(|| {
+                u64::checked_pow(2, 7)?.checked_mul(u64::checked_pow(10, 9)?)
+            })
+            .expect("calculation does not overflow"),
+            max_per_epoch_activation_exit_churn_limit: option_wrapper(|| {
+                u64::checked_pow(2, 8)?.checked_mul(u64::checked_pow(10, 9)?)
+            })
+            .expect("calculation does not overflow"),
 
             /*
              * Network specific
@@ -789,7 +830,7 @@ impl ChainSpec {
             epochs_per_sync_committee_period: Epoch::new(8),
             altair_fork_version: [0x01, 0x00, 0x00, 0x01],
             altair_fork_epoch: None,
-            // Merge
+            // Bellatrix
             bellatrix_fork_version: [0x02, 0x00, 0x00, 0x01],
             bellatrix_fork_epoch: None,
             terminal_total_difficulty: Uint256::MAX
@@ -809,6 +850,8 @@ impl ChainSpec {
             // Electra
             electra_fork_version: [0x05, 0x00, 0x00, 0x01],
             electra_fork_epoch: None,
+            max_pending_partials_per_withdrawals_sweep: u64::checked_pow(2, 0)
+                .expect("pow does not overflow"),
             // Other
             network_id: 2, // lighthouse testnet network id
             deposit_chain_id: 5,
@@ -874,6 +917,7 @@ impl ChainSpec {
             genesis_fork_version: [0x00, 0x00, 0x00, 0x64],
             bls_withdrawal_prefix_byte: 0x00,
             eth1_address_withdrawal_prefix_byte: 0x01,
+            compounding_withdrawal_prefix_byte: 0x02,
 
             /*
              * Time parameters
@@ -907,6 +951,7 @@ impl ChainSpec {
             domain_voluntary_exit: 4,
             domain_selection_proof: 5,
             domain_aggregate_and_proof: 6,
+            domain_consolidation: 0x0B,
 
             /*
              * Fork choice
@@ -948,7 +993,7 @@ impl ChainSpec {
             altair_fork_epoch: Some(Epoch::new(512)),
 
             /*
-             * Merge hard fork params
+             * Bellatrix hard fork params
              */
             inactivity_penalty_quotient_bellatrix: u64::checked_pow(2, 24)
                 .expect("pow does not overflow"),
@@ -983,6 +1028,30 @@ impl ChainSpec {
              */
             electra_fork_version: [0x05, 0x00, 0x00, 0x64],
             electra_fork_epoch: None,
+            unset_deposit_receipts_start_index: u64::MAX,
+            full_exit_request_amount: 0,
+            min_activation_balance: option_wrapper(|| {
+                u64::checked_pow(2, 5)?.checked_mul(u64::checked_pow(10, 9)?)
+            })
+            .expect("calculation does not overflow"),
+            max_effective_balance_electra: option_wrapper(|| {
+                u64::checked_pow(2, 11)?.checked_mul(u64::checked_pow(10, 9)?)
+            })
+            .expect("calculation does not overflow"),
+            min_slashing_penalty_quotient_electra: u64::checked_pow(2, 12)
+                .expect("pow does not overflow"),
+            whistleblower_reward_quotient_electra: u64::checked_pow(2, 12)
+                .expect("pow does not overflow"),
+            max_pending_partials_per_withdrawals_sweep: u64::checked_pow(2, 3)
+                .expect("pow does not overflow"),
+            min_per_epoch_churn_limit_electra: option_wrapper(|| {
+                u64::checked_pow(2, 7)?.checked_mul(u64::checked_pow(10, 9)?)
+            })
+            .expect("calculation does not overflow"),
+            max_per_epoch_activation_exit_churn_limit: option_wrapper(|| {
+                u64::checked_pow(2, 8)?.checked_mul(u64::checked_pow(10, 9)?)
+            })
+            .expect("calculation does not overflow"),
 
             /*
              * Network specific
@@ -1206,6 +1275,13 @@ pub struct Config {
     #[serde(default = "default_blob_sidecar_subnet_count")]
     #[serde(with = "serde_utils::quoted_u64")]
     blob_sidecar_subnet_count: u64,
+
+    #[serde(default = "default_min_per_epoch_churn_limit_electra")]
+    #[serde(with = "serde_utils::quoted_u64")]
+    min_per_epoch_churn_limit_electra: u64,
+    #[serde(default = "default_max_per_epoch_activation_exit_churn_limit")]
+    #[serde(with = "serde_utils::quoted_u64")]
+    max_per_epoch_activation_exit_churn_limit: u64,
 }
 
 fn default_bellatrix_fork_version() -> [u8; 4] {
@@ -1320,6 +1396,14 @@ const fn default_blob_sidecar_subnet_count() -> u64 {
     6
 }
 
+const fn default_min_per_epoch_churn_limit_electra() -> u64 {
+    128_000_000_000
+}
+
+const fn default_max_per_epoch_activation_exit_churn_limit() -> u64 {
+    256_000_000_000
+}
+
 const fn default_epochs_per_subnet_subscription() -> u64 {
     256
 }
@@ -1496,6 +1580,10 @@ impl Config {
             max_request_blob_sidecars: spec.max_request_blob_sidecars,
             min_epochs_for_blob_sidecars_requests: spec.min_epochs_for_blob_sidecars_requests,
             blob_sidecar_subnet_count: spec.blob_sidecar_subnet_count,
+
+            min_per_epoch_churn_limit_electra: spec.min_per_epoch_churn_limit_electra,
+            max_per_epoch_activation_exit_churn_limit: spec
+                .max_per_epoch_activation_exit_churn_limit,
         }
     }
 
@@ -1563,6 +1651,8 @@ impl Config {
             max_request_blob_sidecars,
             min_epochs_for_blob_sidecars_requests,
             blob_sidecar_subnet_count,
+            min_per_epoch_churn_limit_electra,
+            max_per_epoch_activation_exit_churn_limit,
         } = self;
 
         if preset_base != E::spec_name().to_string().as_str() {
@@ -1623,6 +1713,8 @@ impl Config {
             max_request_blob_sidecars,
             min_epochs_for_blob_sidecars_requests,
             blob_sidecar_subnet_count,
+            min_per_epoch_churn_limit_electra,
+            max_per_epoch_activation_exit_churn_limit,
 
             // We need to re-derive any values that might have changed in the config.
             max_blocks_by_root_request: max_blocks_by_root_request_common(max_request_blocks),
@@ -1695,6 +1787,7 @@ mod tests {
             &spec,
         );
         test_domain(Domain::SyncCommittee, spec.domain_sync_committee, &spec);
+        test_domain(Domain::Consolidation, spec.domain_consolidation, &spec);
 
         // The builder domain index is zero
         let builder_domain_pre_mask = [0; 4];
diff --git a/consensus/types/src/config_and_preset.rs b/consensus/types/src/config_and_preset.rs
index f2a6e616daa..6fc6e0642ea 100644
--- a/consensus/types/src/config_and_preset.rs
+++ b/consensus/types/src/config_and_preset.rs
@@ -1,6 +1,6 @@
 use crate::{
-    consts::altair, AltairPreset, BasePreset, BellatrixPreset, CapellaPreset, ChainSpec, Config,
-    DenebPreset, ElectraPreset, EthSpec, ForkName,
+    consts::altair, consts::deneb, AltairPreset, BasePreset, BellatrixPreset, CapellaPreset,
+    ChainSpec, Config, DenebPreset, ElectraPreset, EthSpec, ForkName,
 };
 use maplit::hashmap;
 use serde::{Deserialize, Serialize};
@@ -100,6 +100,7 @@ pub fn get_extra_fields(spec: &ChainSpec) -> HashMap<String, Value> {
     let u8_hex = |v: u8| hex_string(&v.to_le_bytes());
     hashmap! {
         "bls_withdrawal_prefix".to_uppercase() => u8_hex(spec.bls_withdrawal_prefix_byte),
+        "eth1_address_withdrawal_prefix".to_uppercase() => u8_hex(spec.eth1_address_withdrawal_prefix_byte),
         "domain_beacon_proposer".to_uppercase() => u32_hex(spec.domain_beacon_proposer),
         "domain_beacon_attester".to_uppercase() => u32_hex(spec.domain_beacon_attester),
         "domain_randao".to_uppercase()=> u32_hex(spec.domain_randao),
@@ -119,6 +120,13 @@ pub fn get_extra_fields(spec: &ChainSpec) -> HashMap<String, Value> {
             altair::SYNC_COMMITTEE_SUBNET_COUNT.to_string().into(),
         "target_aggregators_per_sync_subcommittee".to_uppercase() =>
             altair::TARGET_AGGREGATORS_PER_SYNC_SUBCOMMITTEE.to_string().into(),
+        // Deneb
+        "versioned_hash_version_kzg".to_uppercase() => deneb::VERSIONED_HASH_VERSION_KZG.to_string().into(),
+        // Electra
+        "compounding_withdrawal_prefix".to_uppercase() => u8_hex(spec.compounding_withdrawal_prefix_byte),
+        "unset_deposit_receipts_start_index".to_uppercase() => spec.unset_deposit_receipts_start_index.to_string().into(),
+        "full_exit_request_amount".to_uppercase() => spec.full_exit_request_amount.to_string().into(),
+        "domain_consolidation".to_uppercase()=> u32_hex(spec.domain_consolidation),
     }
 }
 
diff --git a/consensus/types/src/consolidation.rs b/consensus/types/src/consolidation.rs
new file mode 100644
index 00000000000..09a2d4bb0c3
--- /dev/null
+++ b/consensus/types/src/consolidation.rs
@@ -0,0 +1,35 @@
+use crate::test_utils::TestRandom;
+use crate::Epoch;
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use test_random_derive::TestRandom;
+use tree_hash_derive::TreeHash;
+
+#[derive(
+    arbitrary::Arbitrary,
+    Debug,
+    PartialEq,
+    Eq,
+    Hash,
+    Clone,
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    TreeHash,
+    TestRandom,
+)]
+pub struct Consolidation {
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub source_index: u64,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub target_index: u64,
+    pub epoch: Epoch,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    ssz_and_tree_hash_tests!(Consolidation);
+}
diff --git a/consensus/types/src/consts.rs b/consensus/types/src/consts.rs
index a9377bc3e00..c20d5fe8f33 100644
--- a/consensus/types/src/consts.rs
+++ b/consensus/types/src/consts.rs
@@ -19,6 +19,9 @@ pub mod altair {
 
     pub const NUM_FLAG_INDICES: usize = 3;
 }
-pub mod merge {
+pub mod bellatrix {
     pub const INTERVALS_PER_SLOT: u64 = 3;
 }
+pub mod deneb {
+    pub use crate::VERSIONED_HASH_VERSION_KZG;
+}
diff --git a/consensus/types/src/deposit_receipt.rs b/consensus/types/src/deposit_receipt.rs
new file mode 100644
index 00000000000..6a08f717f3d
--- /dev/null
+++ b/consensus/types/src/deposit_receipt.rs
@@ -0,0 +1,37 @@
+use crate::test_utils::TestRandom;
+use crate::{Hash256, PublicKeyBytes, Signature};
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use test_random_derive::TestRandom;
+use tree_hash_derive::TreeHash;
+
+#[derive(
+    arbitrary::Arbitrary,
+    Debug,
+    PartialEq,
+    Eq,
+    Hash,
+    Clone,
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    TreeHash,
+    TestRandom,
+)]
+pub struct DepositReceipt {
+    pub pubkey: PublicKeyBytes,
+    pub withdrawal_credentials: Hash256,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub amount: u64,
+    pub signature: Signature,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub index: u64,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    ssz_and_tree_hash_tests!(DepositReceipt);
+}
diff --git a/consensus/types/src/eth_spec.rs b/consensus/types/src/eth_spec.rs
index a2972b722a2..62f7f1b8698 100644
--- a/consensus/types/src/eth_spec.rs
+++ b/consensus/types/src/eth_spec.rs
@@ -3,8 +3,9 @@ use crate::*;
 use safe_arith::SafeArith;
 use serde::{Deserialize, Serialize};
 use ssz_types::typenum::{
-    bit::B0, UInt, U0, U1024, U1048576, U1073741824, U1099511627776, U128, U131072, U16, U16777216,
-    U2, U2048, U256, U32, U4, U4096, U512, U6, U625, U64, U65536, U8, U8192,
+    bit::B0, UInt, U0, U1, U1024, U1048576, U1073741824, U1099511627776, U128, U131072, U134217728,
+    U16, U16777216, U2, U2048, U256, U262144, U32, U4, U4096, U512, U6, U625, U64, U65536, U8,
+    U8192,
 };
 use ssz_types::typenum::{U17, U9};
 use std::fmt::{self, Debug};
@@ -90,7 +91,7 @@ pub trait EthSpec:
     /// The number of `sync_committee` subnets.
     type SyncCommitteeSubnetCount: Unsigned + Clone + Sync + Send + Debug + PartialEq;
     /*
-     * New in Merge
+     * New in Bellatrix
      */
     type MaxBytesPerTransaction: Unsigned + Clone + Sync + Send + Debug + PartialEq;
     type MaxTransactionsPerPayload: Unsigned + Clone + Sync + Send + Debug + PartialEq;
@@ -137,7 +138,14 @@ pub trait EthSpec:
     /*
      * New in Electra
      */
-    type ElectraPlaceholder: Unsigned + Clone + Sync + Send + Debug + PartialEq;
+    type PendingBalanceDepositsLimit: Unsigned + Clone + Sync + Send + Debug + PartialEq;
+    type PendingPartialWithdrawalsLimit: Unsigned + Clone + Sync + Send + Debug + PartialEq;
+    type PendingConsolidationsLimit: Unsigned + Clone + Sync + Send + Debug + PartialEq;
+    type MaxConsolidations: Unsigned + Clone + Sync + Send + Debug + PartialEq;
+    type MaxDepositReceiptsPerPayload: Unsigned + Clone + Sync + Send + Debug + PartialEq;
+    type MaxAttesterSlashingsElectra: Unsigned + Clone + Sync + Send + Debug + PartialEq;
+    type MaxAttestationsElectra: Unsigned + Clone + Sync + Send + Debug + PartialEq;
+    type MaxWithdrawalRequestsPerPayload: Unsigned + Clone + Sync + Send + Debug + PartialEq;
 
     fn default_spec() -> ChainSpec;
 
@@ -284,8 +292,44 @@ pub trait EthSpec:
         Self::KzgCommitmentInclusionProofDepth::to_usize()
     }
 
-    fn electra_placeholder() -> usize {
-        Self::ElectraPlaceholder::to_usize()
+    /// Returns the `PENDING_BALANCE_DEPOSITS_LIMIT` constant for this specification.
+    fn pending_balance_deposits_limit() -> usize {
+        Self::PendingBalanceDepositsLimit::to_usize()
+    }
+
+    /// Returns the `PENDING_PARTIAL_WITHDRAWALS_LIMIT` constant for this specification.
+    fn pending_partial_withdrawals_limit() -> usize {
+        Self::PendingPartialWithdrawalsLimit::to_usize()
+    }
+
+    /// Returns the `PENDING_CONSOLIDATIONS_LIMIT` constant for this specification.
+    fn pending_consolidations_limit() -> usize {
+        Self::PendingConsolidationsLimit::to_usize()
+    }
+
+    /// Returns the `MAX_CONSOLIDATIONS` constant for this specification.
+    fn max_consolidations() -> usize {
+        Self::MaxConsolidations::to_usize()
+    }
+
+    /// Returns the `MAX_DEPOSIT_RECEIPTS_PER_PAYLOAD` constant for this specification.
+    fn max_deposit_receipts_per_payload() -> usize {
+        Self::MaxDepositReceiptsPerPayload::to_usize()
+    }
+
+    /// Returns the `MAX_ATTESTER_SLASHINGS_ELECTRA` constant for this specification.
+    fn max_attester_slashings_electra() -> usize {
+        Self::MaxAttesterSlashingsElectra::to_usize()
+    }
+
+    /// Returns the `MAX_ATTESTATIONS_ELECTRA` constant for this specification.
+    fn max_attestations_electra() -> usize {
+        Self::MaxAttestationsElectra::to_usize()
+    }
+
+    /// Returns the `MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD` constant for this specification.
+    fn max_withdrawal_requests_per_payload() -> usize {
+        Self::MaxWithdrawalRequestsPerPayload::to_usize()
     }
 }
 
@@ -337,7 +381,14 @@ impl EthSpec for MainnetEthSpec {
     type SlotsPerEth1VotingPeriod = U2048; // 64 epochs * 32 slots per epoch
     type MaxBlsToExecutionChanges = U16;
     type MaxWithdrawalsPerPayload = U16;
-    type ElectraPlaceholder = U16;
+    type PendingBalanceDepositsLimit = U134217728;
+    type PendingPartialWithdrawalsLimit = U134217728;
+    type PendingConsolidationsLimit = U262144;
+    type MaxConsolidations = U1;
+    type MaxDepositReceiptsPerPayload = U8192;
+    type MaxAttesterSlashingsElectra = U1;
+    type MaxAttestationsElectra = U8;
+    type MaxWithdrawalRequestsPerPayload = U16;
 
     fn default_spec() -> ChainSpec {
         ChainSpec::mainnet()
@@ -367,6 +418,10 @@ impl EthSpec for MinimalEthSpec {
     type BytesPerBlob = U131072;
     type MaxBlobCommitmentsPerBlock = U16;
     type KzgCommitmentInclusionProofDepth = U9;
+    type PendingPartialWithdrawalsLimit = U64;
+    type PendingConsolidationsLimit = U64;
+    type MaxDepositReceiptsPerPayload = U4;
+    type MaxWithdrawalRequestsPerPayload = U2;
 
     params_from_eth_spec!(MainnetEthSpec {
         JustificationBitsLength,
@@ -390,7 +445,10 @@ impl EthSpec for MinimalEthSpec {
         MaxBlsToExecutionChanges,
         MaxBlobsPerBlock,
         BytesPerFieldElement,
-        ElectraPlaceholder
+        PendingBalanceDepositsLimit,
+        MaxConsolidations,
+        MaxAttesterSlashingsElectra,
+        MaxAttestationsElectra
     });
 
     fn default_spec() -> ChainSpec {
@@ -442,7 +500,14 @@ impl EthSpec for GnosisEthSpec {
     type BytesPerFieldElement = U32;
     type BytesPerBlob = U131072;
     type KzgCommitmentInclusionProofDepth = U17;
-    type ElectraPlaceholder = U16;
+    type PendingBalanceDepositsLimit = U134217728;
+    type PendingPartialWithdrawalsLimit = U134217728;
+    type PendingConsolidationsLimit = U262144;
+    type MaxConsolidations = U1;
+    type MaxDepositReceiptsPerPayload = U8192;
+    type MaxAttesterSlashingsElectra = U1;
+    type MaxAttestationsElectra = U8;
+    type MaxWithdrawalRequestsPerPayload = U16;
 
     fn default_spec() -> ChainSpec {
         ChainSpec::gnosis()
diff --git a/consensus/types/src/execution_layer_withdrawal_request.rs b/consensus/types/src/execution_layer_withdrawal_request.rs
new file mode 100644
index 00000000000..b1d814c2834
--- /dev/null
+++ b/consensus/types/src/execution_layer_withdrawal_request.rs
@@ -0,0 +1,34 @@
+use crate::test_utils::TestRandom;
+use crate::{Address, PublicKeyBytes};
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use test_random_derive::TestRandom;
+use tree_hash_derive::TreeHash;
+
+#[derive(
+    arbitrary::Arbitrary,
+    Debug,
+    PartialEq,
+    Eq,
+    Hash,
+    Clone,
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    TreeHash,
+    TestRandom,
+)]
+pub struct ExecutionLayerWithdrawalRequest {
+    pub source_address: Address,
+    pub validator_pubkey: PublicKeyBytes,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub amount: u64,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    ssz_and_tree_hash_tests!(ExecutionLayerWithdrawalRequest);
+}
diff --git a/consensus/types/src/execution_payload.rs b/consensus/types/src/execution_payload.rs
index 27dc8cab0a4..0946b9ecffa 100644
--- a/consensus/types/src/execution_payload.rs
+++ b/consensus/types/src/execution_payload.rs
@@ -15,7 +15,7 @@ pub type Transactions<E> = VariableList<
 pub type Withdrawals<E> = VariableList<Withdrawal, <E as EthSpec>::MaxWithdrawalsPerPayload>;
 
 #[superstruct(
-    variants(Merge, Capella, Deneb, Electra),
+    variants(Bellatrix, Capella, Deneb, Electra),
     variant_attributes(
         derive(
             Default,
@@ -89,6 +89,11 @@ pub struct ExecutionPayload<E: EthSpec> {
     #[superstruct(only(Deneb, Electra), partial_getter(copy))]
     #[serde(with = "serde_utils::quoted_u64")]
     pub excess_blob_gas: u64,
+    #[superstruct(only(Electra))]
+    pub deposit_receipts: VariableList<DepositReceipt, E::MaxDepositReceiptsPerPayload>,
+    #[superstruct(only(Electra))]
+    pub withdrawal_requests:
+        VariableList<ExecutionLayerWithdrawalRequest, E::MaxWithdrawalRequestsPerPayload>,
 }
 
 impl<'a, E: EthSpec> ExecutionPayloadRef<'a, E> {
@@ -107,7 +112,9 @@ impl<E: EthSpec> ExecutionPayload<E> {
             ForkName::Base | ForkName::Altair => Err(ssz::DecodeError::BytesInvalid(format!(
                 "unsupported fork for ExecutionPayload: {fork_name}",
             ))),
-            ForkName::Merge => ExecutionPayloadMerge::from_ssz_bytes(bytes).map(Self::Merge),
+            ForkName::Bellatrix => {
+                ExecutionPayloadBellatrix::from_ssz_bytes(bytes).map(Self::Bellatrix)
+            }
             ForkName::Capella => ExecutionPayloadCapella::from_ssz_bytes(bytes).map(Self::Capella),
             ForkName::Deneb => ExecutionPayloadDeneb::from_ssz_bytes(bytes).map(Self::Deneb),
             ForkName::Electra => ExecutionPayloadElectra::from_ssz_bytes(bytes).map(Self::Electra),
@@ -116,9 +123,9 @@ impl<E: EthSpec> ExecutionPayload<E> {
 
     #[allow(clippy::arithmetic_side_effects)]
     /// Returns the maximum size of an execution payload.
-    pub fn max_execution_payload_merge_size() -> usize {
+    pub fn max_execution_payload_bellatrix_size() -> usize {
         // Fixed part
-        ExecutionPayloadMerge::<E>::default().as_ssz_bytes().len()
+        ExecutionPayloadBellatrix::<E>::default().as_ssz_bytes().len()
             // Max size of variable length `extra_data` field
             + (E::max_extra_data_bytes() * <u8 as Encode>::ssz_fixed_len())
             // Max size of variable length `transactions` field
@@ -175,7 +182,9 @@ impl<E: EthSpec> ForkVersionDeserialize for ExecutionPayload<E> {
         };
 
         Ok(match fork_name {
-            ForkName::Merge => Self::Merge(serde_json::from_value(value).map_err(convert_err)?),
+            ForkName::Bellatrix => {
+                Self::Bellatrix(serde_json::from_value(value).map_err(convert_err)?)
+            }
             ForkName::Capella => Self::Capella(serde_json::from_value(value).map_err(convert_err)?),
             ForkName::Deneb => Self::Deneb(serde_json::from_value(value).map_err(convert_err)?),
             ForkName::Electra => Self::Electra(serde_json::from_value(value).map_err(convert_err)?),
@@ -192,7 +201,7 @@ impl<E: EthSpec> ForkVersionDeserialize for ExecutionPayload<E> {
 impl<E: EthSpec> ExecutionPayload<E> {
     pub fn fork_name(&self) -> ForkName {
         match self {
-            ExecutionPayload::Merge(_) => ForkName::Merge,
+            ExecutionPayload::Bellatrix(_) => ForkName::Bellatrix,
             ExecutionPayload::Capella(_) => ForkName::Capella,
             ExecutionPayload::Deneb(_) => ForkName::Deneb,
             ExecutionPayload::Electra(_) => ForkName::Electra,
diff --git a/consensus/types/src/execution_payload_header.rs b/consensus/types/src/execution_payload_header.rs
index 3d0b0aca41d..324d7b97472 100644
--- a/consensus/types/src/execution_payload_header.rs
+++ b/consensus/types/src/execution_payload_header.rs
@@ -8,7 +8,7 @@ use tree_hash::TreeHash;
 use tree_hash_derive::TreeHash;
 
 #[superstruct(
-    variants(Merge, Capella, Deneb, Electra),
+    variants(Bellatrix, Capella, Deneb, Electra),
     variant_attributes(
         derive(
             Default,
@@ -32,7 +32,8 @@ use tree_hash_derive::TreeHash;
         tree_hash(enum_behaviour = "transparent")
     ),
     cast_error(ty = "Error", expr = "BeaconStateError::IncorrectStateVariant"),
-    partial_getter_error(ty = "Error", expr = "BeaconStateError::IncorrectStateVariant")
+    partial_getter_error(ty = "Error", expr = "BeaconStateError::IncorrectStateVariant"),
+    map_ref_into(ExecutionPayloadHeader)
 )]
 #[derive(
     Debug, Clone, Serialize, Deserialize, Encode, TreeHash, Derivative, arbitrary::Arbitrary,
@@ -87,6 +88,10 @@ pub struct ExecutionPayloadHeader<E: EthSpec> {
     #[serde(with = "serde_utils::quoted_u64")]
     #[superstruct(getter(copy))]
     pub excess_blob_gas: u64,
+    #[superstruct(only(Electra), partial_getter(copy))]
+    pub deposit_receipts_root: Hash256,
+    #[superstruct(only(Electra), partial_getter(copy))]
+    pub withdrawal_requests_root: Hash256,
 }
 
 impl<E: EthSpec> ExecutionPayloadHeader<E> {
@@ -99,7 +104,9 @@ impl<E: EthSpec> ExecutionPayloadHeader<E> {
             ForkName::Base | ForkName::Altair => Err(ssz::DecodeError::BytesInvalid(format!(
                 "unsupported fork for ExecutionPayloadHeader: {fork_name}",
             ))),
-            ForkName::Merge => ExecutionPayloadHeaderMerge::from_ssz_bytes(bytes).map(Self::Merge),
+            ForkName::Bellatrix => {
+                ExecutionPayloadHeaderBellatrix::from_ssz_bytes(bytes).map(Self::Bellatrix)
+            }
             ForkName::Capella => {
                 ExecutionPayloadHeaderCapella::from_ssz_bytes(bytes).map(Self::Capella)
             }
@@ -117,7 +124,7 @@ impl<E: EthSpec> ExecutionPayloadHeader<E> {
         match fork_name {
             ForkName::Base
             | ForkName::Altair
-            | ForkName::Merge
+            | ForkName::Bellatrix
             | ForkName::Capella
             | ForkName::Deneb
             | ForkName::Electra => {
@@ -137,7 +144,7 @@ impl<'a, E: EthSpec> ExecutionPayloadHeaderRef<'a, E> {
     }
 }
 
-impl<E: EthSpec> ExecutionPayloadHeaderMerge<E> {
+impl<E: EthSpec> ExecutionPayloadHeaderBellatrix<E> {
     pub fn upgrade_to_capella(&self) -> ExecutionPayloadHeaderCapella<E> {
         ExecutionPayloadHeaderCapella {
             parent_hash: self.parent_hash,
@@ -203,12 +210,14 @@ impl<E: EthSpec> ExecutionPayloadHeaderDeneb<E> {
             withdrawals_root: self.withdrawals_root,
             blob_gas_used: self.blob_gas_used,
             excess_blob_gas: self.excess_blob_gas,
+            deposit_receipts_root: Hash256::zero(),
+            withdrawal_requests_root: Hash256::zero(),
         }
     }
 }
 
-impl<'a, E: EthSpec> From<&'a ExecutionPayloadMerge<E>> for ExecutionPayloadHeaderMerge<E> {
-    fn from(payload: &'a ExecutionPayloadMerge<E>) -> Self {
+impl<'a, E: EthSpec> From<&'a ExecutionPayloadBellatrix<E>> for ExecutionPayloadHeaderBellatrix<E> {
+    fn from(payload: &'a ExecutionPayloadBellatrix<E>) -> Self {
         Self {
             parent_hash: payload.parent_hash,
             fee_recipient: payload.fee_recipient,
@@ -294,13 +303,15 @@ impl<'a, E: EthSpec> From<&'a ExecutionPayloadElectra<E>> for ExecutionPayloadHe
             withdrawals_root: payload.withdrawals.tree_hash_root(),
             blob_gas_used: payload.blob_gas_used,
             excess_blob_gas: payload.excess_blob_gas,
+            deposit_receipts_root: payload.deposit_receipts.tree_hash_root(),
+            withdrawal_requests_root: payload.withdrawal_requests.tree_hash_root(),
         }
     }
 }
 
 // These impls are required to work around an inelegance in `to_execution_payload_header`.
 // They only clone headers so they should be relatively cheap.
-impl<'a, E: EthSpec> From<&'a Self> for ExecutionPayloadHeaderMerge<E> {
+impl<'a, E: EthSpec> From<&'a Self> for ExecutionPayloadHeaderBellatrix<E> {
     fn from(payload: &'a Self) -> Self {
         payload.clone()
     }
@@ -334,11 +345,13 @@ impl<'a, E: EthSpec> From<ExecutionPayloadRef<'a, E>> for ExecutionPayloadHeader
     }
 }
 
-impl<E: EthSpec> TryFrom<ExecutionPayloadHeader<E>> for ExecutionPayloadHeaderMerge<E> {
+impl<E: EthSpec> TryFrom<ExecutionPayloadHeader<E>> for ExecutionPayloadHeaderBellatrix<E> {
     type Error = BeaconStateError;
     fn try_from(header: ExecutionPayloadHeader<E>) -> Result<Self, Self::Error> {
         match header {
-            ExecutionPayloadHeader::Merge(execution_payload_header) => Ok(execution_payload_header),
+            ExecutionPayloadHeader::Bellatrix(execution_payload_header) => {
+                Ok(execution_payload_header)
+            }
             _ => Err(BeaconStateError::IncorrectStateVariant),
         }
     }
@@ -364,6 +377,27 @@ impl<E: EthSpec> TryFrom<ExecutionPayloadHeader<E>> for ExecutionPayloadHeaderDe
     }
 }
 
+impl<'a, E: EthSpec> ExecutionPayloadHeaderRefMut<'a, E> {
+    /// Mutate through
+    pub fn replace(self, header: ExecutionPayloadHeader<E>) -> Result<(), BeaconStateError> {
+        match self {
+            ExecutionPayloadHeaderRefMut::Bellatrix(mut_ref) => {
+                *mut_ref = header.try_into()?;
+            }
+            ExecutionPayloadHeaderRefMut::Capella(mut_ref) => {
+                *mut_ref = header.try_into()?;
+            }
+            ExecutionPayloadHeaderRefMut::Deneb(mut_ref) => {
+                *mut_ref = header.try_into()?;
+            }
+            ExecutionPayloadHeaderRefMut::Electra(mut_ref) => {
+                *mut_ref = header.try_into()?;
+            }
+        }
+        Ok(())
+    }
+}
+
 impl<E: EthSpec> TryFrom<ExecutionPayloadHeader<E>> for ExecutionPayloadHeaderElectra<E> {
     type Error = BeaconStateError;
     fn try_from(header: ExecutionPayloadHeader<E>) -> Result<Self, Self::Error> {
@@ -389,7 +423,9 @@ impl<E: EthSpec> ForkVersionDeserialize for ExecutionPayloadHeader<E> {
         };
 
         Ok(match fork_name {
-            ForkName::Merge => Self::Merge(serde_json::from_value(value).map_err(convert_err)?),
+            ForkName::Bellatrix => {
+                Self::Bellatrix(serde_json::from_value(value).map_err(convert_err)?)
+            }
             ForkName::Capella => Self::Capella(serde_json::from_value(value).map_err(convert_err)?),
             ForkName::Deneb => Self::Deneb(serde_json::from_value(value).map_err(convert_err)?),
             ForkName::Electra => Self::Electra(serde_json::from_value(value).map_err(convert_err)?),
diff --git a/consensus/types/src/fork_context.rs b/consensus/types/src/fork_context.rs
index 6b052d83976..0f7f0eb769e 100644
--- a/consensus/types/src/fork_context.rs
+++ b/consensus/types/src/fork_context.rs
@@ -36,11 +36,11 @@ impl ForkContext {
             ));
         }
 
-        // Only add Merge to list of forks if it's enabled
-        // Note: `bellatrix_fork_epoch == None` implies merge hasn't been activated yet on the config.
+        // Only add Bellatrix to list of forks if it's enabled
+        // Note: `bellatrix_fork_epoch == None` implies bellatrix hasn't been activated yet on the config.
         if spec.bellatrix_fork_epoch.is_some() {
             fork_to_digest.push((
-                ForkName::Merge,
+                ForkName::Bellatrix,
                 ChainSpec::compute_fork_digest(
                     spec.bellatrix_fork_version,
                     genesis_validators_root,
diff --git a/consensus/types/src/fork_name.rs b/consensus/types/src/fork_name.rs
index f6bd5cbadf9..5cc66214733 100644
--- a/consensus/types/src/fork_name.rs
+++ b/consensus/types/src/fork_name.rs
@@ -13,7 +13,7 @@ use std::str::FromStr;
 pub enum ForkName {
     Base,
     Altair,
-    Merge,
+    Bellatrix,
     Capella,
     Deneb,
     Electra,
@@ -24,7 +24,7 @@ impl ForkName {
         vec![
             ForkName::Base,
             ForkName::Altair,
-            ForkName::Merge,
+            ForkName::Bellatrix,
             ForkName::Capella,
             ForkName::Deneb,
             ForkName::Electra,
@@ -57,7 +57,7 @@ impl ForkName {
                 spec.electra_fork_epoch = None;
                 spec
             }
-            ForkName::Merge => {
+            ForkName::Bellatrix => {
                 spec.altair_fork_epoch = Some(Epoch::new(0));
                 spec.bellatrix_fork_epoch = Some(Epoch::new(0));
                 spec.capella_fork_epoch = None;
@@ -99,8 +99,8 @@ impl ForkName {
         match self {
             ForkName::Base => None,
             ForkName::Altair => Some(ForkName::Base),
-            ForkName::Merge => Some(ForkName::Altair),
-            ForkName::Capella => Some(ForkName::Merge),
+            ForkName::Bellatrix => Some(ForkName::Altair),
+            ForkName::Capella => Some(ForkName::Bellatrix),
             ForkName::Deneb => Some(ForkName::Capella),
             ForkName::Electra => Some(ForkName::Deneb),
         }
@@ -112,8 +112,8 @@ impl ForkName {
     pub fn next_fork(self) -> Option<ForkName> {
         match self {
             ForkName::Base => Some(ForkName::Altair),
-            ForkName::Altair => Some(ForkName::Merge),
-            ForkName::Merge => Some(ForkName::Capella),
+            ForkName::Altair => Some(ForkName::Bellatrix),
+            ForkName::Bellatrix => Some(ForkName::Capella),
             ForkName::Capella => Some(ForkName::Deneb),
             ForkName::Deneb => Some(ForkName::Electra),
             ForkName::Electra => None,
@@ -154,9 +154,9 @@ macro_rules! map_fork_name_with {
                 let (value, extra_data) = $body;
                 ($t::Altair(value), extra_data)
             }
-            ForkName::Merge => {
+            ForkName::Bellatrix => {
                 let (value, extra_data) = $body;
-                ($t::Merge(value), extra_data)
+                ($t::Bellatrix(value), extra_data)
             }
             ForkName::Capella => {
                 let (value, extra_data) = $body;
@@ -181,7 +181,7 @@ impl FromStr for ForkName {
         Ok(match fork_name.to_lowercase().as_ref() {
             "phase0" | "base" => ForkName::Base,
             "altair" => ForkName::Altair,
-            "bellatrix" | "merge" => ForkName::Merge,
+            "bellatrix" | "merge" => ForkName::Bellatrix,
             "capella" => ForkName::Capella,
             "deneb" => ForkName::Deneb,
             "electra" => ForkName::Electra,
@@ -195,7 +195,7 @@ impl Display for ForkName {
         match self {
             ForkName::Base => "phase0".fmt(f),
             ForkName::Altair => "altair".fmt(f),
-            ForkName::Merge => "bellatrix".fmt(f),
+            ForkName::Bellatrix => "bellatrix".fmt(f),
             ForkName::Capella => "capella".fmt(f),
             ForkName::Deneb => "deneb".fmt(f),
             ForkName::Electra => "electra".fmt(f),
@@ -259,9 +259,9 @@ mod test {
 
     #[test]
     fn fork_name_bellatrix_or_merge() {
-        assert_eq!(ForkName::from_str("bellatrix"), Ok(ForkName::Merge));
-        assert_eq!(ForkName::from_str("merge"), Ok(ForkName::Merge));
-        assert_eq!(ForkName::Merge.to_string(), "bellatrix");
+        assert_eq!(ForkName::from_str("bellatrix"), Ok(ForkName::Bellatrix));
+        assert_eq!(ForkName::from_str("merge"), Ok(ForkName::Bellatrix));
+        assert_eq!(ForkName::Bellatrix.to_string(), "bellatrix");
     }
 
     #[test]
diff --git a/consensus/types/src/fork_versioned_response.rs b/consensus/types/src/fork_versioned_response.rs
index 195c083e295..cd78b5b3ca0 100644
--- a/consensus/types/src/fork_versioned_response.rs
+++ b/consensus/types/src/fork_versioned_response.rs
@@ -104,7 +104,8 @@ impl<T, M> ForkVersionedResponse<T, M> {
 #[cfg(test)]
 mod fork_version_response_tests {
     use crate::{
-        ExecutionPayload, ExecutionPayloadMerge, ForkName, ForkVersionedResponse, MainnetEthSpec,
+        ExecutionPayload, ExecutionPayloadBellatrix, ForkName, ForkVersionedResponse,
+        MainnetEthSpec,
     };
     use serde_json::json;
 
@@ -114,9 +115,9 @@ mod fork_version_response_tests {
 
         let response_json =
             serde_json::to_string(&json!(ForkVersionedResponse::<ExecutionPayload<E>> {
-                version: Some(ForkName::Merge),
+                version: Some(ForkName::Bellatrix),
                 metadata: Default::default(),
-                data: ExecutionPayload::Merge(ExecutionPayloadMerge::default()),
+                data: ExecutionPayload::Bellatrix(ExecutionPayloadBellatrix::default()),
             }))
             .unwrap();
 
@@ -134,7 +135,7 @@ mod fork_version_response_tests {
             serde_json::to_string(&json!(ForkVersionedResponse::<ExecutionPayload<E>> {
                 version: Some(ForkName::Capella),
                 metadata: Default::default(),
-                data: ExecutionPayload::Merge(ExecutionPayloadMerge::default()),
+                data: ExecutionPayload::Bellatrix(ExecutionPayloadBellatrix::default()),
             }))
             .unwrap();
 
diff --git a/consensus/types/src/graffiti.rs b/consensus/types/src/graffiti.rs
index bd4abe37d8f..c7a0081c9f7 100644
--- a/consensus/types/src/graffiti.rs
+++ b/consensus/types/src/graffiti.rs
@@ -47,6 +47,12 @@ impl Into<[u8; GRAFFITI_BYTES_LEN]> for Graffiti {
 #[serde(transparent)]
 pub struct GraffitiString(String);
 
+impl GraffitiString {
+    pub fn empty() -> Self {
+        Self(String::new())
+    }
+}
+
 impl FromStr for GraffitiString {
     type Err = String;
 
diff --git a/consensus/types/src/historical_batch.rs b/consensus/types/src/historical_batch.rs
index 1c565c0092d..7bac9699eb6 100644
--- a/consensus/types/src/historical_batch.rs
+++ b/consensus/types/src/historical_batch.rs
@@ -23,8 +23,10 @@ use tree_hash_derive::TreeHash;
 )]
 #[arbitrary(bound = "E: EthSpec")]
 pub struct HistoricalBatch<E: EthSpec> {
-    pub block_roots: FixedVector<Hash256, E::SlotsPerHistoricalRoot>,
-    pub state_roots: FixedVector<Hash256, E::SlotsPerHistoricalRoot>,
+    #[test_random(default)]
+    pub block_roots: Vector<Hash256, E::SlotsPerHistoricalRoot>,
+    #[test_random(default)]
+    pub state_roots: Vector<Hash256, E::SlotsPerHistoricalRoot>,
 }
 
 #[cfg(test)]
diff --git a/consensus/types/src/lib.rs b/consensus/types/src/lib.rs
index 6551ebc1dda..c170b6b70d5 100644
--- a/consensus/types/src/lib.rs
+++ b/consensus/types/src/lib.rs
@@ -29,16 +29,19 @@ pub mod bls_to_execution_change;
 pub mod builder_bid;
 pub mod chain_spec;
 pub mod checkpoint;
+pub mod consolidation;
 pub mod consts;
 pub mod contribution_and_proof;
 pub mod deposit;
 pub mod deposit_data;
 pub mod deposit_message;
+pub mod deposit_receipt;
 pub mod deposit_tree_snapshot;
 pub mod enr_fork_id;
 pub mod eth1_data;
 pub mod eth_spec;
 pub mod execution_block_hash;
+pub mod execution_layer_withdrawal_request;
 pub mod execution_payload;
 pub mod execution_payload_header;
 pub mod fork;
@@ -54,6 +57,9 @@ pub mod light_client_finality_update;
 pub mod light_client_optimistic_update;
 pub mod light_client_update;
 pub mod pending_attestation;
+pub mod pending_balance_deposit;
+pub mod pending_consolidation;
+pub mod pending_partial_withdrawal;
 pub mod proposer_preparation_data;
 pub mod proposer_slashing;
 pub mod relative_epoch;
@@ -63,6 +69,7 @@ pub mod signed_aggregate_and_proof;
 pub mod signed_beacon_block;
 pub mod signed_beacon_block_header;
 pub mod signed_bls_to_execution_change;
+pub mod signed_consolidation;
 pub mod signed_contribution_and_proof;
 pub mod signed_voluntary_exit;
 pub mod signing_data;
@@ -91,7 +98,6 @@ pub mod sync_committee_contribution;
 pub mod sync_committee_message;
 pub mod sync_selection_proof;
 pub mod sync_subnet_id;
-mod tree_hash_impls;
 pub mod validator_registration_data;
 pub mod withdrawal;
 
@@ -114,18 +120,18 @@ pub use crate::attestation_data::AttestationData;
 pub use crate::attestation_duty::AttestationDuty;
 pub use crate::attester_slashing::AttesterSlashing;
 pub use crate::beacon_block::{
-    BeaconBlock, BeaconBlockAltair, BeaconBlockBase, BeaconBlockCapella, BeaconBlockDeneb,
-    BeaconBlockElectra, BeaconBlockMerge, BeaconBlockRef, BeaconBlockRefMut, BlindedBeaconBlock,
-    EmptyBlock,
+    BeaconBlock, BeaconBlockAltair, BeaconBlockBase, BeaconBlockBellatrix, BeaconBlockCapella,
+    BeaconBlockDeneb, BeaconBlockElectra, BeaconBlockRef, BeaconBlockRefMut, BlindedBeaconBlock,
+    BlockImportSource, EmptyBlock,
 };
 pub use crate::beacon_block_body::{
-    BeaconBlockBody, BeaconBlockBodyAltair, BeaconBlockBodyBase, BeaconBlockBodyCapella,
-    BeaconBlockBodyDeneb, BeaconBlockBodyElectra, BeaconBlockBodyMerge, BeaconBlockBodyRef,
+    BeaconBlockBody, BeaconBlockBodyAltair, BeaconBlockBodyBase, BeaconBlockBodyBellatrix,
+    BeaconBlockBodyCapella, BeaconBlockBodyDeneb, BeaconBlockBodyElectra, BeaconBlockBodyRef,
     BeaconBlockBodyRefMut,
 };
 pub use crate::beacon_block_header::BeaconBlockHeader;
 pub use crate::beacon_committee::{BeaconCommittee, OwnedBeaconCommittee};
-pub use crate::beacon_state::{BeaconTreeHashCache, Error as BeaconStateError, *};
+pub use crate::beacon_state::{Error as BeaconStateError, *};
 pub use crate::blob_sidecar::{BlobSidecar, BlobSidecarList, BlobsList};
 pub use crate::bls_to_execution_change::BlsToExecutionChange;
 pub use crate::chain_spec::{ChainSpec, Config, Domain};
@@ -133,10 +139,12 @@ pub use crate::checkpoint::Checkpoint;
 pub use crate::config_and_preset::{
     ConfigAndPreset, ConfigAndPresetCapella, ConfigAndPresetDeneb, ConfigAndPresetElectra,
 };
+pub use crate::consolidation::Consolidation;
 pub use crate::contribution_and_proof::ContributionAndProof;
 pub use crate::deposit::{Deposit, DEPOSIT_TREE_DEPTH};
 pub use crate::deposit_data::DepositData;
 pub use crate::deposit_message::DepositMessage;
+pub use crate::deposit_receipt::DepositReceipt;
 pub use crate::deposit_tree_snapshot::{DepositTreeSnapshot, FinalizedExecutionBlock};
 pub use crate::enr_fork_id::EnrForkId;
 pub use crate::epoch_cache::{EpochCache, EpochCacheError, EpochCacheKey};
@@ -144,13 +152,14 @@ pub use crate::eth1_data::Eth1Data;
 pub use crate::eth_spec::EthSpecId;
 pub use crate::execution_block_hash::ExecutionBlockHash;
 pub use crate::execution_block_header::ExecutionBlockHeader;
+pub use crate::execution_layer_withdrawal_request::ExecutionLayerWithdrawalRequest;
 pub use crate::execution_payload::{
-    ExecutionPayload, ExecutionPayloadCapella, ExecutionPayloadDeneb, ExecutionPayloadElectra,
-    ExecutionPayloadMerge, ExecutionPayloadRef, Transaction, Transactions, Withdrawals,
+    ExecutionPayload, ExecutionPayloadBellatrix, ExecutionPayloadCapella, ExecutionPayloadDeneb,
+    ExecutionPayloadElectra, ExecutionPayloadRef, Transaction, Transactions, Withdrawals,
 };
 pub use crate::execution_payload_header::{
-    ExecutionPayloadHeader, ExecutionPayloadHeaderCapella, ExecutionPayloadHeaderDeneb,
-    ExecutionPayloadHeaderElectra, ExecutionPayloadHeaderMerge, ExecutionPayloadHeaderRef,
+    ExecutionPayloadHeader, ExecutionPayloadHeaderBellatrix, ExecutionPayloadHeaderCapella,
+    ExecutionPayloadHeaderDeneb, ExecutionPayloadHeaderElectra, ExecutionPayloadHeaderRef,
     ExecutionPayloadHeaderRefMut,
 };
 pub use crate::fork::Fork;
@@ -183,12 +192,15 @@ pub use crate::light_client_update::{
 pub use crate::participation_flags::ParticipationFlags;
 pub use crate::participation_list::ParticipationList;
 pub use crate::payload::{
-    AbstractExecPayload, BlindedPayload, BlindedPayloadCapella, BlindedPayloadDeneb,
-    BlindedPayloadElectra, BlindedPayloadMerge, BlindedPayloadRef, BlockType, ExecPayload,
-    FullPayload, FullPayloadCapella, FullPayloadDeneb, FullPayloadElectra, FullPayloadMerge,
+    AbstractExecPayload, BlindedPayload, BlindedPayloadBellatrix, BlindedPayloadCapella,
+    BlindedPayloadDeneb, BlindedPayloadElectra, BlindedPayloadRef, BlockType, ExecPayload,
+    FullPayload, FullPayloadBellatrix, FullPayloadCapella, FullPayloadDeneb, FullPayloadElectra,
     FullPayloadRef, OwnedExecPayload,
 };
 pub use crate::pending_attestation::PendingAttestation;
+pub use crate::pending_balance_deposit::PendingBalanceDeposit;
+pub use crate::pending_consolidation::PendingConsolidation;
+pub use crate::pending_partial_withdrawal::PendingPartialWithdrawal;
 pub use crate::preset::{
     AltairPreset, BasePreset, BellatrixPreset, CapellaPreset, DenebPreset, ElectraPreset,
 };
@@ -201,12 +213,13 @@ pub use crate::shuffling_id::AttestationShufflingId;
 pub use crate::signed_aggregate_and_proof::SignedAggregateAndProof;
 pub use crate::signed_beacon_block::{
     ssz_tagged_signed_beacon_block, ssz_tagged_signed_beacon_block_arc, SignedBeaconBlock,
-    SignedBeaconBlockAltair, SignedBeaconBlockBase, SignedBeaconBlockCapella,
-    SignedBeaconBlockDeneb, SignedBeaconBlockElectra, SignedBeaconBlockHash,
-    SignedBeaconBlockMerge, SignedBlindedBeaconBlock,
+    SignedBeaconBlockAltair, SignedBeaconBlockBase, SignedBeaconBlockBellatrix,
+    SignedBeaconBlockCapella, SignedBeaconBlockDeneb, SignedBeaconBlockElectra,
+    SignedBeaconBlockHash, SignedBlindedBeaconBlock,
 };
 pub use crate::signed_beacon_block_header::SignedBeaconBlockHeader;
 pub use crate::signed_bls_to_execution_change::SignedBlsToExecutionChange;
+pub use crate::signed_consolidation::SignedConsolidation;
 pub use crate::signed_contribution_and_proof::SignedContributionAndProof;
 pub use crate::signed_voluntary_exit::SignedVoluntaryExit;
 pub use crate::signing_data::{SignedRoot, SigningData};
@@ -243,8 +256,7 @@ pub use bls::{
     AggregatePublicKey, AggregateSignature, Keypair, PublicKey, PublicKeyBytes, SecretKey,
     Signature, SignatureBytes,
 };
-
 pub use kzg::{KzgCommitment, KzgProof, VERSIONED_HASH_VERSION_KZG};
-
+pub use milhouse::{self, List, Vector};
 pub use ssz_types::{typenum, typenum::Unsigned, BitList, BitVector, FixedVector, VariableList};
 pub use superstruct::superstruct;
diff --git a/consensus/types/src/light_client_bootstrap.rs b/consensus/types/src/light_client_bootstrap.rs
index 33fbf214c80..61da0e1b117 100644
--- a/consensus/types/src/light_client_bootstrap.rs
+++ b/consensus/types/src/light_client_bootstrap.rs
@@ -1,8 +1,7 @@
-use super::{BeaconState, EthSpec, FixedVector, Hash256, LightClientHeader, SyncCommittee};
 use crate::{
-    light_client_update::*, test_utils::TestRandom, ChainSpec, ForkName, ForkVersionDeserialize,
-    LightClientHeaderAltair, LightClientHeaderCapella, LightClientHeaderDeneb, SignedBeaconBlock,
-    Slot,
+    light_client_update::*, test_utils::TestRandom, BeaconState, ChainSpec, EthSpec, FixedVector,
+    ForkName, ForkVersionDeserialize, Hash256, LightClientHeader, LightClientHeaderAltair,
+    LightClientHeaderCapella, LightClientHeaderDeneb, SignedBeaconBlock, Slot, SyncCommittee,
 };
 use derivative::Derivative;
 use serde::{Deserialize, Deserializer, Serialize};
@@ -79,7 +78,7 @@ impl<E: EthSpec> LightClientBootstrap<E> {
 
     pub fn from_ssz_bytes(bytes: &[u8], fork_name: ForkName) -> Result<Self, ssz::DecodeError> {
         let bootstrap = match fork_name {
-            ForkName::Altair | ForkName::Merge => {
+            ForkName::Altair | ForkName::Bellatrix => {
                 Self::Altair(LightClientBootstrapAltair::from_ssz_bytes(bytes)?)
             }
             ForkName::Capella => Self::Capella(LightClientBootstrapCapella::from_ssz_bytes(bytes)?),
@@ -102,7 +101,7 @@ impl<E: EthSpec> LightClientBootstrap<E> {
         match fork_name {
             ForkName::Base => 0,
             ForkName::Altair
-            | ForkName::Merge
+            | ForkName::Bellatrix
             | ForkName::Capella
             | ForkName::Deneb
             | ForkName::Electra => {
@@ -129,7 +128,7 @@ impl<E: EthSpec> LightClientBootstrap<E> {
             .map_err(|_| Error::InconsistentFork)?
         {
             ForkName::Base => return Err(Error::AltairForkNotActive),
-            ForkName::Altair | ForkName::Merge => Self::Altair(LightClientBootstrapAltair {
+            ForkName::Altair | ForkName::Bellatrix => Self::Altair(LightClientBootstrapAltair {
                 header: LightClientHeaderAltair::block_to_light_client_header(block)?,
                 current_sync_committee,
                 current_sync_committee_branch,
diff --git a/consensus/types/src/light_client_finality_update.rs b/consensus/types/src/light_client_finality_update.rs
index c5c730e8b83..29c526e2916 100644
--- a/consensus/types/src/light_client_finality_update.rs
+++ b/consensus/types/src/light_client_finality_update.rs
@@ -58,6 +58,7 @@ pub struct LightClientFinalityUpdate<E: EthSpec> {
     #[superstruct(only(Deneb), partial_getter(rename = "finalized_header_deneb"))]
     pub finalized_header: LightClientHeaderDeneb<E>,
     /// Merkle proof attesting finalized header.
+    #[test_random(default)]
     pub finality_branch: FixedVector<Hash256, FinalizedRootProofLen>,
     /// current sync aggregate
     pub sync_aggregate: SyncAggregate<E>,
@@ -78,7 +79,7 @@ impl<E: EthSpec> LightClientFinalityUpdate<E> {
             .fork_name(chain_spec)
             .map_err(|_| Error::InconsistentFork)?
         {
-            ForkName::Altair | ForkName::Merge => {
+            ForkName::Altair | ForkName::Bellatrix => {
                 let finality_update = LightClientFinalityUpdateAltair {
                     attested_header: LightClientHeaderAltair::block_to_light_client_header(
                         attested_block,
@@ -146,7 +147,7 @@ impl<E: EthSpec> LightClientFinalityUpdate<E> {
 
     pub fn from_ssz_bytes(bytes: &[u8], fork_name: ForkName) -> Result<Self, ssz::DecodeError> {
         let finality_update = match fork_name {
-            ForkName::Altair | ForkName::Merge => {
+            ForkName::Altair | ForkName::Bellatrix => {
                 Self::Altair(LightClientFinalityUpdateAltair::from_ssz_bytes(bytes)?)
             }
             ForkName::Capella => {
@@ -171,7 +172,7 @@ impl<E: EthSpec> LightClientFinalityUpdate<E> {
         match fork_name {
             ForkName::Base => 0,
             ForkName::Altair
-            | ForkName::Merge
+            | ForkName::Bellatrix
             | ForkName::Capella
             | ForkName::Deneb
             | ForkName::Electra => {
diff --git a/consensus/types/src/light_client_header.rs b/consensus/types/src/light_client_header.rs
index 647ece99499..213ec90f955 100644
--- a/consensus/types/src/light_client_header.rs
+++ b/consensus/types/src/light_client_header.rs
@@ -75,7 +75,7 @@ impl<E: EthSpec> LightClientHeader<E> {
             .map_err(|_| Error::InconsistentFork)?
         {
             ForkName::Base => return Err(Error::AltairForkNotActive),
-            ForkName::Altair | ForkName::Merge => LightClientHeader::Altair(
+            ForkName::Altair | ForkName::Bellatrix => LightClientHeader::Altair(
                 LightClientHeaderAltair::block_to_light_client_header(block)?,
             ),
             ForkName::Capella => LightClientHeader::Capella(
@@ -90,7 +90,7 @@ impl<E: EthSpec> LightClientHeader<E> {
 
     pub fn from_ssz_bytes(bytes: &[u8], fork_name: ForkName) -> Result<Self, ssz::DecodeError> {
         let header = match fork_name {
-            ForkName::Altair | ForkName::Merge => {
+            ForkName::Altair | ForkName::Bellatrix => {
                 LightClientHeader::Altair(LightClientHeaderAltair::from_ssz_bytes(bytes)?)
             }
             ForkName::Capella => {
@@ -119,7 +119,7 @@ impl<E: EthSpec> LightClientHeader<E> {
 
     pub fn ssz_max_var_len_for_fork(fork_name: ForkName) -> usize {
         match fork_name {
-            ForkName::Base | ForkName::Altair | ForkName::Merge => 0,
+            ForkName::Base | ForkName::Altair | ForkName::Bellatrix => 0,
             ForkName::Capella | ForkName::Deneb | ForkName::Electra => {
                 ExecutionPayloadHeader::<E>::ssz_max_var_len_for_fork(fork_name)
             }
@@ -198,7 +198,7 @@ impl<E: EthSpec> ForkVersionDeserialize for LightClientHeader<E> {
         fork_name: ForkName,
     ) -> Result<Self, D::Error> {
         match fork_name {
-            ForkName::Altair | ForkName::Merge => serde_json::from_value(value)
+            ForkName::Altair | ForkName::Bellatrix => serde_json::from_value(value)
                 .map(|light_client_header| Self::Altair(light_client_header))
                 .map_err(serde::de::Error::custom),
             ForkName::Capella => serde_json::from_value(value)
diff --git a/consensus/types/src/light_client_optimistic_update.rs b/consensus/types/src/light_client_optimistic_update.rs
index d22c4535f1e..4727673f6c0 100644
--- a/consensus/types/src/light_client_optimistic_update.rs
+++ b/consensus/types/src/light_client_optimistic_update.rs
@@ -70,13 +70,15 @@ impl<E: EthSpec> LightClientOptimisticUpdate<E> {
             .fork_name(chain_spec)
             .map_err(|_| Error::InconsistentFork)?
         {
-            ForkName::Altair | ForkName::Merge => Self::Altair(LightClientOptimisticUpdateAltair {
-                attested_header: LightClientHeaderAltair::block_to_light_client_header(
-                    attested_block,
-                )?,
-                sync_aggregate,
-                signature_slot,
-            }),
+            ForkName::Altair | ForkName::Bellatrix => {
+                Self::Altair(LightClientOptimisticUpdateAltair {
+                    attested_header: LightClientHeaderAltair::block_to_light_client_header(
+                        attested_block,
+                    )?,
+                    sync_aggregate,
+                    signature_slot,
+                })
+            }
             ForkName::Capella => Self::Capella(LightClientOptimisticUpdateCapella {
                 attested_header: LightClientHeaderCapella::block_to_light_client_header(
                     attested_block,
@@ -131,7 +133,7 @@ impl<E: EthSpec> LightClientOptimisticUpdate<E> {
 
     pub fn from_ssz_bytes(bytes: &[u8], fork_name: ForkName) -> Result<Self, ssz::DecodeError> {
         let optimistic_update = match fork_name {
-            ForkName::Altair | ForkName::Merge => {
+            ForkName::Altair | ForkName::Bellatrix => {
                 Self::Altair(LightClientOptimisticUpdateAltair::from_ssz_bytes(bytes)?)
             }
             ForkName::Capella => {
@@ -156,7 +158,7 @@ impl<E: EthSpec> LightClientOptimisticUpdate<E> {
         match fork_name {
             ForkName::Base => 0,
             ForkName::Altair
-            | ForkName::Merge
+            | ForkName::Bellatrix
             | ForkName::Capella
             | ForkName::Deneb
             | ForkName::Electra => {
diff --git a/consensus/types/src/light_client_update.rs b/consensus/types/src/light_client_update.rs
index af9cbc16610..002fbea2d37 100644
--- a/consensus/types/src/light_client_update.rs
+++ b/consensus/types/src/light_client_update.rs
@@ -37,6 +37,7 @@ pub const EXECUTION_PAYLOAD_PROOF_LEN: usize = 4;
 #[derive(Debug, PartialEq, Clone)]
 pub enum Error {
     SszTypesError(ssz_types::Error),
+    MilhouseError(milhouse::Error),
     BeaconStateError(beacon_state::Error),
     ArithError(ArithError),
     AltairForkNotActive,
@@ -65,6 +66,12 @@ impl From<ArithError> for Error {
     }
 }
 
+impl From<milhouse::Error> for Error {
+    fn from(e: milhouse::Error) -> Error {
+        Error::MilhouseError(e)
+    }
+}
+
 /// A LightClientUpdate is the update we request solely to either complete the bootstrapping process,
 /// or to sync up to the last committee period, we need to have one ready for each ALTAIR period
 /// we go over, note: there is no need to keep all of the updates from [ALTAIR_PERIOD, CURRENT_PERIOD].
@@ -184,7 +191,7 @@ impl<E: EthSpec> LightClientUpdate<E> {
             .map_err(|_| Error::InconsistentFork)?
         {
             ForkName::Base => return Err(Error::AltairForkNotActive),
-            ForkName::Altair | ForkName::Merge => {
+            ForkName::Altair | ForkName::Bellatrix => {
                 let attested_header =
                     LightClientHeaderAltair::block_to_light_client_header(attested_block)?;
                 let finalized_header =
@@ -236,7 +243,7 @@ impl<E: EthSpec> LightClientUpdate<E> {
 
     pub fn from_ssz_bytes(bytes: &[u8], fork_name: ForkName) -> Result<Self, ssz::DecodeError> {
         let update = match fork_name {
-            ForkName::Altair | ForkName::Merge => {
+            ForkName::Altair | ForkName::Bellatrix => {
                 Self::Altair(LightClientUpdateAltair::from_ssz_bytes(bytes)?)
             }
             ForkName::Capella => Self::Capella(LightClientUpdateCapella::from_ssz_bytes(bytes)?),
diff --git a/consensus/types/src/payload.rs b/consensus/types/src/payload.rs
index 18b3199bd35..80a70c171f5 100644
--- a/consensus/types/src/payload.rs
+++ b/consensus/types/src/payload.rs
@@ -79,22 +79,22 @@ pub trait AbstractExecPayload<E: EthSpec>:
     + Sized
     + From<ExecutionPayload<E>>
     + TryFrom<ExecutionPayloadHeader<E>>
-    + TryInto<Self::Merge>
+    + TryInto<Self::Bellatrix>
     + TryInto<Self::Capella>
     + TryInto<Self::Deneb>
     + TryInto<Self::Electra>
 {
     type Ref<'a>: ExecPayload<E>
         + Copy
-        + From<&'a Self::Merge>
+        + From<&'a Self::Bellatrix>
         + From<&'a Self::Capella>
         + From<&'a Self::Deneb>
         + From<&'a Self::Electra>;
 
-    type Merge: OwnedExecPayload<E>
+    type Bellatrix: OwnedExecPayload<E>
         + Into<Self>
-        + for<'a> From<Cow<'a, ExecutionPayloadMerge<E>>>
-        + TryFrom<ExecutionPayloadHeaderMerge<E>>;
+        + for<'a> From<Cow<'a, ExecutionPayloadBellatrix<E>>>
+        + TryFrom<ExecutionPayloadHeaderBellatrix<E>>;
     type Capella: OwnedExecPayload<E>
         + Into<Self>
         + for<'a> From<Cow<'a, ExecutionPayloadCapella<E>>>
@@ -110,7 +110,7 @@ pub trait AbstractExecPayload<E: EthSpec>:
 }
 
 #[superstruct(
-    variants(Merge, Capella, Deneb, Electra),
+    variants(Bellatrix, Capella, Deneb, Electra),
     variant_attributes(
         derive(
             Debug,
@@ -145,8 +145,11 @@ pub trait AbstractExecPayload<E: EthSpec>:
 #[arbitrary(bound = "E: EthSpec")]
 #[tree_hash(enum_behaviour = "transparent")]
 pub struct FullPayload<E: EthSpec> {
-    #[superstruct(only(Merge), partial_getter(rename = "execution_payload_merge"))]
-    pub execution_payload: ExecutionPayloadMerge<E>,
+    #[superstruct(
+        only(Bellatrix),
+        partial_getter(rename = "execution_payload_bellatrix")
+    )]
+    pub execution_payload: ExecutionPayloadBellatrix<E>,
     #[superstruct(only(Capella), partial_getter(rename = "execution_payload_capella"))]
     pub execution_payload: ExecutionPayloadCapella<E>,
     #[superstruct(only(Deneb), partial_getter(rename = "execution_payload_deneb"))]
@@ -252,7 +255,7 @@ impl<E: EthSpec> ExecPayload<E> for FullPayload<E> {
 
     fn withdrawals_root(&self) -> Result<Hash256, Error> {
         match self {
-            FullPayload::Merge(_) => Err(Error::IncorrectStateVariant),
+            FullPayload::Bellatrix(_) => Err(Error::IncorrectStateVariant),
             FullPayload::Capella(ref inner) => {
                 Ok(inner.execution_payload.withdrawals.tree_hash_root())
             }
@@ -267,7 +270,9 @@ impl<E: EthSpec> ExecPayload<E> for FullPayload<E> {
 
     fn blob_gas_used(&self) -> Result<u64, Error> {
         match self {
-            FullPayload::Merge(_) | FullPayload::Capella(_) => Err(Error::IncorrectStateVariant),
+            FullPayload::Bellatrix(_) | FullPayload::Capella(_) => {
+                Err(Error::IncorrectStateVariant)
+            }
             FullPayload::Deneb(ref inner) => Ok(inner.execution_payload.blob_gas_used),
             FullPayload::Electra(ref inner) => Ok(inner.execution_payload.blob_gas_used),
         }
@@ -296,7 +301,7 @@ impl<E: EthSpec> FullPayload<E> {
     pub fn default_at_fork(fork_name: ForkName) -> Result<Self, Error> {
         match fork_name {
             ForkName::Base | ForkName::Altair => Err(Error::IncorrectStateVariant),
-            ForkName::Merge => Ok(FullPayloadMerge::default().into()),
+            ForkName::Bellatrix => Ok(FullPayloadBellatrix::default().into()),
             ForkName::Capella => Ok(FullPayloadCapella::default().into()),
             ForkName::Deneb => Ok(FullPayloadDeneb::default().into()),
             ForkName::Electra => Ok(FullPayloadElectra::default().into()),
@@ -382,7 +387,7 @@ impl<'b, E: EthSpec> ExecPayload<E> for FullPayloadRef<'b, E> {
 
     fn withdrawals_root(&self) -> Result<Hash256, Error> {
         match self {
-            FullPayloadRef::Merge(_) => Err(Error::IncorrectStateVariant),
+            FullPayloadRef::Bellatrix(_) => Err(Error::IncorrectStateVariant),
             FullPayloadRef::Capella(inner) => {
                 Ok(inner.execution_payload.withdrawals.tree_hash_root())
             }
@@ -397,7 +402,7 @@ impl<'b, E: EthSpec> ExecPayload<E> for FullPayloadRef<'b, E> {
 
     fn blob_gas_used(&self) -> Result<u64, Error> {
         match self {
-            FullPayloadRef::Merge(_) | FullPayloadRef::Capella(_) => {
+            FullPayloadRef::Bellatrix(_) | FullPayloadRef::Capella(_) => {
                 Err(Error::IncorrectStateVariant)
             }
             FullPayloadRef::Deneb(inner) => Ok(inner.execution_payload.blob_gas_used),
@@ -420,7 +425,7 @@ impl<'b, E: EthSpec> ExecPayload<E> for FullPayloadRef<'b, E> {
 
 impl<E: EthSpec> AbstractExecPayload<E> for FullPayload<E> {
     type Ref<'a> = FullPayloadRef<'a, E>;
-    type Merge = FullPayloadMerge<E>;
+    type Bellatrix = FullPayloadBellatrix<E>;
     type Capella = FullPayloadCapella<E>;
     type Deneb = FullPayloadDeneb<E>;
     type Electra = FullPayloadElectra<E>;
@@ -442,7 +447,7 @@ impl<E: EthSpec> TryFrom<ExecutionPayloadHeader<E>> for FullPayload<E> {
 }
 
 #[superstruct(
-    variants(Merge, Capella, Deneb, Electra),
+    variants(Bellatrix, Capella, Deneb, Electra),
     variant_attributes(
         derive(
             Debug,
@@ -476,8 +481,11 @@ impl<E: EthSpec> TryFrom<ExecutionPayloadHeader<E>> for FullPayload<E> {
 #[arbitrary(bound = "E: EthSpec")]
 #[tree_hash(enum_behaviour = "transparent")]
 pub struct BlindedPayload<E: EthSpec> {
-    #[superstruct(only(Merge), partial_getter(rename = "execution_payload_merge"))]
-    pub execution_payload_header: ExecutionPayloadHeaderMerge<E>,
+    #[superstruct(
+        only(Bellatrix),
+        partial_getter(rename = "execution_payload_bellatrix")
+    )]
+    pub execution_payload_header: ExecutionPayloadHeaderBellatrix<E>,
     #[superstruct(only(Capella), partial_getter(rename = "execution_payload_capella"))]
     pub execution_payload_header: ExecutionPayloadHeaderCapella<E>,
     #[superstruct(only(Deneb), partial_getter(rename = "execution_payload_deneb"))]
@@ -561,7 +569,7 @@ impl<E: EthSpec> ExecPayload<E> for BlindedPayload<E> {
 
     fn withdrawals_root(&self) -> Result<Hash256, Error> {
         match self {
-            BlindedPayload::Merge(_) => Err(Error::IncorrectStateVariant),
+            BlindedPayload::Bellatrix(_) => Err(Error::IncorrectStateVariant),
             BlindedPayload::Capella(ref inner) => {
                 Ok(inner.execution_payload_header.withdrawals_root)
             }
@@ -574,7 +582,7 @@ impl<E: EthSpec> ExecPayload<E> for BlindedPayload<E> {
 
     fn blob_gas_used(&self) -> Result<u64, Error> {
         match self {
-            BlindedPayload::Merge(_) | BlindedPayload::Capella(_) => {
+            BlindedPayload::Bellatrix(_) | BlindedPayload::Capella(_) => {
                 Err(Error::IncorrectStateVariant)
             }
             BlindedPayload::Deneb(ref inner) => Ok(inner.execution_payload_header.blob_gas_used),
@@ -662,7 +670,7 @@ impl<'b, E: EthSpec> ExecPayload<E> for BlindedPayloadRef<'b, E> {
 
     fn withdrawals_root(&self) -> Result<Hash256, Error> {
         match self {
-            BlindedPayloadRef::Merge(_) => Err(Error::IncorrectStateVariant),
+            BlindedPayloadRef::Bellatrix(_) => Err(Error::IncorrectStateVariant),
             BlindedPayloadRef::Capella(inner) => {
                 Ok(inner.execution_payload_header.withdrawals_root)
             }
@@ -675,7 +683,7 @@ impl<'b, E: EthSpec> ExecPayload<E> for BlindedPayloadRef<'b, E> {
 
     fn blob_gas_used(&self) -> Result<u64, Error> {
         match self {
-            BlindedPayloadRef::Merge(_) | BlindedPayloadRef::Capella(_) => {
+            BlindedPayloadRef::Bellatrix(_) | BlindedPayloadRef::Capella(_) => {
                 Err(Error::IncorrectStateVariant)
             }
             BlindedPayloadRef::Deneb(inner) => Ok(inner.execution_payload_header.blob_gas_used),
@@ -699,12 +707,12 @@ impl<'b, E: EthSpec> ExecPayload<E> for BlindedPayloadRef<'b, E> {
 }
 
 macro_rules! impl_exec_payload_common {
-    ($wrapper_type:ident,           // BlindedPayloadMerge          |   FullPayloadMerge
-     $wrapped_type:ident,           // ExecutionPayloadHeaderMerge  |   ExecutionPayloadMerge
-     $wrapped_type_full:ident,      // ExecutionPayloadMerge        |   ExecutionPayloadMerge
-     $wrapped_type_header:ident,    // ExecutionPayloadHeaderMerge  |   ExecutionPayloadHeaderMerge
+    ($wrapper_type:ident,           // BlindedPayloadBellatrix          |   FullPayloadBellatrix
+     $wrapped_type:ident,           // ExecutionPayloadHeaderBellatrix  |   ExecutionPayloadBellatrix
+     $wrapped_type_full:ident,      // ExecutionPayloadBellatrix        |   ExecutionPayloadBellatrix
+     $wrapped_type_header:ident,    // ExecutionPayloadHeaderBellatrix  |   ExecutionPayloadHeaderBellatrix
      $wrapped_field:ident,          // execution_payload_header     |   execution_payload
-     $fork_variant:ident,           // Merge                        |   Merge
+     $fork_variant:ident,           // Bellatrix                    |   Bellatrix
      $block_type_variant:ident,     // Blinded                      |   Full
      $is_default_with_empty_roots:block,
      $f:block,
@@ -783,17 +791,17 @@ macro_rules! impl_exec_payload_common {
 }
 
 macro_rules! impl_exec_payload_for_fork {
-    // BlindedPayloadMerge, FullPayloadMerge, ExecutionPayloadHeaderMerge, ExecutionPayloadMerge, Merge
+    // BlindedPayloadBellatrix, FullPayloadBellatrix, ExecutionPayloadHeaderBellatrix, ExecutionPayloadBellatrix, Bellatrix
     ($wrapper_type_header:ident, $wrapper_type_full:ident, $wrapped_type_header:ident, $wrapped_type_full:ident, $fork_variant:ident) => {
         //*************** Blinded payload implementations ******************//
 
         impl_exec_payload_common!(
-            $wrapper_type_header, // BlindedPayloadMerge
-            $wrapped_type_header, // ExecutionPayloadHeaderMerge
-            $wrapped_type_full,   // ExecutionPayloadMerge
-            $wrapped_type_header, // ExecutionPayloadHeaderMerge
+            $wrapper_type_header, // BlindedPayloadBellatrix
+            $wrapped_type_header, // ExecutionPayloadHeaderBellatrix
+            $wrapped_type_full,   // ExecutionPayloadBellatrix
+            $wrapped_type_header, // ExecutionPayloadHeaderBellatrix
             execution_payload_header,
-            $fork_variant, // Merge
+            $fork_variant, // Bellatrix
             Blinded,
             {
                 |wrapper: &$wrapper_type_header<E>| {
@@ -872,12 +880,12 @@ macro_rules! impl_exec_payload_for_fork {
         //*************** Full payload implementations ******************//
 
         impl_exec_payload_common!(
-            $wrapper_type_full,   // FullPayloadMerge
-            $wrapped_type_full,   // ExecutionPayloadMerge
-            $wrapped_type_full,   // ExecutionPayloadMerge
-            $wrapped_type_header, // ExecutionPayloadHeaderMerge
+            $wrapper_type_full,   // FullPayloadBellatrix
+            $wrapped_type_full,   // ExecutionPayloadBellatrix
+            $wrapped_type_full,   // ExecutionPayloadBellatrix
+            $wrapped_type_header, // ExecutionPayloadHeaderBellatrix
             execution_payload,
-            $fork_variant, // Merge
+            $fork_variant, // Bellatrix
             Full,
             {
                 |wrapper: &$wrapper_type_full<E>| {
@@ -952,11 +960,11 @@ macro_rules! impl_exec_payload_for_fork {
 }
 
 impl_exec_payload_for_fork!(
-    BlindedPayloadMerge,
-    FullPayloadMerge,
-    ExecutionPayloadHeaderMerge,
-    ExecutionPayloadMerge,
-    Merge
+    BlindedPayloadBellatrix,
+    FullPayloadBellatrix,
+    ExecutionPayloadHeaderBellatrix,
+    ExecutionPayloadBellatrix,
+    Bellatrix
 );
 impl_exec_payload_for_fork!(
     BlindedPayloadCapella,
@@ -982,7 +990,7 @@ impl_exec_payload_for_fork!(
 
 impl<E: EthSpec> AbstractExecPayload<E> for BlindedPayload<E> {
     type Ref<'a> = BlindedPayloadRef<'a, E>;
-    type Merge = BlindedPayloadMerge<E>;
+    type Bellatrix = BlindedPayloadBellatrix<E>;
     type Capella = BlindedPayloadCapella<E>;
     type Deneb = BlindedPayloadDeneb<E>;
     type Electra = BlindedPayloadElectra<E>;
@@ -1002,8 +1010,8 @@ impl<E: EthSpec> From<ExecutionPayload<E>> for BlindedPayload<E> {
 impl<E: EthSpec> From<ExecutionPayloadHeader<E>> for BlindedPayload<E> {
     fn from(execution_payload_header: ExecutionPayloadHeader<E>) -> Self {
         match execution_payload_header {
-            ExecutionPayloadHeader::Merge(execution_payload_header) => {
-                Self::Merge(BlindedPayloadMerge {
+            ExecutionPayloadHeader::Bellatrix(execution_payload_header) => {
+                Self::Bellatrix(BlindedPayloadBellatrix {
                     execution_payload_header,
                 })
             }
@@ -1029,8 +1037,8 @@ impl<E: EthSpec> From<ExecutionPayloadHeader<E>> for BlindedPayload<E> {
 impl<E: EthSpec> From<BlindedPayload<E>> for ExecutionPayloadHeader<E> {
     fn from(blinded: BlindedPayload<E>) -> Self {
         match blinded {
-            BlindedPayload::Merge(blinded_payload) => {
-                ExecutionPayloadHeader::Merge(blinded_payload.execution_payload_header)
+            BlindedPayload::Bellatrix(blinded_payload) => {
+                ExecutionPayloadHeader::Bellatrix(blinded_payload.execution_payload_header)
             }
             BlindedPayload::Capella(blinded_payload) => {
                 ExecutionPayloadHeader::Capella(blinded_payload.execution_payload_header)
diff --git a/consensus/types/src/pending_balance_deposit.rs b/consensus/types/src/pending_balance_deposit.rs
new file mode 100644
index 00000000000..a2bce577f87
--- /dev/null
+++ b/consensus/types/src/pending_balance_deposit.rs
@@ -0,0 +1,33 @@
+use crate::test_utils::TestRandom;
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use test_random_derive::TestRandom;
+use tree_hash_derive::TreeHash;
+
+#[derive(
+    arbitrary::Arbitrary,
+    Debug,
+    PartialEq,
+    Eq,
+    Hash,
+    Clone,
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    TreeHash,
+    TestRandom,
+)]
+pub struct PendingBalanceDeposit {
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub index: u64,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub amount: u64,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    ssz_and_tree_hash_tests!(PendingBalanceDeposit);
+}
diff --git a/consensus/types/src/pending_consolidation.rs b/consensus/types/src/pending_consolidation.rs
new file mode 100644
index 00000000000..6e0b74a7383
--- /dev/null
+++ b/consensus/types/src/pending_consolidation.rs
@@ -0,0 +1,33 @@
+use crate::test_utils::TestRandom;
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use test_random_derive::TestRandom;
+use tree_hash_derive::TreeHash;
+
+#[derive(
+    arbitrary::Arbitrary,
+    Debug,
+    PartialEq,
+    Eq,
+    Hash,
+    Clone,
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    TreeHash,
+    TestRandom,
+)]
+pub struct PendingConsolidation {
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub source_index: u64,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub target_index: u64,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    ssz_and_tree_hash_tests!(PendingConsolidation);
+}
diff --git a/consensus/types/src/pending_partial_withdrawal.rs b/consensus/types/src/pending_partial_withdrawal.rs
new file mode 100644
index 00000000000..e5ace7b2736
--- /dev/null
+++ b/consensus/types/src/pending_partial_withdrawal.rs
@@ -0,0 +1,35 @@
+use crate::test_utils::TestRandom;
+use crate::Epoch;
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use test_random_derive::TestRandom;
+use tree_hash_derive::TreeHash;
+
+#[derive(
+    arbitrary::Arbitrary,
+    Debug,
+    PartialEq,
+    Eq,
+    Hash,
+    Clone,
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    TreeHash,
+    TestRandom,
+)]
+pub struct PendingPartialWithdrawal {
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub index: u64,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub amount: u64,
+    pub withdrawable_epoch: Epoch,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    ssz_and_tree_hash_tests!(PendingPartialWithdrawal);
+}
diff --git a/consensus/types/src/preset.rs b/consensus/types/src/preset.rs
index 626a45d971d..f4008d62e1d 100644
--- a/consensus/types/src/preset.rs
+++ b/consensus/types/src/preset.rs
@@ -230,13 +230,50 @@ impl DenebPreset {
 #[serde(rename_all = "UPPERCASE")]
 pub struct ElectraPreset {
     #[serde(with = "serde_utils::quoted_u64")]
-    pub electra_placeholder: u64,
+    pub min_activation_balance: u64,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub max_effective_balance_electra: u64,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub min_slashing_penalty_quotient_electra: u64,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub whistleblower_reward_quotient_electra: u64,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub max_pending_partials_per_withdrawals_sweep: u64,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub pending_balance_deposits_limit: u64,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub pending_partial_withdrawals_limit: u64,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub pending_consolidations_limit: u64,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub max_consolidations: u64,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub max_deposit_receipts_per_payload: u64,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub max_attester_slashings_electra: u64,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub max_attestations_electra: u64,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub max_withdrawal_requests_per_payload: u64,
 }
 
 impl ElectraPreset {
-    pub fn from_chain_spec<E: EthSpec>(_spec: &ChainSpec) -> Self {
+    pub fn from_chain_spec<E: EthSpec>(spec: &ChainSpec) -> Self {
         Self {
-            electra_placeholder: 0,
+            min_activation_balance: spec.min_activation_balance,
+            max_effective_balance_electra: spec.max_effective_balance_electra,
+            min_slashing_penalty_quotient_electra: spec.min_slashing_penalty_quotient_electra,
+            whistleblower_reward_quotient_electra: spec.whistleblower_reward_quotient_electra,
+            max_pending_partials_per_withdrawals_sweep: spec
+                .max_pending_partials_per_withdrawals_sweep,
+            pending_balance_deposits_limit: E::pending_balance_deposits_limit() as u64,
+            pending_partial_withdrawals_limit: E::pending_partial_withdrawals_limit() as u64,
+            pending_consolidations_limit: E::pending_consolidations_limit() as u64,
+            max_consolidations: E::max_consolidations() as u64,
+            max_deposit_receipts_per_payload: E::max_deposit_receipts_per_payload() as u64,
+            max_attester_slashings_electra: E::max_attester_slashings_electra() as u64,
+            max_attestations_electra: E::max_attestations_electra() as u64,
+            max_withdrawal_requests_per_payload: E::max_withdrawal_requests_per_payload() as u64,
         }
     }
 }
diff --git a/consensus/types/src/signed_beacon_block.rs b/consensus/types/src/signed_beacon_block.rs
index da4ac392362..4d3279a7f77 100644
--- a/consensus/types/src/signed_beacon_block.rs
+++ b/consensus/types/src/signed_beacon_block.rs
@@ -37,7 +37,7 @@ impl From<SignedBeaconBlockHash> for Hash256 {
 
 /// A `BeaconBlock` and a signature from its proposer.
 #[superstruct(
-    variants(Base, Altair, Merge, Capella, Deneb, Electra),
+    variants(Base, Altair, Bellatrix, Capella, Deneb, Electra),
     variant_attributes(
         derive(
             Debug,
@@ -72,8 +72,8 @@ pub struct SignedBeaconBlock<E: EthSpec, Payload: AbstractExecPayload<E> = FullP
     pub message: BeaconBlockBase<E, Payload>,
     #[superstruct(only(Altair), partial_getter(rename = "message_altair"))]
     pub message: BeaconBlockAltair<E, Payload>,
-    #[superstruct(only(Merge), partial_getter(rename = "message_merge"))]
-    pub message: BeaconBlockMerge<E, Payload>,
+    #[superstruct(only(Bellatrix), partial_getter(rename = "message_bellatrix"))]
+    pub message: BeaconBlockBellatrix<E, Payload>,
     #[superstruct(only(Capella), partial_getter(rename = "message_capella"))]
     pub message: BeaconBlockCapella<E, Payload>,
     #[superstruct(only(Deneb), partial_getter(rename = "message_deneb"))]
@@ -150,8 +150,8 @@ impl<E: EthSpec, Payload: AbstractExecPayload<E>> SignedBeaconBlock<E, Payload>
             BeaconBlock::Altair(message) => {
                 SignedBeaconBlock::Altair(SignedBeaconBlockAltair { message, signature })
             }
-            BeaconBlock::Merge(message) => {
-                SignedBeaconBlock::Merge(SignedBeaconBlockMerge { message, signature })
+            BeaconBlock::Bellatrix(message) => {
+                SignedBeaconBlock::Bellatrix(SignedBeaconBlockBellatrix { message, signature })
             }
             BeaconBlock::Capella(message) => {
                 SignedBeaconBlock::Capella(SignedBeaconBlockCapella { message, signature })
@@ -310,20 +310,20 @@ impl<E: EthSpec> From<SignedBeaconBlockAltair<E, BlindedPayload<E>>>
 // Post-Bellatrix blocks can be "unblinded" by adding the full payload.
 // NOTE: It might be nice to come up with a `superstruct` pattern to abstract over this before
 // the first fork after Bellatrix.
-impl<E: EthSpec> SignedBeaconBlockMerge<E, BlindedPayload<E>> {
+impl<E: EthSpec> SignedBeaconBlockBellatrix<E, BlindedPayload<E>> {
     pub fn into_full_block(
         self,
-        execution_payload: ExecutionPayloadMerge<E>,
-    ) -> SignedBeaconBlockMerge<E, FullPayload<E>> {
-        let SignedBeaconBlockMerge {
+        execution_payload: ExecutionPayloadBellatrix<E>,
+    ) -> SignedBeaconBlockBellatrix<E, FullPayload<E>> {
+        let SignedBeaconBlockBellatrix {
             message:
-                BeaconBlockMerge {
+                BeaconBlockBellatrix {
                     slot,
                     proposer_index,
                     parent_root,
                     state_root,
                     body:
-                        BeaconBlockBodyMerge {
+                        BeaconBlockBodyBellatrix {
                             randao_reveal,
                             eth1_data,
                             graffiti,
@@ -333,18 +333,18 @@ impl<E: EthSpec> SignedBeaconBlockMerge<E, BlindedPayload<E>> {
                             deposits,
                             voluntary_exits,
                             sync_aggregate,
-                            execution_payload: BlindedPayloadMerge { .. },
+                            execution_payload: BlindedPayloadBellatrix { .. },
                         },
                 },
             signature,
         } = self;
-        SignedBeaconBlockMerge {
-            message: BeaconBlockMerge {
+        SignedBeaconBlockBellatrix {
+            message: BeaconBlockBellatrix {
                 slot,
                 proposer_index,
                 parent_root,
                 state_root,
-                body: BeaconBlockBodyMerge {
+                body: BeaconBlockBodyBellatrix {
                     randao_reveal,
                     eth1_data,
                     graffiti,
@@ -354,7 +354,7 @@ impl<E: EthSpec> SignedBeaconBlockMerge<E, BlindedPayload<E>> {
                     deposits,
                     voluntary_exits,
                     sync_aggregate,
-                    execution_payload: FullPayloadMerge { execution_payload },
+                    execution_payload: FullPayloadBellatrix { execution_payload },
                 },
             },
             signature,
@@ -536,8 +536,8 @@ impl<E: EthSpec> SignedBeaconBlock<E, BlindedPayload<E>> {
         let full_block = match (self, execution_payload) {
             (SignedBeaconBlock::Base(block), _) => SignedBeaconBlock::Base(block.into()),
             (SignedBeaconBlock::Altair(block), _) => SignedBeaconBlock::Altair(block.into()),
-            (SignedBeaconBlock::Merge(block), Some(ExecutionPayload::Merge(payload))) => {
-                SignedBeaconBlock::Merge(block.into_full_block(payload))
+            (SignedBeaconBlock::Bellatrix(block), Some(ExecutionPayload::Bellatrix(payload))) => {
+                SignedBeaconBlock::Bellatrix(block.into_full_block(payload))
             }
             (SignedBeaconBlock::Capella(block), Some(ExecutionPayload::Capella(payload))) => {
                 SignedBeaconBlock::Capella(block.into_full_block(payload))
@@ -550,7 +550,7 @@ impl<E: EthSpec> SignedBeaconBlock<E, BlindedPayload<E>> {
             }
             // avoid wildcard matching forks so that compiler will
             // direct us here when a new fork has been added
-            (SignedBeaconBlock::Merge(_), _) => return None,
+            (SignedBeaconBlock::Bellatrix(_), _) => return None,
             (SignedBeaconBlock::Capella(_), _) => return None,
             (SignedBeaconBlock::Deneb(_), _) => return None,
             (SignedBeaconBlock::Electra(_), _) => return None,
@@ -687,8 +687,8 @@ pub mod ssz_tagged_signed_beacon_block {
                 ForkName::Altair => Ok(SignedBeaconBlock::Altair(
                     SignedBeaconBlockAltair::from_ssz_bytes(body)?,
                 )),
-                ForkName::Merge => Ok(SignedBeaconBlock::Merge(
-                    SignedBeaconBlockMerge::from_ssz_bytes(body)?,
+                ForkName::Bellatrix => Ok(SignedBeaconBlock::Bellatrix(
+                    SignedBeaconBlockBellatrix::from_ssz_bytes(body)?,
                 )),
                 ForkName::Capella => Ok(SignedBeaconBlock::Capella(
                     SignedBeaconBlockCapella::from_ssz_bytes(body)?,
@@ -744,7 +744,10 @@ mod test {
                 BeaconBlock::Altair(BeaconBlockAltair::empty(spec)),
                 sig.clone(),
             ),
-            SignedBeaconBlock::from_block(BeaconBlock::Merge(BeaconBlockMerge::empty(spec)), sig),
+            SignedBeaconBlock::from_block(
+                BeaconBlock::Bellatrix(BeaconBlockBellatrix::empty(spec)),
+                sig,
+            ),
         ];
 
         for block in blocks {
@@ -783,7 +786,7 @@ mod test {
                 sig.clone(),
             ),
             SignedBeaconBlock::from_block(
-                BeaconBlock::Merge(BeaconBlockMerge::empty(spec)),
+                BeaconBlock::Bellatrix(BeaconBlockBellatrix::empty(spec)),
                 sig.clone(),
             ),
             SignedBeaconBlock::from_block(
diff --git a/consensus/types/src/signed_consolidation.rs b/consensus/types/src/signed_consolidation.rs
new file mode 100644
index 00000000000..f004ec23bd4
--- /dev/null
+++ b/consensus/types/src/signed_consolidation.rs
@@ -0,0 +1,32 @@
+use crate::test_utils::TestRandom;
+use crate::{Consolidation, Signature};
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use test_random_derive::TestRandom;
+use tree_hash_derive::TreeHash;
+
+#[derive(
+    arbitrary::Arbitrary,
+    Debug,
+    PartialEq,
+    Eq,
+    Hash,
+    Clone,
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    TreeHash,
+    TestRandom,
+)]
+pub struct SignedConsolidation {
+    pub message: Consolidation,
+    pub signature: Signature,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    ssz_and_tree_hash_tests!(SignedConsolidation);
+}
diff --git a/consensus/types/src/test_utils/test_random.rs b/consensus/types/src/test_utils/test_random.rs
index 0adaf81bd7d..72a7a036ccc 100644
--- a/consensus/types/src/test_utils/test_random.rs
+++ b/consensus/types/src/test_utils/test_random.rs
@@ -87,7 +87,7 @@ where
     }
 }
 
-impl<T, N: Unsigned> TestRandom for FixedVector<T, N>
+impl<T, N: Unsigned> TestRandom for ssz_types::FixedVector<T, N>
 where
     T: TestRandom,
 {
diff --git a/consensus/types/src/test_utils/test_random/secret_key.rs b/consensus/types/src/test_utils/test_random/secret_key.rs
index 3f3f6ed5184..da1614aa24e 100644
--- a/consensus/types/src/test_utils/test_random/secret_key.rs
+++ b/consensus/types/src/test_utils/test_random/secret_key.rs
@@ -2,6 +2,8 @@ use super::*;
 
 impl TestRandom for SecretKey {
     fn random_for_test(_rng: &mut impl RngCore) -> Self {
+        // TODO: Not deterministic generation. Using `SecretKey::deserialize` results in
+        // `BlstError(BLST_BAD_ENCODING)`, need to debug with blst source on what encoding expects.
         SecretKey::random()
     }
 }
diff --git a/consensus/types/src/test_utils/test_random/signature.rs b/consensus/types/src/test_utils/test_random/signature.rs
index 5b952296b61..8bc0d711103 100644
--- a/consensus/types/src/test_utils/test_random/signature.rs
+++ b/consensus/types/src/test_utils/test_random/signature.rs
@@ -1,11 +1,10 @@
 use super::*;
 
 impl TestRandom for Signature {
-    fn random_for_test(rng: &mut impl RngCore) -> Self {
-        let secret_key = SecretKey::random_for_test(rng);
-        let mut message = vec![0; 32];
-        rng.fill_bytes(&mut message);
-
-        secret_key.sign(Hash256::from_slice(&message))
+    fn random_for_test(_rng: &mut impl RngCore) -> Self {
+        // TODO: `SecretKey::random_for_test` does not return a deterministic signature. Since this
+        // signature will not pass verification we could just return the generator point or the
+        // generator point multiplied by a random scalar if we want disctint signatures.
+        Signature::infinity().expect("infinity signature is valid")
     }
 }
diff --git a/consensus/types/src/tree_hash_impls.rs b/consensus/types/src/tree_hash_impls.rs
deleted file mode 100644
index eb3660d4666..00000000000
--- a/consensus/types/src/tree_hash_impls.rs
+++ /dev/null
@@ -1,165 +0,0 @@
-//! This module contains custom implementations of `CachedTreeHash` for ETH2-specific types.
-//!
-//! It makes some assumptions about the layouts and update patterns of other structs in this
-//! crate, and should be updated carefully whenever those structs are changed.
-use crate::{Epoch, Hash256, PublicKeyBytes, Validator};
-use cached_tree_hash::{int_log, CacheArena, CachedTreeHash, Error, TreeHashCache};
-use int_to_bytes::int_to_fixed_bytes32;
-use tree_hash::merkle_root;
-
-/// Number of struct fields on `Validator`.
-const NUM_VALIDATOR_FIELDS: usize = 8;
-
-impl CachedTreeHash<TreeHashCache> for Validator {
-    fn new_tree_hash_cache(&self, arena: &mut CacheArena) -> TreeHashCache {
-        TreeHashCache::new(arena, int_log(NUM_VALIDATOR_FIELDS), NUM_VALIDATOR_FIELDS)
-    }
-
-    /// Efficiently tree hash a `Validator`, assuming it was updated by a valid state transition.
-    ///
-    /// Specifically, we assume that the `pubkey` field is constant.
-    fn recalculate_tree_hash_root(
-        &self,
-        arena: &mut CacheArena,
-        cache: &mut TreeHashCache,
-    ) -> Result<Hash256, Error> {
-        // Otherwise just check the fields which might have changed.
-        let dirty_indices = cache
-            .leaves()
-            .iter_mut(arena)?
-            .enumerate()
-            .flat_map(|(i, leaf)| {
-                // Pubkey field (index 0) is constant.
-                if i == 0 && cache.initialized {
-                    None
-                } else if process_field_by_index(self, i, leaf, !cache.initialized) {
-                    Some(i)
-                } else {
-                    None
-                }
-            })
-            .collect();
-
-        cache.update_merkle_root(arena, dirty_indices)
-    }
-}
-
-fn process_field_by_index(
-    v: &Validator,
-    field_idx: usize,
-    leaf: &mut Hash256,
-    force_update: bool,
-) -> bool {
-    match field_idx {
-        0 => process_pubkey_bytes_field(&v.pubkey, leaf, force_update),
-        1 => process_slice_field(v.withdrawal_credentials.as_bytes(), leaf, force_update),
-        2 => process_u64_field(v.effective_balance, leaf, force_update),
-        3 => process_bool_field(v.slashed, leaf, force_update),
-        4 => process_epoch_field(v.activation_eligibility_epoch, leaf, force_update),
-        5 => process_epoch_field(v.activation_epoch, leaf, force_update),
-        6 => process_epoch_field(v.exit_epoch, leaf, force_update),
-        7 => process_epoch_field(v.withdrawable_epoch, leaf, force_update),
-        _ => panic!(
-            "Validator type only has {} fields, {} out of bounds",
-            NUM_VALIDATOR_FIELDS, field_idx
-        ),
-    }
-}
-
-fn process_pubkey_bytes_field(
-    val: &PublicKeyBytes,
-    leaf: &mut Hash256,
-    force_update: bool,
-) -> bool {
-    let new_tree_hash = merkle_root(val.as_serialized(), 0);
-    process_slice_field(new_tree_hash.as_bytes(), leaf, force_update)
-}
-
-fn process_slice_field(new_tree_hash: &[u8], leaf: &mut Hash256, force_update: bool) -> bool {
-    if force_update || leaf.as_bytes() != new_tree_hash {
-        leaf.assign_from_slice(new_tree_hash);
-        true
-    } else {
-        false
-    }
-}
-
-fn process_u64_field(val: u64, leaf: &mut Hash256, force_update: bool) -> bool {
-    let new_tree_hash = int_to_fixed_bytes32(val);
-    process_slice_field(&new_tree_hash[..], leaf, force_update)
-}
-
-fn process_epoch_field(val: Epoch, leaf: &mut Hash256, force_update: bool) -> bool {
-    process_u64_field(val.as_u64(), leaf, force_update)
-}
-
-fn process_bool_field(val: bool, leaf: &mut Hash256, force_update: bool) -> bool {
-    process_u64_field(val as u64, leaf, force_update)
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::test_utils::TestRandom;
-    use rand::SeedableRng;
-    use rand_xorshift::XorShiftRng;
-    use tree_hash::TreeHash;
-
-    fn test_validator_tree_hash(v: &Validator) {
-        let arena = &mut CacheArena::default();
-
-        let mut cache = v.new_tree_hash_cache(arena);
-        // With a fresh cache
-        assert_eq!(
-            &v.tree_hash_root()[..],
-            v.recalculate_tree_hash_root(arena, &mut cache)
-                .unwrap()
-                .as_bytes(),
-            "{:?}",
-            v
-        );
-        // With a completely up-to-date cache
-        assert_eq!(
-            &v.tree_hash_root()[..],
-            v.recalculate_tree_hash_root(arena, &mut cache)
-                .unwrap()
-                .as_bytes(),
-            "{:?}",
-            v
-        );
-    }
-
-    #[test]
-    fn default_validator() {
-        test_validator_tree_hash(&Validator::default());
-    }
-
-    #[test]
-    fn zeroed_validator() {
-        let v = Validator {
-            activation_eligibility_epoch: Epoch::from(0u64),
-            activation_epoch: Epoch::from(0u64),
-            ..Default::default()
-        };
-        test_validator_tree_hash(&v);
-    }
-
-    #[test]
-    fn random_validators() {
-        let mut rng = XorShiftRng::from_seed([0xf1; 16]);
-        let num_validators = 1000;
-        (0..num_validators)
-            .map(|_| Validator::random_for_test(&mut rng))
-            .for_each(|v| test_validator_tree_hash(&v));
-    }
-
-    #[test]
-    #[allow(clippy::assertions_on_constants)]
-    pub fn smallvec_size_check() {
-        // If this test fails we need to go and reassess the length of the `SmallVec` in
-        // `cached_tree_hash::TreeHashCache`. If the size of the `SmallVec` is too slow we're going
-        // to start doing heap allocations for each validator, this will fragment memory and slow
-        // us down.
-        assert!(NUM_VALIDATOR_FIELDS <= 8,);
-    }
-}
diff --git a/consensus/types/src/validator.rs b/consensus/types/src/validator.rs
index 98567cd1e6c..9e26d1eeca6 100644
--- a/consensus/types/src/validator.rs
+++ b/consensus/types/src/validator.rs
@@ -1,5 +1,5 @@
 use crate::{
-    test_utils::TestRandom, Address, BeaconState, ChainSpec, Epoch, EthSpec, Hash256,
+    test_utils::TestRandom, Address, BeaconState, ChainSpec, Epoch, EthSpec, ForkName, Hash256,
     PublicKeyBytes,
 };
 use serde::{Deserialize, Serialize};
@@ -55,14 +55,37 @@ impl Validator {
         epoch >= self.withdrawable_epoch
     }
 
+    /// Returns `true` if the validator is eligible to join the activation queue.
+    ///
+    /// Calls the correct function depending on the provided `fork_name`.
+    pub fn is_eligible_for_activation_queue(
+        &self,
+        spec: &ChainSpec,
+        current_fork: ForkName,
+    ) -> bool {
+        if current_fork >= ForkName::Electra {
+            self.is_eligible_for_activation_queue_electra(spec)
+        } else {
+            self.is_eligible_for_activation_queue_base(spec)
+        }
+    }
+
     /// Returns `true` if the validator is eligible to join the activation queue.
     ///
     /// Spec v0.12.1
-    pub fn is_eligible_for_activation_queue(&self, spec: &ChainSpec) -> bool {
+    fn is_eligible_for_activation_queue_base(&self, spec: &ChainSpec) -> bool {
         self.activation_eligibility_epoch == spec.far_future_epoch
             && self.effective_balance == spec.max_effective_balance
     }
 
+    /// Returns `true` if the validator is eligible to join the activation queue.
+    ///
+    /// Modified in electra as part of EIP 7251.
+    fn is_eligible_for_activation_queue_electra(&self, spec: &ChainSpec) -> bool {
+        self.activation_eligibility_epoch == spec.far_future_epoch
+            && self.effective_balance >= spec.min_activation_balance
+    }
+
     /// Returns `true` if the validator is eligible to be activated.
     ///
     /// Spec v0.12.1
@@ -102,6 +125,11 @@ impl Validator {
             .unwrap_or(false)
     }
 
+    /// Check if ``validator`` has an 0x02 prefixed "compounding" withdrawal credential.
+    pub fn has_compounding_withdrawal_credential(&self, spec: &ChainSpec) -> bool {
+        is_compounding_withdrawal_credential(self.withdrawal_credentials, spec)
+    }
+
     /// Get the eth1 withdrawal address if this validator has one initialized.
     pub fn get_eth1_withdrawal_address(&self, spec: &ChainSpec) -> Option<Address> {
         self.has_eth1_withdrawal_credential(spec)
@@ -125,16 +153,99 @@ impl Validator {
     }
 
     /// Returns `true` if the validator is fully withdrawable at some epoch.
-    pub fn is_fully_withdrawable_at(&self, balance: u64, epoch: Epoch, spec: &ChainSpec) -> bool {
+    ///
+    /// Calls the correct function depending on the provided `fork_name`.
+    pub fn is_fully_withdrawable_at(
+        &self,
+        balance: u64,
+        epoch: Epoch,
+        spec: &ChainSpec,
+        current_fork: ForkName,
+    ) -> bool {
+        if current_fork >= ForkName::Electra {
+            self.is_fully_withdrawable_at_electra(balance, epoch, spec)
+        } else {
+            self.is_fully_withdrawable_at_capella(balance, epoch, spec)
+        }
+    }
+
+    /// Returns `true` if the validator is fully withdrawable at some epoch.
+    fn is_fully_withdrawable_at_capella(
+        &self,
+        balance: u64,
+        epoch: Epoch,
+        spec: &ChainSpec,
+    ) -> bool {
         self.has_eth1_withdrawal_credential(spec) && self.withdrawable_epoch <= epoch && balance > 0
     }
 
+    /// Returns `true` if the validator is fully withdrawable at some epoch.
+    ///
+    /// Modified in electra as part of EIP 7251.
+    fn is_fully_withdrawable_at_electra(
+        &self,
+        balance: u64,
+        epoch: Epoch,
+        spec: &ChainSpec,
+    ) -> bool {
+        self.has_execution_withdrawal_credential(spec)
+            && self.withdrawable_epoch <= epoch
+            && balance > 0
+    }
+
+    /// Returns `true` if the validator is partially withdrawable.
+    ///
+    /// Calls the correct function depending on the provided `fork_name`.
+    pub fn is_partially_withdrawable_validator(
+        &self,
+        balance: u64,
+        spec: &ChainSpec,
+        current_fork: ForkName,
+    ) -> bool {
+        if current_fork >= ForkName::Electra {
+            self.is_partially_withdrawable_validator_electra(balance, spec)
+        } else {
+            self.is_partially_withdrawable_validator_capella(balance, spec)
+        }
+    }
+
     /// Returns `true` if the validator is partially withdrawable.
-    pub fn is_partially_withdrawable_validator(&self, balance: u64, spec: &ChainSpec) -> bool {
+    fn is_partially_withdrawable_validator_capella(&self, balance: u64, spec: &ChainSpec) -> bool {
         self.has_eth1_withdrawal_credential(spec)
             && self.effective_balance == spec.max_effective_balance
             && balance > spec.max_effective_balance
     }
+
+    /// Returns `true` if the validator is partially withdrawable.
+    ///
+    /// Modified in electra as part of EIP 7251.
+    pub fn is_partially_withdrawable_validator_electra(
+        &self,
+        balance: u64,
+        spec: &ChainSpec,
+    ) -> bool {
+        let max_effective_balance = self.get_validator_max_effective_balance(spec);
+        let has_max_effective_balance = self.effective_balance == max_effective_balance;
+        let has_excess_balance = balance > max_effective_balance;
+        self.has_execution_withdrawal_credential(spec)
+            && has_max_effective_balance
+            && has_excess_balance
+    }
+
+    /// Returns `true` if the validator has a 0x01 or 0x02 prefixed withdrawal credential.
+    pub fn has_execution_withdrawal_credential(&self, spec: &ChainSpec) -> bool {
+        self.has_compounding_withdrawal_credential(spec)
+            || self.has_eth1_withdrawal_credential(spec)
+    }
+
+    /// Returns the max effective balance for a validator in gwei.
+    pub fn get_validator_max_effective_balance(&self, spec: &ChainSpec) -> u64 {
+        if self.has_compounding_withdrawal_credential(spec) {
+            spec.max_effective_balance_electra
+        } else {
+            spec.min_activation_balance
+        }
+    }
 }
 
 impl Default for Validator {
@@ -153,6 +264,17 @@ impl Default for Validator {
     }
 }
 
+pub fn is_compounding_withdrawal_credential(
+    withdrawal_credentials: Hash256,
+    spec: &ChainSpec,
+) -> bool {
+    withdrawal_credentials
+        .as_bytes()
+        .first()
+        .map(|prefix_byte| *prefix_byte == spec.compounding_withdrawal_prefix_byte)
+        .unwrap_or(false)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/consensus/types/src/voluntary_exit.rs b/consensus/types/src/voluntary_exit.rs
index 74175423e34..4c7c16757ed 100644
--- a/consensus/types/src/voluntary_exit.rs
+++ b/consensus/types/src/voluntary_exit.rs
@@ -42,7 +42,7 @@ impl VoluntaryExit {
     ) -> SignedVoluntaryExit {
         let fork_name = spec.fork_name_at_epoch(self.epoch);
         let fork_version = match fork_name {
-            ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => {
+            ForkName::Base | ForkName::Altair | ForkName::Bellatrix | ForkName::Capella => {
                 spec.fork_version_for_name(fork_name)
             }
             // EIP-7044
diff --git a/crypto/kzg/Cargo.toml b/crypto/kzg/Cargo.toml
index 7b70166f921..d26dfe4992a 100644
--- a/crypto/kzg/Cargo.toml
+++ b/crypto/kzg/Cargo.toml
@@ -16,4 +16,4 @@ serde = { workspace = true }
 ethereum_serde_utils = { workspace = true }
 hex = { workspace = true }
 ethereum_hashing = { workspace = true }
-c-kzg = { git = "https://github.com/ethereum/c-kzg-4844", rev = "748283cced543c486145d5f3f38684becdfe3e1b"}
\ No newline at end of file
+c-kzg = { workspace = true }
diff --git a/crypto/kzg/src/lib.rs b/crypto/kzg/src/lib.rs
index 0e096ba55c2..658dc9fe06e 100644
--- a/crypto/kzg/src/lib.rs
+++ b/crypto/kzg/src/lib.rs
@@ -142,3 +142,11 @@ impl Kzg {
         .map_err(Into::into)
     }
 }
+
+impl TryFrom<TrustedSetup> for Kzg {
+    type Error = Error;
+
+    fn try_from(trusted_setup: TrustedSetup) -> Result<Self, Self::Error> {
+        Kzg::new_from_trusted_setup(trusted_setup)
+    }
+}
diff --git a/lcli/Dockerfile.cross b/lcli/Dockerfile.cross
new file mode 100644
index 00000000000..979688c9cf6
--- /dev/null
+++ b/lcli/Dockerfile.cross
@@ -0,0 +1,6 @@
+# This image is meant to enable cross-architecture builds.
+# It assumes the lcli binary has already been
+# compiled for `$TARGETPLATFORM` and moved to `./bin`.
+FROM --platform=$TARGETPLATFORM ubuntu:22.04
+RUN apt update && apt -y upgrade && apt clean && rm -rf /var/lib/apt/lists/*
+COPY ./bin/lcli /usr/local/bin/lcli
diff --git a/lcli/src/create_payload_header.rs b/lcli/src/create_payload_header.rs
index 7aa1ef70089..974a34591f0 100644
--- a/lcli/src/create_payload_header.rs
+++ b/lcli/src/create_payload_header.rs
@@ -5,8 +5,9 @@ use std::fs::File;
 use std::io::Write;
 use std::time::{SystemTime, UNIX_EPOCH};
 use types::{
-    EthSpec, ExecutionPayloadHeader, ExecutionPayloadHeaderCapella, ExecutionPayloadHeaderDeneb,
-    ExecutionPayloadHeaderElectra, ExecutionPayloadHeaderMerge, ForkName,
+    EthSpec, ExecutionPayloadHeader, ExecutionPayloadHeaderBellatrix,
+    ExecutionPayloadHeaderCapella, ExecutionPayloadHeaderDeneb, ExecutionPayloadHeaderElectra,
+    ForkName,
 };
 
 pub fn run<E: EthSpec>(matches: &ArgMatches) -> Result<(), String> {
@@ -20,17 +21,17 @@ pub fn run<E: EthSpec>(matches: &ArgMatches) -> Result<(), String> {
     let base_fee_per_gas = parse_required(matches, "base-fee-per-gas")?;
     let gas_limit = parse_required(matches, "gas-limit")?;
     let file_name = matches.value_of("file").ok_or("No file supplied")?;
-    let fork_name: ForkName = parse_optional(matches, "fork")?.unwrap_or(ForkName::Merge);
+    let fork_name: ForkName = parse_optional(matches, "fork")?.unwrap_or(ForkName::Bellatrix);
 
     let execution_payload_header: ExecutionPayloadHeader<E> = match fork_name {
         ForkName::Base | ForkName::Altair => return Err("invalid fork name".to_string()),
-        ForkName::Merge => ExecutionPayloadHeader::Merge(ExecutionPayloadHeaderMerge {
+        ForkName::Bellatrix => ExecutionPayloadHeader::Bellatrix(ExecutionPayloadHeaderBellatrix {
             gas_limit,
             base_fee_per_gas,
             timestamp: genesis_time,
             block_hash: eth1_block_hash,
             prev_randao: eth1_block_hash.into_root(),
-            ..ExecutionPayloadHeaderMerge::default()
+            ..ExecutionPayloadHeaderBellatrix::default()
         }),
         ForkName::Capella => ExecutionPayloadHeader::Capella(ExecutionPayloadHeaderCapella {
             gas_limit,
diff --git a/lcli/src/main.rs b/lcli/src/main.rs
index c374a8f4b37..7b5c1598c9e 100644
--- a/lcli/src/main.rs
+++ b/lcli/src/main.rs
@@ -433,7 +433,7 @@ fn main() {
                     .takes_value(true)
                     .default_value("bellatrix")
                     .help("The fork for which the execution payload header should be created.")
-                    .possible_values(&["merge", "bellatrix", "capella", "deneb", "electra"])
+                    .possible_values(&["bellatrix", "capella", "deneb", "electra"])
             )
         )
         .subcommand(
diff --git a/lcli/src/new_testnet.rs b/lcli/src/new_testnet.rs
index f9da3d2b3e9..f6bfb2ac013 100644
--- a/lcli/src/new_testnet.rs
+++ b/lcli/src/new_testnet.rs
@@ -21,8 +21,8 @@ use std::time::{SystemTime, UNIX_EPOCH};
 use types::ExecutionBlockHash;
 use types::{
     test_utils::generate_deterministic_keypairs, Address, BeaconState, ChainSpec, Config, Epoch,
-    Eth1Data, EthSpec, ExecutionPayloadHeader, ExecutionPayloadHeaderCapella,
-    ExecutionPayloadHeaderDeneb, ExecutionPayloadHeaderElectra, ExecutionPayloadHeaderMerge,
+    Eth1Data, EthSpec, ExecutionPayloadHeader, ExecutionPayloadHeaderBellatrix,
+    ExecutionPayloadHeaderCapella, ExecutionPayloadHeaderDeneb, ExecutionPayloadHeaderElectra,
     ForkName, Hash256, Keypair, PublicKey, Validator,
 };
 
@@ -114,9 +114,9 @@ pub fn run<E: EthSpec>(testnet_dir_path: PathBuf, matches: &ArgMatches) -> Resul
                     ForkName::Base | ForkName::Altair => Err(ssz::DecodeError::BytesInvalid(
                         "genesis fork must be post-merge".to_string(),
                     )),
-                    ForkName::Merge => {
-                        ExecutionPayloadHeaderMerge::<E>::from_ssz_bytes(bytes.as_slice())
-                            .map(ExecutionPayloadHeader::Merge)
+                    ForkName::Bellatrix => {
+                        ExecutionPayloadHeaderBellatrix::<E>::from_ssz_bytes(bytes.as_slice())
+                            .map(ExecutionPayloadHeader::Bellatrix)
                     }
                     ForkName::Capella => {
                         ExecutionPayloadHeaderCapella::<E>::from_ssz_bytes(bytes.as_slice())
@@ -246,10 +246,10 @@ fn initialize_state_with_validators<E: EthSpec>(
 ) -> Result<BeaconState<E>, String> {
     // If no header is provided, then start from a Bellatrix state by default
     let default_header: ExecutionPayloadHeader<E> =
-        ExecutionPayloadHeader::Merge(ExecutionPayloadHeaderMerge {
+        ExecutionPayloadHeader::Bellatrix(ExecutionPayloadHeaderBellatrix {
             block_hash: ExecutionBlockHash::from_root(eth1_block_hash),
             parent_hash: ExecutionBlockHash::zero(),
-            ..ExecutionPayloadHeaderMerge::default()
+            ..ExecutionPayloadHeaderBellatrix::default()
         });
     let execution_payload_header = execution_payload_header.unwrap_or(default_header);
     // Empty eth1 data
@@ -264,7 +264,7 @@ fn initialize_state_with_validators<E: EthSpec>(
     let mut state = BeaconState::new(genesis_time, eth1_data, spec);
 
     // Seed RANDAO with Eth1 entropy
-    state.fill_randao_mixes_with(eth1_block_hash);
+    state.fill_randao_mixes_with(eth1_block_hash).unwrap();
 
     for keypair in keypairs.iter() {
         let withdrawal_credentials = |pubkey: &PublicKey| {
@@ -314,9 +314,9 @@ fn initialize_state_with_validators<E: EthSpec>(
 
         // Override latest execution payload header.
         // See https://github.com/ethereum/consensus-specs/blob/v1.1.0/specs/bellatrix/beacon-chain.md#testing
-        if let ExecutionPayloadHeader::Merge(ref header) = execution_payload_header {
+        if let ExecutionPayloadHeader::Bellatrix(ref header) = execution_payload_header {
             *state
-                .latest_execution_payload_header_merge_mut()
+                .latest_execution_payload_header_bellatrix_mut()
                 .or(Err("mismatched fork".to_string()))? = header.clone();
         }
     }
diff --git a/lcli/src/parse_ssz.rs b/lcli/src/parse_ssz.rs
index 5b34fedfb9e..e86ffb73dc2 100644
--- a/lcli/src/parse_ssz.rs
+++ b/lcli/src/parse_ssz.rs
@@ -70,9 +70,11 @@ pub fn run_parse_ssz<E: EthSpec>(
         "SignedBeaconBlockAltair" => {
             decode_and_print(&bytes, SignedBeaconBlockAltair::<E>::from_ssz_bytes, format)?
         }
-        "SignedBeaconBlockMerge" | "SignedBeaconBlockBellatrix" => {
-            decode_and_print(&bytes, SignedBeaconBlockMerge::<E>::from_ssz_bytes, format)?
-        }
+        "SignedBeaconBlockBellatrix" => decode_and_print(
+            &bytes,
+            SignedBeaconBlockBellatrix::<E>::from_ssz_bytes,
+            format,
+        )?,
         "SignedBeaconBlockCapella" => decode_and_print(
             &bytes,
             SignedBeaconBlockCapella::<E>::from_ssz_bytes,
@@ -97,8 +99,8 @@ pub fn run_parse_ssz<E: EthSpec>(
         "BeaconStateAltair" => {
             decode_and_print(&bytes, BeaconStateAltair::<E>::from_ssz_bytes, format)?
         }
-        "BeaconStateMerge" | "BeaconStateBellatrix" => {
-            decode_and_print(&bytes, BeaconStateMerge::<E>::from_ssz_bytes, format)?
+        "BeaconStateBellatrix" => {
+            decode_and_print(&bytes, BeaconStateBellatrix::<E>::from_ssz_bytes, format)?
         }
         "BeaconStateCapella" => {
             decode_and_print(&bytes, BeaconStateCapella::<E>::from_ssz_bytes, format)?
diff --git a/lcli/src/replace_state_pubkeys.rs b/lcli/src/replace_state_pubkeys.rs
index 0f9fac3aff9..e8d012b16ec 100644
--- a/lcli/src/replace_state_pubkeys.rs
+++ b/lcli/src/replace_state_pubkeys.rs
@@ -42,7 +42,8 @@ pub fn run<E: EthSpec>(testnet_dir: PathBuf, matches: &ArgMatches) -> Result<(),
 
     let mut deposit_tree = DepositDataTree::create(&[], 0, DEPOSIT_TREE_DEPTH);
     let mut deposit_root = Hash256::zero();
-    for (index, validator) in state.validators_mut().iter_mut().enumerate() {
+    let validators = state.validators_mut();
+    for index in 0..validators.len() {
         let (secret, _) =
             recover_validator_secret_from_mnemonic(seed.as_bytes(), index as u32, KeyType::Voting)
                 .map_err(|e| format!("Unable to generate validator key: {:?}", e))?;
@@ -52,11 +53,11 @@ pub fn run<E: EthSpec>(testnet_dir: PathBuf, matches: &ArgMatches) -> Result<(),
 
         eprintln!("{}: {}", index, keypair.pk);
 
-        validator.pubkey = keypair.pk.into();
+        validators.get_mut(index).unwrap().pubkey = keypair.pk.into();
 
         // Update the deposit tree.
         let mut deposit_data = DepositData {
-            pubkey: validator.pubkey,
+            pubkey: validators.get(index).unwrap().pubkey,
             // Set this to a junk value since it's very time consuming to generate the withdrawal
             // keys and it's not useful for the time being.
             withdrawal_credentials: Hash256::zero(),
diff --git a/lcli/src/skip_slots.rs b/lcli/src/skip_slots.rs
index 9e5da7709f1..d421c077d83 100644
--- a/lcli/src/skip_slots.rs
+++ b/lcli/src/skip_slots.rs
@@ -57,7 +57,7 @@ use std::fs::File;
 use std::io::prelude::*;
 use std::path::PathBuf;
 use std::time::{Duration, Instant};
-use types::{BeaconState, CloneConfig, EthSpec, Hash256};
+use types::{BeaconState, EthSpec, Hash256};
 
 const HTTP_TIMEOUT: Duration = Duration::from_secs(10);
 
@@ -128,7 +128,7 @@ pub fn run<E: EthSpec>(
     };
 
     for i in 0..runs {
-        let mut state = state.clone_with(CloneConfig::all());
+        let mut state = state.clone();
 
         let start = Instant::now();
 
diff --git a/lcli/src/transition_blocks.rs b/lcli/src/transition_blocks.rs
index c72b41b1d44..77fd352829f 100644
--- a/lcli/src/transition_blocks.rs
+++ b/lcli/src/transition_blocks.rs
@@ -76,7 +76,7 @@ use ssz::Encode;
 use state_processing::state_advance::complete_state_advance;
 use state_processing::{
     block_signature_verifier::BlockSignatureVerifier, per_block_processing, AllCaches,
-    BlockSignatureStrategy, ConsensusContext, StateProcessingStrategy, VerifyBlockRoot,
+    BlockSignatureStrategy, ConsensusContext, VerifyBlockRoot,
 };
 use std::borrow::Cow;
 use std::fs::File;
@@ -85,7 +85,7 @@ use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 use store::HotColdDB;
-use types::{BeaconState, ChainSpec, CloneConfig, EthSpec, Hash256, SignedBeaconBlock};
+use types::{BeaconState, ChainSpec, EthSpec, Hash256, SignedBeaconBlock};
 
 const HTTP_TIMEOUT: Duration = Duration::from_secs(10);
 
@@ -234,7 +234,7 @@ pub fn run<E: EthSpec>(
     let mut output_post_state = None;
     let mut saved_ctxt = None;
     for i in 0..runs {
-        let pre_state = pre_state.clone_with(CloneConfig::all());
+        let pre_state = pre_state.clone();
         let block = block.clone();
 
         let start = Instant::now();
@@ -399,7 +399,6 @@ fn do_transition<E: EthSpec>(
         &mut pre_state,
         &block,
         BlockSignatureStrategy::NoVerification,
-        StateProcessingStrategy::Accurate,
         VerifyBlockRoot::True,
         &mut ctxt,
         spec,
diff --git a/lighthouse/environment/tests/testnet_dir/config.yaml b/lighthouse/environment/tests/testnet_dir/config.yaml
index 86f4dce239b..c71feaa7dc5 100644
--- a/lighthouse/environment/tests/testnet_dir/config.yaml
+++ b/lighthouse/environment/tests/testnet_dir/config.yaml
@@ -32,7 +32,7 @@ GENESIS_DELAY: 604800
 # Altair
 ALTAIR_FORK_VERSION: 0x01000000
 ALTAIR_FORK_EPOCH: 18446744073709551615
-# Merge
+# Bellatrix
 BELLATRIX_FORK_VERSION: 0x02000000
 BELLATRIX_FORK_EPOCH: 18446744073709551615
 # Sharding
diff --git a/lighthouse/tests/beacon_node.rs b/lighthouse/tests/beacon_node.rs
index 68d8e46eb02..62bb067273e 100644
--- a/lighthouse/tests/beacon_node.rs
+++ b/lighthouse/tests/beacon_node.rs
@@ -5,9 +5,11 @@ use beacon_node::beacon_chain::chain_config::{
     DisallowedReOrgOffsets, DEFAULT_RE_ORG_CUTOFF_DENOMINATOR, DEFAULT_RE_ORG_HEAD_THRESHOLD,
     DEFAULT_RE_ORG_MAX_EPOCHS_SINCE_FINALIZATION,
 };
+use beacon_node::beacon_chain::graffiti_calculator::GraffitiOrigin;
 use beacon_processor::BeaconProcessorConfig;
 use eth1::Eth1Endpoint;
 use lighthouse_network::PeerId;
+use lighthouse_version;
 use std::fs::File;
 use std::io::{Read, Write};
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
@@ -19,7 +21,7 @@ use std::string::ToString;
 use std::time::Duration;
 use tempfile::TempDir;
 use types::non_zero_usize::new_non_zero_usize;
-use types::{Address, Checkpoint, Epoch, ExecutionBlockHash, ForkName, Hash256, MainnetEthSpec};
+use types::{Address, Checkpoint, Epoch, ExecutionBlockHash, Hash256, MainnetEthSpec};
 use unused_port::{unused_tcp4_port, unused_tcp6_port, unused_udp4_port, unused_udp6_port};
 
 const DEFAULT_ETH1_ENDPOINT: &str = "http://localhost:8545/";
@@ -172,26 +174,6 @@ fn shuffling_cache_set() {
         .with_config(|config| assert_eq!(config.chain.shuffling_cache_size, 500));
 }
 
-#[test]
-fn snapshot_cache_default() {
-    CommandLineTest::new()
-        .run_with_zero_port()
-        .with_config(|config| {
-            assert_eq!(
-                config.chain.snapshot_cache_size,
-                beacon_node::beacon_chain::snapshot_cache::DEFAULT_SNAPSHOT_CACHE_SIZE
-            )
-        });
-}
-
-#[test]
-fn snapshot_cache_set() {
-    CommandLineTest::new()
-        .flag("state-cache-size", Some("500"))
-        .run_with_zero_port()
-        .with_config(|config| assert_eq!(config.chain.snapshot_cache_size, 500));
-}
-
 #[test]
 fn fork_choice_before_proposal_timeout_default() {
     CommandLineTest::new()
@@ -316,13 +298,36 @@ fn graffiti_flag() {
         .flag("graffiti", Some("nice-graffiti"))
         .run_with_zero_port()
         .with_config(|config| {
+            assert!(matches!(
+                config.beacon_graffiti,
+                GraffitiOrigin::UserSpecified(_)
+            ));
             assert_eq!(
-                config.graffiti.to_string(),
-                "0x6e6963652d677261666669746900000000000000000000000000000000000000"
+                config.beacon_graffiti.graffiti().to_string(),
+                "0x6e6963652d677261666669746900000000000000000000000000000000000000",
             );
         });
 }
 
+#[test]
+fn default_graffiti() {
+    use types::GRAFFITI_BYTES_LEN;
+    // test default graffiti when no graffiti flags are provided
+    CommandLineTest::new()
+        .run_with_zero_port()
+        .with_config(|config| {
+            assert!(matches!(
+                config.beacon_graffiti,
+                GraffitiOrigin::Calculated(_)
+            ));
+            let version_bytes = lighthouse_version::VERSION.as_bytes();
+            let trimmed_len = std::cmp::min(version_bytes.len(), GRAFFITI_BYTES_LEN);
+            let mut bytes = [0u8; GRAFFITI_BYTES_LEN];
+            bytes[..trimmed_len].copy_from_slice(&version_bytes[..trimmed_len]);
+            assert_eq!(config.beacon_graffiti.graffiti().0, bytes);
+        });
+}
+
 #[test]
 fn trusted_peers_flag() {
     let peers = vec![PeerId::random(), PeerId::random()];
@@ -411,7 +416,7 @@ fn eth1_cache_follow_distance_manual() {
 }
 
 // Tests for Bellatrix flags.
-fn run_merge_execution_endpoints_flag_test(flag: &str) {
+fn run_bellatrix_execution_endpoints_flag_test(flag: &str) {
     use sensitive_url::SensitiveUrl;
     let urls = vec!["http://sigp.io/no-way:1337", "http://infura.not_real:4242"];
     // we don't support redundancy for execution-endpoints
@@ -445,13 +450,16 @@ fn run_merge_execution_endpoints_flag_test(flag: &str) {
         .run_with_zero_port()
         .with_config(|config| {
             let config = config.execution_layer.as_ref().unwrap();
-            assert_eq!(config.execution_endpoints.len(), 1);
+            assert_eq!(config.execution_endpoint.is_some(), true);
             assert_eq!(
-                config.execution_endpoints[0],
+                config.execution_endpoint.as_ref().unwrap().clone(),
                 SensitiveUrl::parse(&urls[0]).unwrap()
             );
             // Only the first secret file should be used.
-            assert_eq!(config.secret_files, vec![jwts[0].clone()]);
+            assert_eq!(
+                config.secret_file.as_ref().unwrap().clone(),
+                jwts[0].clone()
+            );
         });
 }
 #[test]
@@ -464,11 +472,11 @@ fn run_execution_jwt_secret_key_is_persisted() {
         .with_config(|config| {
             let config = config.execution_layer.as_ref().unwrap();
             assert_eq!(
-                config.execution_endpoints[0].full.to_string(),
+                config.execution_endpoint.as_ref().unwrap().full.to_string(),
                 "http://localhost:8551/"
             );
             let mut file_jwt_secret_key = String::new();
-            File::open(config.secret_files[0].clone())
+            File::open(config.secret_file.as_ref().unwrap())
                 .expect("could not open jwt_secret_key file")
                 .read_to_string(&mut file_jwt_secret_key)
                 .expect("could not read from file");
@@ -492,15 +500,15 @@ fn execution_timeout_multiplier_flag() {
         });
 }
 #[test]
-fn merge_execution_endpoints_flag() {
-    run_merge_execution_endpoints_flag_test("execution-endpoints")
+fn bellatrix_execution_endpoints_flag() {
+    run_bellatrix_execution_endpoints_flag_test("execution-endpoints")
 }
 #[test]
-fn merge_execution_endpoint_flag() {
-    run_merge_execution_endpoints_flag_test("execution-endpoint")
+fn bellatrix_execution_endpoint_flag() {
+    run_bellatrix_execution_endpoints_flag_test("execution-endpoint")
 }
 #[test]
-fn merge_jwt_secrets_flag() {
+fn bellatrix_jwt_secrets_flag() {
     let dir = TempDir::new().expect("Unable to create temporary directory");
     let mut file = File::create(dir.path().join("jwtsecrets")).expect("Unable to create file");
     file.write_all(b"0x3cbc11b0d8fa16f3344eacfd6ff6430b9d30734450e8adcf5400f88d327dcb33")
@@ -515,14 +523,17 @@ fn merge_jwt_secrets_flag() {
         .with_config(|config| {
             let config = config.execution_layer.as_ref().unwrap();
             assert_eq!(
-                config.execution_endpoints[0].full.to_string(),
+                config.execution_endpoint.as_ref().unwrap().full.to_string(),
                 "http://localhost:8551/"
             );
-            assert_eq!(config.secret_files[0], dir.path().join("jwt-file"));
+            assert_eq!(
+                config.secret_file.as_ref().unwrap().clone(),
+                dir.path().join("jwt-file")
+            );
         });
 }
 #[test]
-fn merge_fee_recipient_flag() {
+fn bellatrix_fee_recipient_flag() {
     let dir = TempDir::new().expect("Unable to create temporary directory");
     CommandLineTest::new()
         .flag("execution-endpoint", Some("http://meow.cats"))
@@ -1215,7 +1226,17 @@ fn private_flag() {
     CommandLineTest::new()
         .flag("private", None)
         .run_with_zero_port()
-        .with_config(|config| assert!(config.network.private));
+        .with_config(|config| {
+            assert!(config.network.private);
+            assert!(matches!(
+                config.beacon_graffiti,
+                GraffitiOrigin::UserSpecified(_)
+            ));
+            assert_eq!(
+                config.beacon_graffiti.graffiti().to_string(),
+                "0x0000000000000000000000000000000000000000000000000000000000000000".to_string(),
+            );
+        });
 }
 #[test]
 fn zero_ports_flag() {
@@ -1583,14 +1604,15 @@ fn http_allow_origin_all_flag() {
         .run_with_zero_port()
         .with_config(|config| assert_eq!(config.http_api.allow_origin, Some("*".to_string())));
 }
+
 #[test]
 fn http_allow_sync_stalled_flag() {
     CommandLineTest::new()
         .flag("http", None)
         .flag("http-allow-sync-stalled", None)
-        .run_with_zero_port()
-        .with_config(|config| assert_eq!(config.http_api.allow_sync_stalled, true));
+        .run_with_zero_port();
 }
+
 #[test]
 fn http_enable_beacon_processor() {
     CommandLineTest::new()
@@ -1642,8 +1664,7 @@ fn http_spec_fork_override() {
     CommandLineTest::new()
         .flag("http", None)
         .flag("http-spec-fork", Some("altair"))
-        .run_with_zero_port()
-        .with_config(|config| assert_eq!(config.http_api.spec_fork_name, Some(ForkName::Altair)));
+        .run_with_zero_port();
 }
 
 // Tests for Metrics flags.
@@ -1825,6 +1846,19 @@ fn block_cache_size_flag() {
         .with_config(|config| assert_eq!(config.store.block_cache_size, new_non_zero_usize(4)));
 }
 #[test]
+fn state_cache_size_default() {
+    CommandLineTest::new()
+        .run_with_zero_port()
+        .with_config(|config| assert_eq!(config.store.state_cache_size, new_non_zero_usize(128)));
+}
+#[test]
+fn state_cache_size_flag() {
+    CommandLineTest::new()
+        .flag("state-cache-size", Some("64"))
+        .run_with_zero_port()
+        .with_config(|config| assert_eq!(config.store.state_cache_size, new_non_zero_usize(64)));
+}
+#[test]
 fn historic_state_cache_size_flag() {
     CommandLineTest::new()
         .flag("historic-state-cache-size", Some("4"))
diff --git a/lighthouse/tests/validator_client.rs b/lighthouse/tests/validator_client.rs
index 764fd87ccdf..cdf8fa15aaa 100644
--- a/lighthouse/tests/validator_client.rs
+++ b/lighthouse/tests/validator_client.rs
@@ -1,4 +1,4 @@
-use validator_client::{ApiTopic, Config};
+use validator_client::{config::DEFAULT_WEB3SIGNER_KEEP_ALIVE, ApiTopic, Config};
 
 use crate::exec::CommandLineTestExec;
 use bls::{Keypair, PublicKeyBytes};
@@ -9,6 +9,7 @@ use std::path::PathBuf;
 use std::process::Command;
 use std::str::FromStr;
 use std::string::ToString;
+use std::time::Duration;
 use tempfile::TempDir;
 use types::Address;
 
@@ -653,3 +654,26 @@ fn validator_disable_web3_signer_slashing_protection() {
             assert!(!config.enable_web3signer_slashing_protection);
         });
 }
+
+#[test]
+fn validator_web3_signer_keep_alive_default() {
+    CommandLineTest::new().run().with_config(|config| {
+        assert_eq!(
+            config.web3_signer_keep_alive_timeout,
+            DEFAULT_WEB3SIGNER_KEEP_ALIVE
+        );
+    });
+}
+
+#[test]
+fn validator_web3_signer_keep_alive_override() {
+    CommandLineTest::new()
+        .flag("web3-signer-keep-alive-timeout", Some("1000"))
+        .run()
+        .with_config(|config| {
+            assert_eq!(
+                config.web3_signer_keep_alive_timeout,
+                Some(Duration::from_secs(1))
+            );
+        });
+}
diff --git a/scripts/local_testnet/beacon_node.sh b/scripts/local_testnet/beacon_node.sh
index 2660dfa3c00..940fe2b8581 100755
--- a/scripts/local_testnet/beacon_node.sh
+++ b/scripts/local_testnet/beacon_node.sh
@@ -67,5 +67,4 @@ exec $lighthouse_binary \
 	--target-peers $((BN_COUNT - 1)) \
   --execution-endpoint $execution_endpoint \
   --execution-jwt $execution_jwt \
-  --http-allow-sync-stalled \
   $BN_ARGS
diff --git a/scripts/local_testnet/start_local_testnet.sh b/scripts/local_testnet/start_local_testnet.sh
index 77422095130..be91d069985 100755
--- a/scripts/local_testnet/start_local_testnet.sh
+++ b/scripts/local_testnet/start_local_testnet.sh
@@ -112,9 +112,6 @@ sleeping 3
 execute_command_add_PID el_bootnode.log ./el_bootnode.sh
 sleeping 3
 
-execute_command_add_PID el_bootnode.log ./el_bootnode.sh
-sleeping 1
-
 # Start beacon nodes
 BN_udp_tcp_base=9000
 BN_http_port_base=8000
diff --git a/testing/ef_tests/src/case_result.rs b/testing/ef_tests/src/case_result.rs
index 67ab9c51bbf..c511d9a1ca0 100644
--- a/testing/ef_tests/src/case_result.rs
+++ b/testing/ef_tests/src/case_result.rs
@@ -39,6 +39,9 @@ pub fn compare_beacon_state_results_without_caches<E: EthSpec, T: Debug>(
     if let (Ok(ref mut result), Some(ref mut expected)) = (result.as_mut(), expected.as_mut()) {
         result.drop_all_caches().unwrap();
         expected.drop_all_caches().unwrap();
+
+        result.apply_pending_mutations().unwrap();
+        expected.apply_pending_mutations().unwrap();
     }
 
     compare_result_detailed(result, expected)
diff --git a/testing/ef_tests/src/cases/common.rs b/testing/ef_tests/src/cases/common.rs
index 342a48ba46c..6763edbe22b 100644
--- a/testing/ef_tests/src/cases/common.rs
+++ b/testing/ef_tests/src/cases/common.rs
@@ -63,8 +63,8 @@ pub fn previous_fork(fork_name: ForkName) -> ForkName {
     match fork_name {
         ForkName::Base => ForkName::Base,
         ForkName::Altair => ForkName::Base,
-        ForkName::Merge => ForkName::Altair,
-        ForkName::Capella => ForkName::Merge,
+        ForkName::Bellatrix => ForkName::Altair,
+        ForkName::Capella => ForkName::Bellatrix,
         ForkName::Deneb => ForkName::Capella,
         ForkName::Electra => ForkName::Deneb,
     }
diff --git a/testing/ef_tests/src/cases/epoch_processing.rs b/testing/ef_tests/src/cases/epoch_processing.rs
index a9c77c53c52..c4c592e4cf2 100644
--- a/testing/ef_tests/src/cases/epoch_processing.rs
+++ b/testing/ef_tests/src/cases/epoch_processing.rs
@@ -105,7 +105,7 @@ impl<E: EthSpec> EpochTransition<E> for JustificationAndFinalization {
                 Ok(())
             }
             BeaconState::Altair(_)
-            | BeaconState::Merge(_)
+            | BeaconState::Bellatrix(_)
             | BeaconState::Capella(_)
             | BeaconState::Deneb(_)
             | BeaconState::Electra(_) => {
@@ -128,7 +128,7 @@ impl<E: EthSpec> EpochTransition<E> for RewardsAndPenalties {
                 base::process_rewards_and_penalties(state, &validator_statuses, spec)
             }
             BeaconState::Altair(_)
-            | BeaconState::Merge(_)
+            | BeaconState::Bellatrix(_)
             | BeaconState::Capella(_)
             | BeaconState::Deneb(_)
             | BeaconState::Electra(_) => altair::process_rewards_and_penalties_slow(state, spec),
@@ -161,7 +161,7 @@ impl<E: EthSpec> EpochTransition<E> for Slashings {
                 )?;
             }
             BeaconState::Altair(_)
-            | BeaconState::Merge(_)
+            | BeaconState::Bellatrix(_)
             | BeaconState::Capella(_)
             | BeaconState::Deneb(_)
             | BeaconState::Electra(_) => {
@@ -203,7 +203,7 @@ impl<E: EthSpec> EpochTransition<E> for RandaoMixesReset {
 impl<E: EthSpec> EpochTransition<E> for HistoricalRootsUpdate {
     fn run(state: &mut BeaconState<E>, _spec: &ChainSpec) -> Result<(), EpochProcessingError> {
         match state {
-            BeaconState::Base(_) | BeaconState::Altair(_) | BeaconState::Merge(_) => {
+            BeaconState::Base(_) | BeaconState::Altair(_) | BeaconState::Bellatrix(_) => {
                 process_historical_roots_update(state)
             }
             _ => Ok(()),
@@ -237,7 +237,7 @@ impl<E: EthSpec> EpochTransition<E> for SyncCommitteeUpdates {
         match state {
             BeaconState::Base(_) => Ok(()),
             BeaconState::Altair(_)
-            | BeaconState::Merge(_)
+            | BeaconState::Bellatrix(_)
             | BeaconState::Capella(_)
             | BeaconState::Deneb(_)
             | BeaconState::Electra(_) => altair::process_sync_committee_updates(state, spec),
@@ -250,7 +250,7 @@ impl<E: EthSpec> EpochTransition<E> for InactivityUpdates {
         match state {
             BeaconState::Base(_) => Ok(()),
             BeaconState::Altair(_)
-            | BeaconState::Merge(_)
+            | BeaconState::Bellatrix(_)
             | BeaconState::Capella(_)
             | BeaconState::Deneb(_)
             | BeaconState::Electra(_) => altair::process_inactivity_updates_slow(state, spec),
@@ -263,7 +263,7 @@ impl<E: EthSpec> EpochTransition<E> for ParticipationFlagUpdates {
         match state {
             BeaconState::Base(_) => Ok(()),
             BeaconState::Altair(_)
-            | BeaconState::Merge(_)
+            | BeaconState::Bellatrix(_)
             | BeaconState::Capella(_)
             | BeaconState::Deneb(_)
             | BeaconState::Electra(_) => altair::process_participation_flag_updates(state),
@@ -313,7 +313,7 @@ impl<E: EthSpec, T: EpochTransition<E>> Case for EpochProcessing<E, T> {
                     && T::name() != "historical_summaries_update"
             }
             // No phase0 tests for Altair and later.
-            ForkName::Altair | ForkName::Merge => {
+            ForkName::Altair | ForkName::Bellatrix => {
                 T::name() != "participation_record_updates"
                     && T::name() != "historical_summaries_update"
             }
diff --git a/testing/ef_tests/src/cases/fork.rs b/testing/ef_tests/src/cases/fork.rs
index be8a344a35a..132cfb4c0ae 100644
--- a/testing/ef_tests/src/cases/fork.rs
+++ b/testing/ef_tests/src/cases/fork.rs
@@ -63,7 +63,9 @@ impl<E: EthSpec> Case for ForkTest<E> {
         let mut result = match fork_name {
             ForkName::Base => panic!("phase0 not supported"),
             ForkName::Altair => upgrade_to_altair(&mut result_state, spec).map(|_| result_state),
-            ForkName::Merge => upgrade_to_bellatrix(&mut result_state, spec).map(|_| result_state),
+            ForkName::Bellatrix => {
+                upgrade_to_bellatrix(&mut result_state, spec).map(|_| result_state)
+            }
             ForkName::Capella => upgrade_to_capella(&mut result_state, spec).map(|_| result_state),
             ForkName::Deneb => upgrade_to_deneb(&mut result_state, spec).map(|_| result_state),
             ForkName::Electra => upgrade_to_electra(&mut result_state, spec).map(|_| result_state),
diff --git a/testing/ef_tests/src/cases/fork_choice.rs b/testing/ef_tests/src/cases/fork_choice.rs
index f0749c3c7e4..bd8cc791565 100644
--- a/testing/ef_tests/src/cases/fork_choice.rs
+++ b/testing/ef_tests/src/cases/fork_choice.rs
@@ -24,9 +24,9 @@ use std::future::Future;
 use std::sync::Arc;
 use std::time::Duration;
 use types::{
-    Attestation, AttesterSlashing, BeaconBlock, BeaconState, BlobSidecar, BlobsList, Checkpoint,
-    ExecutionBlockHash, Hash256, IndexedAttestation, KzgProof, ProposerPreparationData,
-    SignedBeaconBlock, Slot, Uint256,
+    Attestation, AttesterSlashing, BeaconBlock, BeaconState, BlobSidecar, BlobsList,
+    BlockImportSource, Checkpoint, ExecutionBlockHash, Hash256, IndexedAttestation, KzgProof,
+    ProposerPreparationData, SignedBeaconBlock, Slot, Uint256,
 };
 
 #[derive(Default, Debug, PartialEq, Clone, Deserialize, Decode)]
@@ -498,6 +498,7 @@ impl<E: EthSpec> Tester<E> {
                 block_root,
                 block.clone(),
                 NotifyExecutionLayer::Yes,
+                BlockImportSource::Lookup,
                 || Ok(()),
             ))?
             .map(|avail: AvailabilityProcessingStatus| avail.try_into());
diff --git a/testing/ef_tests/src/cases/merkle_proof_validity.rs b/testing/ef_tests/src/cases/merkle_proof_validity.rs
index a2e831ade59..8d5c0687753 100644
--- a/testing/ef_tests/src/cases/merkle_proof_validity.rs
+++ b/testing/ef_tests/src/cases/merkle_proof_validity.rs
@@ -51,7 +51,7 @@ impl<E: EthSpec> LoadCase for MerkleProofValidity<E> {
 impl<E: EthSpec> Case for MerkleProofValidity<E> {
     fn result(&self, _case_index: usize, _fork_name: ForkName) -> Result<(), Error> {
         let mut state = self.state.clone();
-        state.initialize_tree_hash_cache();
+        state.update_tree_hash_cache().unwrap();
         let Ok(proof) = state.compute_merkle_proof(self.merkle_proof.leaf_index) else {
             return Err(Error::FailedToParseTest(
                 "Could not retrieve merkle proof".to_string(),
@@ -77,9 +77,6 @@ impl<E: EthSpec> Case for MerkleProofValidity<E> {
             }
         }
 
-        // Tree hash cache should still be initialized (not dropped).
-        assert!(state.tree_hash_cache().is_initialized());
-
         Ok(())
     }
 }
@@ -95,7 +92,7 @@ pub struct KzgInclusionMerkleProofValidity<E: EthSpec> {
 impl<E: EthSpec> LoadCase for KzgInclusionMerkleProofValidity<E> {
     fn load_from_dir(path: &Path, fork_name: ForkName) -> Result<Self, Error> {
         let block: BeaconBlockBody<E, FullPayload<E>> = match fork_name {
-            ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => {
+            ForkName::Base | ForkName::Altair | ForkName::Bellatrix | ForkName::Capella => {
                 return Err(Error::InternalError(format!(
                     "KZG inclusion merkle proof validity test skipped for {:?}",
                     fork_name
diff --git a/testing/ef_tests/src/cases/operations.rs b/testing/ef_tests/src/cases/operations.rs
index a2f50896a57..158f2334dc3 100644
--- a/testing/ef_tests/src/cases/operations.rs
+++ b/testing/ef_tests/src/cases/operations.rs
@@ -20,8 +20,8 @@ use state_processing::{
 };
 use std::fmt::Debug;
 use types::{
-    Attestation, AttesterSlashing, BeaconBlock, BeaconBlockBody, BeaconBlockBodyCapella,
-    BeaconBlockBodyDeneb, BeaconBlockBodyMerge, BeaconState, BlindedPayload, Deposit,
+    Attestation, AttesterSlashing, BeaconBlock, BeaconBlockBody, BeaconBlockBodyBellatrix,
+    BeaconBlockBodyCapella, BeaconBlockBodyDeneb, BeaconState, BlindedPayload, Deposit,
     ExecutionPayload, FullPayload, ProposerSlashing, SignedBlsToExecutionChange,
     SignedVoluntaryExit, SyncAggregate,
 };
@@ -99,7 +99,7 @@ impl<E: EthSpec> Operation<E> for Attestation<E> {
                 spec,
             ),
             BeaconState::Altair(_)
-            | BeaconState::Merge(_)
+            | BeaconState::Bellatrix(_)
             | BeaconState::Capella(_)
             | BeaconState::Deneb(_)
             | BeaconState::Electra(_) => {
@@ -289,7 +289,7 @@ impl<E: EthSpec> Operation<E> for BeaconBlockBody<E, FullPayload<E>> {
     fn decode(path: &Path, fork_name: ForkName, _spec: &ChainSpec) -> Result<Self, Error> {
         ssz_decode_file_with(path, |bytes| {
             Ok(match fork_name {
-                ForkName::Merge => BeaconBlockBody::Merge(<_>::from_ssz_bytes(bytes)?),
+                ForkName::Bellatrix => BeaconBlockBody::Bellatrix(<_>::from_ssz_bytes(bytes)?),
                 ForkName::Capella => BeaconBlockBody::Capella(<_>::from_ssz_bytes(bytes)?),
                 ForkName::Deneb => BeaconBlockBody::Deneb(<_>::from_ssz_bytes(bytes)?),
                 _ => panic!(),
@@ -330,9 +330,10 @@ impl<E: EthSpec> Operation<E> for BeaconBlockBody<E, BlindedPayload<E>> {
     fn decode(path: &Path, fork_name: ForkName, _spec: &ChainSpec) -> Result<Self, Error> {
         ssz_decode_file_with(path, |bytes| {
             Ok(match fork_name {
-                ForkName::Merge => {
-                    let inner = <BeaconBlockBodyMerge<E, FullPayload<E>>>::from_ssz_bytes(bytes)?;
-                    BeaconBlockBody::Merge(inner.clone_as_blinded())
+                ForkName::Bellatrix => {
+                    let inner =
+                        <BeaconBlockBodyBellatrix<E, FullPayload<E>>>::from_ssz_bytes(bytes)?;
+                    BeaconBlockBody::Bellatrix(inner.clone_as_blinded())
                 }
                 ForkName::Capella => {
                     let inner = <BeaconBlockBodyCapella<E, FullPayload<E>>>::from_ssz_bytes(bytes)?;
@@ -375,7 +376,9 @@ impl<E: EthSpec> Operation<E> for WithdrawalsPayload<E> {
     }
 
     fn is_enabled_for_fork(fork_name: ForkName) -> bool {
-        fork_name != ForkName::Base && fork_name != ForkName::Altair && fork_name != ForkName::Merge
+        fork_name != ForkName::Base
+            && fork_name != ForkName::Altair
+            && fork_name != ForkName::Bellatrix
     }
 
     fn decode(path: &Path, fork_name: ForkName, _spec: &ChainSpec) -> Result<Self, Error> {
@@ -407,7 +410,9 @@ impl<E: EthSpec> Operation<E> for SignedBlsToExecutionChange {
     }
 
     fn is_enabled_for_fork(fork_name: ForkName) -> bool {
-        fork_name != ForkName::Base && fork_name != ForkName::Altair && fork_name != ForkName::Merge
+        fork_name != ForkName::Base
+            && fork_name != ForkName::Altair
+            && fork_name != ForkName::Bellatrix
     }
 
     fn decode(path: &Path, _fork_name: ForkName, _spec: &ChainSpec) -> Result<Self, Error> {
diff --git a/testing/ef_tests/src/cases/sanity_blocks.rs b/testing/ef_tests/src/cases/sanity_blocks.rs
index b0902cb5b74..91bb995cc43 100644
--- a/testing/ef_tests/src/cases/sanity_blocks.rs
+++ b/testing/ef_tests/src/cases/sanity_blocks.rs
@@ -5,7 +5,7 @@ use crate::decode::{ssz_decode_file_with, ssz_decode_state, yaml_decode_file};
 use serde::Deserialize;
 use state_processing::{
     per_block_processing, per_slot_processing, BlockProcessingError, BlockSignatureStrategy,
-    ConsensusContext, StateProcessingStrategy, VerifyBlockRoot,
+    ConsensusContext, VerifyBlockRoot,
 };
 use types::{BeaconState, RelativeEpoch, SignedBeaconBlock};
 
@@ -96,7 +96,6 @@ impl<E: EthSpec> Case for SanityBlocks<E> {
                     &mut indiv_state,
                     signed_block,
                     BlockSignatureStrategy::VerifyIndividual,
-                    StateProcessingStrategy::Accurate,
                     VerifyBlockRoot::True,
                     &mut ctxt,
                     spec,
@@ -107,7 +106,6 @@ impl<E: EthSpec> Case for SanityBlocks<E> {
                     &mut bulk_state,
                     signed_block,
                     BlockSignatureStrategy::VerifyBulk,
-                    StateProcessingStrategy::Accurate,
                     VerifyBlockRoot::True,
                     &mut ctxt,
                     spec,
diff --git a/testing/ef_tests/src/cases/ssz_generic.rs b/testing/ef_tests/src/cases/ssz_generic.rs
index bb2465aae10..8de3e217f00 100644
--- a/testing/ef_tests/src/cases/ssz_generic.rs
+++ b/testing/ef_tests/src/cases/ssz_generic.rs
@@ -1,14 +1,14 @@
 #![allow(non_snake_case)]
 
 use super::*;
-use crate::cases::common::{TestU128, TestU256};
-use crate::decode::{snappy_decode_file, yaml_decode_file};
-use serde::Deserialize;
-use serde::{de::Error as SerdeError, Deserializer};
+use crate::cases::common::{SszStaticType, TestU128, TestU256};
+use crate::cases::ssz_static::{check_serialization, check_tree_hash};
+use crate::decode::{log_file_access, snappy_decode_file, yaml_decode_file};
+use serde::{de::Error as SerdeError, Deserialize, Deserializer};
 use ssz_derive::{Decode, Encode};
 use tree_hash_derive::TreeHash;
 use types::typenum::*;
-use types::{BitList, BitVector, FixedVector, VariableList};
+use types::{BitList, BitVector, FixedVector, ForkName, VariableList, Vector};
 
 #[derive(Debug, Clone, Deserialize)]
 struct Metadata {
@@ -125,6 +125,20 @@ impl Case for SszGeneric {
                 let elem_ty = parts[1];
                 let length = parts[2];
 
+                // Skip length 0 tests. Milhouse doesn't have any checks against 0-capacity lists.
+                if length == "0" {
+                    log_file_access(self.path.join("serialized.ssz_snappy"));
+                    return Ok(());
+                }
+
+                type_dispatch!(
+                    ssz_generic_test,
+                    (&self.path),
+                    Vector,
+                    <>,
+                    [elem_ty => primitive_type]
+                    [length => typenum]
+                )?;
                 type_dispatch!(
                     ssz_generic_test,
                     (&self.path),
@@ -263,8 +277,8 @@ struct ComplexTestStruct {
     #[serde(deserialize_with = "byte_list_from_hex_str")]
     D: VariableList<u8, U256>,
     E: VarTestStruct,
-    F: FixedVector<FixedTestStruct, U4>,
-    G: FixedVector<VarTestStruct, U2>,
+    F: Vector<FixedTestStruct, U4>,
+    G: Vector<VarTestStruct, U2>,
 }
 
 #[derive(Debug, Clone, PartialEq, Decode, Encode, TreeHash, Deserialize)]
diff --git a/testing/ef_tests/src/cases/ssz_static.rs b/testing/ef_tests/src/cases/ssz_static.rs
index e41c90c6e03..5f0ac3525c4 100644
--- a/testing/ef_tests/src/cases/ssz_static.rs
+++ b/testing/ef_tests/src/cases/ssz_static.rs
@@ -118,7 +118,6 @@ impl<E: EthSpec> Case for SszStaticTHC<BeaconState<E>> {
         check_tree_hash(&self.roots.root, self.value.tree_hash_root().as_bytes())?;
 
         let mut state = self.value.clone();
-        state.initialize_tree_hash_cache();
         let cached_tree_hash_root = state.update_tree_hash_cache().unwrap();
         check_tree_hash(&self.roots.root, cached_tree_hash_root.as_bytes())?;
 
diff --git a/testing/ef_tests/src/cases/transition.rs b/testing/ef_tests/src/cases/transition.rs
index 927589948a2..dc5029d53e7 100644
--- a/testing/ef_tests/src/cases/transition.rs
+++ b/testing/ef_tests/src/cases/transition.rs
@@ -4,7 +4,7 @@ use crate::decode::{ssz_decode_file_with, ssz_decode_state, yaml_decode_file};
 use serde::Deserialize;
 use state_processing::{
     per_block_processing, state_advance::complete_state_advance, BlockSignatureStrategy,
-    ConsensusContext, StateProcessingStrategy, VerifyBlockRoot,
+    ConsensusContext, VerifyBlockRoot,
 };
 use std::str::FromStr;
 use types::{BeaconState, Epoch, SignedBeaconBlock};
@@ -38,7 +38,7 @@ impl<E: EthSpec> LoadCase for TransitionTest<E> {
             ForkName::Altair => {
                 spec.altair_fork_epoch = Some(metadata.fork_epoch);
             }
-            ForkName::Merge => {
+            ForkName::Bellatrix => {
                 spec.altair_fork_epoch = Some(Epoch::new(0));
                 spec.bellatrix_fork_epoch = Some(metadata.fork_epoch);
             }
@@ -114,7 +114,6 @@ impl<E: EthSpec> Case for TransitionTest<E> {
                     &mut state,
                     block,
                     BlockSignatureStrategy::VerifyBulk,
-                    StateProcessingStrategy::Accurate,
                     VerifyBlockRoot::True,
                     &mut ctxt,
                     spec,
diff --git a/testing/ef_tests/src/handler.rs b/testing/ef_tests/src/handler.rs
index 59b5cb6ba74..2d5ea4149ef 100644
--- a/testing/ef_tests/src/handler.rs
+++ b/testing/ef_tests/src/handler.rs
@@ -217,8 +217,8 @@ impl<T, E> SszStaticHandler<T, E> {
         Self::for_forks(vec![ForkName::Altair])
     }
 
-    pub fn merge_only() -> Self {
-        Self::for_forks(vec![ForkName::Merge])
+    pub fn bellatrix_only() -> Self {
+        Self::for_forks(vec![ForkName::Bellatrix])
     }
 
     pub fn capella_only() -> Self {
@@ -558,7 +558,7 @@ impl<E: EthSpec + TypeName> Handler for ForkChoiceHandler<E> {
 
     fn is_enabled_for_fork(&self, fork_name: ForkName) -> bool {
         // Merge block tests are only enabled for Bellatrix.
-        if self.handler_name == "on_merge_block" && fork_name != ForkName::Merge {
+        if self.handler_name == "on_merge_block" && fork_name != ForkName::Bellatrix {
             return false;
         }
 
@@ -823,7 +823,7 @@ impl<E: EthSpec + TypeName> Handler for KzgInclusionMerkleProofValidityHandler<E
         // Enabled in Deneb
         fork_name != ForkName::Base
             && fork_name != ForkName::Altair
-            && fork_name != ForkName::Merge
+            && fork_name != ForkName::Bellatrix
             && fork_name != ForkName::Capella
     }
 }
diff --git a/testing/ef_tests/src/type_name.rs b/testing/ef_tests/src/type_name.rs
index ef5d7eb001c..49ebbe81909 100644
--- a/testing/ef_tests/src/type_name.rs
+++ b/testing/ef_tests/src/type_name.rs
@@ -46,7 +46,7 @@ type_name_generic!(BeaconBlock);
 type_name_generic!(BeaconBlockBody);
 type_name_generic!(BeaconBlockBodyBase, "BeaconBlockBody");
 type_name_generic!(BeaconBlockBodyAltair, "BeaconBlockBody");
-type_name_generic!(BeaconBlockBodyMerge, "BeaconBlockBody");
+type_name_generic!(BeaconBlockBodyBellatrix, "BeaconBlockBody");
 type_name_generic!(BeaconBlockBodyCapella, "BeaconBlockBody");
 type_name_generic!(BeaconBlockBodyDeneb, "BeaconBlockBody");
 type_name!(BeaconBlockHeader);
@@ -60,12 +60,12 @@ type_name!(DepositData);
 type_name!(DepositMessage);
 type_name!(Eth1Data);
 type_name_generic!(ExecutionPayload);
-type_name_generic!(ExecutionPayloadMerge, "ExecutionPayload");
+type_name_generic!(ExecutionPayloadBellatrix, "ExecutionPayload");
 type_name_generic!(ExecutionPayloadCapella, "ExecutionPayload");
 type_name_generic!(ExecutionPayloadDeneb, "ExecutionPayload");
 type_name_generic!(FullPayload, "ExecutionPayload");
 type_name_generic!(ExecutionPayloadHeader);
-type_name_generic!(ExecutionPayloadHeaderMerge, "ExecutionPayloadHeader");
+type_name_generic!(ExecutionPayloadHeaderBellatrix, "ExecutionPayloadHeader");
 type_name_generic!(ExecutionPayloadHeaderCapella, "ExecutionPayloadHeader");
 type_name_generic!(ExecutionPayloadHeaderDeneb, "ExecutionPayloadHeader");
 type_name_generic!(BlindedPayload, "ExecutionPayloadHeader");
diff --git a/testing/ef_tests/tests/tests.rs b/testing/ef_tests/tests/tests.rs
index 3093239f7fd..5226c7ac2b0 100644
--- a/testing/ef_tests/tests/tests.rs
+++ b/testing/ef_tests/tests/tests.rs
@@ -258,9 +258,9 @@ mod ssz_static {
             .run();
         SszStaticHandler::<BeaconBlockBodyAltair<MainnetEthSpec>, MainnetEthSpec>::altair_only()
             .run();
-        SszStaticHandler::<BeaconBlockBodyMerge<MinimalEthSpec>, MinimalEthSpec>::merge_only()
+        SszStaticHandler::<BeaconBlockBodyBellatrix<MinimalEthSpec>, MinimalEthSpec>::bellatrix_only()
             .run();
-        SszStaticHandler::<BeaconBlockBodyMerge<MainnetEthSpec>, MainnetEthSpec>::merge_only()
+        SszStaticHandler::<BeaconBlockBodyBellatrix<MainnetEthSpec>, MainnetEthSpec>::bellatrix_only()
             .run();
         SszStaticHandler::<BeaconBlockBodyCapella<MinimalEthSpec>, MinimalEthSpec>::capella_only()
             .run();
@@ -290,10 +290,10 @@ mod ssz_static {
             .run();
         SszStaticHandler::<LightClientBootstrapAltair<MainnetEthSpec>, MainnetEthSpec>::altair_only()
             .run();
-        SszStaticHandler::<LightClientBootstrapAltair<MinimalEthSpec>, MinimalEthSpec>::merge_only(
+        SszStaticHandler::<LightClientBootstrapAltair<MinimalEthSpec>, MinimalEthSpec>::bellatrix_only(
         )
         .run();
-        SszStaticHandler::<LightClientBootstrapAltair<MainnetEthSpec>, MainnetEthSpec>::merge_only(
+        SszStaticHandler::<LightClientBootstrapAltair<MainnetEthSpec>, MainnetEthSpec>::bellatrix_only(
         )
         .run();
         SszStaticHandler::<LightClientBootstrapCapella<MinimalEthSpec>, MinimalEthSpec>::capella_only()
@@ -313,9 +313,9 @@ mod ssz_static {
             .run();
         SszStaticHandler::<LightClientHeaderAltair<MainnetEthSpec>, MainnetEthSpec>::altair_only()
             .run();
-        SszStaticHandler::<LightClientHeaderAltair<MinimalEthSpec>, MinimalEthSpec>::merge_only()
+        SszStaticHandler::<LightClientHeaderAltair<MinimalEthSpec>, MinimalEthSpec>::bellatrix_only()
             .run();
-        SszStaticHandler::<LightClientHeaderAltair<MainnetEthSpec>, MainnetEthSpec>::merge_only()
+        SszStaticHandler::<LightClientHeaderAltair<MainnetEthSpec>, MainnetEthSpec>::bellatrix_only()
             .run();
 
         SszStaticHandler::<LightClientHeaderCapella<MinimalEthSpec>, MinimalEthSpec>::capella_only(
@@ -340,10 +340,10 @@ mod ssz_static {
         SszStaticHandler::<LightClientOptimisticUpdateAltair<MainnetEthSpec>, MainnetEthSpec>::altair_only(
         )
             .run();
-        SszStaticHandler::<LightClientOptimisticUpdateAltair<MinimalEthSpec>, MinimalEthSpec>::merge_only(
+        SszStaticHandler::<LightClientOptimisticUpdateAltair<MinimalEthSpec>, MinimalEthSpec>::bellatrix_only(
         )
             .run();
-        SszStaticHandler::<LightClientOptimisticUpdateAltair<MainnetEthSpec>, MainnetEthSpec>::merge_only(
+        SszStaticHandler::<LightClientOptimisticUpdateAltair<MainnetEthSpec>, MainnetEthSpec>::bellatrix_only(
         )
             .run();
         SszStaticHandler::<LightClientOptimisticUpdateCapella<MinimalEthSpec>, MinimalEthSpec>::capella_only(
@@ -369,10 +369,10 @@ mod ssz_static {
         SszStaticHandler::<LightClientFinalityUpdateAltair<MainnetEthSpec>, MainnetEthSpec>::altair_only(
         )
             .run();
-        SszStaticHandler::<LightClientFinalityUpdateAltair<MinimalEthSpec>, MinimalEthSpec>::merge_only(
+        SszStaticHandler::<LightClientFinalityUpdateAltair<MinimalEthSpec>, MinimalEthSpec>::bellatrix_only(
         )
             .run();
-        SszStaticHandler::<LightClientFinalityUpdateAltair<MainnetEthSpec>, MainnetEthSpec>::merge_only(
+        SszStaticHandler::<LightClientFinalityUpdateAltair<MainnetEthSpec>, MainnetEthSpec>::bellatrix_only(
         )
             .run();
         SszStaticHandler::<LightClientFinalityUpdateCapella<MinimalEthSpec>, MinimalEthSpec>::capella_only(
@@ -396,9 +396,9 @@ mod ssz_static {
             .run();
         SszStaticHandler::<LightClientUpdateAltair<MainnetEthSpec>, MainnetEthSpec>::altair_only()
             .run();
-        SszStaticHandler::<LightClientUpdateAltair<MinimalEthSpec>, MinimalEthSpec>::merge_only()
+        SszStaticHandler::<LightClientUpdateAltair<MinimalEthSpec>, MinimalEthSpec>::bellatrix_only()
             .run();
-        SszStaticHandler::<LightClientUpdateAltair<MainnetEthSpec>, MainnetEthSpec>::merge_only()
+        SszStaticHandler::<LightClientUpdateAltair<MainnetEthSpec>, MainnetEthSpec>::bellatrix_only()
             .run();
         SszStaticHandler::<LightClientUpdateCapella<MinimalEthSpec>, MinimalEthSpec>::capella_only(
         )
@@ -448,12 +448,12 @@ mod ssz_static {
         SszStaticHandler::<SyncAggregatorSelectionData, MainnetEthSpec>::altair_and_later().run();
     }
 
-    // Merge and later
+    // Bellatrix and later
     #[test]
     fn execution_payload() {
-        SszStaticHandler::<ExecutionPayloadMerge<MinimalEthSpec>, MinimalEthSpec>::merge_only()
+        SszStaticHandler::<ExecutionPayloadBellatrix<MinimalEthSpec>, MinimalEthSpec>::bellatrix_only()
             .run();
-        SszStaticHandler::<ExecutionPayloadMerge<MainnetEthSpec>, MainnetEthSpec>::merge_only()
+        SszStaticHandler::<ExecutionPayloadBellatrix<MainnetEthSpec>, MainnetEthSpec>::bellatrix_only()
             .run();
         SszStaticHandler::<ExecutionPayloadCapella<MinimalEthSpec>, MinimalEthSpec>::capella_only()
             .run();
@@ -467,9 +467,9 @@ mod ssz_static {
 
     #[test]
     fn execution_payload_header() {
-        SszStaticHandler::<ExecutionPayloadHeaderMerge<MinimalEthSpec>, MinimalEthSpec>::merge_only()
+        SszStaticHandler::<ExecutionPayloadHeaderBellatrix<MinimalEthSpec>, MinimalEthSpec>::bellatrix_only()
             .run();
-        SszStaticHandler::<ExecutionPayloadHeaderMerge<MainnetEthSpec>, MainnetEthSpec>::merge_only()
+        SszStaticHandler::<ExecutionPayloadHeaderBellatrix<MainnetEthSpec>, MainnetEthSpec>::bellatrix_only()
             .run();
         SszStaticHandler::<ExecutionPayloadHeaderCapella<MinimalEthSpec>, MinimalEthSpec>
             ::capella_only().run();
diff --git a/testing/execution_engine_integration/src/test_rig.rs b/testing/execution_engine_integration/src/test_rig.rs
index 8f782c7e4e0..c7d5e704524 100644
--- a/testing/execution_engine_integration/src/test_rig.rs
+++ b/testing/execution_engine_integration/src/test_rig.rs
@@ -121,11 +121,11 @@ impl<Engine: GenericExecutionEngine> TestRig<Engine> {
 
         let ee_a = {
             let execution_engine = ExecutionEngine::new(generic_engine.clone());
-            let urls = vec![execution_engine.http_auth_url()];
+            let url = Some(execution_engine.http_auth_url());
 
             let config = execution_layer::Config {
-                execution_endpoints: urls,
-                secret_files: vec![],
+                execution_endpoint: url,
+                secret_file: None,
                 suggested_fee_recipient: Some(Address::repeat_byte(42)),
                 default_datadir: execution_engine.datadir(),
                 ..Default::default()
@@ -140,11 +140,11 @@ impl<Engine: GenericExecutionEngine> TestRig<Engine> {
 
         let ee_b = {
             let execution_engine = ExecutionEngine::new(generic_engine);
-            let urls = vec![execution_engine.http_auth_url()];
+            let url = Some(execution_engine.http_auth_url());
 
             let config = execution_layer::Config {
-                execution_endpoints: urls,
-                secret_files: vec![],
+                execution_endpoint: url,
+                secret_file: None,
                 suggested_fee_recipient: fee_recipient,
                 default_datadir: execution_engine.datadir(),
                 ..Default::default()
@@ -180,7 +180,7 @@ impl<Engine: GenericExecutionEngine> TestRig<Engine> {
                 // Run the routine to check for online nodes.
                 pair.execution_layer.watchdog_task().await;
 
-                if pair.execution_layer.is_synced().await {
+                if !pair.execution_layer.is_offline_or_erroring().await {
                     break;
                 } else if start_instant + EXECUTION_ENGINE_START_TIMEOUT > Instant::now() {
                     sleep(Duration::from_millis(500)).await;
diff --git a/testing/simulator/Cargo.toml b/testing/simulator/Cargo.toml
index eadcaf51b20..d7ff7b3dd85 100644
--- a/testing/simulator/Cargo.toml
+++ b/testing/simulator/Cargo.toml
@@ -14,8 +14,11 @@ types = { workspace = true }
 parking_lot = { workspace = true }
 futures = { workspace = true }
 tokio = { workspace = true }
-eth1_test_rig = { workspace = true }
 env_logger = { workspace = true }
 clap = { workspace = true }
 rayon = { workspace = true }
 sensitive_url  = { path = "../../common/sensitive_url" }
+ssz_types = { workspace = true }
+ethereum-types = { workspace = true }
+eth2_network_config = { workspace = true }
+serde_json = { workspace = true }
diff --git a/testing/simulator/src/eth1_sim.rs b/testing/simulator/src/basic_sim.rs
similarity index 50%
rename from testing/simulator/src/eth1_sim.rs
rename to testing/simulator/src/basic_sim.rs
index 8d6ffc42ffa..755bb71b430 100644
--- a/testing/simulator/src/eth1_sim.rs
+++ b/testing/simulator/src/basic_sim.rs
@@ -1,50 +1,48 @@
-use crate::local_network::{EXECUTION_PORT, TERMINAL_BLOCK, TERMINAL_DIFFICULTY};
+use crate::local_network::LocalNetworkParams;
+use crate::local_network::TERMINAL_BLOCK;
 use crate::{checks, LocalNetwork};
 use clap::ArgMatches;
-use eth1::{Eth1Endpoint, DEFAULT_CHAIN_ID};
-use eth1_test_rig::AnvilEth1Instance;
 
 use crate::retry::with_retry;
-use execution_layer::http::deposit_methods::Eth1Id;
 use futures::prelude::*;
-use node_test_rig::environment::RuntimeContext;
 use node_test_rig::{
     environment::{EnvironmentBuilder, LoggerConfig},
-    testing_client_config, testing_validator_config, ApiTopic, ClientConfig, ClientGenesis,
-    ValidatorFiles,
+    testing_validator_config, ApiTopic, ValidatorFiles,
 };
 use rayon::prelude::*;
-use sensitive_url::SensitiveUrl;
 use std::cmp::max;
-use std::net::Ipv4Addr;
 use std::time::Duration;
 use tokio::time::sleep;
 use types::{Epoch, EthSpec, MinimalEthSpec};
 
 const END_EPOCH: u64 = 16;
-const ALTAIR_FORK_EPOCH: u64 = 1;
-const BELLATRIX_FORK_EPOCH: u64 = 2;
+const GENESIS_DELAY: u64 = 32;
+const ALTAIR_FORK_EPOCH: u64 = 0;
+const BELLATRIX_FORK_EPOCH: u64 = 0;
+const CAPELLA_FORK_EPOCH: u64 = 1;
+const DENEB_FORK_EPOCH: u64 = 2;
+//const ELECTRA_FORK_EPOCH: u64 = 3;
 
 const SUGGESTED_FEE_RECIPIENT: [u8; 20] =
     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
 
-pub fn run_eth1_sim(matches: &ArgMatches) -> Result<(), String> {
-    let node_count = value_t!(matches, "nodes", usize).expect("missing nodes default");
-    let proposer_nodes = value_t!(matches, "proposer-nodes", usize).unwrap_or(0);
-    println!("PROPOSER-NODES: {}", proposer_nodes);
-    let validators_per_node = value_t!(matches, "validators_per_node", usize)
-        .expect("missing validators_per_node default");
+pub fn run_basic_sim(matches: &ArgMatches) -> Result<(), String> {
+    let node_count = value_t!(matches, "nodes", usize).expect("Missing nodes default");
+    let proposer_nodes =
+        value_t!(matches, "proposer-nodes", usize).expect("Missing proposer-nodes default");
+    let validators_per_node = value_t!(matches, "validators-per-node", usize)
+        .expect("Missing validators-per-node default");
     let speed_up_factor =
-        value_t!(matches, "speed_up_factor", u64).expect("missing speed_up_factor default");
-    let continue_after_checks = matches.is_present("continue_after_checks");
-    let post_merge_sim = matches.is_present("post-merge");
+        value_t!(matches, "speed-up-factor", u64).expect("Missing speed-up-factor default");
+    let log_level = value_t!(matches, "debug-level", String).expect("Missing default log-level");
+    let continue_after_checks = matches.is_present("continue-after-checks");
 
-    println!("Beacon Chain Simulator:");
-    println!(" nodes:{}, proposer_nodes: {}", node_count, proposer_nodes);
-
-    println!(" validators_per_node:{}", validators_per_node);
-    println!(" post merge simulation:{}", post_merge_sim);
-    println!(" continue_after_checks:{}", continue_after_checks);
+    println!("Basic Simulator:");
+    println!(" nodes: {}", node_count);
+    println!(" proposer-nodes: {}", proposer_nodes);
+    println!(" validators-per-node: {}", validators_per_node);
+    println!(" speed-up-factor: {}", speed_up_factor);
+    println!(" continue-after-checks: {}", continue_after_checks);
 
     // Generate the directories and keystores required for the validator clients.
     let validator_files = (0..node_count)
@@ -65,8 +63,8 @@ pub fn run_eth1_sim(matches: &ArgMatches) -> Result<(), String> {
     let mut env = EnvironmentBuilder::minimal()
         .initialize_logger(LoggerConfig {
             path: None,
-            debug_level: String::from("debug"),
-            logfile_debug_level: String::from("debug"),
+            debug_level: log_level.clone(),
+            logfile_debug_level: log_level,
             log_format: None,
             logfile_format: None,
             log_color: false,
@@ -80,32 +78,29 @@ pub fn run_eth1_sim(matches: &ArgMatches) -> Result<(), String> {
         .multi_threaded_tokio_runtime()?
         .build()?;
 
-    let eth1_block_time = Duration::from_millis(15_000 / speed_up_factor);
-
     let spec = &mut env.eth2_config.spec;
 
     let total_validator_count = validators_per_node * node_count;
-    let altair_fork_version = spec.altair_fork_version;
-    let bellatrix_fork_version = spec.bellatrix_fork_version;
+    let genesis_delay = GENESIS_DELAY;
+
+    // Convenience variables. Update these values when adding a newer fork.
+    let latest_fork_version = spec.deneb_fork_version;
+    let latest_fork_start_epoch = DENEB_FORK_EPOCH;
 
     spec.seconds_per_slot /= speed_up_factor;
     spec.seconds_per_slot = max(1, spec.seconds_per_slot);
-    spec.eth1_follow_distance = 16;
-    spec.genesis_delay = eth1_block_time.as_secs() * spec.eth1_follow_distance * 2;
+    spec.genesis_delay = genesis_delay;
     spec.min_genesis_time = 0;
     spec.min_genesis_active_validator_count = total_validator_count as u64;
-    spec.seconds_per_eth1_block = eth1_block_time.as_secs();
     spec.altair_fork_epoch = Some(Epoch::new(ALTAIR_FORK_EPOCH));
-    // Set these parameters only if we are doing a merge simulation
-    if post_merge_sim {
-        spec.terminal_total_difficulty = TERMINAL_DIFFICULTY.into();
-        spec.bellatrix_fork_epoch = Some(Epoch::new(BELLATRIX_FORK_EPOCH));
-    }
+    spec.bellatrix_fork_epoch = Some(Epoch::new(BELLATRIX_FORK_EPOCH));
+    spec.capella_fork_epoch = Some(Epoch::new(CAPELLA_FORK_EPOCH));
+    spec.deneb_fork_epoch = Some(Epoch::new(DENEB_FORK_EPOCH));
+    //spec.electra_fork_epoch = Some(Epoch::new(ELECTRA_FORK_EPOCH));
 
-    let seconds_per_slot = spec.seconds_per_slot;
     let slot_duration = Duration::from_secs(spec.seconds_per_slot);
+    let slots_per_epoch = MinimalEthSpec::slots_per_epoch();
     let initial_validator_count = spec.min_genesis_active_validator_count as usize;
-    let deposit_amount = env.eth2_config.spec.max_effective_balance;
 
     let context = env.core_context();
 
@@ -114,36 +109,36 @@ pub fn run_eth1_sim(matches: &ArgMatches) -> Result<(), String> {
          * Create a new `LocalNetwork` with one beacon node.
          */
         let max_retries = 3;
-        let (network, beacon_config) = with_retry(max_retries, || {
-            Box::pin(create_local_network(
+        let (network, beacon_config, mock_execution_config) = with_retry(max_retries, || {
+            Box::pin(LocalNetwork::create_local_network(
+                None,
+                None,
                 LocalNetworkParams {
-                    eth1_block_time,
-                    total_validator_count,
-                    deposit_amount,
+                    validator_count: total_validator_count,
                     node_count,
                     proposer_nodes,
-                    post_merge_sim,
+                    genesis_delay,
                 },
                 context.clone(),
             ))
         })
         .await?;
 
-        /*
-         * One by one, add beacon nodes to the network.
-         */
-        for _ in 0..node_count - 1 {
+        // Add nodes to the network.
+        for _ in 0..node_count {
             network
-                .add_beacon_node(beacon_config.clone(), false)
+                .add_beacon_node(beacon_config.clone(), mock_execution_config.clone(), false)
                 .await?;
         }
 
         /*
          * One by one, add proposer nodes to the network.
          */
-        for _ in 0..proposer_nodes - 1 {
+        for _ in 0..proposer_nodes {
             println!("Adding a proposer node");
-            network.add_beacon_node(beacon_config.clone(), true).await?;
+            network
+                .add_beacon_node(beacon_config.clone(), mock_execution_config.clone(), true)
+                .await?;
         }
 
         /*
@@ -156,9 +151,7 @@ pub fn run_eth1_sim(matches: &ArgMatches) -> Result<(), String> {
             executor.spawn(
                 async move {
                     let mut validator_config = testing_validator_config();
-                    if post_merge_sim {
-                        validator_config.fee_recipient = Some(SUGGESTED_FEE_RECIPIENT.into());
-                    }
+                    validator_config.fee_recipient = Some(SUGGESTED_FEE_RECIPIENT.into());
                     println!("Adding validator client {}", i);
 
                     // Enable broadcast on every 4th node.
@@ -175,7 +168,7 @@ pub fn run_eth1_sim(matches: &ArgMatches) -> Result<(), String> {
                             .await
                     } else {
                         network_1
-                            .add_validator_client(validator_config, i, files, i % 2 == 0)
+                            .add_validator_client(validator_config, i, files)
                             .await
                     }
                     .expect("should add validator");
@@ -184,25 +177,15 @@ pub fn run_eth1_sim(matches: &ArgMatches) -> Result<(), String> {
             );
         }
 
+        // Set all payloads as valid. This effectively assumes the EL is infalliable.
+        network.execution_nodes.write().iter().for_each(|node| {
+            node.server.all_payloads_valid();
+        });
+
         let duration_to_genesis = network.duration_to_genesis().await;
         println!("Duration to genesis: {}", duration_to_genesis.as_secs());
         sleep(duration_to_genesis).await;
 
-        if post_merge_sim {
-            let executor = executor.clone();
-            let network_2 = network.clone();
-            executor.spawn(
-                async move {
-                    println!("Mining pow blocks");
-                    let mut interval = tokio::time::interval(Duration::from_secs(seconds_per_slot));
-                    for i in 1..=TERMINAL_BLOCK + 1 {
-                        interval.tick().await;
-                        let _ = network_2.mine_pow_blocks(i);
-                    }
-                },
-                "pow_mining",
-            );
-        }
         /*
          * Start the checks that ensure the network performs as expected.
          *
@@ -211,6 +194,7 @@ pub fn run_eth1_sim(matches: &ArgMatches) -> Result<(), String> {
          * tests start at the right time. Whilst this is works well for now, it's subject to
          * breakage by changes to the VC.
          */
+        let network_1 = network.clone();
 
         let (
             finalization,
@@ -221,13 +205,16 @@ pub fn run_eth1_sim(matches: &ArgMatches) -> Result<(), String> {
             sync_aggregate,
             transition,
             light_client_update,
+            blobs,
+            start_node_with_delay,
+            sync,
         ) = futures::join!(
             // Check that the chain finalizes at the first given opportunity.
             checks::verify_first_finalization(network.clone(), slot_duration),
             // Check that a block is produced at every slot.
             checks::verify_full_block_production_up_to(
                 network.clone(),
-                Epoch::new(END_EPOCH).start_slot(MinimalEthSpec::slots_per_epoch()),
+                Epoch::new(END_EPOCH).start_slot(slots_per_epoch),
                 slot_duration,
             ),
             // Check that the chain starts with the expected validator count.
@@ -246,41 +233,55 @@ pub fn run_eth1_sim(matches: &ArgMatches) -> Result<(), String> {
             // Check that all nodes have transitioned to the required fork.
             checks::verify_fork_version(
                 network.clone(),
-                if post_merge_sim {
-                    Epoch::new(BELLATRIX_FORK_EPOCH)
-                } else {
-                    Epoch::new(ALTAIR_FORK_EPOCH)
-                },
+                Epoch::new(latest_fork_start_epoch),
                 slot_duration,
-                if post_merge_sim {
-                    bellatrix_fork_version
-                } else {
-                    altair_fork_version
-                }
+                latest_fork_version,
             ),
             // Check that all sync aggregates are full.
             checks::verify_full_sync_aggregates_up_to(
                 network.clone(),
                 // Start checking for sync_aggregates at `FORK_EPOCH + 1` to account for
                 // inefficiencies in finding subnet peers at the `fork_slot`.
-                Epoch::new(ALTAIR_FORK_EPOCH + 1).start_slot(MinimalEthSpec::slots_per_epoch()),
-                Epoch::new(END_EPOCH).start_slot(MinimalEthSpec::slots_per_epoch()),
+                Epoch::new(ALTAIR_FORK_EPOCH + 1).start_slot(slots_per_epoch),
+                Epoch::new(END_EPOCH).start_slot(slots_per_epoch),
                 slot_duration,
             ),
             // Check that the transition block is finalized.
             checks::verify_transition_block_finalized(
                 network.clone(),
-                Epoch::new(TERMINAL_BLOCK / MinimalEthSpec::slots_per_epoch()),
+                Epoch::new(TERMINAL_BLOCK / slots_per_epoch),
                 slot_duration,
-                post_merge_sim
+                true,
             ),
             checks::verify_light_client_updates(
                 network.clone(),
                 // Sync aggregate available from slot 1 after Altair fork transition.
-                Epoch::new(ALTAIR_FORK_EPOCH).start_slot(MinimalEthSpec::slots_per_epoch()) + 1,
-                Epoch::new(END_EPOCH).start_slot(MinimalEthSpec::slots_per_epoch()),
+                Epoch::new(ALTAIR_FORK_EPOCH).start_slot(slots_per_epoch) + 1,
+                Epoch::new(END_EPOCH).start_slot(slots_per_epoch),
                 slot_duration
-            )
+            ),
+            checks::verify_full_blob_production_up_to(
+                network.clone(),
+                // Blobs should be available immediately after the Deneb fork.
+                Epoch::new(DENEB_FORK_EPOCH).start_slot(slots_per_epoch),
+                Epoch::new(END_EPOCH).start_slot(slots_per_epoch),
+                slot_duration
+            ),
+            network_1.add_beacon_node_with_delay(
+                beacon_config.clone(),
+                mock_execution_config.clone(),
+                END_EPOCH - 1,
+                slot_duration,
+                slots_per_epoch
+            ),
+            checks::ensure_node_synced_up_to_slot(
+                network.clone(),
+                // This must be set to be the node which was just created. Should be equal to
+                // `node_count`.
+                node_count,
+                Epoch::new(END_EPOCH).start_slot(slots_per_epoch),
+                slot_duration,
+            ),
         );
 
         block_prod?;
@@ -291,6 +292,9 @@ pub fn run_eth1_sim(matches: &ArgMatches) -> Result<(), String> {
         sync_aggregate?;
         transition?;
         light_client_update?;
+        blobs?;
+        start_node_with_delay?;
+        sync?;
 
         // The `final_future` either completes immediately or never completes, depending on the value
         // of `continue_after_checks`.
@@ -321,91 +325,3 @@ pub fn run_eth1_sim(matches: &ArgMatches) -> Result<(), String> {
 
     Ok(())
 }
-
-struct LocalNetworkParams {
-    eth1_block_time: Duration,
-    total_validator_count: usize,
-    deposit_amount: u64,
-    node_count: usize,
-    proposer_nodes: usize,
-    post_merge_sim: bool,
-}
-
-async fn create_local_network<E: EthSpec>(
-    LocalNetworkParams {
-        eth1_block_time,
-        total_validator_count,
-        deposit_amount,
-        node_count,
-        proposer_nodes,
-        post_merge_sim,
-    }: LocalNetworkParams,
-    context: RuntimeContext<E>,
-) -> Result<(LocalNetwork<E>, ClientConfig), String> {
-    /*
-     * Deploy the deposit contract, spawn tasks to keep creating new blocks and deposit
-     * validators.
-     */
-    let anvil_eth1_instance = AnvilEth1Instance::new(DEFAULT_CHAIN_ID.into()).await?;
-    let deposit_contract = anvil_eth1_instance.deposit_contract;
-    let chain_id = anvil_eth1_instance.anvil.chain_id();
-    let anvil = anvil_eth1_instance.anvil;
-    let eth1_endpoint =
-        SensitiveUrl::parse(anvil.endpoint().as_str()).expect("Unable to parse anvil endpoint.");
-    let deposit_contract_address = deposit_contract.address();
-
-    // Start a timer that produces eth1 blocks on an interval.
-    tokio::spawn(async move {
-        let mut interval = tokio::time::interval(eth1_block_time);
-        loop {
-            interval.tick().await;
-            let _ = anvil.evm_mine().await;
-        }
-    });
-
-    // Submit deposits to the deposit contract.
-    tokio::spawn(async move {
-        for i in 0..total_validator_count {
-            println!("Submitting deposit for validator {}...", i);
-            let _ = deposit_contract
-                .deposit_deterministic_async::<E>(i, deposit_amount)
-                .await;
-        }
-    });
-
-    let mut beacon_config = testing_client_config();
-
-    beacon_config.genesis = ClientGenesis::DepositContract;
-    beacon_config.eth1.endpoint = Eth1Endpoint::NoAuth(eth1_endpoint);
-    beacon_config.eth1.deposit_contract_address = deposit_contract_address;
-    beacon_config.eth1.deposit_contract_deploy_block = 0;
-    beacon_config.eth1.lowest_cached_block_number = 0;
-    beacon_config.eth1.follow_distance = 1;
-    beacon_config.eth1.node_far_behind_seconds = 20;
-    beacon_config.dummy_eth1_backend = false;
-    beacon_config.sync_eth1_chain = true;
-    beacon_config.eth1.auto_update_interval_millis = eth1_block_time.as_millis() as u64;
-    beacon_config.eth1.chain_id = Eth1Id::from(chain_id);
-    beacon_config.network.target_peers = node_count + proposer_nodes - 1;
-
-    beacon_config.network.enr_address = (Some(Ipv4Addr::LOCALHOST), None);
-    beacon_config.network.enable_light_client_server = true;
-    beacon_config.chain.enable_light_client_server = true;
-    beacon_config.http_api.enable_light_client_server = true;
-
-    if post_merge_sim {
-        let el_config = execution_layer::Config {
-            execution_endpoints: vec![SensitiveUrl::parse(&format!(
-                "http://localhost:{}",
-                EXECUTION_PORT
-            ))
-            .unwrap()],
-            ..Default::default()
-        };
-
-        beacon_config.execution_layer = Some(el_config);
-    }
-
-    let network = LocalNetwork::new(context, beacon_config.clone()).await?;
-    Ok((network, beacon_config))
-}
diff --git a/testing/simulator/src/checks.rs b/testing/simulator/src/checks.rs
index d30e44a1174..03cc17fab3e 100644
--- a/testing/simulator/src/checks.rs
+++ b/testing/simulator/src/checks.rs
@@ -1,7 +1,7 @@
 use crate::local_network::LocalNetwork;
 use node_test_rig::eth2::types::{BlockId, FinalityCheckpointsData, StateId};
 use std::time::Duration;
-use types::{Epoch, EthSpec, ExecPayload, ExecutionBlockHash, Hash256, Slot, Unsigned};
+use types::{Epoch, EthSpec, ExecPayload, ExecutionBlockHash, Slot, Unsigned};
 
 /// Checks that all of the validators have on-boarded by the start of the second eth1 voting
 /// period.
@@ -234,7 +234,7 @@ pub async fn verify_transition_block_finalized<E: EthSpec>(
     }
 
     let first = block_hashes[0];
-    if first.into_root() != Hash256::zero() && block_hashes.iter().all(|&item| item == first) {
+    if block_hashes.iter().all(|&item| item == first) {
         Ok(())
     } else {
         Err(format!(
@@ -333,3 +333,173 @@ pub(crate) async fn verify_light_client_updates<E: EthSpec>(
 
     Ok(())
 }
+
+/// Checks that a node is synced with the network.
+/// Useful for ensuring that a node which started after genesis is able to sync to the head.
+pub async fn ensure_node_synced_up_to_slot<E: EthSpec>(
+    network: LocalNetwork<E>,
+    node_index: usize,
+    upto_slot: Slot,
+    slot_duration: Duration,
+) -> Result<(), String> {
+    slot_delay(upto_slot, slot_duration).await;
+    let node = &network
+        .remote_nodes()?
+        .get(node_index)
+        .expect("Should get node")
+        .clone();
+
+    let head = node
+        .get_beacon_blocks::<E>(BlockId::Head)
+        .await
+        .ok()
+        .flatten()
+        .ok_or(format!("No head block exists on node {node_index}"))?
+        .data;
+
+    // Check the head block is synced with the rest of the network.
+    if head.slot() >= upto_slot {
+        Ok(())
+    } else {
+        Err(format!(
+            "Head not synced for node {node_index}. Found {}; Should be {upto_slot}",
+            head.slot()
+        ))
+    }
+}
+
+/// Verifies that there's been blobs produced at every slot with a block from `blob_start_slot` up
+/// to and including `upto_slot`.
+pub async fn verify_full_blob_production_up_to<E: EthSpec>(
+    network: LocalNetwork<E>,
+    blob_start_slot: Slot,
+    upto_slot: Slot,
+    slot_duration: Duration,
+) -> Result<(), String> {
+    slot_delay(upto_slot, slot_duration).await;
+    let remote_nodes = network.remote_nodes()?;
+    let remote_node = remote_nodes.first().unwrap();
+
+    for slot in blob_start_slot.as_u64()..=upto_slot.as_u64() {
+        // Ensure block exists.
+        let block = remote_node
+            .get_beacon_blocks::<E>(BlockId::Slot(Slot::new(slot)))
+            .await
+            .ok()
+            .flatten();
+
+        // Only check blobs if the block exists. If you also want to ensure full block production, use
+        // the `verify_full_block_production_up_to` function.
+        if block.is_some() {
+            remote_node
+                .get_blobs::<E>(BlockId::Slot(Slot::new(slot)), None)
+                .await
+                .map_err(|e| format!("Failed to get blobs at slot {slot:?}: {e:?}"))?
+                .ok_or_else(|| format!("No blobs available at slot {slot:?}"))?;
+        }
+    }
+
+    Ok(())
+}
+
+// Causes the beacon node at `node_index` to disconnect from the execution layer.
+pub async fn disconnect_from_execution_layer<E: EthSpec>(
+    network: LocalNetwork<E>,
+    node_index: usize,
+) -> Result<(), String> {
+    eprintln!("Disabling Execution Node {node_index}");
+
+    // Force the execution node to return the `syncing` status.
+    network.execution_nodes.read()[node_index]
+        .server
+        .all_payloads_syncing(false);
+    Ok(())
+}
+
+// Causes the beacon node at `node_index` to reconnect from the execution layer.
+pub async fn reconnect_to_execution_layer<E: EthSpec>(
+    network: LocalNetwork<E>,
+    node_index: usize,
+) -> Result<(), String> {
+    network.execution_nodes.read()[node_index]
+        .server
+        .all_payloads_valid();
+
+    eprintln!("Enabling Execution Node {node_index}");
+    Ok(())
+}
+
+/// Ensure all validators have attested correctly.
+pub async fn check_attestation_correctness<E: EthSpec>(
+    network: LocalNetwork<E>,
+    start_epoch: u64,
+    upto_epoch: u64,
+    slot_duration: Duration,
+    // Select which node to query. Will use this node to determine the global network performance.
+    node_index: usize,
+    acceptable_attestation_performance: f64,
+) -> Result<(), String> {
+    epoch_delay(Epoch::new(upto_epoch), slot_duration, E::slots_per_epoch()).await;
+
+    let remote_node = &network.remote_nodes()?[node_index];
+
+    let results = remote_node
+        .get_lighthouse_analysis_attestation_performance(
+            Epoch::new(start_epoch),
+            Epoch::new(upto_epoch - 2),
+            "global".to_string(),
+        )
+        .await
+        .map_err(|e| format!("Unable to get attestation performance: {e}"))?;
+
+    let mut active_successes: f64 = 0.0;
+    let mut head_successes: f64 = 0.0;
+    let mut target_successes: f64 = 0.0;
+    let mut source_successes: f64 = 0.0;
+
+    let mut total: f64 = 0.0;
+
+    for result in results {
+        for epochs in result.epochs.values() {
+            total += 1.0;
+
+            if epochs.active {
+                active_successes += 1.0;
+            }
+            if epochs.head {
+                head_successes += 1.0;
+            }
+            if epochs.target {
+                target_successes += 1.0;
+            }
+            if epochs.source {
+                source_successes += 1.0;
+            }
+        }
+    }
+    let active_percent = active_successes / total * 100.0;
+    let head_percent = head_successes / total * 100.0;
+    let target_percent = target_successes / total * 100.0;
+    let source_percent = source_successes / total * 100.0;
+
+    eprintln!("Total Attestations: {}", total);
+    eprintln!("Active: {}: {}%", active_successes, active_percent);
+    eprintln!("Head: {}: {}%", head_successes, head_percent);
+    eprintln!("Target: {}: {}%", target_successes, target_percent);
+    eprintln!("Source: {}: {}%", source_successes, source_percent);
+
+    if active_percent < acceptable_attestation_performance {
+        return Err("Active percent was below required level".to_string());
+    }
+    if head_percent < acceptable_attestation_performance {
+        return Err("Head percent was below required level".to_string());
+    }
+    if target_percent < acceptable_attestation_performance {
+        return Err("Target percent was below required level".to_string());
+    }
+    if source_percent < acceptable_attestation_performance {
+        return Err("Source percent was below required level".to_string());
+    }
+
+    Ok(())
+}
diff --git a/testing/simulator/src/cli.rs b/testing/simulator/src/cli.rs
index ff80201051f..00af7e560ce 100644
--- a/testing/simulator/src/cli.rs
+++ b/testing/simulator/src/cli.rs
@@ -6,120 +6,121 @@ pub fn cli_app<'a, 'b>() -> App<'a, 'b> {
         .author("Sigma Prime <contact@sigmaprime.io>")
         .about("Options for interacting with simulator")
         .subcommand(
-            SubCommand::with_name("eth1-sim")
-            .about(
-                "Lighthouse Beacon Chain Simulator creates `n` beacon node and validator clients, \
-                    each with `v` validators. A deposit contract is deployed at the start of the \
-                    simulation using a local `anvil` instance (you must have `anvil` \
-                    installed and avaliable on your path). All beacon nodes independently listen \
-                    for genesis from the deposit contract, then start operating. \
-                    \
+            SubCommand::with_name("basic-sim")
+                .about(
+                    "Runs a Beacon Chain simulation with `n` beacon node and validator clients, \
+                    each with `v` validators. \
+                    The simulation runs with a post-Merge Genesis using `mock-el`. \
                     As the simulation runs, there are checks made to ensure that all components \
                     are running correctly. If any of these checks fail, the simulation will \
                     exit immediately.",
-                    )
-                    .arg(Arg::with_name("nodes")
+                )
+                .arg(
+                    Arg::with_name("nodes")
                         .short("n")
                         .long("nodes")
                         .takes_value(true)
-                        .default_value("4")
-                        .help("Number of beacon nodes"))
-                    .arg(Arg::with_name("proposer-nodes")
+                        .default_value("3")
+                        .help("Number of beacon nodes"),
+                )
+                .arg(
+                    Arg::with_name("proposer-nodes")
                         .short("p")
-                        .long("proposer_nodes")
+                        .long("proposer-nodes")
                         .takes_value(true)
-                        .default_value("2")
-                        .help("Number of proposer-only beacon nodes"))
-                    .arg(Arg::with_name("validators_per_node")
+                        .default_value("3")
+                        .help("Number of proposer-only beacon nodes"),
+                )
+                .arg(
+                    Arg::with_name("validators-per-node")
                         .short("v")
-                        .long("validators_per_node")
+                        .long("validators-per-node")
                         .takes_value(true)
                         .default_value("20")
-                        .help("Number of validators"))
-                    .arg(Arg::with_name("speed_up_factor")
+                        .help("Number of validators"),
+                )
+                .arg(
+                    Arg::with_name("speed-up-factor")
                         .short("s")
-                        .long("speed_up_factor")
+                        .long("speed-up-factor")
                         .takes_value(true)
                         .default_value("3")
-                        .help("Speed up factor. Please use a divisor of 12."))
-                    .arg(Arg::with_name("post-merge")
-                        .short("m")
-                        .long("post-merge")
-                        .takes_value(false)
-                        .help("Simulate the merge transition"))
-                    .arg(Arg::with_name("continue_after_checks")
+                        .help("Speed up factor. Please use a divisor of 12."),
+                )
+                .arg(
+                    Arg::with_name("debug-level")
+                        .short("d")
+                        .long("debug-level")
+                        .takes_value(true)
+                        .default_value("debug")
+                        .help("Set the severity level of the logs."),
+                )
+                .arg(
+                    Arg::with_name("continue-after-checks")
                         .short("c")
                         .long("continue_after_checks")
                         .takes_value(false)
-                        .help("Continue after checks (default false)"))
+                        .help("Continue after checks (default false)"),
+                ),
         )
         .subcommand(
-            SubCommand::with_name("no-eth1-sim")
-            .about("Runs a simulator that bypasses the eth1 chain. Useful for faster testing of
-                components that don't rely upon eth1")
-                    .arg(Arg::with_name("nodes")
-                        .short("n")
-                        .long("nodes")
+            SubCommand::with_name("fallback-sim")
+                .about(
+                    "Runs a Beacon Chain simulation with `c` validator clients where each VC is \
+                    connected to `b` beacon nodes with `v` validators. \
+                    During the simulation, all but the last connected BN for each VC are \
+                    disconnected from the execution layer, which causes the VC to fallback to the \
+                    single remaining BN. \
+                    At the end of the simulation, there are checks made to ensure that all VCs  \
+                    efficiently performed this fallback, within a certain tolerance. \
+                    Otherwise, the simulation will exit and an error will be reported.",
+                )
+                .arg(
+                    Arg::with_name("vc-count")
+                        .short("c")
+                        .long("vc-count")
                         .takes_value(true)
-                        .default_value("4")
-                        .help("Number of beacon nodes"))
-                    .arg(Arg::with_name("proposer-nodes")
-                        .short("p")
-                        .long("proposer_nodes")
+                        .default_value("3")
+                        .help("Number of validator clients."),
+                )
+                .arg(
+                    Arg::with_name("bns-per-vc")
+                        .short("b")
+                        .long("bns-per-vc")
                         .takes_value(true)
                         .default_value("2")
-                        .help("Number of proposer-only beacon nodes"))
-                    .arg(Arg::with_name("validators_per_node")
+                        .help("Number of beacon nodes per validator client."),
+                )
+                .arg(
+                    Arg::with_name("validators-per-vc")
                         .short("v")
-                        .long("validators_per_node")
+                        .long("validators-per-vc")
                         .takes_value(true)
                         .default_value("20")
-                        .help("Number of validators"))
-                    .arg(Arg::with_name("speed_up_factor")
-                        .short("s")
-                        .long("speed_up_factor")
-                        .takes_value(true)
-                        .default_value("3")
-                        .help("Speed up factor"))
-                    .arg(Arg::with_name("continue_after_checks")
-                        .short("c")
-                        .long("continue_after_checks")
-                        .takes_value(false)
-                        .help("Continue after checks (default false)"))
-        )
-        .subcommand(
-            SubCommand::with_name("syncing-sim")
-                .about("Run the syncing simulation")
-                .arg(
-                    Arg::with_name("speedup")
-                        .short("s")
-                        .long("speedup")
-                        .takes_value(true)
-                        .default_value("15")
-                        .help("Speed up factor for eth1 blocks and slot production"),
+                        .help("Number of validators per client."),
                 )
                 .arg(
-                    Arg::with_name("initial_delay")
-                        .short("i")
-                        .long("initial_delay")
+                    Arg::with_name("speed-up-factor")
+                        .short("s")
+                        .long("speed-up-factor")
                         .takes_value(true)
-                        .default_value("5")
-                        .help("Epoch delay for new beacon node to start syncing"),
+                        .default_value("3")
+                        .help("Speed up factor. Please use a divisor of 12."),
                 )
                 .arg(
-                    Arg::with_name("sync_timeout")
-                        .long("sync_timeout")
+                    Arg::with_name("debug-level")
+                        .short("d")
+                        .long("debug-level")
                         .takes_value(true)
-                        .default_value("10")
-                        .help("Number of epochs after which newly added beacon nodes must be synced"),
+                        .default_value("debug")
+                        .help("Set the severity level of the logs."),
                 )
                 .arg(
-                    Arg::with_name("strategy")
-                        .long("strategy")
-                        .takes_value(true)
-                        .default_value("all")
-                        .possible_values(&["one-node", "two-nodes", "mixed", "all"])
-                        .help("Sync verification strategy to run."),
+                    Arg::with_name("continue-after-checks")
+                        .short("c")
+                        .long("continue_after_checks")
+                        .takes_value(false)
+                        .help("Continue after checks (default false)"),
                 ),
         )
 }
diff --git a/testing/simulator/src/fallback_sim.rs b/testing/simulator/src/fallback_sim.rs
new file mode 100644
index 00000000000..c9deeba04d9
--- /dev/null
+++ b/testing/simulator/src/fallback_sim.rs
@@ -0,0 +1,261 @@
+use crate::local_network::LocalNetworkParams;
+use crate::{checks, LocalNetwork};
+use clap::ArgMatches;
+
+use crate::retry::with_retry;
+use futures::prelude::*;
+use node_test_rig::{
+    environment::{EnvironmentBuilder, LoggerConfig},
+    testing_validator_config, ValidatorFiles,
+};
+use rayon::prelude::*;
+use std::cmp::max;
+use std::time::Duration;
+use tokio::time::sleep;
+use types::{Epoch, EthSpec, MinimalEthSpec};
+
+const END_EPOCH: u64 = 16;
+const GENESIS_DELAY: u64 = 32;
+const ALTAIR_FORK_EPOCH: u64 = 0;
+const BELLATRIX_FORK_EPOCH: u64 = 0;
+const CAPELLA_FORK_EPOCH: u64 = 1;
+const DENEB_FORK_EPOCH: u64 = 2;
+//const ELECTRA_FORK_EPOCH: u64 = 3;
+
+// Since simulator tests are non-deterministic and there is a non-zero chance of missed
+// attestations, define an acceptable network-wide attestation performance.
+//
+// This has potential to block CI so it should be set conservatively enough that spurious failures
+// don't become very common, but not so conservatively that regressions to the fallback mechanism
+// cannot be detected.
+const ACCEPTABLE_FALLBACK_ATTESTATION_HIT_PERCENTAGE: f64 = 85.0;
+
+const SUGGESTED_FEE_RECIPIENT: [u8; 20] =
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
+
+pub fn run_fallback_sim(matches: &ArgMatches) -> Result<(), String> {
+    let vc_count = value_t!(matches, "vc-count", usize).expect("Missing validator-count default");
+    let validators_per_vc =
+        value_t!(matches, "validators-per-vc", usize).expect("Missing validators-per-vc default");
+    let bns_per_vc = value_t!(matches, "bns-per-vc", usize).expect("Missing bns-per-vc default");
+    assert!(bns_per_vc > 1);
+    let speed_up_factor =
+        value_t!(matches, "speed-up-factor", u64).expect("Missing speed-up-factor default");
+    let log_level = value_t!(matches, "debug-level", String).expect("Missing default log-level");
+    let continue_after_checks = matches.is_present("continue-after-checks");
+
+    println!("Fallback Simulator:");
+    println!(" vc-count: {}", vc_count);
+    println!(" validators-per-vc: {}", validators_per_vc);
+    println!(" bns-per-vc: {}", bns_per_vc);
+    println!(" speed-up-factor: {}", speed_up_factor);
+    println!(" continue-after-checks: {}", continue_after_checks);
+
+    // Generate the directories and keystores required for the validator clients.
+    let validator_files = (0..vc_count)
+        .into_par_iter()
+        .map(|i| {
+            println!(
+                "Generating keystores for validator {} of {}",
+                i + 1,
+                vc_count
+            );
+
+            let indices = (i * validators_per_vc..(i + 1) * validators_per_vc).collect::<Vec<_>>();
+            ValidatorFiles::with_keystores(&indices).unwrap()
+        })
+        .collect::<Vec<_>>();
+
+    let mut env = EnvironmentBuilder::minimal()
+        .initialize_logger(LoggerConfig {
+            path: None,
+            debug_level: log_level.clone(),
+            logfile_debug_level: log_level,
+            log_format: None,
+            logfile_format: None,
+            log_color: false,
+            disable_log_timestamp: false,
+            max_log_size: 0,
+            max_log_number: 0,
+            compression: false,
+            is_restricted: true,
+            sse_logging: false,
+        })?
+        .multi_threaded_tokio_runtime()?
+        .build()?;
+
+    let spec = &mut env.eth2_config.spec;
+
+    let total_validator_count = validators_per_vc * vc_count;
+    let node_count = vc_count * bns_per_vc;
+
+    let genesis_delay = GENESIS_DELAY;
+
+    spec.seconds_per_slot /= speed_up_factor;
+    spec.seconds_per_slot = max(1, spec.seconds_per_slot);
+    spec.genesis_delay = genesis_delay;
+    spec.min_genesis_time = 0;
+    spec.min_genesis_active_validator_count = total_validator_count as u64;
+    spec.altair_fork_epoch = Some(Epoch::new(ALTAIR_FORK_EPOCH));
+    spec.bellatrix_fork_epoch = Some(Epoch::new(BELLATRIX_FORK_EPOCH));
+    spec.capella_fork_epoch = Some(Epoch::new(CAPELLA_FORK_EPOCH));
+    spec.deneb_fork_epoch = Some(Epoch::new(DENEB_FORK_EPOCH));
+    //spec.electra_fork_epoch = Some(Epoch::new(ELECTRA_FORK_EPOCH));
+
+    let slot_duration = Duration::from_secs(spec.seconds_per_slot);
+    let slots_per_epoch = MinimalEthSpec::slots_per_epoch();
+
+    let disconnection_epoch = 1;
+    let epochs_disconnected = 14;
+
+    let context = env.core_context();
+
+    let main_future = async {
+        /*
+         * Create a new `LocalNetwork` with one beacon node.
+         */
+        let max_retries = 3;
+        let (network, beacon_config, mock_execution_config) = with_retry(max_retries, || {
+            Box::pin(LocalNetwork::create_local_network(
+                None,
+                None,
+                LocalNetworkParams {
+                    validator_count: total_validator_count,
+                    node_count,
+                    proposer_nodes: 0,
+                    genesis_delay,
+                },
+                context.clone(),
+            ))
+        })
+        .await?;
+
+        // Add nodes to the network.
+        for _ in 0..node_count {
+            network
+                .add_beacon_node(beacon_config.clone(), mock_execution_config.clone(), false)
+                .await?;
+        }
+
+        /*
+         * One by one, add validators to the network.
+         */
+        let executor = context.executor.clone();
+        for (i, files) in validator_files.into_iter().enumerate() {
+            let network_1 = network.clone();
+
+            let mut beacon_nodes = Vec::with_capacity(vc_count * bns_per_vc);
+            // Each VC gets a unique set of BNs which are not shared with any other VC.
+            for j in 0..bns_per_vc {
+                beacon_nodes.push(bns_per_vc * i + j)
+            }
+
+            executor.spawn(
+                async move {
+                    let mut validator_config = testing_validator_config();
+                    validator_config.fee_recipient = Some(SUGGESTED_FEE_RECIPIENT.into());
+                    println!("Adding validator client {}", i);
+                    network_1
+                        .add_validator_client_with_fallbacks(
+                            validator_config,
+                            i,
+                            beacon_nodes,
+                            files,
+                        )
+                        .await
+                        .expect("should add validator");
+                },
+                "vc",
+            );
+        }
+
+        let duration_to_genesis = network.duration_to_genesis().await;
+        println!("Duration to genesis: {}", duration_to_genesis.as_secs());
+        sleep(duration_to_genesis).await;
+
+        let test_sequence = async {
+            checks::epoch_delay(
+                Epoch::new(disconnection_epoch),
+                slot_duration,
+                slots_per_epoch,
+            )
+            .await;
+            // Iterate through each VC and disconnect all BNs but the last node for each VC.
+            for i in 0..vc_count {
+                for j in 0..(bns_per_vc - 1) {
+                    let node_index = bns_per_vc * i + j;
+                    checks::disconnect_from_execution_layer(network.clone(), node_index).await?;
+                }
+            }
+            checks::epoch_delay(
+                Epoch::new(epochs_disconnected),
+                slot_duration,
+                slots_per_epoch,
+            )
+            .await;
+            // Enable all BNs.
+            for i in 0..node_count {
+                checks::reconnect_to_execution_layer(network.clone(), i).await?;
+            }
+            Ok::<(), String>(())
+        };
+
+        /*
+         * Start the checks that ensure the network performs as expected.
+         *
+         * We start these checks immediately after the validators have started. This means we're
+         * relying on the validator futures to all return immediately after genesis so that these
+         * tests start at the right time. Whilst this is works well for now, it's subject to
+         * breakage by changes to the VC.
+         */
+
+        let (sequence, check_attestations, block_production) = futures::join!(
+            test_sequence,
+            checks::check_attestation_correctness(
+                network.clone(),
+                0,
+                END_EPOCH,
+                slot_duration,
+                // Use the last node index as this will never have been disabled.
+                node_count - 1,
+                ACCEPTABLE_FALLBACK_ATTESTATION_HIT_PERCENTAGE,
+            ),
+            checks::verify_full_block_production_up_to(
+                network.clone(),
+                Epoch::new(END_EPOCH).start_slot(slots_per_epoch),
+                slot_duration,
+            ),
+        );
+        sequence?;
+        block_production?;
+        check_attestations?;
+
+        // The `final_future` either completes immediately or never completes, depending on the value
+        // of `continue_after_checks`.
+
+        if continue_after_checks {
+            future::pending::<()>().await;
+        }
+        /*
+         * End the simulation by dropping the network. This will kill all running beacon nodes and
+         * validator clients.
+         */
+        println!(
+            "Simulation complete. Finished with {} beacon nodes and {} validator clients",
+            network.beacon_node_count(),
+            network.validator_client_count()
+        );
+
+        // Be explicit about dropping the network, as this kills all the nodes. This ensures
+        // all the checks have adequate time to pass.
+        drop(network);
+        Ok::<(), String>(())
+    };
+
+    env.runtime().block_on(main_future).unwrap();
+
+    env.fire_signal();
+    env.shutdown_on_idle();
+
+    Ok(())
+}
diff --git a/testing/simulator/src/local_network.rs b/testing/simulator/src/local_network.rs
index dc8bf0d27dd..63f2ec93537 100644
--- a/testing/simulator/src/local_network.rs
+++ b/testing/simulator/src/local_network.rs
@@ -1,26 +1,95 @@
+use crate::checks::epoch_delay;
+use eth2_network_config::TRUSTED_SETUP_BYTES;
 use node_test_rig::{
     environment::RuntimeContext,
     eth2::{types::StateId, BeaconNodeHttpClient},
-    ClientConfig, LocalBeaconNode, LocalExecutionNode, LocalValidatorClient, MockExecutionConfig,
-    MockServerConfig, ValidatorConfig, ValidatorFiles,
+    testing_client_config, ClientConfig, ClientGenesis, LocalBeaconNode, LocalExecutionNode,
+    LocalValidatorClient, MockExecutionConfig, MockServerConfig, ValidatorConfig, ValidatorFiles,
 };
 use parking_lot::RwLock;
 use sensitive_url::SensitiveUrl;
 use std::{
+    net::Ipv4Addr,
     ops::Deref,
-    time::{SystemTime, UNIX_EPOCH},
+    sync::Arc,
+    time::{Duration, SystemTime, UNIX_EPOCH},
 };
-use std::{sync::Arc, time::Duration};
-use types::{Epoch, EthSpec};
+use types::{ChainSpec, Epoch, EthSpec};
 
 const BOOTNODE_PORT: u16 = 42424;
 const QUIC_PORT: u16 = 43424;
-pub const INVALID_ADDRESS: &str = "http://127.0.0.1:42423";
 
 pub const EXECUTION_PORT: u16 = 4000;
 
-pub const TERMINAL_DIFFICULTY: u64 = 6400;
-pub const TERMINAL_BLOCK: u64 = 64;
+pub const TERMINAL_BLOCK: u64 = 0;
+
+pub struct LocalNetworkParams {
+    pub validator_count: usize,
+    pub node_count: usize,
+    pub proposer_nodes: usize,
+    pub genesis_delay: u64,
+}
+
+fn default_client_config(network_params: LocalNetworkParams, genesis_time: u64) -> ClientConfig {
+    let mut beacon_config = testing_client_config();
+
+    beacon_config.genesis = ClientGenesis::InteropMerge {
+        validator_count: network_params.validator_count,
+        genesis_time,
+    };
+    beacon_config.network.target_peers =
+        network_params.node_count + network_params.proposer_nodes - 1;
+    beacon_config.network.enr_address = (Some(Ipv4Addr::LOCALHOST), None);
+    beacon_config.network.enable_light_client_server = true;
+    beacon_config.network.discv5_config.enable_packet_filter = false;
+    beacon_config.chain.enable_light_client_server = true;
+    beacon_config.http_api.enable_light_client_server = true;
+    beacon_config.chain.optimistic_finalized_sync = false;
+    beacon_config.trusted_setup =
+        serde_json::from_reader(TRUSTED_SETUP_BYTES).expect("Trusted setup bytes should be valid");
+
+    let el_config = execution_layer::Config {
+        execution_endpoint: Some(
+            SensitiveUrl::parse(&format!("http://localhost:{}", EXECUTION_PORT)).unwrap(),
+        ),
+        ..Default::default()
+    };
+    beacon_config.execution_layer = Some(el_config);
+    beacon_config
+}
+
+fn default_mock_execution_config<E: EthSpec>(
+    spec: &ChainSpec,
+    genesis_time: u64,
+) -> MockExecutionConfig {
+    let mut mock_execution_config = MockExecutionConfig {
+        server_config: MockServerConfig {
+            listen_port: EXECUTION_PORT,
+            ..Default::default()
+        },
+        ..Default::default()
+    };
+
+    if let Some(capella_fork_epoch) = spec.capella_fork_epoch {
+        mock_execution_config.shanghai_time = Some(
+            genesis_time
+                + spec.seconds_per_slot * E::slots_per_epoch() * capella_fork_epoch.as_u64(),
+        )
+    }
+    if let Some(deneb_fork_epoch) = spec.deneb_fork_epoch {
+        mock_execution_config.cancun_time = Some(
+            genesis_time + spec.seconds_per_slot * E::slots_per_epoch() * deneb_fork_epoch.as_u64(),
+        )
+    }
+    if let Some(electra_fork_epoch) = spec.electra_fork_epoch {
+        mock_execution_config.prague_time = Some(
+            genesis_time
+                + spec.seconds_per_slot * E::slots_per_epoch() * electra_fork_epoch.as_u64(),
+        )
+    }
+
+    mock_execution_config
+}
 
 /// Helper struct to reduce `Arc` usage.
 pub struct Inner<E: EthSpec> {
@@ -55,56 +124,41 @@ impl<E: EthSpec> Deref for LocalNetwork<E> {
 }
 
 impl<E: EthSpec> LocalNetwork<E> {
-    /// Creates a new network with a single `BeaconNode` and a connected `ExecutionNode`.
-    pub async fn new(
+    pub async fn create_local_network(
+        client_config: Option<ClientConfig>,
+        mock_execution_config: Option<MockExecutionConfig>,
+        network_params: LocalNetworkParams,
         context: RuntimeContext<E>,
-        mut beacon_config: ClientConfig,
-    ) -> Result<Self, String> {
-        beacon_config.network.set_ipv4_listening_address(
-            std::net::Ipv4Addr::UNSPECIFIED,
-            BOOTNODE_PORT,
-            BOOTNODE_PORT,
-            QUIC_PORT,
-        );
-        beacon_config.network.enr_udp4_port = Some(BOOTNODE_PORT.try_into().expect("non zero"));
-        beacon_config.network.enr_tcp4_port = Some(BOOTNODE_PORT.try_into().expect("non zero"));
-        beacon_config.network.discv5_config.table_filter = |_| true;
+    ) -> Result<(LocalNetwork<E>, ClientConfig, MockExecutionConfig), String> {
+        let genesis_time: u64 = (SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .map_err(|_| "should get system time")?
+            + Duration::from_secs(network_params.genesis_delay))
+        .as_secs();
 
-        let execution_node = if let Some(el_config) = &mut beacon_config.execution_layer {
-            let mock_execution_config = MockExecutionConfig {
-                server_config: MockServerConfig {
-                    listen_port: EXECUTION_PORT,
-                    ..Default::default()
-                },
-                terminal_block: TERMINAL_BLOCK,
-                terminal_difficulty: TERMINAL_DIFFICULTY.into(),
-                ..Default::default()
-            };
-            let execution_node = LocalExecutionNode::new(
-                context.service_context("boot_node_el".into()),
-                mock_execution_config,
-            );
-            el_config.default_datadir = execution_node.datadir.path().to_path_buf();
-            el_config.secret_files = vec![execution_node.datadir.path().join("jwt.hex")];
-            el_config.execution_endpoints =
-                vec![SensitiveUrl::parse(&execution_node.server.url()).unwrap()];
-            vec![execution_node]
+        let beacon_config = if let Some(config) = client_config {
+            config
         } else {
-            vec![]
+            default_client_config(network_params, genesis_time)
         };
 
-        let beacon_node =
-            LocalBeaconNode::production(context.service_context("boot_node".into()), beacon_config)
-                .await?;
-        Ok(Self {
+        let execution_config = if let Some(config) = mock_execution_config {
+            config
+        } else {
+            default_mock_execution_config::<E>(&context.eth2_config().spec, genesis_time)
+        };
+
+        let network = Self {
             inner: Arc::new(Inner {
                 context,
-                beacon_nodes: RwLock::new(vec![beacon_node]),
+                beacon_nodes: RwLock::new(vec![]),
                 proposer_nodes: RwLock::new(vec![]),
-                execution_nodes: RwLock::new(execution_node),
+                execution_nodes: RwLock::new(vec![]),
                 validator_clients: RwLock::new(vec![]),
             }),
-        })
+        };
+
+        Ok((network, beacon_config, execution_config))
     }
 
     /// Returns the number of beacon nodes in the network.
@@ -131,77 +185,151 @@ impl<E: EthSpec> LocalNetwork<E> {
         self.validator_clients.read().len()
     }
 
-    /// Adds a beacon node to the network, connecting to the 0'th beacon node via ENR.
-    pub async fn add_beacon_node(
+    async fn construct_boot_node(
+        &self,
+        mut beacon_config: ClientConfig,
+        mock_execution_config: MockExecutionConfig,
+    ) -> Result<(LocalBeaconNode<E>, LocalExecutionNode<E>), String> {
+        beacon_config.network.set_ipv4_listening_address(
+            std::net::Ipv4Addr::UNSPECIFIED,
+            BOOTNODE_PORT,
+            BOOTNODE_PORT,
+            QUIC_PORT,
+        );
+
+        beacon_config.network.enr_udp4_port = Some(BOOTNODE_PORT.try_into().expect("non zero"));
+        beacon_config.network.enr_tcp4_port = Some(BOOTNODE_PORT.try_into().expect("non zero"));
+        beacon_config.network.discv5_config.table_filter = |_| true;
+
+        let execution_node = LocalExecutionNode::new(
+            self.context.service_context("boot_node_el".into()),
+            mock_execution_config,
+        );
+
+        beacon_config.execution_layer = Some(execution_layer::Config {
+            execution_endpoint: Some(SensitiveUrl::parse(&execution_node.server.url()).unwrap()),
+            default_datadir: execution_node.datadir.path().to_path_buf(),
+            secret_file: Some(execution_node.datadir.path().join("jwt.hex")),
+            ..Default::default()
+        });
+
+        let beacon_node = LocalBeaconNode::production(
+            self.context.service_context("boot_node".into()),
+            beacon_config,
+        )
+        .await?;
+
+        Ok((beacon_node, execution_node))
+    }
+
+    async fn construct_beacon_node(
         &self,
         mut beacon_config: ClientConfig,
+        mut mock_execution_config: MockExecutionConfig,
         is_proposer: bool,
-    ) -> Result<(), String> {
-        let self_1 = self.clone();
-        let count = self.beacon_node_count() as u16;
-        println!("Adding beacon node..");
-        {
-            let read_lock = self.beacon_nodes.read();
+    ) -> Result<(LocalBeaconNode<E>, LocalExecutionNode<E>), String> {
+        let count = (self.beacon_node_count() + self.proposer_node_count()) as u16;
 
-            let boot_node = read_lock.first().expect("should have at least one node");
+        // Set config.
+        let libp2p_tcp_port = BOOTNODE_PORT + count;
+        let discv5_port = BOOTNODE_PORT + count;
+        beacon_config.network.set_ipv4_listening_address(
+            std::net::Ipv4Addr::UNSPECIFIED,
+            libp2p_tcp_port,
+            discv5_port,
+            QUIC_PORT + count,
+        );
+        beacon_config.network.enr_udp4_port = Some(discv5_port.try_into().unwrap());
+        beacon_config.network.enr_tcp4_port = Some(libp2p_tcp_port.try_into().unwrap());
+        beacon_config.network.discv5_config.table_filter = |_| true;
+        beacon_config.network.proposer_only = is_proposer;
 
-            beacon_config.network.boot_nodes_enr.push(
-                boot_node
-                    .client
-                    .enr()
-                    .expect("bootnode must have a network"),
-            );
-            let count = (self.beacon_node_count() + self.proposer_node_count()) as u16;
-            let libp2p_tcp_port = BOOTNODE_PORT + count;
-            let discv5_port = BOOTNODE_PORT + count;
-            beacon_config.network.set_ipv4_listening_address(
-                std::net::Ipv4Addr::UNSPECIFIED,
-                libp2p_tcp_port,
-                discv5_port,
-                QUIC_PORT + count,
-            );
-            beacon_config.network.enr_udp4_port = Some(discv5_port.try_into().unwrap());
-            beacon_config.network.enr_tcp4_port = Some(libp2p_tcp_port.try_into().unwrap());
-            beacon_config.network.discv5_config.table_filter = |_| true;
-            beacon_config.network.proposer_only = is_proposer;
-        }
-        if let Some(el_config) = &mut beacon_config.execution_layer {
-            let config = MockExecutionConfig {
-                server_config: MockServerConfig {
-                    listen_port: EXECUTION_PORT + count,
-                    ..Default::default()
-                },
-                terminal_block: TERMINAL_BLOCK,
-                terminal_difficulty: TERMINAL_DIFFICULTY.into(),
-                ..Default::default()
-            };
-            let execution_node = LocalExecutionNode::new(
-                self.context.service_context(format!("node_{}_el", count)),
-                config,
-            );
-            el_config.default_datadir = execution_node.datadir.path().to_path_buf();
-            el_config.secret_files = vec![execution_node.datadir.path().join("jwt.hex")];
-            el_config.execution_endpoints =
-                vec![SensitiveUrl::parse(&execution_node.server.url()).unwrap()];
-            self.execution_nodes.write().push(execution_node);
-        }
+        mock_execution_config.server_config.listen_port = EXECUTION_PORT + count;
 
-        // We create the beacon node without holding the lock, so that the lock isn't held
-        // across the await. This is only correct if this function never runs in parallel
-        // with itself (which at the time of writing, it does not).
+        // Construct execution node.
+        let execution_node = LocalExecutionNode::new(
+            self.context.service_context(format!("node_{}_el", count)),
+            mock_execution_config,
+        );
+
+        // Pair the beacon node and execution node.
+        beacon_config.execution_layer = Some(execution_layer::Config {
+            execution_endpoint: Some(SensitiveUrl::parse(&execution_node.server.url()).unwrap()),
+            default_datadir: execution_node.datadir.path().to_path_buf(),
+            secret_file: Some(execution_node.datadir.path().join("jwt.hex")),
+            ..Default::default()
+        });
+
+        // Construct beacon node using the config,
         let beacon_node = LocalBeaconNode::production(
             self.context.service_context(format!("node_{}", count)),
             beacon_config,
         )
         .await?;
+
+        Ok((beacon_node, execution_node))
+    }
+
+    /// Adds a beacon node to the network, connecting to the 0'th beacon node via ENR.
+    pub async fn add_beacon_node(
+        &self,
+        mut beacon_config: ClientConfig,
+        mock_execution_config: MockExecutionConfig,
+        is_proposer: bool,
+    ) -> Result<(), String> {
+        let first_bn_exists: bool;
+        {
+            let read_lock = self.beacon_nodes.read();
+            let boot_node = read_lock.first();
+            first_bn_exists = boot_node.is_some();
+
+            if let Some(boot_node) = boot_node {
+                // Modify beacon_config to add boot node details.
+                beacon_config.network.boot_nodes_enr.push(
+                    boot_node
+                        .client
+                        .enr()
+                        .expect("Bootnode must have a network."),
+                );
+            }
+        }
+        let (beacon_node, execution_node) = if first_bn_exists {
+            // Network already exists. We construct a new node.
+            self.construct_beacon_node(beacon_config, mock_execution_config, is_proposer)
+                .await?
+        } else {
+            // Network does not exist. We construct a boot node.
+            self.construct_boot_node(beacon_config, mock_execution_config)
+                .await?
+        };
+        // Add nodes to the network.
+        self.execution_nodes.write().push(execution_node);
         if is_proposer {
-            self_1.proposer_nodes.write().push(beacon_node);
+            self.proposer_nodes.write().push(beacon_node);
         } else {
-            self_1.beacon_nodes.write().push(beacon_node);
+            self.beacon_nodes.write().push(beacon_node);
         }
         Ok(())
     }
 
+    // Add a new node with a delay. This node will not have validators and is only used to test
+    // sync.
+    pub async fn add_beacon_node_with_delay(
+        &self,
+        beacon_config: ClientConfig,
+        mock_execution_config: MockExecutionConfig,
+        wait_until_epoch: u64,
+        slot_duration: Duration,
+        slots_per_epoch: u64,
+    ) -> Result<(), String> {
+        epoch_delay(Epoch::new(wait_until_epoch), slot_duration, slots_per_epoch).await;
+
+        self.add_beacon_node(beacon_config, mock_execution_config, false)
+            .await?;
+
+        Ok(())
+    }
+
     /// Adds a validator client to the network, connecting it to the beacon node with index
     /// `beacon_node`.
     pub async fn add_validator_client(
@@ -209,7 +337,6 @@ impl<E: EthSpec> LocalNetwork<E> {
         mut validator_config: ValidatorConfig,
         beacon_node: usize,
         validator_files: ValidatorFiles,
-        invalid_first_beacon_node: bool, //to test beacon node fallbacks
     ) -> Result<(), String> {
         let context = self
             .context
@@ -240,11 +367,7 @@ impl<E: EthSpec> LocalNetwork<E> {
             format!("http://{}:{}", socket_addr.ip(), socket_addr.port()).as_str(),
         )
         .unwrap();
-        validator_config.beacon_nodes = if invalid_first_beacon_node {
-            vec![SensitiveUrl::parse(INVALID_ADDRESS).unwrap(), beacon_node]
-        } else {
-            vec![beacon_node]
-        };
+        validator_config.beacon_nodes = vec![beacon_node];
 
         // If we have a proposer node established, use it.
         if let Some(proposer_socket_addr) = proposer_socket_addr {
@@ -293,11 +416,11 @@ impl<E: EthSpec> LocalNetwork<E> {
                     .http_api_listen_addr()
                     .expect("Must have http started")
             };
-            let beacon_node = SensitiveUrl::parse(
+            let beacon_node_url = SensitiveUrl::parse(
                 format!("http://{}:{}", socket_addr.ip(), socket_addr.port()).as_str(),
             )
             .unwrap();
-            beacon_node_urls.push(beacon_node);
+            beacon_node_urls.push(beacon_node_url);
         }
 
         validator_config.beacon_nodes = beacon_node_urls;
@@ -325,7 +448,7 @@ impl<E: EthSpec> LocalNetwork<E> {
     }
 
     /// Return current epoch of bootnode.
-    pub async fn bootnode_epoch(&self) -> Result<Epoch, String> {
+    pub async fn _bootnode_epoch(&self) -> Result<Epoch, String> {
         let nodes = self.remote_nodes().expect("Failed to get remote nodes");
         let bootnode = nodes.first().expect("Should contain bootnode");
         bootnode
@@ -335,16 +458,6 @@ impl<E: EthSpec> LocalNetwork<E> {
             .map(|body| body.unwrap().data.finalized.epoch)
     }
 
-    pub fn mine_pow_blocks(&self, block_number: u64) -> Result<(), String> {
-        let execution_nodes = self.execution_nodes.read();
-        for execution_node in execution_nodes.iter() {
-            let mut block_gen = execution_node.server.ctx.execution_block_generator.write();
-            block_gen.insert_pow_block(block_number)?;
-            println!("Mined pow block {}", block_number);
-        }
-        Ok(())
-    }
-
     pub async fn duration_to_genesis(&self) -> Duration {
         let nodes = self.remote_nodes().expect("Failed to get remote nodes");
         let bootnode = nodes.first().expect("Should contain bootnode");
diff --git a/testing/simulator/src/main.rs b/testing/simulator/src/main.rs
index e8af9c18067..d1a2d0dc672 100644
--- a/testing/simulator/src/main.rs
+++ b/testing/simulator/src/main.rs
@@ -1,10 +1,8 @@
-//! This crate provides a simluation that creates `n` beacon node and validator clients, each with
-//! `v` validators. A deposit contract is deployed at the start of the simulation using a local
-//! `anvil` instance (you must have `anvil` installed and avaliable on your path). All
-//! beacon nodes independently listen for genesis from the deposit contract, then start operating.
+//! This crate provides various simulations that create both beacon nodes and validator clients,
+//! each with `v` validators.
 //!
-//! As the simulation runs, there are checks made to ensure that all components are running
-//! correctly. If any of these checks fail, the simulation will exit immediately.
+//! When a simulation runs, there are checks made to ensure that all components are operating
+//! as expected. If any of these checks fail, the simulation will exit immediately.
 //!
 //! ## Future works
 //!
@@ -16,13 +14,12 @@
 #[macro_use]
 extern crate clap;
 
+mod basic_sim;
 mod checks;
 mod cli;
-mod eth1_sim;
+mod fallback_sim;
 mod local_network;
-mod no_eth1_sim;
 mod retry;
-mod sync_sim;
 
 use cli::cli_app;
 use env_logger::{Builder, Env};
@@ -37,21 +34,14 @@ fn main() {
 
     let matches = cli_app().get_matches();
     match matches.subcommand() {
-        ("eth1-sim", Some(matches)) => match eth1_sim::run_eth1_sim(matches) {
+        ("basic-sim", Some(matches)) => match basic_sim::run_basic_sim(matches) {
             Ok(()) => println!("Simulation exited successfully"),
             Err(e) => {
                 eprintln!("Simulation exited with error: {}", e);
                 std::process::exit(1)
             }
         },
-        ("no-eth1-sim", Some(matches)) => match no_eth1_sim::run_no_eth1_sim(matches) {
-            Ok(()) => println!("Simulation exited successfully"),
-            Err(e) => {
-                eprintln!("Simulation exited with error: {}", e);
-                std::process::exit(1)
-            }
-        },
-        ("syncing-sim", Some(matches)) => match sync_sim::run_syncing_sim(matches) {
+        ("fallback-sim", Some(matches)) => match fallback_sim::run_fallback_sim(matches) {
             Ok(()) => println!("Simulation exited successfully"),
             Err(e) => {
                 eprintln!("Simulation exited with error: {}", e);
diff --git a/testing/simulator/src/no_eth1_sim.rs b/testing/simulator/src/no_eth1_sim.rs
deleted file mode 100644
index fc18b1cd489..00000000000
--- a/testing/simulator/src/no_eth1_sim.rs
+++ /dev/null
@@ -1,172 +0,0 @@
-use crate::{checks, LocalNetwork};
-use clap::ArgMatches;
-use futures::prelude::*;
-use node_test_rig::{
-    environment::{EnvironmentBuilder, LoggerConfig},
-    testing_client_config, testing_validator_config, ClientGenesis, ValidatorFiles,
-};
-use rayon::prelude::*;
-use std::cmp::max;
-use std::net::Ipv4Addr;
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
-use tokio::time::sleep;
-use types::{Epoch, EthSpec, MainnetEthSpec};
-
-pub fn run_no_eth1_sim(matches: &ArgMatches) -> Result<(), String> {
-    let node_count = value_t!(matches, "nodes", usize).expect("missing nodes default");
-    let validators_per_node = value_t!(matches, "validators_per_node", usize)
-        .expect("missing validators_per_node default");
-    let speed_up_factor =
-        value_t!(matches, "speed_up_factor", u64).expect("missing speed_up_factor default");
-    let continue_after_checks = matches.is_present("continue_after_checks");
-
-    println!("Beacon Chain Simulator:");
-    println!(" nodes:{}", node_count);
-    println!(" validators_per_node:{}", validators_per_node);
-    println!(" continue_after_checks:{}", continue_after_checks);
-
-    // Generate the directories and keystores required for the validator clients.
-    let validator_files = (0..node_count)
-        .into_par_iter()
-        .map(|i| {
-            println!(
-                "Generating keystores for validator {} of {}",
-                i + 1,
-                node_count
-            );
-
-            let indices =
-                (i * validators_per_node..(i + 1) * validators_per_node).collect::<Vec<_>>();
-            ValidatorFiles::with_keystores(&indices).unwrap()
-        })
-        .collect::<Vec<_>>();
-
-    let mut env = EnvironmentBuilder::mainnet()
-        .initialize_logger(LoggerConfig {
-            path: None,
-            debug_level: String::from("debug"),
-            logfile_debug_level: String::from("debug"),
-            log_format: None,
-            logfile_format: None,
-            log_color: false,
-            disable_log_timestamp: false,
-            max_log_size: 0,
-            max_log_number: 0,
-            compression: false,
-            is_restricted: true,
-            sse_logging: false,
-        })?
-        .multi_threaded_tokio_runtime()?
-        .build()?;
-
-    let eth1_block_time = Duration::from_millis(15_000 / speed_up_factor);
-
-    let spec = &mut env.eth2_config.spec;
-
-    let total_validator_count = validators_per_node * node_count;
-
-    spec.seconds_per_slot /= speed_up_factor;
-    spec.seconds_per_slot = max(1, spec.seconds_per_slot);
-    spec.eth1_follow_distance = 16;
-    spec.genesis_delay = eth1_block_time.as_secs() * spec.eth1_follow_distance * 2;
-    spec.min_genesis_time = 0;
-    spec.min_genesis_active_validator_count = total_validator_count as u64;
-    spec.seconds_per_eth1_block = 1;
-
-    let genesis_delay = Duration::from_secs(5);
-    let genesis_time = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map_err(|_| "should get system time")?
-        + genesis_delay;
-
-    let slot_duration = Duration::from_secs(spec.seconds_per_slot);
-
-    let context = env.core_context();
-
-    let mut beacon_config = testing_client_config();
-
-    beacon_config.genesis = ClientGenesis::Interop {
-        validator_count: total_validator_count,
-        genesis_time: genesis_time.as_secs(),
-    };
-    beacon_config.dummy_eth1_backend = true;
-    beacon_config.sync_eth1_chain = true;
-
-    beacon_config.network.enr_address = (Some(Ipv4Addr::LOCALHOST), None);
-
-    let main_future = async {
-        let network = LocalNetwork::new(context.clone(), beacon_config.clone()).await?;
-        /*
-         * One by one, add beacon nodes to the network.
-         */
-
-        for _ in 0..node_count - 1 {
-            network
-                .add_beacon_node(beacon_config.clone(), false)
-                .await?;
-        }
-
-        /*
-         * Create a future that will add validator clients to the network. Each validator client is
-         * attached to a single corresponding beacon node. Spawn each validator in a new task.
-         */
-        let executor = context.executor.clone();
-        for (i, files) in validator_files.into_iter().enumerate() {
-            let network_1 = network.clone();
-            executor.spawn(
-                async move {
-                    println!("Adding validator client {}", i);
-                    network_1
-                        .add_validator_client(testing_validator_config(), i, files, i % 2 == 0)
-                        .await
-                        .expect("should add validator");
-                },
-                "vc",
-            );
-        }
-
-        let duration_to_genesis = network.duration_to_genesis().await;
-        println!("Duration to genesis: {}", duration_to_genesis.as_secs());
-        sleep(duration_to_genesis).await;
-
-        let (finalization, block_prod) = futures::join!(
-            // Check that the chain finalizes at the first given opportunity.
-            checks::verify_first_finalization(network.clone(), slot_duration),
-            // Check that a block is produced at every slot.
-            checks::verify_full_block_production_up_to(
-                network.clone(),
-                Epoch::new(4).start_slot(MainnetEthSpec::slots_per_epoch()),
-                slot_duration,
-            ),
-        );
-        finalization?;
-        block_prod?;
-
-        // The `final_future` either completes immediately or never completes, depending on the value
-        // of `continue_after_checks`.
-
-        if continue_after_checks {
-            future::pending::<()>().await;
-        }
-        /*
-         * End the simulation by dropping the network. This will kill all running beacon nodes and
-         * validator clients.
-         */
-        println!(
-            "Simulation complete. Finished with {} beacon nodes and {} validator clients",
-            network.beacon_node_count() + network.proposer_node_count(),
-            network.validator_client_count()
-        );
-
-        // Be explicit about dropping the network, as this kills all the nodes. This ensures
-        // all the checks have adequate time to pass.
-        drop(network);
-        Ok::<(), String>(())
-    };
-
-    env.runtime().block_on(main_future).unwrap();
-
-    env.fire_signal();
-    env.shutdown_on_idle();
-    Ok(())
-}
diff --git a/testing/simulator/src/sync_sim.rs b/testing/simulator/src/sync_sim.rs
deleted file mode 100644
index 78f7e1ee9fb..00000000000
--- a/testing/simulator/src/sync_sim.rs
+++ /dev/null
@@ -1,392 +0,0 @@
-use crate::checks::{epoch_delay, verify_all_finalized_at};
-use crate::local_network::LocalNetwork;
-use clap::ArgMatches;
-use futures::prelude::*;
-use node_test_rig::{
-    environment::{EnvironmentBuilder, LoggerConfig},
-    testing_client_config, ClientGenesis, ValidatorFiles,
-};
-use node_test_rig::{testing_validator_config, ClientConfig};
-use std::cmp::max;
-use std::net::Ipv4Addr;
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
-use types::{Epoch, EthSpec};
-
-pub fn run_syncing_sim(matches: &ArgMatches) -> Result<(), String> {
-    let initial_delay = value_t!(matches, "initial_delay", u64).unwrap();
-    let sync_timeout = value_t!(matches, "sync_timeout", u64).unwrap();
-    let speed_up_factor = value_t!(matches, "speedup", u64).unwrap();
-    let strategy = value_t!(matches, "strategy", String).unwrap();
-
-    println!("Syncing Simulator:");
-    println!(" initial_delay:{}", initial_delay);
-    println!(" sync timeout: {}", sync_timeout);
-    println!(" speed up factor:{}", speed_up_factor);
-    println!(" strategy:{}", strategy);
-
-    let log_level = "debug";
-    let log_format = None;
-
-    syncing_sim(
-        speed_up_factor,
-        initial_delay,
-        sync_timeout,
-        strategy,
-        log_level,
-        log_format,
-    )
-}
-
-fn syncing_sim(
-    speed_up_factor: u64,
-    initial_delay: u64,
-    sync_timeout: u64,
-    strategy: String,
-    log_level: &str,
-    log_format: Option<&str>,
-) -> Result<(), String> {
-    let mut env = EnvironmentBuilder::minimal()
-        .initialize_logger(LoggerConfig {
-            path: None,
-            debug_level: String::from(log_level),
-            logfile_debug_level: String::from("debug"),
-            log_format: log_format.map(String::from),
-            logfile_format: None,
-            log_color: false,
-            disable_log_timestamp: false,
-            max_log_size: 0,
-            max_log_number: 0,
-            compression: false,
-            is_restricted: true,
-            sse_logging: false,
-        })?
-        .multi_threaded_tokio_runtime()?
-        .build()?;
-
-    let spec = &mut env.eth2_config.spec;
-    let end_after_checks = true;
-    let eth1_block_time = Duration::from_millis(15_000 / speed_up_factor);
-
-    // Set fork epochs to test syncing across fork boundaries
-    spec.altair_fork_epoch = Some(Epoch::new(1));
-    spec.bellatrix_fork_epoch = Some(Epoch::new(2));
-    spec.seconds_per_slot /= speed_up_factor;
-    spec.seconds_per_slot = max(1, spec.seconds_per_slot);
-    spec.eth1_follow_distance = 16;
-    spec.genesis_delay = eth1_block_time.as_secs() * spec.eth1_follow_distance * 2;
-    spec.min_genesis_time = 0;
-    spec.min_genesis_active_validator_count = 64;
-    spec.seconds_per_eth1_block = 1;
-
-    let num_validators = 8;
-    let slot_duration = Duration::from_secs(spec.seconds_per_slot);
-    let context = env.core_context();
-    let mut beacon_config = testing_client_config();
-
-    let genesis_time = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map_err(|_| "should get system time")?
-        + Duration::from_secs(5);
-    beacon_config.genesis = ClientGenesis::Interop {
-        validator_count: num_validators,
-        genesis_time: genesis_time.as_secs(),
-    };
-    beacon_config.dummy_eth1_backend = true;
-    beacon_config.sync_eth1_chain = true;
-
-    beacon_config.http_api.allow_sync_stalled = true;
-
-    beacon_config.network.enr_address = (Some(Ipv4Addr::LOCALHOST), None);
-
-    // Generate the directories and keystores required for the validator clients.
-    let validator_indices = (0..num_validators).collect::<Vec<_>>();
-    let validator_files = ValidatorFiles::with_keystores(&validator_indices).unwrap();
-
-    let main_future = async {
-        /*
-         * Create a new `LocalNetwork` with one beacon node.
-         */
-        let network = LocalNetwork::new(context, beacon_config.clone()).await?;
-
-        /*
-         * Add a validator client which handles all validators from the genesis state.
-         */
-        network
-            .add_validator_client(testing_validator_config(), 0, validator_files, true)
-            .await?;
-
-        // Check all syncing strategies one after other.
-        pick_strategy(
-            &strategy,
-            network.clone(),
-            beacon_config.clone(),
-            slot_duration,
-            initial_delay,
-            sync_timeout,
-        )
-        .await?;
-
-        // The `final_future` either completes immediately or never completes, depending on the value
-        // of `end_after_checks`.
-
-        if !end_after_checks {
-            future::pending::<()>().await;
-        }
-
-        /*
-         * End the simulation by dropping the network. This will kill all running beacon nodes and
-         * validator clients.
-         */
-        println!(
-            "Simulation complete. Finished with {} beacon nodes and {} validator clients",
-            network.beacon_node_count(),
-            network.validator_client_count()
-        );
-
-        // Be explicit about dropping the network, as this kills all the nodes. This ensures
-        // all the checks have adequate time to pass.
-        drop(network);
-        Ok::<(), String>(())
-    };
-
-    env.runtime().block_on(main_future).unwrap();
-
-    env.fire_signal();
-    env.shutdown_on_idle();
-
-    Ok(())
-}
-
-pub async fn pick_strategy<E: EthSpec>(
-    strategy: &str,
-    network: LocalNetwork<E>,
-    beacon_config: ClientConfig,
-    slot_duration: Duration,
-    initial_delay: u64,
-    sync_timeout: u64,
-) -> Result<(), String> {
-    match strategy {
-        "one-node" => {
-            verify_one_node_sync(
-                network,
-                beacon_config,
-                slot_duration,
-                initial_delay,
-                sync_timeout,
-            )
-            .await
-        }
-        "two-nodes" => {
-            verify_two_nodes_sync(
-                network,
-                beacon_config,
-                slot_duration,
-                initial_delay,
-                sync_timeout,
-            )
-            .await
-        }
-        "mixed" => {
-            verify_in_between_sync(
-                network,
-                beacon_config,
-                slot_duration,
-                initial_delay,
-                sync_timeout,
-            )
-            .await
-        }
-        "all" => {
-            verify_syncing(
-                network,
-                beacon_config,
-                slot_duration,
-                initial_delay,
-                sync_timeout,
-            )
-            .await
-        }
-        _ => Err("Invalid strategy".into()),
-    }
-}
-
-/// Verify one node added after `initial_delay` epochs is in sync
-/// after `sync_timeout` epochs.
-pub async fn verify_one_node_sync<E: EthSpec>(
-    network: LocalNetwork<E>,
-    beacon_config: ClientConfig,
-    slot_duration: Duration,
-    initial_delay: u64,
-    sync_timeout: u64,
-) -> Result<(), String> {
-    let epoch_duration = slot_duration * (E::slots_per_epoch() as u32);
-    let network_c = network.clone();
-    // Delay for `initial_delay` epochs before adding another node to start syncing
-    epoch_delay(
-        Epoch::new(initial_delay),
-        slot_duration,
-        E::slots_per_epoch(),
-    )
-    .await;
-    // Add a beacon node
-    network.add_beacon_node(beacon_config, false).await?;
-    // Check every `epoch_duration` if nodes are synced
-    // limited to at most `sync_timeout` epochs
-    let mut interval = tokio::time::interval(epoch_duration);
-    let mut count = 0;
-    loop {
-        interval.tick().await;
-        if count >= sync_timeout || !check_still_syncing(&network_c).await? {
-            break;
-        }
-        count += 1;
-    }
-    let epoch = network.bootnode_epoch().await?;
-    verify_all_finalized_at(network, epoch)
-        .map_err(|e| format!("One node sync error: {}", e))
-        .await
-}
-
-/// Verify two nodes added after `initial_delay` epochs are in sync
-/// after `sync_timeout` epochs.
-pub async fn verify_two_nodes_sync<E: EthSpec>(
-    network: LocalNetwork<E>,
-    beacon_config: ClientConfig,
-    slot_duration: Duration,
-    initial_delay: u64,
-    sync_timeout: u64,
-) -> Result<(), String> {
-    let epoch_duration = slot_duration * (E::slots_per_epoch() as u32);
-    let network_c = network.clone();
-    // Delay for `initial_delay` epochs before adding another node to start syncing
-    epoch_delay(
-        Epoch::new(initial_delay),
-        slot_duration,
-        E::slots_per_epoch(),
-    )
-    .await;
-    // Add beacon nodes
-    network
-        .add_beacon_node(beacon_config.clone(), false)
-        .await?;
-    network.add_beacon_node(beacon_config, false).await?;
-    // Check every `epoch_duration` if nodes are synced
-    // limited to at most `sync_timeout` epochs
-    let mut interval = tokio::time::interval(epoch_duration);
-    let mut count = 0;
-    loop {
-        interval.tick().await;
-        if count >= sync_timeout || !check_still_syncing(&network_c).await? {
-            break;
-        }
-        count += 1;
-    }
-    let epoch = network.bootnode_epoch().await?;
-    verify_all_finalized_at(network, epoch)
-        .map_err(|e| format!("One node sync error: {}", e))
-        .await
-}
-
-/// Add 2 syncing nodes after `initial_delay` epochs,
-/// Add another node after `sync_timeout - 5` epochs and verify all are
-/// in sync after `sync_timeout + 5` epochs.
-pub async fn verify_in_between_sync<E: EthSpec>(
-    network: LocalNetwork<E>,
-    beacon_config: ClientConfig,
-    slot_duration: Duration,
-    initial_delay: u64,
-    sync_timeout: u64,
-) -> Result<(), String> {
-    let epoch_duration = slot_duration * (E::slots_per_epoch() as u32);
-    let network_c = network.clone();
-    // Delay for `initial_delay` epochs before adding another node to start syncing
-    let config1 = beacon_config.clone();
-    epoch_delay(
-        Epoch::new(initial_delay),
-        slot_duration,
-        E::slots_per_epoch(),
-    )
-    .await;
-    // Add two beacon nodes
-    network
-        .add_beacon_node(beacon_config.clone(), false)
-        .await?;
-    network.add_beacon_node(beacon_config, false).await?;
-    // Delay before adding additional syncing nodes.
-    epoch_delay(
-        Epoch::new(sync_timeout - 5),
-        slot_duration,
-        E::slots_per_epoch(),
-    )
-    .await;
-    // Add a beacon node
-    network.add_beacon_node(config1.clone(), false).await?;
-    // Check every `epoch_duration` if nodes are synced
-    // limited to at most `sync_timeout` epochs
-    let mut interval = tokio::time::interval(epoch_duration);
-    let mut count = 0;
-    loop {
-        interval.tick().await;
-        if count >= sync_timeout || !check_still_syncing(&network_c).await? {
-            break;
-        }
-        count += 1;
-    }
-    let epoch = network.bootnode_epoch().await?;
-    verify_all_finalized_at(network, epoch)
-        .map_err(|e| format!("One node sync error: {}", e))
-        .await
-}
-
-/// Run syncing strategies one after other.
-pub async fn verify_syncing<E: EthSpec>(
-    network: LocalNetwork<E>,
-    beacon_config: ClientConfig,
-    slot_duration: Duration,
-    initial_delay: u64,
-    sync_timeout: u64,
-) -> Result<(), String> {
-    verify_one_node_sync(
-        network.clone(),
-        beacon_config.clone(),
-        slot_duration,
-        initial_delay,
-        sync_timeout,
-    )
-    .await?;
-    println!("Completed one node sync");
-    verify_two_nodes_sync(
-        network.clone(),
-        beacon_config.clone(),
-        slot_duration,
-        initial_delay,
-        sync_timeout,
-    )
-    .await?;
-    println!("Completed two node sync");
-    verify_in_between_sync(
-        network,
-        beacon_config,
-        slot_duration,
-        initial_delay,
-        sync_timeout,
-    )
-    .await?;
-    println!("Completed in between sync");
-    Ok(())
-}
-
-pub async fn check_still_syncing<E: EthSpec>(network: &LocalNetwork<E>) -> Result<bool, String> {
-    // get syncing status of nodes
-    let mut status = Vec::new();
-    for remote_node in network.remote_nodes()? {
-        status.push(
-            remote_node
-                .get_node_syncing()
-                .await
-                .map(|body| body.data.is_syncing)
-                .map_err(|e| format!("Get syncing status via http failed: {:?}", e))?,
-        )
-    }
-    Ok(status.iter().any(|is_syncing| *is_syncing))
-}
diff --git a/testing/state_transition_vectors/src/exit.rs b/testing/state_transition_vectors/src/exit.rs
index e3cd346da13..61cae6dbe1b 100644
--- a/testing/state_transition_vectors/src/exit.rs
+++ b/testing/state_transition_vectors/src/exit.rs
@@ -1,7 +1,7 @@
 use super::*;
 use state_processing::{
     per_block_processing, per_block_processing::errors::ExitInvalid, BlockProcessingError,
-    BlockSignatureStrategy, ConsensusContext, StateProcessingStrategy, VerifyBlockRoot,
+    BlockSignatureStrategy, ConsensusContext, VerifyBlockRoot,
 };
 use types::{BeaconBlock, Epoch};
 
@@ -68,7 +68,6 @@ impl ExitTest {
             state,
             block,
             BlockSignatureStrategy::VerifyIndividual,
-            StateProcessingStrategy::Accurate,
             VerifyBlockRoot::True,
             &mut ctxt,
             &E::default_spec(),
@@ -332,7 +331,7 @@ mod custom_tests {
     fn assert_exited(state: &BeaconState<E>, validator_index: usize) {
         let spec = E::default_spec();
 
-        let validator = &state.validators()[validator_index];
+        let validator = &state.validators().get(validator_index).unwrap();
         assert_eq!(
             validator.exit_epoch,
             // This is correct until we exceed the churn limit. If that happens, we
diff --git a/testing/web3signer_tests/src/lib.rs b/testing/web3signer_tests/src/lib.rs
index 3090b4da556..292e10d0542 100644
--- a/testing/web3signer_tests/src/lib.rs
+++ b/testing/web3signer_tests/src/lib.rs
@@ -724,11 +724,11 @@ mod tests {
         .await;
     }
 
-    /// Test all the Merge types.
-    async fn test_merge_types(network: &str, listen_port: u16) {
+    /// Test all the Bellatrix types.
+    async fn test_bellatrix_types(network: &str, listen_port: u16) {
         let network_config = Eth2NetworkConfig::constant(network).unwrap().unwrap();
         let spec = &network_config.chain_spec::<E>().unwrap();
-        let merge_fork_slot = spec
+        let bellatrix_fork_slot = spec
             .bellatrix_fork_epoch
             .unwrap()
             .start_slot(E::slots_per_epoch());
@@ -740,14 +740,21 @@ mod tests {
             listen_port,
         )
         .await
-        .assert_signatures_match("beacon_block_merge", |pubkey, validator_store| async move {
-            let mut merge_block = BeaconBlockMerge::empty(spec);
-            merge_block.slot = merge_fork_slot;
-            validator_store
-                .sign_block(pubkey, BeaconBlock::Merge(merge_block), merge_fork_slot)
-                .await
-                .unwrap()
-        })
+        .assert_signatures_match(
+            "beacon_block_bellatrix",
+            |pubkey, validator_store| async move {
+                let mut bellatrix_block = BeaconBlockBellatrix::empty(spec);
+                bellatrix_block.slot = bellatrix_fork_slot;
+                validator_store
+                    .sign_block(
+                        pubkey,
+                        BeaconBlock::Bellatrix(bellatrix_block),
+                        bellatrix_fork_slot,
+                    )
+                    .await
+                    .unwrap()
+            },
+        )
         .await;
     }
 
@@ -760,7 +767,7 @@ mod tests {
 
         let network_config = Eth2NetworkConfig::constant(network).unwrap().unwrap();
         let spec = &network_config.chain_spec::<E>().unwrap();
-        let merge_fork_slot = spec
+        let bellatrix_fork_slot = spec
             .bellatrix_fork_epoch
             .unwrap()
             .start_slot(E::slots_per_epoch());
@@ -797,9 +804,9 @@ mod tests {
         };
 
         let first_block = || {
-            let mut merge_block = BeaconBlockMerge::empty(spec);
-            merge_block.slot = merge_fork_slot;
-            BeaconBlock::Merge(merge_block)
+            let mut bellatrix_block = BeaconBlockBellatrix::empty(spec);
+            bellatrix_block.slot = bellatrix_fork_slot;
+            BeaconBlock::Bellatrix(bellatrix_block)
         };
 
         let double_vote_block = || {
@@ -914,8 +921,8 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn sepolia_merge_types() {
-        test_merge_types("sepolia", 4252).await
+    async fn sepolia_bellatrix_types() {
+        test_bellatrix_types("sepolia", 4252).await
     }
 
     #[tokio::test]
diff --git a/validator_client/Cargo.toml b/validator_client/Cargo.toml
index d3dffc3d02e..0df687abec5 100644
--- a/validator_client/Cargo.toml
+++ b/validator_client/Cargo.toml
@@ -61,3 +61,4 @@ sysinfo = { workspace = true }
 system_health = { path = "../common/system_health" }
 logging = { workspace = true }
 strum = { workspace = true }
+fdlimit = "0.3.0"
diff --git a/validator_client/slashing_protection/src/slashing_database.rs b/validator_client/slashing_protection/src/slashing_database.rs
index b497abd7dde..04554786f6f 100644
--- a/validator_client/slashing_protection/src/slashing_database.rs
+++ b/validator_client/slashing_protection/src/slashing_database.rs
@@ -23,7 +23,7 @@ pub const POOL_SIZE: u32 = 1;
 #[cfg(not(test))]
 pub const CONNECTION_TIMEOUT: Duration = Duration::from_secs(5);
 #[cfg(test)]
-pub const CONNECTION_TIMEOUT: Duration = Duration::from_millis(500);
+pub const CONNECTION_TIMEOUT: Duration = Duration::from_secs(1);
 
 /// Supported version of the interchange format.
 pub const SUPPORTED_INTERCHANGE_FORMAT_VERSION: u64 = 5;
diff --git a/validator_client/src/block_service.rs b/validator_client/src/block_service.rs
index 445d4f1a5d9..06d484a52bb 100644
--- a/validator_client/src/block_service.rs
+++ b/validator_client/src/block_service.rs
@@ -892,6 +892,7 @@ impl<E: EthSpec> UnsignedBlock<E> {
     }
 }
 
+#[derive(Debug)]
 pub enum SignedBlock<E: EthSpec> {
     Full(PublishBlockRequest<E>),
     Blinded(Arc<SignedBlindedBeaconBlock<E>>),
diff --git a/validator_client/src/cli.rs b/validator_client/src/cli.rs
index 16a265212e5..991b621f27d 100644
--- a/validator_client/src/cli.rs
+++ b/validator_client/src/cli.rs
@@ -73,7 +73,6 @@ pub fn cli_app<'a, 'b>() -> App<'a, 'b> {
                     key. Defaults to ~/.lighthouse/{network}/secrets.",
                 )
                 .takes_value(true)
-                .conflicts_with("datadir")
         )
         .arg(
             Arg::with_name("init-slashing-protection")
@@ -391,7 +390,7 @@ pub fn cli_app<'a, 'b>() -> App<'a, 'b> {
             Arg::with_name("web3-signer-keep-alive-timeout")
                 .long("web3-signer-keep-alive-timeout")
                 .value_name("MILLIS")
-                .default_value("90000")
+                .default_value("20000")
                 .help("Keep-alive timeout for each web3signer connection. Set to 'null' to never \
                        timeout")
                 .takes_value(true),
diff --git a/validator_client/src/config.rs b/validator_client/src/config.rs
index ae59829a3e6..5bd32fced2a 100644
--- a/validator_client/src/config.rs
+++ b/validator_client/src/config.rs
@@ -18,6 +18,7 @@ use std::time::Duration;
 use types::{Address, GRAFFITI_BYTES_LEN};
 
 pub const DEFAULT_BEACON_NODE: &str = "http://localhost:5052/";
+pub const DEFAULT_WEB3SIGNER_KEEP_ALIVE: Option<Duration> = Some(Duration::from_secs(20));
 
 /// Stores the core configuration for this validator instance.
 #[derive(Clone, Serialize, Deserialize)]
@@ -133,7 +134,7 @@ impl Default for Config {
             builder_boost_factor: None,
             prefer_builder_proposals: false,
             distributed: false,
-            web3_signer_keep_alive_timeout: Some(Duration::from_secs(90)),
+            web3_signer_keep_alive_timeout: DEFAULT_WEB3SIGNER_KEEP_ALIVE,
             web3_signer_max_idle_connections: None,
         }
     }
diff --git a/validator_client/src/duties_service.rs b/validator_client/src/duties_service.rs
index b5b56943c4b..6f25a1c05d7 100644
--- a/validator_client/src/duties_service.rs
+++ b/validator_client/src/duties_service.rs
@@ -88,14 +88,15 @@ const _: () = assert!({
 /// bringing in the entire crate.
 const _: () = assert!(ATTESTATION_SUBSCRIPTION_OFFSETS[0] > 2);
 
+// The info in the enum variants is displayed in logging, clippy thinks it's dead code.
 #[derive(Debug)]
 pub enum Error {
     UnableToReadSlotClock,
-    FailedToDownloadAttesters(String),
-    FailedToProduceSelectionProof(ValidatorStoreError),
-    InvalidModulo(ArithError),
-    Arith(ArithError),
-    SyncDutiesNotFound(u64),
+    FailedToDownloadAttesters(#[allow(dead_code)] String),
+    FailedToProduceSelectionProof(#[allow(dead_code)] ValidatorStoreError),
+    InvalidModulo(#[allow(dead_code)] ArithError),
+    Arith(#[allow(dead_code)] ArithError),
+    SyncDutiesNotFound(#[allow(dead_code)] u64),
 }
 
 impl From<ArithError> for Error {
@@ -896,7 +897,7 @@ async fn poll_beacon_attesters_for_epoch<T: SlotClock + 'static, E: EthSpec>(
                         "Attester duties re-org";
                         "prior_dependent_root" => %prior_dependent_root,
                         "dependent_root" => %dependent_root,
-                        "msg" => "this may happen from time to time"
+                        "note" => "this may happen from time to time"
                     )
                 }
                 *mut_value = (dependent_root, duty_and_proof);
diff --git a/validator_client/src/http_metrics/mod.rs b/validator_client/src/http_metrics/mod.rs
index de6c06437b4..67cab2bdc37 100644
--- a/validator_client/src/http_metrics/mod.rs
+++ b/validator_client/src/http_metrics/mod.rs
@@ -17,8 +17,8 @@ use warp::{http::Response, Filter};
 
 #[derive(Debug)]
 pub enum Error {
-    Warp(warp::Error),
-    Other(String),
+    Warp(#[allow(dead_code)] warp::Error),
+    Other(#[allow(dead_code)] String),
 }
 
 impl From<warp::Error> for Error {
diff --git a/validator_client/src/lib.rs b/validator_client/src/lib.rs
index 32a0eadbef4..377b0640483 100644
--- a/validator_client/src/lib.rs
+++ b/validator_client/src/lib.rs
@@ -3,7 +3,6 @@ mod beacon_node_fallback;
 mod block_service;
 mod check_synced;
 mod cli;
-mod config;
 mod duties_service;
 mod graffiti_file;
 mod http_metrics;
@@ -14,6 +13,7 @@ mod preparation_service;
 mod signing_method;
 mod sync_committee_service;
 
+pub mod config;
 mod doppelganger_service;
 pub mod http_api;
 pub mod initialized_validators;
@@ -47,7 +47,7 @@ use notifier::spawn_notifier;
 use parking_lot::RwLock;
 use preparation_service::{PreparationService, PreparationServiceBuilder};
 use reqwest::Certificate;
-use slog::{error, info, warn, Logger};
+use slog::{debug, error, info, warn, Logger};
 use slot_clock::SlotClock;
 use slot_clock::SystemTimeSlotClock;
 use std::fs::File;
@@ -121,6 +121,27 @@ impl<E: EthSpec> ProductionValidatorClient<E> {
     pub async fn new(context: RuntimeContext<E>, config: Config) -> Result<Self, String> {
         let log = context.log().clone();
 
+        // Attempt to raise soft fd limit. The behavior is OS specific:
+        // `linux` - raise soft fd limit to hard
+        // `macos` - raise soft fd limit to `min(kernel limit, hard fd limit)`
+        // `windows` & rest - noop
+        match fdlimit::raise_fd_limit().map_err(|e| format!("Unable to raise fd limit: {}", e))? {
+            fdlimit::Outcome::LimitRaised { from, to } => {
+                debug!(
+                    log,
+                    "Raised soft open file descriptor resource limit";
+                    "old_limit" => from,
+                    "new_limit" => to
+                );
+            }
+            fdlimit::Outcome::Unsupported => {
+                debug!(
+                    log,
+                    "Raising soft open file descriptor resource limit is not supported"
+                );
+            }
+        };
+
         info!(
             log,
             "Starting validator client";
diff --git a/validator_client/src/signing_method.rs b/validator_client/src/signing_method.rs
index fe520e11f5f..8c11027b8d0 100644
--- a/validator_client/src/signing_method.rs
+++ b/validator_client/src/signing_method.rs
@@ -7,7 +7,7 @@ use crate::http_metrics::metrics;
 use eth2_keystore::Keystore;
 use lockfile::Lockfile;
 use parking_lot::Mutex;
-use reqwest::Client;
+use reqwest::{header::ACCEPT, Client};
 use std::path::PathBuf;
 use std::sync::Arc;
 use task_executor::TaskExecutor;
@@ -243,6 +243,7 @@ impl SigningMethod {
                 // Request a signature from the Web3Signer instance via HTTP(S).
                 let response: SigningResponse = http_client
                     .post(signing_url.clone())
+                    .header(ACCEPT, "application/json")
                     .json(&request)
                     .send()
                     .await
diff --git a/validator_client/src/signing_method/web3signer.rs b/validator_client/src/signing_method/web3signer.rs
index 7973cab2c1e..8ad37a1620a 100644
--- a/validator_client/src/signing_method/web3signer.rs
+++ b/validator_client/src/signing_method/web3signer.rs
@@ -87,7 +87,7 @@ impl<'a, E: EthSpec, Payload: AbstractExecPayload<E>> Web3SignerObject<'a, E, Pa
                 block: Some(block),
                 block_header: None,
             }),
-            BeaconBlock::Merge(_) => Ok(Web3SignerObject::BeaconBlock {
+            BeaconBlock::Bellatrix(_) => Ok(Web3SignerObject::BeaconBlock {
                 version: ForkName::Bellatrix,
                 block: None,
                 block_header: Some(block.block_header()),
diff --git a/validator_client/src/validator_store.rs b/validator_client/src/validator_store.rs
index 0a00dad9beb..f3bdc2c0f69 100644
--- a/validator_client/src/validator_store.rs
+++ b/validator_client/src/validator_store.rs
@@ -360,7 +360,7 @@ impl<T: SlotClock + 'static, E: EthSpec> ValidatorStore<T, E> {
     fn signing_context(&self, domain: Domain, signing_epoch: Epoch) -> SigningContext {
         if domain == Domain::VoluntaryExit {
             match self.spec.fork_name_at_epoch(signing_epoch) {
-                ForkName::Base | ForkName::Altair | ForkName::Merge | ForkName::Capella => {
+                ForkName::Base | ForkName::Altair | ForkName::Bellatrix | ForkName::Capella => {
                     SigningContext {
                         domain,
                         epoch: signing_epoch,
diff --git a/watch/src/database/mod.rs b/watch/src/database/mod.rs
index 59547c303ab..315fcbc8358 100644
--- a/watch/src/database/mod.rs
+++ b/watch/src/database/mod.rs
@@ -146,7 +146,7 @@ pub fn insert_beacon_block<E: EthSpec>(
     let full_payload = block_message.execution_payload().ok();
 
     let transaction_count: Option<i32> = if let Some(bellatrix_payload) =
-        full_payload.and_then(|payload| payload.execution_payload_merge().ok())
+        full_payload.and_then(|payload| payload.execution_payload_bellatrix().ok())
     {
         Some(bellatrix_payload.transactions.len() as i32)
     } else {
diff --git a/watch/src/server/mod.rs b/watch/src/server/mod.rs
index 25dd242aab6..08036db9510 100644
--- a/watch/src/server/mod.rs
+++ b/watch/src/server/mod.rs
@@ -31,7 +31,7 @@ pub async fn serve(config: FullConfig) -> Result<(), Error> {
             )
         })?;
 
-    let server = start_server(&config, slots_per_epoch as u64, db)?;
+    let (_addr, server) = start_server(&config, slots_per_epoch as u64, db)?;
 
     server.await?;
 
@@ -58,7 +58,13 @@ pub fn start_server(
     config: &FullConfig,
     slots_per_epoch: u64,
     pool: PgPool,
-) -> Result<impl Future<Output = Result<(), std::io::Error>> + 'static, Error> {
+) -> Result<
+    (
+        SocketAddr,
+        impl Future<Output = Result<(), std::io::Error>> + 'static,
+    ),
+    Error,
+> {
     let mut routes = Router::new()
         .route("/v1/slots", get(handler::get_slots_by_range))
         .route("/v1/slots/:slot", get(handler::get_slot))
@@ -106,11 +112,15 @@ pub fn start_server(
     let addr = SocketAddr::new(config.server.listen_addr, config.server.listen_port);
     let listener = TcpListener::bind(addr)?;
     listener.set_nonblocking(true)?;
+
+    // Read the socket address (it may be different from `addr` if listening on port 0).
+    let socket_addr = listener.local_addr()?;
+
     let serve = axum::serve(tokio::net::TcpListener::from_std(listener)?, app);
 
     info!("HTTP server listening on {}", addr);
 
-    Ok(serve.into_future())
+    Ok((socket_addr, serve.into_future()))
 }
 
 // The default route indicating that no available routes matched the request.
diff --git a/watch/tests/tests.rs b/watch/tests/tests.rs
index 0e29e7f0cd8..5461508edd8 100644
--- a/watch/tests/tests.rs
+++ b/watch/tests/tests.rs
@@ -14,7 +14,6 @@ use rand::distributions::Alphanumeric;
 use rand::{thread_rng, Rng};
 use std::collections::HashMap;
 use std::env;
-use std::net::SocketAddr;
 use std::time::Duration;
 use testcontainers::{clients::Cli, core::WaitFor, Image, RunnableImage};
 use tokio::{runtime, task::JoinHandle};
@@ -154,7 +153,7 @@ impl TesterBuilder {
          * Create a watch configuration
          */
         let database_port = unused_tcp4_port().expect("Unable to find unused port.");
-        let server_port = unused_tcp4_port().expect("Unable to find unused port.");
+        let server_port = 0;
         let config = Config {
             database: DatabaseConfig {
                 dbname: random_dbname(),
@@ -187,14 +186,9 @@ impl TesterBuilder {
         /*
          * Spawn a Watch HTTP API.
          */
-        let watch_server = start_server(&self.config, SLOTS_PER_EPOCH, pool).unwrap();
+        let (addr, watch_server) = start_server(&self.config, SLOTS_PER_EPOCH, pool).unwrap();
         tokio::spawn(watch_server);
 
-        let addr = SocketAddr::new(
-            self.config.server.listen_addr,
-            self.config.server.listen_port,
-        );
-
         /*
          * Create a HTTP client to talk to the watch HTTP API.
          */