Merge branch 'master' into release/1.13

all: release go-ethereum v1.13.12 (#28961 )
all: release go-ethereum v1.13.12
2024-02-21 15:48:38 +01:00 · 2024-02-09 07:58:48 +01:00 · 2024-01-24 11:52:24 +01:00 · 2024-01-11 19:21:29 +02:00 · 2024-01-10 17:31:15 +01:00 · 2023-12-22 13:44:46 +01:00
942 changed files with 44935 additions and 57193 deletions
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -4,22 +4,19 @@
 accounts/usbwallet              @karalabe
 accounts/scwallet               @gballet
 accounts/abi                    @gballet @MariusVanDerWijden
-beacon/engine                   @lightclient
 cmd/clef                        @holiman
-cmd/evm                         @holiman @MariusVanDerWijden @lightclient
 consensus                       @karalabe
 core/                           @karalabe @holiman @rjl493456442
 eth/                            @karalabe @holiman @rjl493456442
-eth/catalyst/                   @gballet @lightclient
+eth/catalyst/                   @gballet
 eth/tracers/                    @s1na
-core/tracing/                   @s1na
 graphql/                        @s1na
-internal/ethapi                 @lightclient
-internal/era                    @lightclient
 les/                            @zsfelfoldi @rjl493456442
 light/                          @zsfelfoldi @rjl493456442
 node/                           @fjl
 p2p/                            @fjl @zsfelfoldi
-params/                         @fjl @holiman @karalabe @gballet @rjl493456442 @zsfelfoldi
 rpc/                            @fjl @holiman
+p2p/simulations                 @fjl
+p2p/protocols                   @fjl
+p2p/testing                     @fjl
 signer/                         @holiman
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -11,12 +11,11 @@ jobs:
  build:
    runs-on: self-hosted
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
      - name: Set up Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v2
        with:
-          go-version: 1.23.0
-          cache: false
+          go-version: 1.21.4
      - name: Run tests
        run: go test -short ./...
        env:
--- a/.gitignore
+++ b/.gitignore
@@ -4,11 +4,16 @@
 # or operating system, you probably want to add a global ignore instead:
 #   git config --global core.excludesfile ~/.gitignore_global

+/tmp
 */**/*un~
 */**/*.test
 *un~
 .DS_Store
 */**/.DS_Store
+.ethtest
+*/**/*tx_database*
+*/**/*dapps*
+build/_vendor/pkg

 #*
 .#*
@@ -23,14 +28,6 @@
 /build/bin/
 /geth*.zip

-# used by the build/ci.go archive + upload tool
-/geth*.tar.gz
-/geth*.tar.gz.sig
-/geth*.tar.gz.asc
-/geth*.zip.sig
-/geth*.zip.asc
-
-
 # travis
 profile.tmp
 profile.cov
@@ -41,4 +38,15 @@ profile.cov
 # VS Code
 .vscode

+# dashboard
+/dashboard/assets/flow-typed
+/dashboard/assets/node_modules
+/dashboard/assets/stats.json
+/dashboard/assets/bundle.js
+/dashboard/assets/bundle.js.map
+/dashboard/assets/package-lock.json
+
+**/yarn-error.log
+logs/
+
 tests/spec-tests/
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -6,6 +6,8 @@ run:
  # default is true. Enables skipping of directories:
  #   vendor$, third_party$, testdata$, examples$, Godeps$, builtin$
  skip-dirs-use-default: true
+  skip-files:
+    - core/genesis_alloc.go

 linters:
  disable-all: true
@@ -21,16 +23,9 @@ linters:
    - staticcheck
    - bidichk
    - durationcheck
-    - copyloopvar
+    - exportloopref
    - whitespace
-    - revive # only certain checks enabled
-    - durationcheck
-    - gocheckcompilerdirectives
-    - reassign
-    - mirror
-    - tenv
-    ### linters we tried and will not be using:
-    ###
+
    # - structcheck # lots of false positives
    # - errcheck #lot of false positives
    # - contextcheck
@@ -43,35 +38,21 @@ linters:
 linters-settings:
  gofmt:
    simplify: true
-  revive:
-    enable-all-rules: false
-    # here we enable specific useful rules
-    # see https://golangci-lint.run/usage/linters/#revive for supported rules
-    rules:
-      - name: receiver-naming
-        severity: warning
-        disabled: false
-        exclude: [""]

 issues:
-  exclude-files:
-    - core/genesis_alloc.go
  exclude-rules:
    - path: crypto/bn256/cloudflare/optate.go
      linters:
        - deadcode
        - staticcheck
-    - path: crypto/bn256/
-      linters:
-        - revive
-    - path: cmd/utils/flags.go
-      text: "SA1019: cfg.TxLookupLimit is deprecated: use 'TransactionHistory' instead."
-    - path: cmd/utils/flags.go
-      text: "SA1019: ethconfig.Defaults.TxLookupLimit is deprecated: use 'TransactionHistory' instead."
    - path: internal/build/pgp.go
      text: 'SA1019: "golang.org/x/crypto/openpgp" is deprecated: this package is unmaintained except for security fixes.'
    - path: core/vm/contracts.go
      text: 'SA1019: "golang.org/x/crypto/ripemd160" is deprecated: RIPEMD-160 is a legacy hash and should not be used for new applications.'
+    - path: accounts/usbwallet/trezor.go
+      text: 'SA1019: "github.com/golang/protobuf/proto" is deprecated: Use the "google.golang.org/protobuf/proto" package instead.'
+    - path: accounts/usbwallet/trezor/
+      text: 'SA1019: "github.com/golang/protobuf/proto" is deprecated: Use the "google.golang.org/protobuf/proto" package instead.'
  exclude:
    - 'SA1019: event.TypeMux is deprecated: use Feed'
    - 'SA1019: strings.Title is deprecated'
--- a/.mailmap
+++ b/.mailmap
@@ -56,6 +56,7 @@ Diederik Loerakker <proto@protolambda.com>
 Dimitry Khokhlov <winsvega@mail.ru>

 Domino Valdano <dominoplural@gmail.com>
+Domino Valdano <dominoplural@gmail.com> <jeff@okcupid.com>

 Edgar Aroutiounian <edgar.factorial@gmail.com>

--- a/.travis.yml
+++ b/.travis.yml
@@ -9,13 +9,14 @@ jobs:
        - azure-osx

  include:
-    # This builder create and push the Docker images for all architectures
+    # These builders create the Docker sub-images for multi-arch push and each
+    # will attempt to push the multi-arch image if they are the last builder
    - stage: build
      if: type = push
      os: linux
      arch: amd64
-      dist: focal
-      go: 1.23.x
+      dist: bionic
+      go: 1.21.x
      env:
        - docker
      services:
@@ -25,27 +26,44 @@ jobs:
      before_install:
        - export DOCKER_CLI_EXPERIMENTAL=enabled
      script:
-        - go run build/ci.go dockerx -platform "linux/amd64,linux/arm64" -upload ethereum/client-go
+        - go run build/ci.go docker -image -manifest amd64,arm64 -upload ethereum/client-go
+
+    - stage: build
+      if: type = push
+      os: linux
+      arch: arm64
+      dist: bionic
+      go: 1.21.x
+      env:
+        - docker
+      services:
+        - docker
+      git:
+        submodules: false # avoid cloning ethereum/tests
+      before_install:
+        - export DOCKER_CLI_EXPERIMENTAL=enabled
+      script:
+        - go run build/ci.go docker -image -manifest amd64,arm64 -upload ethereum/client-go

    # This builder does the Linux Azure uploads
    - stage: build
      if: type = push
      os: linux
-      dist: focal
+      dist: bionic
      sudo: required
-      go: 1.23.x
+      go: 1.21.x
      env:
        - azure-linux
      git:
        submodules: false # avoid cloning ethereum/tests
+      addons:
+        apt:
+          packages:
+            - gcc-multilib
      script:
-        # build amd64
+        # Build for the primary platforms that Trusty can manage
        - go run build/ci.go install -dlgo
        - go run build/ci.go archive -type tar -signer LINUX_SIGNING_KEY -signify SIGNIFY_KEY -upload gethstore/builds
-
-        # build 386
-        - sudo -E apt-get -yq --no-install-suggests --no-install-recommends install gcc-multilib
-        - git status --porcelain
        - go run build/ci.go install -dlgo -arch 386
        - go run build/ci.go archive -arch 386 -type tar -signer LINUX_SIGNING_KEY -signify SIGNIFY_KEY -upload gethstore/builds

@@ -67,13 +85,12 @@ jobs:
      if: type = push
      os: osx
      osx_image: xcode14.2
-      go: 1.23.1 # See https://github.com/ethereum/go-ethereum/pull/30478
+      go: 1.21.x
      env:
        - azure-osx
      git:
        submodules: false # avoid cloning ethereum/tests
      script:
-        - ln -sf /Users/travis/gopath/bin/go1.23.1 /usr/local/bin/go # Work around travis go-setup bug
        - go run build/ci.go install -dlgo
        - go run build/ci.go archive -type tar -signer OSX_SIGNING_KEY -signify SIGNIFY_KEY -upload gethstore/builds
        - go run build/ci.go install -dlgo -arch arm64
@@ -81,34 +98,48 @@ jobs:

    # These builders run the tests
    - stage: build
-      if: type = push
      os: linux
      arch: amd64
-      dist: focal
-      go: 1.23.x
+      dist: bionic
+      go: 1.21.x
      script:
-        - travis_wait 45 go run build/ci.go test $TEST_PACKAGES
+        - travis_wait 30 go run build/ci.go test $TEST_PACKAGES

    - stage: build
-      if: type = push
+      if: type = pull_request
      os: linux
-      dist: focal
-      go: 1.22.x
+      arch: arm64
+      dist: bionic
+      go: 1.20.x
      script:
-        - travis_wait 45 go run build/ci.go test $TEST_PACKAGES
+        - travis_wait 30 go run build/ci.go test $TEST_PACKAGES
+
+    - stage: build
+      os: linux
+      dist: bionic
+      go: 1.20.x
+      script:
+        - travis_wait 30 go run build/ci.go test $TEST_PACKAGES

    # This builder does the Ubuntu PPA nightly uploads
    - stage: build
      if: type = cron || (type = push && tag ~= /^v[0-9]/)
      os: linux
-      dist: focal
-      go: 1.23.x
+      dist: bionic
+      go: 1.21.x
      env:
        - ubuntu-ppa
      git:
        submodules: false # avoid cloning ethereum/tests
-      before_install:
-        - sudo -E apt-get -yq --no-install-suggests --no-install-recommends install devscripts debhelper dput fakeroot
+      addons:
+        apt:
+          packages:
+            - devscripts
+            - debhelper
+            - dput
+            - fakeroot
+            - python-bzrlib
+            - python-paramiko
      script:
        - echo '|1|7SiYPr9xl3uctzovOTj4gMwAC1M=|t6ReES75Bo/PxlOPJ6/GsGbTrM0= ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA0aKz5UTUndYgIGG7dQBV+HaeuEZJ2xPHo2DS2iSKvUL4xNMSAY4UguNW+pX56nAQmZKIZZ8MaEvSj6zMEDiq6HFfn5JcTlM80UwlnyKe8B8p7Nk06PPQLrnmQt5fh0HmEcZx+JU9TZsfCHPnX7MNz4ELfZE6cFsclClrKim3BHUIGq//t93DllB+h4O9LHjEUsQ1Sr63irDLSutkLJD6RXchjROXkNirlcNVHH/jwLWR5RcYilNX7S5bIkK8NlWPjsn/8Ua5O7I9/YoE97PpO6i73DTGLh5H9JN/SITwCKBkgSDWUt61uPK3Y11Gty7o2lWsBjhBUm2Y38CBsoGmBw==' >> ~/.ssh/known_hosts
        - go run build/ci.go debsrc -upload ethereum/ethereum -sftp-user geth-ci -signer "Go Ethereum Linux Builder <geth-ci@ethereum.org>"
@@ -117,8 +148,8 @@ jobs:
    - stage: build
      if: type = cron
      os: linux
-      dist: focal
-      go: 1.23.x
+      dist: bionic
+      go: 1.21.x
      env:
        - azure-purge
      git:
@@ -130,9 +161,8 @@ jobs:
    - stage: build
      if: type = cron
      os: linux
-      dist: focal
-      go: 1.23.x
-      env:
-        - racetests
+      dist: bionic
+      go: 1.21.x
      script:
-        - travis_wait 60 go run build/ci.go test -race $TEST_PACKAGES
+        - travis_wait 30 go run build/ci.go test  -race $TEST_PACKAGES
+
--- a/4
+++ b/4
@@ -4,7 +4,7 @@ ARG VERSION=""
 ARG BUILDNUM=""

 # Build Geth in a stock Go builder container
-FROM golang:1.23-alpine AS builder
+FROM golang:1.21-alpine as builder

 RUN apk add --no-cache gcc musl-dev linux-headers git

@@ -25,7 +25,7 @@ COPY --from=builder /go-ethereum/build/bin/geth /usr/local/bin/
 EXPOSE 8545 8546 30303 30303/udp
 ENTRYPOINT ["geth"]

-# Add some metadata labels to help programmatic image consumption
+# Add some metadata labels to help programatic image consumption
 ARG COMMIT=""
 ARG VERSION=""
 ARG BUILDNUM=""
--- a/Dockerfile.alltools
+++ b/Dockerfile.alltools
@@ -4,7 +4,7 @@ ARG VERSION=""
 ARG BUILDNUM=""

 # Build Geth in a stock Go builder container
-FROM golang:1.23-alpine AS builder
+FROM golang:1.21-alpine as builder

 RUN apk add --no-cache gcc musl-dev linux-headers git

@@ -14,13 +14,6 @@ COPY go.sum /go-ethereum/
 RUN cd /go-ethereum && go mod download

 ADD . /go-ethereum
-
-# This is not strictly necessary, but it matches the "Dockerfile" steps, thus
-# makes it so that under certain circumstances, the docker layer can be cached,
-# and the builder can jump to the next (build all) command, with the go cache fully loaded.
-#
-RUN cd /go-ethereum && go run build/ci.go install -static ./cmd/geth
-
 RUN cd /go-ethereum && go run build/ci.go install -static

 # Pull all binaries into a second stage deploy alpine container
@@ -31,7 +24,7 @@ COPY --from=builder /go-ethereum/build/bin/* /usr/local/bin/

 EXPOSE 8545 8546 30303 30303/udp

-# Add some metadata labels to help programmatic image consumption
+# Add some metadata labels to help programatic image consumption
 ARG COMMIT=""
 ARG VERSION=""
 ARG BUILDNUM=""
--- a/27
+++ b/27
@@ -2,35 +2,31 @@
 # with Go source code. If you know what GOPATH is then you probably
 # don't need to bother with make.

-.PHONY: geth all test lint fmt clean devtools help
+.PHONY: geth android ios evm all test clean

 GOBIN = ./build/bin
 GO ?= latest
 GORUN = go run

-#? geth: Build geth.
+#? geth: Build geth
 geth:
 	$(GORUN) build/ci.go install ./cmd/geth
 	@echo "Done building."
 	@echo "Run \"$(GOBIN)/geth\" to launch geth."

-#? all: Build all packages and executables.
+#? all: Build all packages and executables
 all:
 	$(GORUN) build/ci.go install

-#? test: Run the tests.
+#? test: Run the tests
 test: all
 	$(GORUN) build/ci.go test

-#? lint: Run certain pre-selected linters.
+#? lint: Run certain pre-selected linters
 lint: ## Run linters.
 	$(GORUN) build/ci.go lint

-#? fmt: Ensure consistent code formatting.
-fmt:
-	gofmt -s -w $(shell find . -name "*.go")
-
-#? clean: Clean go cache, built executables, and the auto generated folder.
+#? clean: Clean go cache, built executables, and the auto generated folder
 clean:
 	go clean -cache
 	rm -fr build/_workspace/pkg/ $(GOBIN)/*
@@ -38,20 +34,17 @@ clean:
 # The devtools target installs tools required for 'go generate'.
 # You need to put $GOBIN (or $GOPATH/bin) in your PATH to use 'go generate'.

-#? devtools: Install recommended developer tools.
+#? devtools: Install recommended developer tools
 devtools:
 	env GOBIN= go install golang.org/x/tools/cmd/stringer@latest
 	env GOBIN= go install github.com/fjl/gencodec@latest
-	env GOBIN= go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
+	env GOBIN= go install github.com/golang/protobuf/protoc-gen-go@latest
 	env GOBIN= go install ./cmd/abigen
 	@type "solc" 2> /dev/null || echo 'Please install solc'
 	@type "protoc" 2> /dev/null || echo 'Please install protoc'

 #? help: Get more info on make commands.
 help: Makefile
-	@echo ''
-	@echo 'Usage:'
-	@echo '  make [target]'
-	@echo ''
-	@echo 'Targets:'
+	@echo " Choose a command run in go-ethereum:"
 	@sed -n 's/^#?//p' $< | column -t -s ':' |  sort | sed -e 's/^/ /'
+.PHONY: help
--- a/README.md
+++ b/README.md
@@ -16,7 +16,7 @@ archives are published at https://geth.ethereum.org/downloads/.

 For prerequisites and detailed build instructions please read the [Installation Instructions](https://geth.ethereum.org/docs/getting-started/installing-geth).

-Building `geth` requires both a Go (version 1.22 or later) and a C compiler. You can install
+Building `geth` requires both a Go (version 1.19 or later) and a C compiler. You can install
 them using your favourite package manager. Once the dependencies are installed, run

 ```shell
@@ -89,7 +89,7 @@ This command will:
   This tool is optional and if you leave it out you can always attach it to an already running
   `geth` instance with `geth attach`.

-### A Full node on the Holesky test network
+### A Full node on the Görli test network

 Transitioning towards developers, if you'd like to play around with creating Ethereum
 contracts, you almost certainly would like to do that without any real money involved until
@@ -98,23 +98,23 @@ network, you want to join the **test** network with your node, which is fully eq
 the main network, but with play-Ether only.

 ```shell
-$ geth --holesky console
+$ geth --goerli console
 ```

 The `console` subcommand has the same meaning as above and is equally
 useful on the testnet too.

-Specifying the `--holesky` flag, however, will reconfigure your `geth` instance a bit:
+Specifying the `--goerli` flag, however, will reconfigure your `geth` instance a bit:

- * Instead of connecting to the main Ethereum network, the client will connect to the Holesky 
+ * Instead of connecting to the main Ethereum network, the client will connect to the Görli
   test network, which uses different P2P bootnodes, different network IDs and genesis
   states.
 * Instead of using the default data directory (`~/.ethereum` on Linux for example), `geth`
-   will nest itself one level deeper into a `holesky` subfolder (`~/.ethereum/holesky` on
+   will nest itself one level deeper into a `goerli` subfolder (`~/.ethereum/goerli` on
   Linux). Note, on OSX and Linux this also means that attaching to a running testnet node
   requires the use of a custom endpoint since `geth attach` will try to attach to a
   production node endpoint by default, e.g.,
-   `geth attach <datadir>/holesky/geth.ipc`. Windows users are not affected by
+   `geth attach <datadir>/goerli/geth.ipc`. Windows users are not affected by
   this.

 *Note: Although some internal protective measures prevent transactions from
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -29,69 +29,147 @@ Fingerprint: `AE96 ED96 9E47 9B00 84F3 E17F E88D 3334 FA5F 6A0A`

 ```
 -----BEGIN PGP PUBLIC KEY BLOCK-----
+Version: SKS 1.1.6
+Comment: Hostname: pgp.mit.edu

-mQINBFgl3tgBEAC8A1tUBkD9YV+eLrOmtgy+/JS/H9RoZvkg3K1WZ8IYfj6iIRaY
-neAk3Bp182GUPVz/zhKr2g0tMXIScDR3EnaDsY+Qg+JqQl8NOG+Cikr1nnkG2on9
-L8c8yiqry1ZTCmYMqCa2acTFqnyuXJ482aZNtB4QG2BpzfhW4k8YThpegk/EoRUi
-m+y7buJDtoNf7YILlhDQXN8qlHB02DWOVUihph9tUIFsPK6BvTr9SIr/eG6j6k0b
-fUo9pexOn7LS4SojoJmsm/5dp6AoKlac48cZU5zwR9AYcq/nvkrfmf2WkObg/xRd
-EvKZzn05jRopmAIwmoC3CiLmqCHPmT5a29vEob/yPFE335k+ujjZCPOu7OwjzDk7
-M0zMSfnNfDq8bXh16nn+ueBxJ0NzgD1oC6c2PhM+XRQCXChoyI8vbfp4dGvCvYqv
-QAE1bWjqnumZ/7vUPgZN6gDfiAzG2mUxC2SeFBhacgzDvtQls+uuvm+FnQOUgg2H
-h8x2zgoZ7kqV29wjaUPFREuew7e+Th5BxielnzOfVycVXeSuvvIn6cd3g/s8mX1c
-2kLSXJR7+KdWDrIrR5Az0kwAqFZt6B6QTlDrPswu3mxsm5TzMbny0PsbL/HBM+GZ
-EZCjMXxB8bqV2eSaktjnSlUNX1VXxyOxXA+ZG2jwpr51egi57riVRXokrQARAQAB
-tDRFdGhlcmV1bSBGb3VuZGF0aW9uIEJ1ZyBCb3VudHkgPGJvdW50eUBldGhlcmV1
-bS5vcmc+iQJVBBMBCAA/AhsDBgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgBYhBK6W
-7ZaeR5sAhPPhf+iNMzT6X2oKBQJl2LD9BQkRdTklAAoJEOiNMzT6X2oKYYYQALkV
-wJjWYoVoMuw9D1ybQo4Sqyp6D/XYHXSpqZDO9RlADQisYBfuO7EW75evgZ+54Ajc
-8gZ2BUkFcSR9z2t0TEkUyjmPDZsaElTTP2Boa2GG5pyziEM6t1cMMY1sP1aotx9H
-DYwCeMmDv0wTMi6v0C6+/in2hBxbGALRbQKWKd/5ss4OEPe37hG9zAJcBYZg2tes
-O7ceg7LHZpNC1zvMUrBY6os74FJ437f8bankqvVE83/dvTcCDhMsei9LiWS2uo26
-qiyqeR9lZEj8W5F6UgkQH+UOhamJ9UB3N/h//ipKrwtiv0+jQm9oNG7aIAi3UJgD
-CvSod87H0l7/U8RWzyam/r8eh4KFM75hIVtqEy5jFV2z7x2SibXQi7WRfAysjFLp
-/li8ff6kLDR9IMATuMSF7Ol0O9JMRfSPjRZRtVOwYVIBla3BhfMrjvMMcZMAy/qS
-DWx2iFYDMGsswv7hp3lsFOaa1ju95ClZZk3q/z7u5gH7LFAxR0jPaW48ay3CFylW
-sDpQpO1DWb9uXBdhOU+MN18uSjqzocga3Wz2C8jhWRvxyFf3SNIybm3zk6W6IIoy
-6KmwSRZ30oxizy6zMYw1qJE89zjjumzlZAm0R/Q4Ui+WJhlSyrYbqzqdxYuLgdEL
-lgKfbv9/t8tNXGGSuCe5L7quOv9k7l2+QmLlg+SJtDlFdGhlcmV1bSBGb3VuZGF0
-aW9uIFNlY3VyaXR5IFRlYW0gPHNlY3VyaXR5QGV0aGVyZXVtLm9yZz6JAlUEEwEI
-AD8CGwMGCwkIBwMCBhUIAgkKCwQWAgMBAh4BAheAFiEErpbtlp5HmwCE8+F/6I0z
-NPpfagoFAmXYsP4FCRF1OSUACgkQ6I0zNPpfagoUGA/+LVzXUJrsfi8+ADMF1hru
-wFDcY1r+vM4Ovbk1NhCc/DnV5VG40j5FiQpE81BNiH59sYeZkQm9jFbwevK7Zpuq
-RZaG2WGiwU/11xrt5/Qjq7T+vEtd94546kFcBnP8uexZqP4dTi4LHa2on8aRbwzN
-7RjCpCQhy1TUuk47dyOR1y3ZHrpTwkHpuhwgffaWtxgSyCMYz7fsd5Ukh3eE+Ani
-90CIUieve2U3o+WPxBD9PRaIPg6LmBhfGxGvC/6tqY9W3Z9xEOVDxC4wdYppQzsg
-Pg7bNnVmlFWHsEk8FuMfY8nTqY3/ojhJxikWKz2V3Y2AbsLEXCvrEg6b4FvmsS97
-8ifEBbFXU8hvMSpMLtO7vLamWyOHq41IXWH6HLNLhDfDzTfpAJ8iYDKGj72YsMzF
-0fIjPa6mniMB2RmREAM0Jas3M/6DUw1EzwK1iQofIBoCRPIkR5mxmzjcRB6tVdQa
-on20/9YTKKBUQAdK0OWW8j1euuULDgNdkN2LBXdQLy/JcQiggU8kOCKL/Lmj5HWP
-FNT9rYfnjmCuux3UfJGfhPryujEA0CdIfq1Qf4ldOVzpWYjsMn+yQxAQTorAzF3z
-iYddP2cw/Nvookay8xywKJnDsaRaWqdQ8Ceox3qSB4LCjQRNR5c3HfvGm3EBdEyI
-zEEpjZ6GHa05DCajqKjtjlm5Ag0EWCXe2AEQAJuCrodM3mAQGLSWQP8xp8ieY2L7
-n1TmBEZiqTjpaV9GOEe51eMOmAPSWiUZviFiie2QxopGUKDZG+CO+Tdm97Q8paMr
-DuCvxgFr18wVjwGEBcjfY53Ij2sWHERkV9YB/ApWZPX0F14BBEW9x937zDx/VdVz
-7N11QswkUFOv7EoOUhFbBOR0s9B5ZuOjR4eX+Di24uIutPFVuePbpt/7b7UNsz/D
-lVq/M+uS+Ieq8p79A/+BrLhANWJa8WAtv3SJ18Ach2w+B+WnRUNLmtUcUvoPvetJ
-F0hGjcjxzyZig2NJHhcO6+A6QApb0tHem+i4UceOnoWvQZ6xFuttvYQbrqI+xH30
-xDsWogv1Uwc+baa1H5e9ucqQfatjISpoxtJ2Tb2MZqmQBaV7iwiFIqTvj0Di0aQe
-XTwpnY32joat9R6E/9XZ4ktqmHYOKgUvUfFGvKsrLzRBAoswlF6TGKCryCt5bzEH
-jO5/0yS6i75Ec2ajw95seMWy0uKCIPr/M/Z77i1SatPT8lMY5KGgYyXxG3RVHF08
-iYq6f7gs5dt87ECs5KRjqLfn6CyCSRLLWBMkTQFjdL1q5Pr5iuCVj9NY9D0gnFZU
-4qVP7dYinnAm7ZsEpDjbRUuoNjOShbK16X9szUAJS2KkyIhV5Sza4WJGOnMDVbLR
-Aco9N1K4aUk9Gt9xABEBAAGJAjwEGAEIACYCGwwWIQSulu2WnkebAITz4X/ojTM0
-+l9qCgUCZdiwoAUJEXU4yAAKCRDojTM0+l9qCj2PD/9pbIPRMZtvKIIE+OhOAl/s
-qfZJXByAM40ELpUhDHqwbOplIEyvXtWfQ5c+kWlG/LPJ2CgLkHyFQDn6tuat82rH
-/5VoZyxp16CBAwEgYdycOr9hMGSVKNIJDfV9Bu6VtZnn6fa/swBzGE7eVpXsIoNr
-jeqsogBtzLecG1oHMXRMq7oUqu9c6VNoCx2uxRUOeWW8YuP7h9j6mxIuKKbcpmQ5
-RSLNEhJZJsMMFLf8RAQPXmshG1ZixY2ZliNe/TTm6eEfFCw0KcQxoX9LmurLWE9w
-dIKgn1/nQ04GFnmtcq3hVxY/m9BvzY1jmZXNd4TdpfrPXhi0W/GDn53ERFPJmw5L
-F8ogxzD/ekxzyd9nCCgtzkamtBKDJk35x/MoVWMLjD5k6P+yW7YY4xMQliSJHKss
-leLnaPpgDBi4KPtLxPswgFqObcy4TNse07rFO4AyHf11FBwMTEfuODCOMnQTpi3z
-Zx6KxvS3BEY36abjvwrqsmt8dJ/+/QXT0e82fo2kJ65sXIszez3e0VUZ8KrMp+wd
-X0GWYWAfqXws6HrQFYfIpEE0Vz9gXDxEOTFZ2FoVIvIHyRfyDrAIz3wZLmnLGk1h
-l3CDjHF0Wigv0CacIQ1V1aYp3NhIVwAvShQ+qS5nFgik6UZnjjWibobOm3yQDzll
-6F7hEeTW+gnXEI2gPjfb5w==
-=b5eA
-----END PGP PUBLIC KEY BLOCK-----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=
+=arte
+-----END PGP PUBLIC KEY BLOCK------
 ```
--- a/accounts/abi/abi_test.go
+++ b/accounts/abi/abi_test.go
@@ -1199,6 +1199,7 @@ func TestUnpackRevert(t *testing.T) {
 		{"4e487b7100000000000000000000000000000000000000000000000000000000000000ff", "unknown panic code: 0xff", nil},
 	}
 	for index, c := range cases {
+		index, c := index, c
 		t.Run(fmt.Sprintf("case %d", index), func(t *testing.T) {
 			t.Parallel()
 			got, err := UnpackRevert(common.Hex2Bytes(c.input))
@@ -1217,10 +1218,3 @@ func TestUnpackRevert(t *testing.T) {
 		})
 	}
 }
-
-func TestInternalContractType(t *testing.T) {
-	jsonData := `[{"inputs":[{"components":[{"internalType":"uint256","name":"dailyLimit","type":"uint256"},{"internalType":"uint256","name":"txLimit","type":"uint256"},{"internalType":"uint256","name":"accountDailyLimit","type":"uint256"},{"internalType":"uint256","name":"minAmount","type":"uint256"},{"internalType":"bool","name":"onlyWhitelisted","type":"bool"}],"internalType":"struct IMessagePassingBridge.BridgeLimits","name":"bridgeLimits","type":"tuple"},{"components":[{"internalType":"uint256","name":"lastTransferReset","type":"uint256"},{"internalType":"uint256","name":"bridged24Hours","type":"uint256"}],"internalType":"struct IMessagePassingBridge.AccountLimit","name":"accountDailyLimit","type":"tuple"},{"components":[{"internalType":"uint256","name":"lastTransferReset","type":"uint256"},{"internalType":"uint256","name":"bridged24Hours","type":"uint256"}],"internalType":"struct IMessagePassingBridge.BridgeDailyLimit","name":"bridgeDailyLimit","type":"tuple"},{"internalType":"contract INameService","name":"nameService","type":"INameService"},{"internalType":"bool","name":"isClosed","type":"bool"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"canBridge","outputs":[{"internalType":"bool","name":"isWithinLimit","type":"bool"},{"internalType":"string","name":"error","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint8","name":"decimals","type":"uint8"}],"name":"normalizeFrom18ToTokenDecimals","outputs":[{"internalType":"uint256","name":"normalized","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint8","name":"decimals","type":"uint8"}],"name":"normalizeFromTokenTo18Decimals","outputs":[{"internalType":"uint256","name":"normalized","type":"uint256"}],"stateMutability":"pure","type":"function"}]`
-	if _, err := JSON(strings.NewReader(jsonData)); err != nil {
-		t.Fatal(err)
-	}
-}
--- a/accounts/abi/argument.go
+++ b/accounts/abi/argument.go
@@ -127,7 +127,7 @@ func (arguments Arguments) Copy(v interface{}, values []interface{}) error {
 	return arguments.copyAtomic(v, values[0])
 }

-// copyAtomic copies ( hexdata -> go ) a single value
+// unpackAtomic unpacks ( hexdata -> go ) a single value
 func (arguments Arguments) copyAtomic(v interface{}, marshalledValues interface{}) error {
 	dst := reflect.ValueOf(v).Elem()
 	src := reflect.ValueOf(marshalledValues)
--- a/accounts/abi/bind/auth.go
+++ b/accounts/abi/bind/auth.go
@@ -142,10 +142,10 @@ func NewKeyStoreTransactorWithChainID(keystore *keystore.KeyStore, account accou
 // NewKeyedTransactorWithChainID is a utility method to easily create a transaction signer
 // from a single private key.
 func NewKeyedTransactorWithChainID(key *ecdsa.PrivateKey, chainID *big.Int) (*TransactOpts, error) {
+	keyAddr := crypto.PubkeyToAddress(key.PublicKey)
 	if chainID == nil {
 		return nil, ErrNoChainID
 	}
-	keyAddr := crypto.PubkeyToAddress(key.PublicKey)
 	signer := types.LatestSignerForChainID(chainID)
 	return &TransactOpts{
 		From: keyAddr,
--- a/accounts/abi/bind/base.go
+++ b/accounts/abi/bind/base.go
@@ -64,7 +64,6 @@ type TransactOpts struct {
 	GasFeeCap *big.Int // Gas fee cap to use for the 1559 transaction execution (nil = gas price oracle)
 	GasTipCap *big.Int // Gas priority fee cap to use for the 1559 transaction execution (nil = gas price oracle)
 	GasLimit  uint64   // Gas limit to set for the transaction execution (0 = estimate)
-	AccessList types.AccessList // Access list to set for the transaction execution (nil = no access list)

 	Context context.Context // Network context to support cancellation and timeouts (nil = no timeout)

@@ -308,14 +307,13 @@ func (c *BoundContract) createDynamicTx(opts *TransactOpts, contract *common.Add
 		Gas:       gasLimit,
 		Value:     value,
 		Data:      input,
-		AccessList: opts.AccessList,
 	}
 	return types.NewTx(baseTx), nil
 }

 func (c *BoundContract) createLegacyTx(opts *TransactOpts, contract *common.Address, input []byte) (*types.Transaction, error) {
-	if opts.GasFeeCap != nil || opts.GasTipCap != nil || opts.AccessList != nil {
-		return nil, errors.New("maxFeePerGas or maxPriorityFeePerGas or accessList specified but london is not active yet")
+	if opts.GasFeeCap != nil || opts.GasTipCap != nil {
+		return nil, errors.New("maxFeePerGas or maxPriorityFeePerGas specified but london is not active yet")
 	}
 	// Normalize value
 	value := opts.Value
@@ -463,7 +461,7 @@ func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]int
 	if err != nil {
 		return nil, nil, err
 	}
-	sub := event.NewSubscription(func(quit <-chan struct{}) error {
+	sub, err := event.NewSubscription(func(quit <-chan struct{}) error {
 		for _, log := range buff {
 			select {
 			case logs <- log:
@@ -472,8 +470,11 @@ func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]int
 			}
 		}
 		return nil
-	})
+	}), nil

+	if err != nil {
+		return nil, nil, err
+	}
 	return logs, sub, nil
 }

--- a/accounts/abi/bind/bind.go
+++ b/accounts/abi/bind/bind.go
@@ -252,7 +252,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 		}
 		// Parse library references.
 		for pattern, name := range libs {
-			matched, err := regexp.MatchString("__\\$"+pattern+"\\$__", contracts[types[i]].InputBin)
+			matched, err := regexp.Match("__\\$"+pattern+"\\$__", []byte(contracts[types[i]].InputBin))
 			if err != nil {
 				log.Error("Could not search for pattern", "pattern", pattern, "contract", contracts[types[i]], "err", err)
 			}
--- a/accounts/abi/bind/source.go.tpl
+++ b/accounts/abi/bind/source.go.tpl
@@ -1,487 +0,0 @@
-// Code generated - DO NOT EDIT.
-// This file is a generated binding and any manual changes will be lost.
-
-package {{.Package}}
-
-import (
-	"math/big"
-	"strings"
-	"errors"
-
-	ethereum "github.com/ethereum/go-ethereum"
-	"github.com/ethereum/go-ethereum/accounts/abi"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/event"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var (
-	_ = errors.New
-	_ = big.NewInt
-	_ = strings.NewReader
-	_ = ethereum.NotFound
-	_ = bind.Bind
-	_ = common.Big1
-	_ = types.BloomLookup
-	_ = event.NewSubscription
-	_ = abi.ConvertType
-)
-
-{{$structs := .Structs}}
-{{range $structs}}
-	// {{.Name}} is an auto generated low-level Go binding around an user-defined struct.
-	type {{.Name}} struct {
-	{{range $field := .Fields}}
-	{{$field.Name}} {{$field.Type}}{{end}}
-	}
-{{end}}
-
-{{range $contract := .Contracts}}
-	// {{.Type}}MetaData contains all meta data concerning the {{.Type}} contract.
-	var {{.Type}}MetaData = &bind.MetaData{
-		ABI: "{{.InputABI}}",
-		{{if $contract.FuncSigs -}}
-		Sigs: map[string]string{
-			{{range $strsig, $binsig := .FuncSigs}}"{{$binsig}}": "{{$strsig}}",
-			{{end}}
-		},
-		{{end -}}
-		{{if .InputBin -}}
-		Bin: "0x{{.InputBin}}",
-		{{end}}
-	}
-	// {{.Type}}ABI is the input ABI used to generate the binding from.
-	// Deprecated: Use {{.Type}}MetaData.ABI instead.
-	var {{.Type}}ABI = {{.Type}}MetaData.ABI
-
-	{{if $contract.FuncSigs}}
-		// Deprecated: Use {{.Type}}MetaData.Sigs instead.
-		// {{.Type}}FuncSigs maps the 4-byte function signature to its string representation.
-		var {{.Type}}FuncSigs = {{.Type}}MetaData.Sigs
-	{{end}}
-
-	{{if .InputBin}}
-		// {{.Type}}Bin is the compiled bytecode used for deploying new contracts.
-		// Deprecated: Use {{.Type}}MetaData.Bin instead.
-		var {{.Type}}Bin = {{.Type}}MetaData.Bin
-
-		// Deploy{{.Type}} deploys a new Ethereum contract, binding an instance of {{.Type}} to it.
-		func Deploy{{.Type}}(auth *bind.TransactOpts, backend bind.ContractBackend {{range .Constructor.Inputs}}, {{.Name}} {{bindtype .Type $structs}}{{end}}) (common.Address, *types.Transaction, *{{.Type}}, error) {
-		  parsed, err := {{.Type}}MetaData.GetAbi()
-		  if err != nil {
-		    return common.Address{}, nil, nil, err
-		  }
-		  if parsed == nil {
-			return common.Address{}, nil, nil, errors.New("GetABI returned nil")
-		  }
-		  {{range $pattern, $name := .Libraries}}
-			{{decapitalise $name}}Addr, _, _, _ := Deploy{{capitalise $name}}(auth, backend)
-			{{$contract.Type}}Bin = strings.ReplaceAll({{$contract.Type}}Bin, "__${{$pattern}}$__", {{decapitalise $name}}Addr.String()[2:])
-		  {{end}}
-		  address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex({{.Type}}Bin), backend {{range .Constructor.Inputs}}, {{.Name}}{{end}})
-		  if err != nil {
-		    return common.Address{}, nil, nil, err
-		  }
-		  return address, tx, &{{.Type}}{ {{.Type}}Caller: {{.Type}}Caller{contract: contract}, {{.Type}}Transactor: {{.Type}}Transactor{contract: contract}, {{.Type}}Filterer: {{.Type}}Filterer{contract: contract} }, nil
-		}
-	{{end}}
-
-	// {{.Type}} is an auto generated Go binding around an Ethereum contract.
-	type {{.Type}} struct {
-	  {{.Type}}Caller     // Read-only binding to the contract
-	  {{.Type}}Transactor // Write-only binding to the contract
-	  {{.Type}}Filterer   // Log filterer for contract events
-	}
-
-	// {{.Type}}Caller is an auto generated read-only Go binding around an Ethereum contract.
-	type {{.Type}}Caller struct {
-	  contract *bind.BoundContract // Generic contract wrapper for the low level calls
-	}
-
-	// {{.Type}}Transactor is an auto generated write-only Go binding around an Ethereum contract.
-	type {{.Type}}Transactor struct {
-	  contract *bind.BoundContract // Generic contract wrapper for the low level calls
-	}
-
-	// {{.Type}}Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
-	type {{.Type}}Filterer struct {
-	  contract *bind.BoundContract // Generic contract wrapper for the low level calls
-	}
-
-	// {{.Type}}Session is an auto generated Go binding around an Ethereum contract,
-	// with pre-set call and transact options.
-	type {{.Type}}Session struct {
-	  Contract     *{{.Type}}        // Generic contract binding to set the session for
-	  CallOpts     bind.CallOpts     // Call options to use throughout this session
-	  TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
-	}
-
-	// {{.Type}}CallerSession is an auto generated read-only Go binding around an Ethereum contract,
-	// with pre-set call options.
-	type {{.Type}}CallerSession struct {
-	  Contract *{{.Type}}Caller // Generic contract caller binding to set the session for
-	  CallOpts bind.CallOpts    // Call options to use throughout this session
-	}
-
-	// {{.Type}}TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
-	// with pre-set transact options.
-	type {{.Type}}TransactorSession struct {
-	  Contract     *{{.Type}}Transactor // Generic contract transactor binding to set the session for
-	  TransactOpts bind.TransactOpts    // Transaction auth options to use throughout this session
-	}
-
-	// {{.Type}}Raw is an auto generated low-level Go binding around an Ethereum contract.
-	type {{.Type}}Raw struct {
-	  Contract *{{.Type}} // Generic contract binding to access the raw methods on
-	}
-
-	// {{.Type}}CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
-	type {{.Type}}CallerRaw struct {
-		Contract *{{.Type}}Caller // Generic read-only contract binding to access the raw methods on
-	}
-
-	// {{.Type}}TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
-	type {{.Type}}TransactorRaw struct {
-		Contract *{{.Type}}Transactor // Generic write-only contract binding to access the raw methods on
-	}
-
-	// New{{.Type}} creates a new instance of {{.Type}}, bound to a specific deployed contract.
-	func New{{.Type}}(address common.Address, backend bind.ContractBackend) (*{{.Type}}, error) {
-	  contract, err := bind{{.Type}}(address, backend, backend, backend)
-	  if err != nil {
-	    return nil, err
-	  }
-	  return &{{.Type}}{ {{.Type}}Caller: {{.Type}}Caller{contract: contract}, {{.Type}}Transactor: {{.Type}}Transactor{contract: contract}, {{.Type}}Filterer: {{.Type}}Filterer{contract: contract} }, nil
-	}
-
-	// New{{.Type}}Caller creates a new read-only instance of {{.Type}}, bound to a specific deployed contract.
-	func New{{.Type}}Caller(address common.Address, caller bind.ContractCaller) (*{{.Type}}Caller, error) {
-	  contract, err := bind{{.Type}}(address, caller, nil, nil)
-	  if err != nil {
-	    return nil, err
-	  }
-	  return &{{.Type}}Caller{contract: contract}, nil
-	}
-
-	// New{{.Type}}Transactor creates a new write-only instance of {{.Type}}, bound to a specific deployed contract.
-	func New{{.Type}}Transactor(address common.Address, transactor bind.ContractTransactor) (*{{.Type}}Transactor, error) {
-	  contract, err := bind{{.Type}}(address, nil, transactor, nil)
-	  if err != nil {
-	    return nil, err
-	  }
-	  return &{{.Type}}Transactor{contract: contract}, nil
-	}
-
-	// New{{.Type}}Filterer creates a new log filterer instance of {{.Type}}, bound to a specific deployed contract.
- 	func New{{.Type}}Filterer(address common.Address, filterer bind.ContractFilterer) (*{{.Type}}Filterer, error) {
- 	  contract, err := bind{{.Type}}(address, nil, nil, filterer)
- 	  if err != nil {
- 	    return nil, err
- 	  }
- 	  return &{{.Type}}Filterer{contract: contract}, nil
- 	}
-
-	// bind{{.Type}} binds a generic wrapper to an already deployed contract.
-	func bind{{.Type}}(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
-	  parsed, err := {{.Type}}MetaData.GetAbi()
-	  if err != nil {
-	    return nil, err
-	  }
-	  return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil
-	}
-
-	// Call invokes the (constant) contract method with params as input values and
-	// sets the output to result. The result type might be a single field for simple
-	// returns, a slice of interfaces for anonymous returns and a struct for named
-	// returns.
-	func (_{{$contract.Type}} *{{$contract.Type}}Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
-		return _{{$contract.Type}}.Contract.{{$contract.Type}}Caller.contract.Call(opts, result, method, params...)
-	}
-
-	// Transfer initiates a plain transaction to move funds to the contract, calling
-	// its default method if one is available.
-	func (_{{$contract.Type}} *{{$contract.Type}}Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-		return _{{$contract.Type}}.Contract.{{$contract.Type}}Transactor.contract.Transfer(opts)
-	}
-
-	// Transact invokes the (paid) contract method with params as input values.
-	func (_{{$contract.Type}} *{{$contract.Type}}Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-		return _{{$contract.Type}}.Contract.{{$contract.Type}}Transactor.contract.Transact(opts, method, params...)
-	}
-
-	// Call invokes the (constant) contract method with params as input values and
-	// sets the output to result. The result type might be a single field for simple
-	// returns, a slice of interfaces for anonymous returns and a struct for named
-	// returns.
-	func (_{{$contract.Type}} *{{$contract.Type}}CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
-		return _{{$contract.Type}}.Contract.contract.Call(opts, result, method, params...)
-	}
-
-	// Transfer initiates a plain transaction to move funds to the contract, calling
-	// its default method if one is available.
-	func (_{{$contract.Type}} *{{$contract.Type}}TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-		return _{{$contract.Type}}.Contract.contract.Transfer(opts)
-	}
-
-	// Transact invokes the (paid) contract method with params as input values.
-	func (_{{$contract.Type}} *{{$contract.Type}}TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-		return _{{$contract.Type}}.Contract.contract.Transact(opts, method, params...)
-	}
-
-	{{range .Calls}}
-		// {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}.
-		//
-		// Solidity: {{.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Caller) {{.Normalized.Name}}(opts *bind.CallOpts {{range .Normalized.Inputs}}, {{.Name}} {{bindtype .Type $structs}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} },{{else}}{{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}}{{end}} error) {
-			var out []interface{}
-			err := _{{$contract.Type}}.contract.Call(opts, &out, "{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}})
-			{{if .Structured}}
-			outstruct := new(struct{ {{range .Normalized.Outputs}} {{.Name}} {{bindtype .Type $structs}}; {{end}} })
-			if err != nil {
-				return *outstruct, err
-			}
-			{{range $i, $t := .Normalized.Outputs}}
-			outstruct.{{.Name}} = *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}}
-
-			return *outstruct, err
-			{{else}}
-			if err != nil {
-				return {{range $i, $_ := .Normalized.Outputs}}*new({{bindtype .Type $structs}}), {{end}} err
-			}
-			{{range $i, $t := .Normalized.Outputs}}
-			out{{$i}} := *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}}
-
-			return {{range $i, $t := .Normalized.Outputs}}out{{$i}}, {{end}} err
-			{{end}}
-		}
-
-		// {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}.
-		//
-		// Solidity: {{.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Session) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} }, {{else}} {{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}} {{end}} error) {
-		  return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.CallOpts {{range .Normalized.Inputs}}, {{.Name}}{{end}})
-		}
-
-		// {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}.
-		//
-		// Solidity: {{.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}CallerSession) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} }, {{else}} {{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}} {{end}} error) {
-		  return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.CallOpts {{range .Normalized.Inputs}}, {{.Name}}{{end}})
-		}
-	{{end}}
-
-	{{range .Transacts}}
-		// {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}.
-		//
-		// Solidity: {{.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Transactor) {{.Normalized.Name}}(opts *bind.TransactOpts {{range .Normalized.Inputs}}, {{.Name}} {{bindtype .Type $structs}} {{end}}) (*types.Transaction, error) {
-			return _{{$contract.Type}}.contract.Transact(opts, "{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}})
-		}
-
-		// {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}.
-		//
-		// Solidity: {{.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Session) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) (*types.Transaction, error) {
-		  return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.TransactOpts {{range $i, $_ := .Normalized.Inputs}}, {{.Name}}{{end}})
-		}
-
-		// {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}.
-		//
-		// Solidity: {{.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}TransactorSession) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) (*types.Transaction, error) {
-		  return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.TransactOpts {{range $i, $_ := .Normalized.Inputs}}, {{.Name}}{{end}})
-		}
-	{{end}}
-
-	{{if .Fallback}}
-		// Fallback is a paid mutator transaction binding the contract fallback function.
-		//
-		// Solidity: {{.Fallback.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Transactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error) {
-			return _{{$contract.Type}}.contract.RawTransact(opts, calldata)
-		}
-
-		// Fallback is a paid mutator transaction binding the contract fallback function.
-		//
-		// Solidity: {{.Fallback.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Session) Fallback(calldata []byte) (*types.Transaction, error) {
-		  return _{{$contract.Type}}.Contract.Fallback(&_{{$contract.Type}}.TransactOpts, calldata)
-		}
-
-		// Fallback is a paid mutator transaction binding the contract fallback function.
-		//
-		// Solidity: {{.Fallback.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}TransactorSession) Fallback(calldata []byte) (*types.Transaction, error) {
-		  return _{{$contract.Type}}.Contract.Fallback(&_{{$contract.Type}}.TransactOpts, calldata)
-		}
-	{{end}}
-
-	{{if .Receive}}
-		// Receive is a paid mutator transaction binding the contract receive function.
-		//
-		// Solidity: {{.Receive.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Transactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error) {
-			return _{{$contract.Type}}.contract.RawTransact(opts, nil) // calldata is disallowed for receive function
-		}
-
-		// Receive is a paid mutator transaction binding the contract receive function.
-		//
-		// Solidity: {{.Receive.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Session) Receive() (*types.Transaction, error) {
-		  return _{{$contract.Type}}.Contract.Receive(&_{{$contract.Type}}.TransactOpts)
-		}
-
-		// Receive is a paid mutator transaction binding the contract receive function.
-		//
-		// Solidity: {{.Receive.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}TransactorSession) Receive() (*types.Transaction, error) {
-		  return _{{$contract.Type}}.Contract.Receive(&_{{$contract.Type}}.TransactOpts)
-		}
-	{{end}}
-
-	{{range .Events}}
-		// {{$contract.Type}}{{.Normalized.Name}}Iterator is returned from Filter{{.Normalized.Name}} and is used to iterate over the raw logs and unpacked data for {{.Normalized.Name}} events raised by the {{$contract.Type}} contract.
-		type {{$contract.Type}}{{.Normalized.Name}}Iterator struct {
-			Event *{{$contract.Type}}{{.Normalized.Name}} // Event containing the contract specifics and raw log
-
-			contract *bind.BoundContract // Generic contract to use for unpacking event data
-			event    string              // Event name to use for unpacking event data
-
-			logs chan types.Log        // Log channel receiving the found contract events
-			sub  ethereum.Subscription // Subscription for errors, completion and termination
-			done bool                  // Whether the subscription completed delivering logs
-			fail error                 // Occurred error to stop iteration
-		}
-		// Next advances the iterator to the subsequent event, returning whether there
-		// are any more events found. In case of a retrieval or parsing error, false is
-		// returned and Error() can be queried for the exact failure.
-		func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Next() bool {
-			// If the iterator failed, stop iterating
-			if (it.fail != nil) {
-				return false
-			}
-			// If the iterator completed, deliver directly whatever's available
-			if (it.done) {
-				select {
-				case log := <-it.logs:
-					it.Event = new({{$contract.Type}}{{.Normalized.Name}})
-					if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
-						it.fail = err
-						return false
-					}
-					it.Event.Raw = log
-					return true
-
-				default:
-					return false
-				}
-			}
-			// Iterator still in progress, wait for either a data or an error event
-			select {
-			case log := <-it.logs:
-				it.Event = new({{$contract.Type}}{{.Normalized.Name}})
-				if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
-					it.fail = err
-					return false
-				}
-				it.Event.Raw = log
-				return true
-
-			case err := <-it.sub.Err():
-				it.done = true
-				it.fail = err
-				return it.Next()
-			}
-		}
-		// Error returns any retrieval or parsing error occurred during filtering.
-		func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Error() error {
-			return it.fail
-		}
-		// Close terminates the iteration process, releasing any pending underlying
-		// resources.
-		func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Close() error {
-			it.sub.Unsubscribe()
-			return nil
-		}
-
-		// {{$contract.Type}}{{.Normalized.Name}} represents a {{.Normalized.Name}} event raised by the {{$contract.Type}} contract.
-		type {{$contract.Type}}{{.Normalized.Name}} struct { {{range .Normalized.Inputs}}
-			{{capitalise .Name}} {{if .Indexed}}{{bindtopictype .Type $structs}}{{else}}{{bindtype .Type $structs}}{{end}}; {{end}}
-			Raw types.Log // Blockchain specific contextual infos
-		}
-
-		// Filter{{.Normalized.Name}} is a free log retrieval operation binding the contract event 0x{{printf "%x" .Original.ID}}.
-		//
-		// Solidity: {{.Original.String}}
- 		func (_{{$contract.Type}} *{{$contract.Type}}Filterer) Filter{{.Normalized.Name}}(opts *bind.FilterOpts{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}} []{{bindtype .Type $structs}}{{end}}{{end}}) (*{{$contract.Type}}{{.Normalized.Name}}Iterator, error) {
-			{{range .Normalized.Inputs}}
-			{{if .Indexed}}var {{.Name}}Rule []interface{}
-			for _, {{.Name}}Item := range {{.Name}} {
-				{{.Name}}Rule = append({{.Name}}Rule, {{.Name}}Item)
-			}{{end}}{{end}}
-
-			logs, sub, err := _{{$contract.Type}}.contract.FilterLogs(opts, "{{.Original.Name}}"{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}}Rule{{end}}{{end}})
-			if err != nil {
-				return nil, err
-			}
-			return &{{$contract.Type}}{{.Normalized.Name}}Iterator{contract: _{{$contract.Type}}.contract, event: "{{.Original.Name}}", logs: logs, sub: sub}, nil
- 		}
-
-		// Watch{{.Normalized.Name}} is a free log subscription operation binding the contract event 0x{{printf "%x" .Original.ID}}.
-		//
-		// Solidity: {{.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Filterer) Watch{{.Normalized.Name}}(opts *bind.WatchOpts, sink chan<- *{{$contract.Type}}{{.Normalized.Name}}{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}} []{{bindtype .Type $structs}}{{end}}{{end}}) (event.Subscription, error) {
-			{{range .Normalized.Inputs}}
-			{{if .Indexed}}var {{.Name}}Rule []interface{}
-			for _, {{.Name}}Item := range {{.Name}} {
-				{{.Name}}Rule = append({{.Name}}Rule, {{.Name}}Item)
-			}{{end}}{{end}}
-
-			logs, sub, err := _{{$contract.Type}}.contract.WatchLogs(opts, "{{.Original.Name}}"{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}}Rule{{end}}{{end}})
-			if err != nil {
-				return nil, err
-			}
-			return event.NewSubscription(func(quit <-chan struct{}) error {
-				defer sub.Unsubscribe()
-				for {
-					select {
-					case log := <-logs:
-						// New log arrived, parse the event and forward to the user
-						event := new({{$contract.Type}}{{.Normalized.Name}})
-						if err := _{{$contract.Type}}.contract.UnpackLog(event, "{{.Original.Name}}", log); err != nil {
-							return err
-						}
-						event.Raw = log
-
-						select {
-						case sink <- event:
-						case err := <-sub.Err():
-							return err
-						case <-quit:
-							return nil
-						}
-					case err := <-sub.Err():
-						return err
-					case <-quit:
-						return nil
-					}
-				}
-			}), nil
-		}
-
-		// Parse{{.Normalized.Name}} is a log parse operation binding the contract event 0x{{printf "%x" .Original.ID}}.
-		//
-		// Solidity: {{.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Filterer) Parse{{.Normalized.Name}}(log types.Log) (*{{$contract.Type}}{{.Normalized.Name}}, error) {
-			event := new({{$contract.Type}}{{.Normalized.Name}})
-			if err := _{{$contract.Type}}.contract.UnpackLog(event, "{{.Original.Name}}", log); err != nil {
-				return nil, err
-			}
-			event.Raw = log
-			return event, nil
-		}
-
- 	{{end}}
-{{end}}
--- a/accounts/abi/bind/template.go
+++ b/accounts/abi/bind/template.go
@@ -16,11 +16,7 @@

 package bind

-import (
-	_ "embed"
-
-	"github.com/ethereum/go-ethereum/accounts/abi"
-)
+import "github.com/ethereum/go-ethereum/accounts/abi"

 // tmplData is the data structure required to fill the binding template.
 type tmplData struct {
@@ -84,6 +80,492 @@ var tmplSource = map[Lang]string{

 // tmplSourceGo is the Go source template that the generated Go contract binding
 // is based on.
-//
-//go:embed source.go.tpl
-var tmplSourceGo string
+const tmplSourceGo = `
+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+
+package {{.Package}}
+
+import (
+	"math/big"
+	"strings"
+	"errors"
+
+	ethereum "github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/event"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var (
+	_ = errors.New
+	_ = big.NewInt
+	_ = strings.NewReader
+	_ = ethereum.NotFound
+	_ = bind.Bind
+	_ = common.Big1
+	_ = types.BloomLookup
+	_ = event.NewSubscription
+	_ = abi.ConvertType
+)
+
+{{$structs := .Structs}}
+{{range $structs}}
+	// {{.Name}} is an auto generated low-level Go binding around an user-defined struct.
+	type {{.Name}} struct {
+	{{range $field := .Fields}}
+	{{$field.Name}} {{$field.Type}}{{end}}
+	}
+{{end}}
+
+{{range $contract := .Contracts}}
+	// {{.Type}}MetaData contains all meta data concerning the {{.Type}} contract.
+	var {{.Type}}MetaData = &bind.MetaData{
+		ABI: "{{.InputABI}}",
+		{{if $contract.FuncSigs -}}
+		Sigs: map[string]string{
+			{{range $strsig, $binsig := .FuncSigs}}"{{$binsig}}": "{{$strsig}}",
+			{{end}}
+		},
+		{{end -}}
+		{{if .InputBin -}}
+		Bin: "0x{{.InputBin}}",
+		{{end}}
+	}
+	// {{.Type}}ABI is the input ABI used to generate the binding from.
+	// Deprecated: Use {{.Type}}MetaData.ABI instead.
+	var {{.Type}}ABI = {{.Type}}MetaData.ABI
+
+	{{if $contract.FuncSigs}}
+		// Deprecated: Use {{.Type}}MetaData.Sigs instead.
+		// {{.Type}}FuncSigs maps the 4-byte function signature to its string representation.
+		var {{.Type}}FuncSigs = {{.Type}}MetaData.Sigs
+	{{end}}
+
+	{{if .InputBin}}
+		// {{.Type}}Bin is the compiled bytecode used for deploying new contracts.
+		// Deprecated: Use {{.Type}}MetaData.Bin instead.
+		var {{.Type}}Bin = {{.Type}}MetaData.Bin
+
+		// Deploy{{.Type}} deploys a new Ethereum contract, binding an instance of {{.Type}} to it.
+		func Deploy{{.Type}}(auth *bind.TransactOpts, backend bind.ContractBackend {{range .Constructor.Inputs}}, {{.Name}} {{bindtype .Type $structs}}{{end}}) (common.Address, *types.Transaction, *{{.Type}}, error) {
+		  parsed, err := {{.Type}}MetaData.GetAbi()
+		  if err != nil {
+		    return common.Address{}, nil, nil, err
+		  }
+		  if parsed == nil {
+			return common.Address{}, nil, nil, errors.New("GetABI returned nil")
+		  }
+		  {{range $pattern, $name := .Libraries}}
+			{{decapitalise $name}}Addr, _, _, _ := Deploy{{capitalise $name}}(auth, backend)
+			{{$contract.Type}}Bin = strings.ReplaceAll({{$contract.Type}}Bin, "__${{$pattern}}$__", {{decapitalise $name}}Addr.String()[2:])
+		  {{end}}
+		  address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex({{.Type}}Bin), backend {{range .Constructor.Inputs}}, {{.Name}}{{end}})
+		  if err != nil {
+		    return common.Address{}, nil, nil, err
+		  }
+		  return address, tx, &{{.Type}}{ {{.Type}}Caller: {{.Type}}Caller{contract: contract}, {{.Type}}Transactor: {{.Type}}Transactor{contract: contract}, {{.Type}}Filterer: {{.Type}}Filterer{contract: contract} }, nil
+		}
+	{{end}}
+
+	// {{.Type}} is an auto generated Go binding around an Ethereum contract.
+	type {{.Type}} struct {
+	  {{.Type}}Caller     // Read-only binding to the contract
+	  {{.Type}}Transactor // Write-only binding to the contract
+	  {{.Type}}Filterer   // Log filterer for contract events
+	}
+
+	// {{.Type}}Caller is an auto generated read-only Go binding around an Ethereum contract.
+	type {{.Type}}Caller struct {
+	  contract *bind.BoundContract // Generic contract wrapper for the low level calls
+	}
+
+	// {{.Type}}Transactor is an auto generated write-only Go binding around an Ethereum contract.
+	type {{.Type}}Transactor struct {
+	  contract *bind.BoundContract // Generic contract wrapper for the low level calls
+	}
+
+	// {{.Type}}Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
+	type {{.Type}}Filterer struct {
+	  contract *bind.BoundContract // Generic contract wrapper for the low level calls
+	}
+
+	// {{.Type}}Session is an auto generated Go binding around an Ethereum contract,
+	// with pre-set call and transact options.
+	type {{.Type}}Session struct {
+	  Contract     *{{.Type}}        // Generic contract binding to set the session for
+	  CallOpts     bind.CallOpts     // Call options to use throughout this session
+	  TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+	}
+
+	// {{.Type}}CallerSession is an auto generated read-only Go binding around an Ethereum contract,
+	// with pre-set call options.
+	type {{.Type}}CallerSession struct {
+	  Contract *{{.Type}}Caller // Generic contract caller binding to set the session for
+	  CallOpts bind.CallOpts    // Call options to use throughout this session
+	}
+
+	// {{.Type}}TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+	// with pre-set transact options.
+	type {{.Type}}TransactorSession struct {
+	  Contract     *{{.Type}}Transactor // Generic contract transactor binding to set the session for
+	  TransactOpts bind.TransactOpts    // Transaction auth options to use throughout this session
+	}
+
+	// {{.Type}}Raw is an auto generated low-level Go binding around an Ethereum contract.
+	type {{.Type}}Raw struct {
+	  Contract *{{.Type}} // Generic contract binding to access the raw methods on
+	}
+
+	// {{.Type}}CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+	type {{.Type}}CallerRaw struct {
+		Contract *{{.Type}}Caller // Generic read-only contract binding to access the raw methods on
+	}
+
+	// {{.Type}}TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+	type {{.Type}}TransactorRaw struct {
+		Contract *{{.Type}}Transactor // Generic write-only contract binding to access the raw methods on
+	}
+
+	// New{{.Type}} creates a new instance of {{.Type}}, bound to a specific deployed contract.
+	func New{{.Type}}(address common.Address, backend bind.ContractBackend) (*{{.Type}}, error) {
+	  contract, err := bind{{.Type}}(address, backend, backend, backend)
+	  if err != nil {
+	    return nil, err
+	  }
+	  return &{{.Type}}{ {{.Type}}Caller: {{.Type}}Caller{contract: contract}, {{.Type}}Transactor: {{.Type}}Transactor{contract: contract}, {{.Type}}Filterer: {{.Type}}Filterer{contract: contract} }, nil
+	}
+
+	// New{{.Type}}Caller creates a new read-only instance of {{.Type}}, bound to a specific deployed contract.
+	func New{{.Type}}Caller(address common.Address, caller bind.ContractCaller) (*{{.Type}}Caller, error) {
+	  contract, err := bind{{.Type}}(address, caller, nil, nil)
+	  if err != nil {
+	    return nil, err
+	  }
+	  return &{{.Type}}Caller{contract: contract}, nil
+	}
+
+	// New{{.Type}}Transactor creates a new write-only instance of {{.Type}}, bound to a specific deployed contract.
+	func New{{.Type}}Transactor(address common.Address, transactor bind.ContractTransactor) (*{{.Type}}Transactor, error) {
+	  contract, err := bind{{.Type}}(address, nil, transactor, nil)
+	  if err != nil {
+	    return nil, err
+	  }
+	  return &{{.Type}}Transactor{contract: contract}, nil
+	}
+
+	// New{{.Type}}Filterer creates a new log filterer instance of {{.Type}}, bound to a specific deployed contract.
+ 	func New{{.Type}}Filterer(address common.Address, filterer bind.ContractFilterer) (*{{.Type}}Filterer, error) {
+ 	  contract, err := bind{{.Type}}(address, nil, nil, filterer)
+ 	  if err != nil {
+ 	    return nil, err
+ 	  }
+ 	  return &{{.Type}}Filterer{contract: contract}, nil
+ 	}
+
+	// bind{{.Type}} binds a generic wrapper to an already deployed contract.
+	func bind{{.Type}}(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	  parsed, err := {{.Type}}MetaData.GetAbi()
+	  if err != nil {
+	    return nil, err
+	  }
+	  return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil
+	}
+
+	// Call invokes the (constant) contract method with params as input values and
+	// sets the output to result. The result type might be a single field for simple
+	// returns, a slice of interfaces for anonymous returns and a struct for named
+	// returns.
+	func (_{{$contract.Type}} *{{$contract.Type}}Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+		return _{{$contract.Type}}.Contract.{{$contract.Type}}Caller.contract.Call(opts, result, method, params...)
+	}
+
+	// Transfer initiates a plain transaction to move funds to the contract, calling
+	// its default method if one is available.
+	func (_{{$contract.Type}} *{{$contract.Type}}Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+		return _{{$contract.Type}}.Contract.{{$contract.Type}}Transactor.contract.Transfer(opts)
+	}
+
+	// Transact invokes the (paid) contract method with params as input values.
+	func (_{{$contract.Type}} *{{$contract.Type}}Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+		return _{{$contract.Type}}.Contract.{{$contract.Type}}Transactor.contract.Transact(opts, method, params...)
+	}
+
+	// Call invokes the (constant) contract method with params as input values and
+	// sets the output to result. The result type might be a single field for simple
+	// returns, a slice of interfaces for anonymous returns and a struct for named
+	// returns.
+	func (_{{$contract.Type}} *{{$contract.Type}}CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+		return _{{$contract.Type}}.Contract.contract.Call(opts, result, method, params...)
+	}
+
+	// Transfer initiates a plain transaction to move funds to the contract, calling
+	// its default method if one is available.
+	func (_{{$contract.Type}} *{{$contract.Type}}TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+		return _{{$contract.Type}}.Contract.contract.Transfer(opts)
+	}
+
+	// Transact invokes the (paid) contract method with params as input values.
+	func (_{{$contract.Type}} *{{$contract.Type}}TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+		return _{{$contract.Type}}.Contract.contract.Transact(opts, method, params...)
+	}
+
+	{{range .Calls}}
+		// {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}.
+		//
+		// Solidity: {{.Original.String}}
+		func (_{{$contract.Type}} *{{$contract.Type}}Caller) {{.Normalized.Name}}(opts *bind.CallOpts {{range .Normalized.Inputs}}, {{.Name}} {{bindtype .Type $structs}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} },{{else}}{{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}}{{end}} error) {
+			var out []interface{}
+			err := _{{$contract.Type}}.contract.Call(opts, &out, "{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}})
+			{{if .Structured}}
+			outstruct := new(struct{ {{range .Normalized.Outputs}} {{.Name}} {{bindtype .Type $structs}}; {{end}} })
+			if err != nil {
+				return *outstruct, err
+			}
+			{{range $i, $t := .Normalized.Outputs}}
+			outstruct.{{.Name}} = *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}}
+
+			return *outstruct, err
+			{{else}}
+			if err != nil {
+				return {{range $i, $_ := .Normalized.Outputs}}*new({{bindtype .Type $structs}}), {{end}} err
+			}
+			{{range $i, $t := .Normalized.Outputs}}
+			out{{$i}} := *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}}
+
+			return {{range $i, $t := .Normalized.Outputs}}out{{$i}}, {{end}} err
+			{{end}}
+		}
+
+		// {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}.
+		//
+		// Solidity: {{.Original.String}}
+		func (_{{$contract.Type}} *{{$contract.Type}}Session) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} }, {{else}} {{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}} {{end}} error) {
+		  return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.CallOpts {{range .Normalized.Inputs}}, {{.Name}}{{end}})
+		}
+
+		// {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}.
+		//
+		// Solidity: {{.Original.String}}
+		func (_{{$contract.Type}} *{{$contract.Type}}CallerSession) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} }, {{else}} {{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}} {{end}} error) {
+		  return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.CallOpts {{range .Normalized.Inputs}}, {{.Name}}{{end}})
+		}
+	{{end}}
+
+	{{range .Transacts}}
+		// {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}.
+		//
+		// Solidity: {{.Original.String}}
+		func (_{{$contract.Type}} *{{$contract.Type}}Transactor) {{.Normalized.Name}}(opts *bind.TransactOpts {{range .Normalized.Inputs}}, {{.Name}} {{bindtype .Type $structs}} {{end}}) (*types.Transaction, error) {
+			return _{{$contract.Type}}.contract.Transact(opts, "{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}})
+		}
+
+		// {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}.
+		//
+		// Solidity: {{.Original.String}}
+		func (_{{$contract.Type}} *{{$contract.Type}}Session) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) (*types.Transaction, error) {
+		  return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.TransactOpts {{range $i, $_ := .Normalized.Inputs}}, {{.Name}}{{end}})
+		}
+
+		// {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}.
+		//
+		// Solidity: {{.Original.String}}
+		func (_{{$contract.Type}} *{{$contract.Type}}TransactorSession) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) (*types.Transaction, error) {
+		  return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.TransactOpts {{range $i, $_ := .Normalized.Inputs}}, {{.Name}}{{end}})
+		}
+	{{end}}
+
+	{{if .Fallback}}
+		// Fallback is a paid mutator transaction binding the contract fallback function.
+		//
+		// Solidity: {{.Fallback.Original.String}}
+		func (_{{$contract.Type}} *{{$contract.Type}}Transactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error) {
+			return _{{$contract.Type}}.contract.RawTransact(opts, calldata)
+		}
+
+		// Fallback is a paid mutator transaction binding the contract fallback function.
+		//
+		// Solidity: {{.Fallback.Original.String}}
+		func (_{{$contract.Type}} *{{$contract.Type}}Session) Fallback(calldata []byte) (*types.Transaction, error) {
+		  return _{{$contract.Type}}.Contract.Fallback(&_{{$contract.Type}}.TransactOpts, calldata)
+		}
+
+		// Fallback is a paid mutator transaction binding the contract fallback function.
+		//
+		// Solidity: {{.Fallback.Original.String}}
+		func (_{{$contract.Type}} *{{$contract.Type}}TransactorSession) Fallback(calldata []byte) (*types.Transaction, error) {
+		  return _{{$contract.Type}}.Contract.Fallback(&_{{$contract.Type}}.TransactOpts, calldata)
+		}
+	{{end}}
+
+	{{if .Receive}}
+		// Receive is a paid mutator transaction binding the contract receive function.
+		//
+		// Solidity: {{.Receive.Original.String}}
+		func (_{{$contract.Type}} *{{$contract.Type}}Transactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error) {
+			return _{{$contract.Type}}.contract.RawTransact(opts, nil) // calldata is disallowed for receive function
+		}
+
+		// Receive is a paid mutator transaction binding the contract receive function.
+		//
+		// Solidity: {{.Receive.Original.String}}
+		func (_{{$contract.Type}} *{{$contract.Type}}Session) Receive() (*types.Transaction, error) {
+		  return _{{$contract.Type}}.Contract.Receive(&_{{$contract.Type}}.TransactOpts)
+		}
+
+		// Receive is a paid mutator transaction binding the contract receive function.
+		//
+		// Solidity: {{.Receive.Original.String}}
+		func (_{{$contract.Type}} *{{$contract.Type}}TransactorSession) Receive() (*types.Transaction, error) {
+		  return _{{$contract.Type}}.Contract.Receive(&_{{$contract.Type}}.TransactOpts)
+		}
+	{{end}}
+
+	{{range .Events}}
+		// {{$contract.Type}}{{.Normalized.Name}}Iterator is returned from Filter{{.Normalized.Name}} and is used to iterate over the raw logs and unpacked data for {{.Normalized.Name}} events raised by the {{$contract.Type}} contract.
+		type {{$contract.Type}}{{.Normalized.Name}}Iterator struct {
+			Event *{{$contract.Type}}{{.Normalized.Name}} // Event containing the contract specifics and raw log
+
+			contract *bind.BoundContract // Generic contract to use for unpacking event data
+			event    string              // Event name to use for unpacking event data
+
+			logs chan types.Log        // Log channel receiving the found contract events
+			sub  ethereum.Subscription // Subscription for errors, completion and termination
+			done bool                  // Whether the subscription completed delivering logs
+			fail error                 // Occurred error to stop iteration
+		}
+		// Next advances the iterator to the subsequent event, returning whether there
+		// are any more events found. In case of a retrieval or parsing error, false is
+		// returned and Error() can be queried for the exact failure.
+		func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Next() bool {
+			// If the iterator failed, stop iterating
+			if (it.fail != nil) {
+				return false
+			}
+			// If the iterator completed, deliver directly whatever's available
+			if (it.done) {
+				select {
+				case log := <-it.logs:
+					it.Event = new({{$contract.Type}}{{.Normalized.Name}})
+					if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+						it.fail = err
+						return false
+					}
+					it.Event.Raw = log
+					return true
+
+				default:
+					return false
+				}
+			}
+			// Iterator still in progress, wait for either a data or an error event
+			select {
+			case log := <-it.logs:
+				it.Event = new({{$contract.Type}}{{.Normalized.Name}})
+				if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+					it.fail = err
+					return false
+				}
+				it.Event.Raw = log
+				return true
+
+			case err := <-it.sub.Err():
+				it.done = true
+				it.fail = err
+				return it.Next()
+			}
+		}
+		// Error returns any retrieval or parsing error occurred during filtering.
+		func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Error() error {
+			return it.fail
+		}
+		// Close terminates the iteration process, releasing any pending underlying
+		// resources.
+		func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Close() error {
+			it.sub.Unsubscribe()
+			return nil
+		}
+
+		// {{$contract.Type}}{{.Normalized.Name}} represents a {{.Normalized.Name}} event raised by the {{$contract.Type}} contract.
+		type {{$contract.Type}}{{.Normalized.Name}} struct { {{range .Normalized.Inputs}}
+			{{capitalise .Name}} {{if .Indexed}}{{bindtopictype .Type $structs}}{{else}}{{bindtype .Type $structs}}{{end}}; {{end}}
+			Raw types.Log // Blockchain specific contextual infos
+		}
+
+		// Filter{{.Normalized.Name}} is a free log retrieval operation binding the contract event 0x{{printf "%x" .Original.ID}}.
+		//
+		// Solidity: {{.Original.String}}
+ 		func (_{{$contract.Type}} *{{$contract.Type}}Filterer) Filter{{.Normalized.Name}}(opts *bind.FilterOpts{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}} []{{bindtype .Type $structs}}{{end}}{{end}}) (*{{$contract.Type}}{{.Normalized.Name}}Iterator, error) {
+			{{range .Normalized.Inputs}}
+			{{if .Indexed}}var {{.Name}}Rule []interface{}
+			for _, {{.Name}}Item := range {{.Name}} {
+				{{.Name}}Rule = append({{.Name}}Rule, {{.Name}}Item)
+			}{{end}}{{end}}
+
+			logs, sub, err := _{{$contract.Type}}.contract.FilterLogs(opts, "{{.Original.Name}}"{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}}Rule{{end}}{{end}})
+			if err != nil {
+				return nil, err
+			}
+			return &{{$contract.Type}}{{.Normalized.Name}}Iterator{contract: _{{$contract.Type}}.contract, event: "{{.Original.Name}}", logs: logs, sub: sub}, nil
+ 		}
+
+		// Watch{{.Normalized.Name}} is a free log subscription operation binding the contract event 0x{{printf "%x" .Original.ID}}.
+		//
+		// Solidity: {{.Original.String}}
+		func (_{{$contract.Type}} *{{$contract.Type}}Filterer) Watch{{.Normalized.Name}}(opts *bind.WatchOpts, sink chan<- *{{$contract.Type}}{{.Normalized.Name}}{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}} []{{bindtype .Type $structs}}{{end}}{{end}}) (event.Subscription, error) {
+			{{range .Normalized.Inputs}}
+			{{if .Indexed}}var {{.Name}}Rule []interface{}
+			for _, {{.Name}}Item := range {{.Name}} {
+				{{.Name}}Rule = append({{.Name}}Rule, {{.Name}}Item)
+			}{{end}}{{end}}
+
+			logs, sub, err := _{{$contract.Type}}.contract.WatchLogs(opts, "{{.Original.Name}}"{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}}Rule{{end}}{{end}})
+			if err != nil {
+				return nil, err
+			}
+			return event.NewSubscription(func(quit <-chan struct{}) error {
+				defer sub.Unsubscribe()
+				for {
+					select {
+					case log := <-logs:
+						// New log arrived, parse the event and forward to the user
+						event := new({{$contract.Type}}{{.Normalized.Name}})
+						if err := _{{$contract.Type}}.contract.UnpackLog(event, "{{.Original.Name}}", log); err != nil {
+							return err
+						}
+						event.Raw = log
+
+						select {
+						case sink <- event:
+						case err := <-sub.Err():
+							return err
+						case <-quit:
+							return nil
+						}
+					case err := <-sub.Err():
+						return err
+					case <-quit:
+						return nil
+					}
+				}
+			}), nil
+		}
+
+		// Parse{{.Normalized.Name}} is a log parse operation binding the contract event 0x{{printf "%x" .Original.ID}}.
+		//
+		// Solidity: {{.Original.String}}
+		func (_{{$contract.Type}} *{{$contract.Type}}Filterer) Parse{{.Normalized.Name}}(log types.Log) (*{{$contract.Type}}{{.Normalized.Name}}, error) {
+			event := new({{$contract.Type}}{{.Normalized.Name}})
+			if err := _{{$contract.Type}}.contract.UnpackLog(event, "{{.Original.Name}}", log); err != nil {
+				return nil, err
+			}
+			event.Raw = log
+			return event, nil
+		}
+
+ 	{{end}}
+{{end}}
+`
--- a/accounts/abi/bind/util_test.go
+++ b/accounts/abi/bind/util_test.go
@@ -82,9 +82,7 @@ func TestWaitDeployed(t *testing.T) {
 		}()

 		// Send and mine the transaction.
-		if err := backend.Client().SendTransaction(ctx, tx); err != nil {
-			t.Errorf("test %q: failed to send transaction: %v", name, err)
-		}
+		backend.Client().SendTransaction(ctx, tx)
 		backend.Commit()

 		select {
@@ -118,9 +116,7 @@ func TestWaitDeployedCornerCases(t *testing.T) {
 	tx, _ = types.SignTx(tx, types.LatestSigner(params.AllDevChainProtocolChanges), testKey)
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	if err := backend.Client().SendTransaction(ctx, tx); err != nil {
-		t.Errorf("failed to send transaction: %q", err)
-	}
+	backend.Client().SendTransaction(ctx, tx)
 	backend.Commit()
 	notContractCreation := errors.New("tx is not contract creation")
 	if _, err := bind.WaitDeployed(ctx, backend.Client(), tx); err.Error() != notContractCreation.Error() {
@@ -138,8 +134,6 @@ func TestWaitDeployedCornerCases(t *testing.T) {
 		}
 	}()

-	if err := backend.Client().SendTransaction(ctx, tx); err != nil {
-		t.Errorf("failed to send transaction: %q", err)
-	}
+	backend.Client().SendTransaction(ctx, tx)
 	cancel()
 }
--- a/accounts/abi/event_test.go
+++ b/accounts/abi/event_test.go
@@ -331,6 +331,7 @@ func TestEventTupleUnpack(t *testing.T) {

 	for _, tc := range testCases {
 		assert := assert.New(t)
+		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
 			err := unpackTestEventData(tc.dest, tc.data, tc.jsonLog, assert)
 			if tc.error == "" {
--- a/accounts/abi/pack_test.go
+++ b/accounts/abi/pack_test.go
@@ -34,6 +34,7 @@ import (
 func TestPack(t *testing.T) {
 	t.Parallel()
 	for i, test := range packUnpackTests {
+		i, test := i, test
 		t.Run(strconv.Itoa(i), func(t *testing.T) {
 			t.Parallel()
 			encb, err := hex.DecodeString(test.packed)
--- a/accounts/abi/reflect.go
+++ b/accounts/abi/reflect.go
@@ -24,7 +24,7 @@ import (
 	"strings"
 )

-// ConvertType converts an interface of a runtime type into an interface of the
+// ConvertType converts an interface of a runtime type into a interface of the
 // given type, e.g. turn this code:
 //
 //	var fields []reflect.StructField
@@ -33,7 +33,7 @@ import (
 //			Name: "X",
 //			Type: reflect.TypeOf(new(big.Int)),
 //			Tag:  reflect.StructTag("json:\"" + "x" + "\""),
-//	})
+//	}
 //
 // into:
 //
--- a/accounts/abi/reflect_test.go
+++ b/accounts/abi/reflect_test.go
@@ -172,6 +172,7 @@ var reflectTests = []reflectTest{
 func TestReflectNameToStruct(t *testing.T) {
 	t.Parallel()
 	for _, test := range reflectTests {
+		test := test
 		t.Run(test.name, func(t *testing.T) {
 			t.Parallel()
 			m, err := mapArgNamesToStructFields(test.args, reflect.ValueOf(test.struc))
--- a/accounts/abi/topics_test.go
+++ b/accounts/abi/topics_test.go
@@ -137,6 +137,7 @@ func TestMakeTopics(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
+		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			got, err := MakeTopics(tt.args.query...)
@@ -372,6 +373,7 @@ func TestParseTopics(t *testing.T) {
 	tests := setupTopicsTests()

 	for _, tt := range tests {
+		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			createObj := tt.args.createObj()
@@ -391,6 +393,7 @@ func TestParseTopicsIntoMap(t *testing.T) {
 	tests := setupTopicsTests()

 	for _, tt := range tests {
+		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			outMap := make(map[string]interface{})
--- a/accounts/abi/type.go
+++ b/accounts/abi/type.go
@@ -64,9 +64,6 @@ type Type struct {
 var (
 	// typeRegex parses the abi sub types
 	typeRegex = regexp.MustCompile("([a-zA-Z]+)(([0-9]+)(x([0-9]+))?)?")
-
-	// sliceSizeRegex grab the slice size
-	sliceSizeRegex = regexp.MustCompile("[0-9]+")
 )

 // NewType creates a new reflection type of abi type given in t.
@@ -94,7 +91,8 @@ func NewType(t string, internalType string, components []ArgumentMarshaling) (ty
 		// grab the last cell and create a type from there
 		sliced := t[i:]
 		// grab the slice size with regexp
-		intz := sliceSizeRegex.FindAllString(sliced, -1)
+		re := regexp.MustCompile("[0-9]+")
+		intz := re.FindAllString(sliced, -1)

 		if len(intz) == 0 {
 			// is a slice
@@ -181,6 +179,9 @@ func NewType(t string, internalType string, components []ArgumentMarshaling) (ty
 				return Type{}, errors.New("abi: purely anonymous or underscored field is not supported")
 			}
 			fieldName := ResolveNameConflict(name, func(s string) bool { return used[s] })
+			if err != nil {
+				return Type{}, err
+			}
 			used[fieldName] = true
 			if !isValidFieldName(fieldName) {
 				return Type{}, fmt.Errorf("field %d has invalid name", idx)
@@ -219,13 +220,8 @@ func NewType(t string, internalType string, components []ArgumentMarshaling) (ty
 		typ.T = FunctionTy
 		typ.Size = 24
 	default:
-		if strings.HasPrefix(internalType, "contract ") {
-			typ.Size = 20
-			typ.T = AddressTy
-		} else {
 		return Type{}, fmt.Errorf("unsupported arg type: %s", t)
 	}
-	}

 	return
 }
--- a/accounts/abi/type_test.go
+++ b/accounts/abi/type_test.go
@@ -25,7 +25,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 )

-// typeWithoutStringer is an alias for the Type type which simply doesn't implement
+// typeWithoutStringer is a alias for the Type type which simply doesn't implement
 // the stringer interface to allow printing type details in the tests below.
 type typeWithoutStringer Type

--- a/accounts/abi/unpack_test.go
+++ b/accounts/abi/unpack_test.go
@@ -389,6 +389,7 @@ func TestMethodMultiReturn(t *testing.T) {
 		"Can not unpack into a slice with wrong types",
 	}}
 	for _, tc := range testCases {
+		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
 			require := require.New(t)
 			err := abi.UnpackIntoInterface(tc.dest, "multi", data)
@@ -946,7 +947,7 @@ func TestOOMMaliciousInput(t *testing.T) {
 		}
 		encb, err := hex.DecodeString(test.enc)
 		if err != nil {
-			t.Fatalf("invalid hex: %s", test.enc)
+			t.Fatalf("invalid hex: %s" + test.enc)
 		}
 		_, err = abi.Methods["method"].Outputs.UnpackValues(encb)
 		if err == nil {
--- a/accounts/accounts.go
+++ b/accounts/accounts.go
@@ -195,7 +195,7 @@ func TextHash(data []byte) []byte {
 //
 // This gives context to the signed message and prevents signing of transactions.
 func TextAndHash(data []byte) ([]byte, string) {
-	msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(data), data)
+	msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(data), string(data))
 	hasher := sha3.NewLegacyKeccak256()
 	hasher.Write([]byte(msg))
 	return hasher.Sum(nil), msg
--- a/accounts/external/backend.go
+++ b/accounts/external/backend.go
@@ -205,7 +205,7 @@ func (api *ExternalSigner) SignTx(account accounts.Account, tx *types.Transactio
 		to = &t
 	}
 	args := &apitypes.SendTxArgs{
-		Input: &data,
+		Data:  &data,
 		Nonce: hexutil.Uint64(tx.Nonce()),
 		Value: hexutil.Big(*tx.Value()),
 		Gas:   hexutil.Uint64(tx.Gas()),
@@ -215,7 +215,7 @@ func (api *ExternalSigner) SignTx(account accounts.Account, tx *types.Transactio
 	switch tx.Type() {
 	case types.LegacyTxType, types.AccessListTxType:
 		args.GasPrice = (*hexutil.Big)(tx.GasPrice())
-	case types.DynamicFeeTxType, types.BlobTxType:
+	case types.DynamicFeeTxType:
 		args.MaxFeePerGas = (*hexutil.Big)(tx.GasFeeCap())
 		args.MaxPriorityFeePerGas = (*hexutil.Big)(tx.GasTipCap())
 	default:
@@ -235,17 +235,6 @@ func (api *ExternalSigner) SignTx(account accounts.Account, tx *types.Transactio
 		accessList := tx.AccessList()
 		args.AccessList = &accessList
 	}
-	if tx.Type() == types.BlobTxType {
-		args.BlobHashes = tx.BlobHashes()
-		sidecar := tx.BlobTxSidecar()
-		if sidecar == nil {
-			return nil, errors.New("blobs must be present for signing")
-		}
-		args.Blobs = sidecar.Blobs
-		args.Commitments = sidecar.Commitments
-		args.Proofs = sidecar.Proofs
-	}
-
 	var res signTransactionResult
 	if err := api.client.Call(&res, "account_signTransaction", args); err != nil {
 		return nil, err
--- a/accounts/keystore/account_cache.go
+++ b/accounts/keystore/account_cache.go
@@ -22,7 +22,6 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"slices"
 	"sort"
 	"strings"
 	"sync"
@@ -32,6 +31,7 @@ import (
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
+	"golang.org/x/exp/slices"
 )

 // Minimum amount of time between cache reloads. This limit applies if the platform does
--- a/accounts/keystore/account_cache_test.go
+++ b/accounts/keystore/account_cache_test.go
@@ -23,7 +23,6 @@ import (
 	"os"
 	"path/filepath"
 	"reflect"
-	"slices"
 	"testing"
 	"time"

@@ -31,6 +30,7 @@ import (
 	"github.com/davecgh/go-spew/spew"
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/common"
+	"golang.org/x/exp/slices"
 )

 var (
@@ -51,7 +51,7 @@ var (
 	}
 )

-// waitWatcherStart waits up to 1s for the keystore watcher to start.
+// waitWatcherStarts waits up to 1s for the keystore watcher to start.
 func waitWatcherStart(ks *KeyStore) bool {
 	// On systems where file watch is not supported, just return "ok".
 	if !ks.cache.watcher.enabled() {
@@ -86,7 +86,7 @@ func waitForAccounts(wantAccounts []accounts.Account, ks *KeyStore) error {
 func TestWatchNewFile(t *testing.T) {
 	t.Parallel()

-	dir, ks := tmpKeyStore(t)
+	dir, ks := tmpKeyStore(t, false)

 	// Ensure the watcher is started before adding any files.
 	ks.Accounts()
@@ -114,7 +114,7 @@ func TestWatchNewFile(t *testing.T) {
 func TestWatchNoDir(t *testing.T) {
 	t.Parallel()
 	// Create ks but not the directory that it watches.
-	dir := filepath.Join(t.TempDir(), fmt.Sprintf("eth-keystore-watchnodir-test-%d-%d", os.Getpid(), rand.Int()))
+	dir := filepath.Join(os.TempDir(), fmt.Sprintf("eth-keystore-watchnodir-test-%d-%d", os.Getpid(), rand.Int()))
 	ks := NewKeyStore(dir, LightScryptN, LightScryptP)
 	list := ks.Accounts()
 	if len(list) > 0 {
@@ -126,6 +126,7 @@ func TestWatchNoDir(t *testing.T) {
 	}
 	// Create the directory and copy a key file into it.
 	os.MkdirAll(dir, 0700)
+	defer os.RemoveAll(dir)
 	file := filepath.Join(dir, "aaa")
 	if err := cp.CopyFile(file, cachetestAccounts[0].URL.Path); err != nil {
 		t.Fatal(err)
@@ -324,8 +325,7 @@ func TestUpdatedKeyfileContents(t *testing.T) {
 	t.Parallel()

 	// Create a temporary keystore to test with
-	dir := t.TempDir()
-
+	dir := filepath.Join(os.TempDir(), fmt.Sprintf("eth-keystore-updatedkeyfilecontents-test-%d-%d", os.Getpid(), rand.Int()))
 	ks := NewKeyStore(dir, LightScryptN, LightScryptP)

 	list := ks.Accounts()
@@ -335,7 +335,9 @@ func TestUpdatedKeyfileContents(t *testing.T) {
 	if !waitWatcherStart(ks) {
 		t.Fatal("keystore watcher didn't start in time")
 	}
-	// Copy a key file into it
+	// Create the directory and copy a key file into it.
+	os.MkdirAll(dir, 0700)
+	defer os.RemoveAll(dir)
 	file := filepath.Join(dir, "aaa")

 	// Place one of our testfiles in there
--- a/accounts/keystore/keystore.go
+++ b/accounts/keystore/keystore.go
@@ -87,6 +87,15 @@ func NewKeyStore(keydir string, scryptN, scryptP int) *KeyStore {
 	return ks
 }

+// NewPlaintextKeyStore creates a keystore for the given directory.
+// Deprecated: Use NewKeyStore.
+func NewPlaintextKeyStore(keydir string) *KeyStore {
+	keydir, _ = filepath.Abs(keydir)
+	ks := &KeyStore{storage: &keyStorePlain{keydir}}
+	ks.init(keydir)
+	return ks
+}
+
 func (ks *KeyStore) init(keydir string) {
 	// Lock the mutex since the account cache might call back with events
 	ks.mu.Lock()
@@ -312,10 +321,11 @@ func (ks *KeyStore) Unlock(a accounts.Account, passphrase string) error {
 // Lock removes the private key with the given address from memory.
 func (ks *KeyStore) Lock(addr common.Address) error {
 	ks.mu.Lock()
-	unl, found := ks.unlocked[addr]
+	if unl, found := ks.unlocked[addr]; found {
 		ks.mu.Unlock()
-	if found {
 		ks.expire(addr, unl, time.Duration(0)*time.Nanosecond)
+	} else {
+		ks.mu.Unlock()
 	}
 	return nil
 }
@@ -499,5 +509,7 @@ func (ks *KeyStore) isUpdating() bool {
 // zeroKey zeroes a private key in memory.
 func zeroKey(k *ecdsa.PrivateKey) {
 	b := k.D.Bits()
-	clear(b)
+	for i := range b {
+		b[i] = 0
+	}
 }
--- a/accounts/keystore/keystore_test.go
+++ b/accounts/keystore/keystore_test.go
@@ -20,7 +20,6 @@ import (
 	"math/rand"
 	"os"
 	"runtime"
-	"slices"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -31,13 +30,14 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/event"
+	"golang.org/x/exp/slices"
 )

 var testSigData = make([]byte, 32)

 func TestKeyStore(t *testing.T) {
 	t.Parallel()
-	dir, ks := tmpKeyStore(t)
+	dir, ks := tmpKeyStore(t, true)

 	a, err := ks.NewAccount("foo")
 	if err != nil {
@@ -72,7 +72,7 @@ func TestKeyStore(t *testing.T) {

 func TestSign(t *testing.T) {
 	t.Parallel()
-	_, ks := tmpKeyStore(t)
+	_, ks := tmpKeyStore(t, true)

 	pass := "" // not used but required by API
 	a1, err := ks.NewAccount(pass)
@@ -89,7 +89,7 @@ func TestSign(t *testing.T) {

 func TestSignWithPassphrase(t *testing.T) {
 	t.Parallel()
-	_, ks := tmpKeyStore(t)
+	_, ks := tmpKeyStore(t, true)

 	pass := "passwd"
 	acc, err := ks.NewAccount(pass)
@@ -117,7 +117,7 @@ func TestSignWithPassphrase(t *testing.T) {

 func TestTimedUnlock(t *testing.T) {
 	t.Parallel()
-	_, ks := tmpKeyStore(t)
+	_, ks := tmpKeyStore(t, true)

 	pass := "foo"
 	a1, err := ks.NewAccount(pass)
@@ -152,7 +152,7 @@ func TestTimedUnlock(t *testing.T) {

 func TestOverrideUnlock(t *testing.T) {
 	t.Parallel()
-	_, ks := tmpKeyStore(t)
+	_, ks := tmpKeyStore(t, false)

 	pass := "foo"
 	a1, err := ks.NewAccount(pass)
@@ -193,7 +193,7 @@ func TestOverrideUnlock(t *testing.T) {
 // This test should fail under -race if signing races the expiration goroutine.
 func TestSignRace(t *testing.T) {
 	t.Parallel()
-	_, ks := tmpKeyStore(t)
+	_, ks := tmpKeyStore(t, false)

 	// Create a test account.
 	a1, err := ks.NewAccount("")
@@ -238,7 +238,7 @@ func waitForKsUpdating(t *testing.T, ks *KeyStore, wantStatus bool, maxTime time
 func TestWalletNotifierLifecycle(t *testing.T) {
 	t.Parallel()
 	// Create a temporary keystore to test with
-	_, ks := tmpKeyStore(t)
+	_, ks := tmpKeyStore(t, false)

 	// Ensure that the notification updater is not running yet
 	time.Sleep(250 * time.Millisecond)
@@ -284,7 +284,7 @@ type walletEvent struct {
 // or deleted from the keystore.
 func TestWalletNotifications(t *testing.T) {
 	t.Parallel()
-	_, ks := tmpKeyStore(t)
+	_, ks := tmpKeyStore(t, false)

 	// Subscribe to the wallet feed and collect events.
 	var (
@@ -343,10 +343,10 @@ func TestWalletNotifications(t *testing.T) {
 	checkEvents(t, wantEvents, events)
 }

-// TestImportECDSA tests the import functionality of a keystore.
+// TestImportExport tests the import functionality of a keystore.
 func TestImportECDSA(t *testing.T) {
 	t.Parallel()
-	_, ks := tmpKeyStore(t)
+	_, ks := tmpKeyStore(t, true)
 	key, err := crypto.GenerateKey()
 	if err != nil {
 		t.Fatalf("failed to generate key: %v", key)
@@ -362,10 +362,10 @@ func TestImportECDSA(t *testing.T) {
 	}
 }

-// TestImportExport tests the import and export functionality of a keystore.
+// TestImportECDSA tests the import and export functionality of a keystore.
 func TestImportExport(t *testing.T) {
 	t.Parallel()
-	_, ks := tmpKeyStore(t)
+	_, ks := tmpKeyStore(t, true)
 	acc, err := ks.NewAccount("old")
 	if err != nil {
 		t.Fatalf("failed to create account: %v", acc)
@@ -374,7 +374,7 @@ func TestImportExport(t *testing.T) {
 	if err != nil {
 		t.Fatalf("failed to export account: %v", acc)
 	}
-	_, ks2 := tmpKeyStore(t)
+	_, ks2 := tmpKeyStore(t, true)
 	if _, err = ks2.Import(json, "old", "old"); err == nil {
 		t.Errorf("importing with invalid password succeeded")
 	}
@@ -394,7 +394,7 @@ func TestImportExport(t *testing.T) {
 // This test should fail under -race if importing races.
 func TestImportRace(t *testing.T) {
 	t.Parallel()
-	_, ks := tmpKeyStore(t)
+	_, ks := tmpKeyStore(t, true)
 	acc, err := ks.NewAccount("old")
 	if err != nil {
 		t.Fatalf("failed to create account: %v", acc)
@@ -403,7 +403,7 @@ func TestImportRace(t *testing.T) {
 	if err != nil {
 		t.Fatalf("failed to export account: %v", acc)
 	}
-	_, ks2 := tmpKeyStore(t)
+	_, ks2 := tmpKeyStore(t, true)
 	var atom atomic.Uint32
 	var wg sync.WaitGroup
 	wg.Add(2)
@@ -457,7 +457,11 @@ func checkEvents(t *testing.T, want []walletEvent, have []walletEvent) {
 	}
 }

-func tmpKeyStore(t *testing.T) (string, *KeyStore) {
+func tmpKeyStore(t *testing.T, encrypted bool) (string, *KeyStore) {
 	d := t.TempDir()
-	return d, NewKeyStore(d, veryLightScryptN, veryLightScryptP)
+	newKs := NewPlaintextKeyStore
+	if encrypted {
+		newKs = func(kd string) *KeyStore { return NewKeyStore(kd, veryLightScryptN, veryLightScryptP) }
+	}
+	return d, newKs(d)
 }
--- a/accounts/scwallet/hub.go
+++ b/accounts/scwallet/hub.go
@@ -95,7 +95,6 @@ func (hub *Hub) readPairings() error {
 		}
 		return err
 	}
-	defer pairingFile.Close()

 	pairingData, err := io.ReadAll(pairingFile)
 	if err != nil {
--- a/accounts/scwallet/securechannel.go
+++ b/accounts/scwallet/securechannel.go
@@ -20,6 +20,7 @@ import (
 	"bytes"
 	"crypto/aes"
 	"crypto/cipher"
+	"crypto/elliptic"
 	"crypto/rand"
 	"crypto/sha256"
 	"crypto/sha512"
@@ -71,11 +72,11 @@ func NewSecureChannelSession(card *pcsc.Card, keyData []byte) (*SecureChannelSes
 	if err != nil {
 		return nil, fmt.Errorf("could not unmarshal public key from card: %v", err)
 	}
-	secret, _ := crypto.S256().ScalarMult(cardPublic.X, cardPublic.Y, key.D.Bytes())
+	secret, _ := key.Curve.ScalarMult(cardPublic.X, cardPublic.Y, key.D.Bytes())
 	return &SecureChannelSession{
 		card:      card,
 		secret:    secret.Bytes(),
-		publicKey: crypto.FromECDSAPub(&key.PublicKey),
+		publicKey: elliptic.Marshal(crypto.S256(), key.PublicKey.X, key.PublicKey.Y),
 	}, nil
 }

--- a/accounts/scwallet/wallet.go
+++ b/accounts/scwallet/wallet.go
@@ -73,14 +73,6 @@ var (
 	DerivationSignatureHash = sha256.Sum256(common.Hash{}.Bytes())
 )

-var (
-	// PinRegexp is the regular expression used to validate PIN codes.
-	pinRegexp = regexp.MustCompile(`^[0-9]{6,}$`)
-
-	// PukRegexp is the regular expression used to validate PUK codes.
-	pukRegexp = regexp.MustCompile(`^[0-9]{12,}$`)
-)
-
 // List of APDU command-related constants
 const (
 	claISO7816  = 0
@@ -388,7 +380,7 @@ func (w *Wallet) Open(passphrase string) error {
 	case passphrase == "":
 		return ErrPINUnblockNeeded
 	case status.PinRetryCount > 0:
-		if !pinRegexp.MatchString(passphrase) {
+		if !regexp.MustCompile(`^[0-9]{6,}$`).MatchString(passphrase) {
 			w.log.Error("PIN needs to be at least 6 digits")
 			return ErrPINNeeded
 		}
@@ -396,7 +388,7 @@ func (w *Wallet) Open(passphrase string) error {
 			return err
 		}
 	default:
-		if !pukRegexp.MatchString(passphrase) {
+		if !regexp.MustCompile(`^[0-9]{12,}$`).MatchString(passphrase) {
 			w.log.Error("PUK needs to be at least 12 digits")
 			return ErrPINUnblockNeeded
 		}
--- a/accounts/usbwallet/hub.go
+++ b/accounts/usbwallet/hub.go
@@ -26,7 +26,7 @@ import (
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/karalabe/hid"
+	"github.com/karalabe/usb"
 )

 // LedgerScheme is the protocol scheme prefixing account and wallet URLs.
@@ -109,7 +109,7 @@ func NewTrezorHubWithWebUSB() (*Hub, error) {

 // newHub creates a new hardware wallet manager for generic USB devices.
 func newHub(scheme string, vendorID uint16, productIDs []uint16, usageID uint16, endpointID int, makeDriver func(log.Logger) driver) (*Hub, error) {
-	if !hid.Supported() {
+	if !usb.Supported() {
 		return nil, errors.New("unsupported platform")
 	}
 	hub := &Hub{
@@ -155,7 +155,7 @@ func (hub *Hub) refreshWallets() {
 		return
 	}
 	// Retrieve the current list of USB wallet devices
-	var devices []hid.DeviceInfo
+	var devices []usb.DeviceInfo

 	if runtime.GOOS == "linux" {
 		// hidapi on Linux opens the device during enumeration to retrieve some infos,
@@ -170,7 +170,7 @@ func (hub *Hub) refreshWallets() {
 			return
 		}
 	}
-	infos, err := hid.Enumerate(hub.vendorID, 0)
+	infos, err := usb.Enumerate(hub.vendorID, 0)
 	if err != nil {
 		failcount := hub.enumFails.Add(1)
 		if runtime.GOOS == "linux" {
--- a/accounts/usbwallet/ledger.go
+++ b/accounts/usbwallet/ledger.go
@@ -16,7 +16,7 @@

 // This file contains the implementation for interacting with the Ledger hardware
 // wallets. The wire protocol spec can be found in the Ledger Blue GitHub repo:
-// https://github.com/LedgerHQ/app-ethereum/blob/develop/doc/ethapp.adoc
+// https://raw.githubusercontent.com/LedgerHQ/blue-app-eth/master/doc/ethapp.asc

 package usbwallet

--- a/accounts/usbwallet/trezor.go
+++ b/accounts/usbwallet/trezor.go
@@ -33,7 +33,7 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
-	"google.golang.org/protobuf/proto"
+	"github.com/golang/protobuf/proto"
 )

 // ErrTrezorPINNeeded is returned if opening the trezor requires a PIN code. In
--- a/accounts/usbwallet/trezor/messages-common.pb.go
+++ b/accounts/usbwallet/trezor/messages-common.pb.go
--- a/accounts/usbwallet/trezor/messages-common.proto
+++ b/accounts/usbwallet/trezor/messages-common.proto
@@ -5,8 +5,6 @@
 syntax = "proto2";
 package hw.trezor.messages.common;

-option go_package  = "github.com/ethereum/go-ethereum/accounts/usbwallet/trezor";
-
 /**
 * Response: Success of the previous request
 * @end
--- a/accounts/usbwallet/trezor/messages-ethereum.pb.go
+++ b/accounts/usbwallet/trezor/messages-ethereum.pb.go
--- a/accounts/usbwallet/trezor/messages-ethereum.proto
+++ b/accounts/usbwallet/trezor/messages-ethereum.proto
@@ -5,8 +5,6 @@
 syntax = "proto2";
 package hw.trezor.messages.ethereum;

-option go_package  = "github.com/ethereum/go-ethereum/accounts/usbwallet/trezor";
-
 // Sugar for easier handling in Java
 option java_package = "com.satoshilabs.trezor.lib.protobuf";
 option java_outer_classname = "TrezorMessageEthereum";
--- a/accounts/usbwallet/trezor/messages-management.pb.go
+++ b/accounts/usbwallet/trezor/messages-management.pb.go
--- a/accounts/usbwallet/trezor/messages-management.proto
+++ b/accounts/usbwallet/trezor/messages-management.proto
@@ -5,8 +5,6 @@
 syntax = "proto2";
 package hw.trezor.messages.management;

-option go_package  = "github.com/ethereum/go-ethereum/accounts/usbwallet/trezor";
-
 // Sugar for easier handling in Java
 option java_package = "com.satoshilabs.trezor.lib.protobuf";
 option java_outer_classname = "TrezorMessageManagement";
--- a/accounts/usbwallet/trezor/messages.pb.go
+++ b/accounts/usbwallet/trezor/messages.pb.go
@@ -1,29 +1,26 @@
-// This file originates from the SatoshiLabs Trezor `common` repository at:
-//   https://github.com/trezor/trezor-common/blob/master/protob/messages.proto
-// dated 28.05.2019, commit 893fd219d4a01bcffa0cd9cfa631856371ec5aa9.
-
 // Code generated by protoc-gen-go. DO NOT EDIT.
-// versions:
-// 	protoc-gen-go v1.34.2
-// 	protoc        v5.27.1
 // source: messages.proto

 package trezor

 import (
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	descriptorpb "google.golang.org/protobuf/types/descriptorpb"
-	reflect "reflect"
-	sync "sync"
+	fmt "fmt"
+	math "math"
+
+	proto "github.com/golang/protobuf/proto"
+	descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor"
 )

-const (
-	// Verify that this generated code is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
-	// Verify that runtime/protoimpl is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
-)
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

 // *
 // Mapping between TREZOR wire identifier (uint) and a protobuf message
@@ -244,9 +241,7 @@ const (
 	MessageType_MessageType_BinanceSignedTx     MessageType = 709
 )

-// Enum value maps for MessageType.
-var (
-	MessageType_name = map[int32]string{
+var MessageType_name = map[int32]string{
 	0:   "MessageType_Initialize",
 	1:   "MessageType_Ping",
 	2:   "MessageType_Success",
@@ -440,8 +435,9 @@ var (
 	707: "MessageType_BinanceOrderMsg",
 	708: "MessageType_BinanceCancelMsg",
 	709: "MessageType_BinanceSignedTx",
-	}
-	MessageType_value = map[string]int32{
+}
+
+var MessageType_value = map[string]int32{
 	"MessageType_Initialize":                                0,
 	"MessageType_Ping":                                      1,
 	"MessageType_Success":                                   2,
@@ -635,8 +631,7 @@ var (
 	"MessageType_BinanceOrderMsg":                           707,
 	"MessageType_BinanceCancelMsg":                          708,
 	"MessageType_BinanceSignedTx":                           709,
-	}
-)
+}

 func (x MessageType) Enum() *MessageType {
 	p := new(MessageType)
@@ -645,722 +640,250 @@ func (x MessageType) Enum() *MessageType {
 }

 func (x MessageType) String() string {
-	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+	return proto.EnumName(MessageType_name, int32(x))
 }

-func (MessageType) Descriptor() protoreflect.EnumDescriptor {
-	return file_messages_proto_enumTypes[0].Descriptor()
-}
-
-func (MessageType) Type() protoreflect.EnumType {
-	return &file_messages_proto_enumTypes[0]
-}
-
-func (x MessageType) Number() protoreflect.EnumNumber {
-	return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Do not use.
-func (x *MessageType) UnmarshalJSON(b []byte) error {
-	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+func (x *MessageType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(MessageType_value, data, "MessageType")
 	if err != nil {
 		return err
 	}
-	*x = MessageType(num)
+	*x = MessageType(value)
 	return nil
 }

-// Deprecated: Use MessageType.Descriptor instead.
 func (MessageType) EnumDescriptor() ([]byte, []int) {
-	return file_messages_proto_rawDescGZIP(), []int{0}
+	return fileDescriptor_4dc296cbfe5ffcd5, []int{0}
 }

-var file_messages_proto_extTypes = []protoimpl.ExtensionInfo{
-	{
-		ExtendedType:  (*descriptorpb.EnumValueOptions)(nil),
+var E_WireIn = &proto.ExtensionDesc{
+	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
 	ExtensionType: (*bool)(nil),
 	Field:         50002,
 	Name:          "hw.trezor.messages.wire_in",
 	Tag:           "varint,50002,opt,name=wire_in",
 	Filename:      "messages.proto",
-	},
-	{
-		ExtendedType:  (*descriptorpb.EnumValueOptions)(nil),
+}
+
+var E_WireOut = &proto.ExtensionDesc{
+	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
 	ExtensionType: (*bool)(nil),
 	Field:         50003,
 	Name:          "hw.trezor.messages.wire_out",
 	Tag:           "varint,50003,opt,name=wire_out",
 	Filename:      "messages.proto",
-	},
-	{
-		ExtendedType:  (*descriptorpb.EnumValueOptions)(nil),
+}
+
+var E_WireDebugIn = &proto.ExtensionDesc{
+	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
 	ExtensionType: (*bool)(nil),
 	Field:         50004,
 	Name:          "hw.trezor.messages.wire_debug_in",
 	Tag:           "varint,50004,opt,name=wire_debug_in",
 	Filename:      "messages.proto",
-	},
-	{
-		ExtendedType:  (*descriptorpb.EnumValueOptions)(nil),
+}
+
+var E_WireDebugOut = &proto.ExtensionDesc{
+	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
 	ExtensionType: (*bool)(nil),
 	Field:         50005,
 	Name:          "hw.trezor.messages.wire_debug_out",
 	Tag:           "varint,50005,opt,name=wire_debug_out",
 	Filename:      "messages.proto",
-	},
-	{
-		ExtendedType:  (*descriptorpb.EnumValueOptions)(nil),
+}
+
+var E_WireTiny = &proto.ExtensionDesc{
+	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
 	ExtensionType: (*bool)(nil),
 	Field:         50006,
 	Name:          "hw.trezor.messages.wire_tiny",
 	Tag:           "varint,50006,opt,name=wire_tiny",
 	Filename:      "messages.proto",
-	},
-	{
-		ExtendedType:  (*descriptorpb.EnumValueOptions)(nil),
+}
+
+var E_WireBootloader = &proto.ExtensionDesc{
+	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
 	ExtensionType: (*bool)(nil),
 	Field:         50007,
 	Name:          "hw.trezor.messages.wire_bootloader",
 	Tag:           "varint,50007,opt,name=wire_bootloader",
 	Filename:      "messages.proto",
-	},
-	{
-		ExtendedType:  (*descriptorpb.EnumValueOptions)(nil),
+}
+
+var E_WireNoFsm = &proto.ExtensionDesc{
+	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
 	ExtensionType: (*bool)(nil),
 	Field:         50008,
 	Name:          "hw.trezor.messages.wire_no_fsm",
 	Tag:           "varint,50008,opt,name=wire_no_fsm",
 	Filename:      "messages.proto",
-	},
 }

-// Extension fields to descriptorpb.EnumValueOptions.
-var (
-	// optional bool wire_in = 50002;
-	E_WireIn = &file_messages_proto_extTypes[0] // message can be transmitted via wire from PC to TREZOR
-	// optional bool wire_out = 50003;
-	E_WireOut = &file_messages_proto_extTypes[1] // message can be transmitted via wire from TREZOR to PC
-	// optional bool wire_debug_in = 50004;
-	E_WireDebugIn = &file_messages_proto_extTypes[2] // message can be transmitted via debug wire from PC to TREZOR
-	// optional bool wire_debug_out = 50005;
-	E_WireDebugOut = &file_messages_proto_extTypes[3] // message can be transmitted via debug wire from TREZOR to PC
-	// optional bool wire_tiny = 50006;
-	E_WireTiny = &file_messages_proto_extTypes[4] // message is handled by TREZOR when the USB stack is in tiny mode
-	// optional bool wire_bootloader = 50007;
-	E_WireBootloader = &file_messages_proto_extTypes[5] // message is only handled by TREZOR Bootloader
-	// optional bool wire_no_fsm = 50008;
-	E_WireNoFsm = &file_messages_proto_extTypes[6] // message is not handled by TREZOR unless the USB stack is in tiny mode
-)
-
-var File_messages_proto protoreflect.FileDescriptor
-
-var file_messages_proto_rawDesc = []byte{
-	0x0a, 0x0e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x12, 0x12, 0x68, 0x77, 0x2e, 0x74, 0x72, 0x65, 0x7a, 0x6f, 0x72, 0x2e, 0x6d, 0x65, 0x73, 0x73,
-	0x61, 0x67, 0x65, 0x73, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2a, 0xb9, 0x3f, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61,
-	0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x24, 0x0a, 0x16, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65,
-	0x10, 0x00, 0x1a, 0x08, 0x90, 0xb5, 0x18, 0x01, 0xb0, 0xb5, 0x18, 0x01, 0x12, 0x1a, 0x0a, 0x10,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x50, 0x69, 0x6e, 0x67,
-	0x10, 0x01, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x1d, 0x0a, 0x13, 0x4d, 0x65, 0x73, 0x73,
-	0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x10,
-	0x02, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x1d, 0x0a, 0x13, 0x4d, 0x65, 0x73, 0x73, 0x61,
-	0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0x03,
-	0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x1f, 0x0a, 0x15, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x50, 0x69, 0x6e, 0x10,
-	0x04, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x20, 0x0a, 0x16, 0x4d, 0x65, 0x73, 0x73, 0x61,
-	0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x57, 0x69, 0x70, 0x65, 0x44, 0x65, 0x76, 0x69, 0x63,
-	0x65, 0x10, 0x05, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x20, 0x0a, 0x16, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x47, 0x65, 0x74, 0x45, 0x6e, 0x74, 0x72,
-	0x6f, 0x70, 0x79, 0x10, 0x09, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x1d, 0x0a, 0x13, 0x4d,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x45, 0x6e, 0x74, 0x72, 0x6f,
-	0x70, 0x79, 0x10, 0x0a, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x20, 0x0a, 0x16, 0x4d, 0x65,
-	0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4c, 0x6f, 0x61, 0x64, 0x44, 0x65,
-	0x76, 0x69, 0x63, 0x65, 0x10, 0x0d, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x21, 0x0a, 0x17,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x52, 0x65, 0x73, 0x65,
-	0x74, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x10, 0x0e, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12,
-	0x1e, 0x0a, 0x14, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x46,
-	0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x10, 0x11, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12,
-	0x26, 0x0a, 0x1c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x50,
-	0x69, 0x6e, 0x4d, 0x61, 0x74, 0x72, 0x69, 0x78, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10,
-	0x12, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x2a, 0x0a, 0x18, 0x4d, 0x65, 0x73, 0x73, 0x61,
-	0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x50, 0x69, 0x6e, 0x4d, 0x61, 0x74, 0x72, 0x69, 0x78,
-	0x41, 0x63, 0x6b, 0x10, 0x13, 0x1a, 0x0c, 0x90, 0xb5, 0x18, 0x01, 0xb0, 0xb5, 0x18, 0x01, 0xc0,
-	0xb5, 0x18, 0x01, 0x12, 0x20, 0x0a, 0x12, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79,
-	0x70, 0x65, 0x5f, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x10, 0x14, 0x1a, 0x08, 0x90, 0xb5, 0x18,
-	0x01, 0xb0, 0xb5, 0x18, 0x01, 0x12, 0x22, 0x0a, 0x18, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x54, 0x79, 0x70, 0x65, 0x5f, 0x43, 0x6c, 0x65, 0x61, 0x72, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f,
-	0x6e, 0x10, 0x18, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x23, 0x0a, 0x19, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x41, 0x70, 0x70, 0x6c, 0x79, 0x53, 0x65,
-	0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x10, 0x19, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x23,
-	0x0a, 0x19, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x42, 0x75,
-	0x74, 0x74, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0x1a, 0x1a, 0x04, 0x98,
-	0xb5, 0x18, 0x01, 0x12, 0x27, 0x0a, 0x15, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79,
-	0x70, 0x65, 0x5f, 0x42, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x41, 0x63, 0x6b, 0x10, 0x1b, 0x1a, 0x0c,
-	0x90, 0xb5, 0x18, 0x01, 0xb0, 0xb5, 0x18, 0x01, 0xc0, 0xb5, 0x18, 0x01, 0x12, 0x20, 0x0a, 0x16,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x41, 0x70, 0x70, 0x6c,
-	0x79, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x10, 0x1c, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x22,
-	0x0a, 0x18, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x42, 0x61,
-	0x63, 0x6b, 0x75, 0x70, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x10, 0x22, 0x1a, 0x04, 0x90, 0xb5,
-	0x18, 0x01, 0x12, 0x24, 0x0a, 0x1a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70,
-	0x65, 0x5f, 0x45, 0x6e, 0x74, 0x72, 0x6f, 0x70, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x10, 0x23, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x20, 0x0a, 0x16, 0x4d, 0x65, 0x73, 0x73,
-	0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x45, 0x6e, 0x74, 0x72, 0x6f, 0x70, 0x79, 0x41,
-	0x63, 0x6b, 0x10, 0x24, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x27, 0x0a, 0x1d, 0x4d, 0x65,
-	0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x50, 0x61, 0x73, 0x73, 0x70, 0x68,
-	0x72, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0x29, 0x1a, 0x04, 0x98,
-	0xb5, 0x18, 0x01, 0x12, 0x2b, 0x0a, 0x19, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79,
-	0x70, 0x65, 0x5f, 0x50, 0x61, 0x73, 0x73, 0x70, 0x68, 0x72, 0x61, 0x73, 0x65, 0x41, 0x63, 0x6b,
-	0x10, 0x2a, 0x1a, 0x0c, 0x90, 0xb5, 0x18, 0x01, 0xb0, 0xb5, 0x18, 0x01, 0xc0, 0xb5, 0x18, 0x01,
-	0x12, 0x2c, 0x0a, 0x22, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f,
-	0x50, 0x61, 0x73, 0x73, 0x70, 0x68, 0x72, 0x61, 0x73, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0x4d, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x30,
-	0x0a, 0x1e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x50, 0x61,
-	0x73, 0x73, 0x70, 0x68, 0x72, 0x61, 0x73, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x41, 0x63, 0x6b,
-	0x10, 0x4e, 0x1a, 0x0c, 0x90, 0xb5, 0x18, 0x01, 0xb0, 0xb5, 0x18, 0x01, 0xc0, 0xb5, 0x18, 0x01,
-	0x12, 0x24, 0x0a, 0x1a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f,
-	0x52, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x10, 0x2d,
-	0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x21, 0x0a, 0x17, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x57, 0x6f, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x10, 0x2e, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x1d, 0x0a, 0x13, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x57, 0x6f, 0x72, 0x64, 0x41, 0x63, 0x6b,
-	0x10, 0x2f, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x21, 0x0a, 0x17, 0x4d, 0x65, 0x73, 0x73,
-	0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x47, 0x65, 0x74, 0x46, 0x65, 0x61, 0x74, 0x75,
-	0x72, 0x65, 0x73, 0x10, 0x37, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x23, 0x0a, 0x19, 0x4d,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x53, 0x65, 0x74, 0x55, 0x32,
-	0x46, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x10, 0x3f, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01,
-	0x12, 0x27, 0x0a, 0x19, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f,
-	0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x45, 0x72, 0x61, 0x73, 0x65, 0x10, 0x06, 0x1a,
-	0x08, 0x90, 0xb5, 0x18, 0x01, 0xb8, 0xb5, 0x18, 0x01, 0x12, 0x28, 0x0a, 0x1a, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72,
-	0x65, 0x55, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x10, 0x07, 0x1a, 0x08, 0x90, 0xb5, 0x18, 0x01, 0xb8,
-	0xb5, 0x18, 0x01, 0x12, 0x29, 0x0a, 0x1b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79,
-	0x70, 0x65, 0x5f, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x10, 0x08, 0x1a, 0x08, 0x98, 0xb5, 0x18, 0x01, 0xb8, 0xb5, 0x18, 0x01, 0x12, 0x22,
-	0x0a, 0x14, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x53, 0x65,
-	0x6c, 0x66, 0x54, 0x65, 0x73, 0x74, 0x10, 0x20, 0x1a, 0x08, 0x90, 0xb5, 0x18, 0x01, 0xb8, 0xb5,
-	0x18, 0x01, 0x12, 0x22, 0x0a, 0x18, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70,
-	0x65, 0x5f, 0x47, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x10, 0x0b,
-	0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x1f, 0x0a, 0x15, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x10,
-	0x0c, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x1c, 0x0a, 0x12, 0x4d, 0x65, 0x73, 0x73, 0x61,
-	0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x53, 0x69, 0x67, 0x6e, 0x54, 0x78, 0x10, 0x0f, 0x1a,
-	0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x1f, 0x0a, 0x15, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x54, 0x79, 0x70, 0x65, 0x5f, 0x54, 0x78, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0x15,
-	0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x1b, 0x0a, 0x11, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x54, 0x78, 0x41, 0x63, 0x6b, 0x10, 0x16, 0x1a, 0x04, 0x90,
-	0xb5, 0x18, 0x01, 0x12, 0x20, 0x0a, 0x16, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79,
-	0x70, 0x65, 0x5f, 0x47, 0x65, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x10, 0x1d, 0x1a,
-	0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x1d, 0x0a, 0x13, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x54, 0x79, 0x70, 0x65, 0x5f, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x10, 0x1e, 0x1a, 0x04,
-	0x98, 0xb5, 0x18, 0x01, 0x12, 0x21, 0x0a, 0x17, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54,
-	0x79, 0x70, 0x65, 0x5f, 0x53, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x10,
-	0x26, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x23, 0x0a, 0x19, 0x4d, 0x65, 0x73, 0x73, 0x61,
-	0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x10, 0x27, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x26, 0x0a, 0x1c,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x65, 0x73, 0x73,
-	0x61, 0x67, 0x65, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x10, 0x28, 0x1a, 0x04,
-	0x98, 0xb5, 0x18, 0x01, 0x12, 0x24, 0x0a, 0x1a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54,
-	0x79, 0x70, 0x65, 0x5f, 0x43, 0x69, 0x70, 0x68, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c,
-	0x75, 0x65, 0x10, 0x17, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x26, 0x0a, 0x1c, 0x4d, 0x65,
-	0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x43, 0x69, 0x70, 0x68, 0x65, 0x72,
-	0x65, 0x64, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x10, 0x30, 0x1a, 0x04, 0x98, 0xb5,
-	0x18, 0x01, 0x12, 0x22, 0x0a, 0x18, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70,
-	0x65, 0x5f, 0x53, 0x69, 0x67, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x10, 0x35,
-	0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x24, 0x0a, 0x1a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x49, 0x64, 0x65, 0x6e,
-	0x74, 0x69, 0x74, 0x79, 0x10, 0x36, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x27, 0x0a, 0x1d,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x47, 0x65, 0x74, 0x45,
-	0x43, 0x44, 0x48, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x10, 0x3d, 0x1a,
-	0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x24, 0x0a, 0x1a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x54, 0x79, 0x70, 0x65, 0x5f, 0x45, 0x43, 0x44, 0x48, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e,
-	0x4b, 0x65, 0x79, 0x10, 0x3e, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x20, 0x0a, 0x16, 0x4d,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x43, 0x6f, 0x73, 0x69, 0x43,
-	0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x10, 0x47, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x24, 0x0a,
-	0x1a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x43, 0x6f, 0x73,
-	0x69, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x10, 0x48, 0x1a, 0x04, 0x98,
-	0xb5, 0x18, 0x01, 0x12, 0x1e, 0x0a, 0x14, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79,
-	0x70, 0x65, 0x5f, 0x43, 0x6f, 0x73, 0x69, 0x53, 0x69, 0x67, 0x6e, 0x10, 0x49, 0x1a, 0x04, 0x90,
-	0xb5, 0x18, 0x01, 0x12, 0x23, 0x0a, 0x19, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79,
-	0x70, 0x65, 0x5f, 0x43, 0x6f, 0x73, 0x69, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65,
-	0x10, 0x4a, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x2f, 0x0a, 0x1d, 0x4d, 0x65, 0x73, 0x73,
-	0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x44, 0x65, 0x62, 0x75, 0x67, 0x4c, 0x69, 0x6e,
-	0x6b, 0x44, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x10, 0x64, 0x1a, 0x0c, 0xa0, 0xb5, 0x18,
-	0x01, 0xb0, 0xb5, 0x18, 0x01, 0xc0, 0xb5, 0x18, 0x01, 0x12, 0x2b, 0x0a, 0x1d, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x44, 0x65, 0x62, 0x75, 0x67, 0x4c, 0x69,
-	0x6e, 0x6b, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x10, 0x65, 0x1a, 0x08, 0xa0, 0xb5,
-	0x18, 0x01, 0xb0, 0xb5, 0x18, 0x01, 0x12, 0x24, 0x0a, 0x1a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x44, 0x65, 0x62, 0x75, 0x67, 0x4c, 0x69, 0x6e, 0x6b, 0x53,
-	0x74, 0x61, 0x74, 0x65, 0x10, 0x66, 0x1a, 0x04, 0xa8, 0xb5, 0x18, 0x01, 0x12, 0x23, 0x0a, 0x19,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x44, 0x65, 0x62, 0x75,
-	0x67, 0x4c, 0x69, 0x6e, 0x6b, 0x53, 0x74, 0x6f, 0x70, 0x10, 0x67, 0x1a, 0x04, 0xa0, 0xb5, 0x18,
-	0x01, 0x12, 0x22, 0x0a, 0x18, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65,
-	0x5f, 0x44, 0x65, 0x62, 0x75, 0x67, 0x4c, 0x69, 0x6e, 0x6b, 0x4c, 0x6f, 0x67, 0x10, 0x68, 0x1a,
-	0x04, 0xa8, 0xb5, 0x18, 0x01, 0x12, 0x29, 0x0a, 0x1f, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x54, 0x79, 0x70, 0x65, 0x5f, 0x44, 0x65, 0x62, 0x75, 0x67, 0x4c, 0x69, 0x6e, 0x6b, 0x4d, 0x65,
-	0x6d, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x61, 0x64, 0x10, 0x6e, 0x1a, 0x04, 0xa0, 0xb5, 0x18, 0x01,
-	0x12, 0x25, 0x0a, 0x1b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f,
-	0x44, 0x65, 0x62, 0x75, 0x67, 0x4c, 0x69, 0x6e, 0x6b, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x10,
-	0x6f, 0x1a, 0x04, 0xa8, 0xb5, 0x18, 0x01, 0x12, 0x2a, 0x0a, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61,
-	0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x44, 0x65, 0x62, 0x75, 0x67, 0x4c, 0x69, 0x6e, 0x6b,
-	0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x57, 0x72, 0x69, 0x74, 0x65, 0x10, 0x70, 0x1a, 0x04, 0xa0,
-	0xb5, 0x18, 0x01, 0x12, 0x29, 0x0a, 0x1f, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79,
-	0x70, 0x65, 0x5f, 0x44, 0x65, 0x62, 0x75, 0x67, 0x4c, 0x69, 0x6e, 0x6b, 0x46, 0x6c, 0x61, 0x73,
-	0x68, 0x45, 0x72, 0x61, 0x73, 0x65, 0x10, 0x71, 0x1a, 0x04, 0xa0, 0xb5, 0x18, 0x01, 0x12, 0x2b,
-	0x0a, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x45, 0x74,
-	0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x47, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b,
-	0x65, 0x79, 0x10, 0xc2, 0x03, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x28, 0x0a, 0x1d, 0x4d,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x45, 0x74, 0x68, 0x65, 0x72,
-	0x65, 0x75, 0x6d, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x10, 0xc3, 0x03, 0x1a,
-	0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x28, 0x0a, 0x1e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x54, 0x79, 0x70, 0x65, 0x5f, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x47, 0x65, 0x74,
-	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x10, 0x38, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12,
-	0x25, 0x0a, 0x1b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x45,
-	0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x10, 0x39,
-	0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x24, 0x0a, 0x1a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x53, 0x69,
-	0x67, 0x6e, 0x54, 0x78, 0x10, 0x3a, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x27, 0x0a, 0x1d,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x45, 0x74, 0x68, 0x65,
-	0x72, 0x65, 0x75, 0x6d, 0x54, 0x78, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0x3b, 0x1a,
-	0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x23, 0x0a, 0x19, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x54, 0x79, 0x70, 0x65, 0x5f, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x54, 0x78, 0x41,
-	0x63, 0x6b, 0x10, 0x3c, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x29, 0x0a, 0x1f, 0x4d, 0x65,
-	0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65,
-	0x75, 0x6d, 0x53, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x10, 0x40, 0x1a,
-	0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x2b, 0x0a, 0x21, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x54, 0x79, 0x70, 0x65, 0x5f, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x56, 0x65, 0x72,
-	0x69, 0x66, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x10, 0x41, 0x1a, 0x04, 0x90, 0xb5,
-	0x18, 0x01, 0x12, 0x2e, 0x0a, 0x24, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70,
-	0x65, 0x5f, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x10, 0x42, 0x1a, 0x04, 0x98, 0xb5,
-	0x18, 0x01, 0x12, 0x23, 0x0a, 0x19, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70,
-	0x65, 0x5f, 0x4e, 0x45, 0x4d, 0x47, 0x65, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x10,
-	0x43, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x20, 0x0a, 0x16, 0x4d, 0x65, 0x73, 0x73, 0x61,
-	0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4e, 0x45, 0x4d, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73,
-	0x73, 0x10, 0x44, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x1f, 0x0a, 0x15, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4e, 0x45, 0x4d, 0x53, 0x69, 0x67, 0x6e,
-	0x54, 0x78, 0x10, 0x45, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x21, 0x0a, 0x17, 0x4d, 0x65,
-	0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4e, 0x45, 0x4d, 0x53, 0x69, 0x67,
-	0x6e, 0x65, 0x64, 0x54, 0x78, 0x10, 0x46, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x27, 0x0a,
-	0x1d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4e, 0x45, 0x4d,
-	0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x10, 0x4b,
-	0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x29, 0x0a, 0x1f, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4e, 0x45, 0x4d, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74,
-	0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x10, 0x4c, 0x1a, 0x04, 0x98, 0xb5, 0x18,
-	0x01, 0x12, 0x24, 0x0a, 0x1a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65,
-	0x5f, 0x4c, 0x69, 0x73, 0x6b, 0x47, 0x65, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x10,
-	0x72, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x21, 0x0a, 0x17, 0x4d, 0x65, 0x73, 0x73, 0x61,
-	0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4c, 0x69, 0x73, 0x6b, 0x41, 0x64, 0x64, 0x72, 0x65,
-	0x73, 0x73, 0x10, 0x73, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x20, 0x0a, 0x16, 0x4d, 0x65,
-	0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4c, 0x69, 0x73, 0x6b, 0x53, 0x69,
-	0x67, 0x6e, 0x54, 0x78, 0x10, 0x74, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x22, 0x0a, 0x18,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4c, 0x69, 0x73, 0x6b,
-	0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x78, 0x10, 0x75, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01,
-	0x12, 0x25, 0x0a, 0x1b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f,
-	0x4c, 0x69, 0x73, 0x6b, 0x53, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x10,
-	0x76, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x2a, 0x0a, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61,
-	0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4c, 0x69, 0x73, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61,
-	0x67, 0x65, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x10, 0x77, 0x1a, 0x04, 0x98,
-	0xb5, 0x18, 0x01, 0x12, 0x27, 0x0a, 0x1d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79,
-	0x70, 0x65, 0x5f, 0x4c, 0x69, 0x73, 0x6b, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x10, 0x78, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x26, 0x0a, 0x1c,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4c, 0x69, 0x73, 0x6b,
-	0x47, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x10, 0x79, 0x1a, 0x04,
-	0x90, 0xb5, 0x18, 0x01, 0x12, 0x23, 0x0a, 0x19, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54,
-	0x79, 0x70, 0x65, 0x5f, 0x4c, 0x69, 0x73, 0x6b, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65,
-	0x79, 0x10, 0x7a, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x26, 0x0a, 0x1b, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x54, 0x65, 0x7a, 0x6f, 0x73, 0x47, 0x65,
-	0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x10, 0x96, 0x01, 0x1a, 0x04, 0x90, 0xb5, 0x18,
-	0x01, 0x12, 0x23, 0x0a, 0x18, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65,
-	0x5f, 0x54, 0x65, 0x7a, 0x6f, 0x73, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x10, 0x97, 0x01,
-	0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x22, 0x0a, 0x17, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x54, 0x65, 0x7a, 0x6f, 0x73, 0x53, 0x69, 0x67, 0x6e, 0x54,
-	0x78, 0x10, 0x98, 0x01, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x24, 0x0a, 0x19, 0x4d, 0x65,
-	0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x54, 0x65, 0x7a, 0x6f, 0x73, 0x53,
-	0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x78, 0x10, 0x99, 0x01, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01,
-	0x12, 0x28, 0x0a, 0x1d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f,
-	0x54, 0x65, 0x7a, 0x6f, 0x73, 0x47, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65,
-	0x79, 0x10, 0x9a, 0x01, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x25, 0x0a, 0x1a, 0x4d, 0x65,
-	0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x54, 0x65, 0x7a, 0x6f, 0x73, 0x50,
-	0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x10, 0x9b, 0x01, 0x1a, 0x04, 0x98, 0xb5, 0x18,
-	0x01, 0x12, 0x24, 0x0a, 0x19, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65,
-	0x5f, 0x53, 0x74, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x53, 0x69, 0x67, 0x6e, 0x54, 0x78, 0x10, 0xca,
-	0x01, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x29, 0x0a, 0x1e, 0x4d, 0x65, 0x73, 0x73, 0x61,
-	0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x53, 0x74, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x54, 0x78,
-	0x4f, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0xcb, 0x01, 0x1a, 0x04, 0x98, 0xb5,
-	0x18, 0x01, 0x12, 0x28, 0x0a, 0x1d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70,
-	0x65, 0x5f, 0x53, 0x74, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x47, 0x65, 0x74, 0x41, 0x64, 0x64, 0x72,
-	0x65, 0x73, 0x73, 0x10, 0xcf, 0x01, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x25, 0x0a, 0x1a,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x53, 0x74, 0x65, 0x6c,
-	0x6c, 0x61, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x10, 0xd0, 0x01, 0x1a, 0x04, 0x98,
-	0xb5, 0x18, 0x01, 0x12, 0x2d, 0x0a, 0x22, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79,
-	0x70, 0x65, 0x5f, 0x53, 0x74, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65,
-	0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x4f, 0x70, 0x10, 0xd2, 0x01, 0x1a, 0x04, 0x90, 0xb5,
-	0x18, 0x01, 0x12, 0x27, 0x0a, 0x1c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70,
-	0x65, 0x5f, 0x53, 0x74, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74,
-	0x4f, 0x70, 0x10, 0xd3, 0x01, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x2b, 0x0a, 0x20, 0x4d,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x53, 0x74, 0x65, 0x6c, 0x6c,
-	0x61, 0x72, 0x50, 0x61, 0x74, 0x68, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x4f, 0x70, 0x10,
-	0xd4, 0x01, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x2b, 0x0a, 0x20, 0x4d, 0x65, 0x73, 0x73,
-	0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x53, 0x74, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x4d,
-	0x61, 0x6e, 0x61, 0x67, 0x65, 0x4f, 0x66, 0x66, 0x65, 0x72, 0x4f, 0x70, 0x10, 0xd5, 0x01, 0x1a,
-	0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x32, 0x0a, 0x27, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x54, 0x79, 0x70, 0x65, 0x5f, 0x53, 0x74, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x43, 0x72, 0x65, 0x61,
-	0x74, 0x65, 0x50, 0x61, 0x73, 0x73, 0x69, 0x76, 0x65, 0x4f, 0x66, 0x66, 0x65, 0x72, 0x4f, 0x70,
-	0x10, 0xd6, 0x01, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x2a, 0x0a, 0x1f, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x53, 0x74, 0x65, 0x6c, 0x6c, 0x61, 0x72,
-	0x53, 0x65, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x4f, 0x70, 0x10, 0xd7, 0x01, 0x1a,
-	0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x2b, 0x0a, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x54, 0x79, 0x70, 0x65, 0x5f, 0x53, 0x74, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x43, 0x68, 0x61, 0x6e,
-	0x67, 0x65, 0x54, 0x72, 0x75, 0x73, 0x74, 0x4f, 0x70, 0x10, 0xd8, 0x01, 0x1a, 0x04, 0x90, 0xb5,
-	0x18, 0x01, 0x12, 0x2a, 0x0a, 0x1f, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70,
-	0x65, 0x5f, 0x53, 0x74, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x54, 0x72,
-	0x75, 0x73, 0x74, 0x4f, 0x70, 0x10, 0xd9, 0x01, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x2c,
-	0x0a, 0x21, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x53, 0x74,
-	0x65, 0x6c, 0x6c, 0x61, 0x72, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x4d, 0x65, 0x72, 0x67,
-	0x65, 0x4f, 0x70, 0x10, 0xda, 0x01, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x2a, 0x0a, 0x1f,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x53, 0x74, 0x65, 0x6c,
-	0x6c, 0x61, 0x72, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x44, 0x61, 0x74, 0x61, 0x4f, 0x70, 0x10,
-	0xdc, 0x01, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x2c, 0x0a, 0x21, 0x4d, 0x65, 0x73, 0x73,
-	0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x53, 0x74, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x42,
-	0x75, 0x6d, 0x70, 0x53, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x4f, 0x70, 0x10, 0xdd, 0x01,
-	0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x26, 0x0a, 0x1b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x53, 0x74, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x53, 0x69, 0x67,
-	0x6e, 0x65, 0x64, 0x54, 0x78, 0x10, 0xe6, 0x01, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x25,
-	0x0a, 0x1a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x54, 0x72,
-	0x6f, 0x6e, 0x47, 0x65, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x10, 0xfa, 0x01, 0x1a,
-	0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x22, 0x0a, 0x17, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x54, 0x79, 0x70, 0x65, 0x5f, 0x54, 0x72, 0x6f, 0x6e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
-	0x10, 0xfb, 0x01, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x21, 0x0a, 0x16, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x54, 0x72, 0x6f, 0x6e, 0x53, 0x69, 0x67,
-	0x6e, 0x54, 0x78, 0x10, 0xfc, 0x01, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x23, 0x0a, 0x18,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x54, 0x72, 0x6f, 0x6e,
-	0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x78, 0x10, 0xfd, 0x01, 0x1a, 0x04, 0x98, 0xb5, 0x18,
-	0x01, 0x12, 0x24, 0x0a, 0x19, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65,
-	0x5f, 0x43, 0x61, 0x72, 0x64, 0x61, 0x6e, 0x6f, 0x53, 0x69, 0x67, 0x6e, 0x54, 0x78, 0x10, 0xaf,
-	0x02, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x27, 0x0a, 0x1c, 0x4d, 0x65, 0x73, 0x73, 0x61,
-	0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x43, 0x61, 0x72, 0x64, 0x61, 0x6e, 0x6f, 0x54, 0x78,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0xb0, 0x02, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01,
-	0x12, 0x2a, 0x0a, 0x1f, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f,
-	0x43, 0x61, 0x72, 0x64, 0x61, 0x6e, 0x6f, 0x47, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63,
-	0x4b, 0x65, 0x79, 0x10, 0xb1, 0x02, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x27, 0x0a, 0x1c,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x43, 0x61, 0x72, 0x64,
-	0x61, 0x6e, 0x6f, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x10, 0xb2, 0x02, 0x1a,
-	0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x28, 0x0a, 0x1d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x54, 0x79, 0x70, 0x65, 0x5f, 0x43, 0x61, 0x72, 0x64, 0x61, 0x6e, 0x6f, 0x47, 0x65, 0x74, 0x41,
-	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x10, 0xb3, 0x02, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12,
-	0x25, 0x0a, 0x1a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x43,
-	0x61, 0x72, 0x64, 0x61, 0x6e, 0x6f, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x10, 0xb4, 0x02,
-	0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x23, 0x0a, 0x18, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x43, 0x61, 0x72, 0x64, 0x61, 0x6e, 0x6f, 0x54, 0x78, 0x41,
-	0x63, 0x6b, 0x10, 0xb5, 0x02, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x26, 0x0a, 0x1b, 0x4d,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x43, 0x61, 0x72, 0x64, 0x61,
-	0x6e, 0x6f, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x78, 0x10, 0xb6, 0x02, 0x1a, 0x04, 0x98,
-	0xb5, 0x18, 0x01, 0x12, 0x29, 0x0a, 0x1e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79,
-	0x70, 0x65, 0x5f, 0x4f, 0x6e, 0x74, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x47, 0x65, 0x74, 0x41, 0x64,
-	0x64, 0x72, 0x65, 0x73, 0x73, 0x10, 0xde, 0x02, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x26,
-	0x0a, 0x1b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4f, 0x6e,
-	0x74, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x10, 0xdf, 0x02,
-	0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x2b, 0x0a, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4f, 0x6e, 0x74, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x47, 0x65,
-	0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x10, 0xe0, 0x02, 0x1a, 0x04, 0x90,
-	0xb5, 0x18, 0x01, 0x12, 0x28, 0x0a, 0x1d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79,
-	0x70, 0x65, 0x5f, 0x4f, 0x6e, 0x74, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x50, 0x75, 0x62, 0x6c, 0x69,
-	0x63, 0x4b, 0x65, 0x79, 0x10, 0xe1, 0x02, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x2b, 0x0a,
-	0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4f, 0x6e, 0x74,
-	0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x53, 0x69, 0x67, 0x6e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65,
-	0x72, 0x10, 0xe2, 0x02, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x2d, 0x0a, 0x22, 0x4d, 0x65,
-	0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4f, 0x6e, 0x74, 0x6f, 0x6c, 0x6f,
-	0x67, 0x79, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72,
-	0x10, 0xe3, 0x02, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x2e, 0x0a, 0x23, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4f, 0x6e, 0x74, 0x6f, 0x6c, 0x6f, 0x67,
-	0x79, 0x53, 0x69, 0x67, 0x6e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x4f, 0x6e, 0x67,
-	0x10, 0xe4, 0x02, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x30, 0x0a, 0x25, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4f, 0x6e, 0x74, 0x6f, 0x6c, 0x6f, 0x67,
-	0x79, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x4f,
-	0x6e, 0x67, 0x10, 0xe5, 0x02, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x30, 0x0a, 0x25, 0x4d,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4f, 0x6e, 0x74, 0x6f, 0x6c,
-	0x6f, 0x67, 0x79, 0x53, 0x69, 0x67, 0x6e, 0x4f, 0x6e, 0x74, 0x49, 0x64, 0x52, 0x65, 0x67, 0x69,
-	0x73, 0x74, 0x65, 0x72, 0x10, 0xe6, 0x02, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x32, 0x0a,
-	0x27, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4f, 0x6e, 0x74,
-	0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x4f, 0x6e, 0x74, 0x49, 0x64,
-	0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x10, 0xe7, 0x02, 0x1a, 0x04, 0x98, 0xb5, 0x18,
-	0x01, 0x12, 0x35, 0x0a, 0x2a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65,
-	0x5f, 0x4f, 0x6e, 0x74, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x53, 0x69, 0x67, 0x6e, 0x4f, 0x6e, 0x74,
-	0x49, 0x64, 0x41, 0x64, 0x64, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x10,
-	0xe8, 0x02, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x37, 0x0a, 0x2c, 0x4d, 0x65, 0x73, 0x73,
-	0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4f, 0x6e, 0x74, 0x6f, 0x6c, 0x6f, 0x67, 0x79,
-	0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x4f, 0x6e, 0x74, 0x49, 0x64, 0x41, 0x64, 0x64, 0x41, 0x74,
-	0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x10, 0xe9, 0x02, 0x1a, 0x04, 0x98, 0xb5, 0x18,
-	0x01, 0x12, 0x27, 0x0a, 0x1c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65,
-	0x5f, 0x52, 0x69, 0x70, 0x70, 0x6c, 0x65, 0x47, 0x65, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73,
-	0x73, 0x10, 0x90, 0x03, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x24, 0x0a, 0x19, 0x4d, 0x65,
-	0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x52, 0x69, 0x70, 0x70, 0x6c, 0x65,
-	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x10, 0x91, 0x03, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01,
-	0x12, 0x23, 0x0a, 0x18, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f,
-	0x52, 0x69, 0x70, 0x70, 0x6c, 0x65, 0x53, 0x69, 0x67, 0x6e, 0x54, 0x78, 0x10, 0x92, 0x03, 0x1a,
-	0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x25, 0x0a, 0x1a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x54, 0x79, 0x70, 0x65, 0x5f, 0x52, 0x69, 0x70, 0x70, 0x6c, 0x65, 0x53, 0x69, 0x67, 0x6e, 0x65,
-	0x64, 0x54, 0x78, 0x10, 0x93, 0x03, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x33, 0x0a, 0x28,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65,
-	0x72, 0x6f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x69,
-	0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0xf5, 0x03, 0x1a, 0x04, 0x98, 0xb5, 0x18,
-	0x01, 0x12, 0x2f, 0x0a, 0x24, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65,
-	0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69,
-	0x6f, 0x6e, 0x49, 0x6e, 0x69, 0x74, 0x41, 0x63, 0x6b, 0x10, 0xf6, 0x03, 0x1a, 0x04, 0x98, 0xb5,
-	0x18, 0x01, 0x12, 0x37, 0x0a, 0x2c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70,
-	0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74,
-	0x69, 0x6f, 0x6e, 0x53, 0x65, 0x74, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x10, 0xf7, 0x03, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x33, 0x0a, 0x28, 0x4d,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72,
-	0x6f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x74, 0x49,
-	0x6e, 0x70, 0x75, 0x74, 0x41, 0x63, 0x6b, 0x10, 0xf8, 0x03, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01,
-	0x12, 0x40, 0x0a, 0x35, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f,
-	0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f,
-	0x6e, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x50, 0x65, 0x72, 0x6d, 0x75, 0x74, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0xf9, 0x03, 0x1a, 0x04, 0x98, 0xb5,
-	0x18, 0x01, 0x12, 0x3c, 0x0a, 0x31, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70,
-	0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74,
-	0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x50, 0x65, 0x72, 0x6d, 0x75, 0x74, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x41, 0x63, 0x6b, 0x10, 0xfa, 0x03, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01,
-	0x12, 0x38, 0x0a, 0x2d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f,
-	0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f,
-	0x6e, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x56, 0x69, 0x6e, 0x69, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x10, 0xfb, 0x03, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x34, 0x0a, 0x29, 0x4d, 0x65,
-	0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f,
-	0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x70, 0x75, 0x74,
-	0x56, 0x69, 0x6e, 0x69, 0x41, 0x63, 0x6b, 0x10, 0xfc, 0x03, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01,
-	0x12, 0x3b, 0x0a, 0x30, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f,
-	0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f,
-	0x6e, 0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x53, 0x65, 0x74, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x10, 0xfd, 0x03, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x37, 0x0a,
-	0x2c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e,
-	0x65, 0x72, 0x6f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x6c,
-	0x6c, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x53, 0x65, 0x74, 0x41, 0x63, 0x6b, 0x10, 0xfe, 0x03,
-	0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x38, 0x0a, 0x2d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x54, 0x72, 0x61, 0x6e,
-	0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x74, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0xff, 0x03, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01,
-	0x12, 0x34, 0x0a, 0x29, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f,
-	0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f,
-	0x6e, 0x53, 0x65, 0x74, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x41, 0x63, 0x6b, 0x10, 0x80, 0x04,
-	0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x38, 0x0a, 0x2d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x54, 0x72, 0x61, 0x6e,
-	0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x6c, 0x6c, 0x4f, 0x75, 0x74, 0x53, 0x65, 0x74,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0x81, 0x04, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01,
-	0x12, 0x34, 0x0a, 0x29, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f,
-	0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f,
-	0x6e, 0x41, 0x6c, 0x6c, 0x4f, 0x75, 0x74, 0x53, 0x65, 0x74, 0x41, 0x63, 0x6b, 0x10, 0x82, 0x04,
-	0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x38, 0x0a, 0x2d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x54, 0x72, 0x61, 0x6e,
-	0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x67, 0x6e, 0x49, 0x6e, 0x70, 0x75, 0x74,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0x83, 0x04, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01,
-	0x12, 0x34, 0x0a, 0x29, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f,
-	0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f,
-	0x6e, 0x53, 0x69, 0x67, 0x6e, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x41, 0x63, 0x6b, 0x10, 0x84, 0x04,
-	0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x34, 0x0a, 0x29, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x54, 0x72, 0x61, 0x6e,
-	0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x10, 0x85, 0x04, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x30, 0x0a, 0x25,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65,
-	0x72, 0x6f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x6e,
-	0x61, 0x6c, 0x41, 0x63, 0x6b, 0x10, 0x86, 0x04, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x36,
-	0x0a, 0x2b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f,
-	0x6e, 0x65, 0x72, 0x6f, 0x4b, 0x65, 0x79, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x45, 0x78, 0x70, 0x6f,
-	0x72, 0x74, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0x92, 0x04,
-	0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x32, 0x0a, 0x27, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x4b, 0x65, 0x79, 0x49,
-	0x6d, 0x61, 0x67, 0x65, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x49, 0x6e, 0x69, 0x74, 0x41, 0x63,
-	0x6b, 0x10, 0x93, 0x04, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x34, 0x0a, 0x29, 0x4d, 0x65,
-	0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f,
-	0x4b, 0x65, 0x79, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x53, 0x79, 0x6e, 0x63, 0x53, 0x74, 0x65, 0x70,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0x94, 0x04, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01,
-	0x12, 0x30, 0x0a, 0x25, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f,
-	0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x4b, 0x65, 0x79, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x53, 0x79,
-	0x6e, 0x63, 0x53, 0x74, 0x65, 0x70, 0x41, 0x63, 0x6b, 0x10, 0x95, 0x04, 0x1a, 0x04, 0x98, 0xb5,
-	0x18, 0x01, 0x12, 0x35, 0x0a, 0x2a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70,
-	0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x4b, 0x65, 0x79, 0x49, 0x6d, 0x61, 0x67, 0x65,
-	0x53, 0x79, 0x6e, 0x63, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x10, 0x96, 0x04, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x31, 0x0a, 0x26, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x4b,
-	0x65, 0x79, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x53, 0x79, 0x6e, 0x63, 0x46, 0x69, 0x6e, 0x61, 0x6c,
-	0x41, 0x63, 0x6b, 0x10, 0x97, 0x04, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x27, 0x0a, 0x1c,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65,
-	0x72, 0x6f, 0x47, 0x65, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x10, 0x9c, 0x04, 0x1a,
-	0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x24, 0x0a, 0x19, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x41, 0x64, 0x64, 0x72, 0x65,
-	0x73, 0x73, 0x10, 0x9d, 0x04, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x28, 0x0a, 0x1d, 0x4d,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72,
-	0x6f, 0x47, 0x65, 0x74, 0x57, 0x61, 0x74, 0x63, 0x68, 0x4b, 0x65, 0x79, 0x10, 0x9e, 0x04, 0x1a,
-	0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x25, 0x0a, 0x1a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x57, 0x61, 0x74, 0x63, 0x68,
-	0x4b, 0x65, 0x79, 0x10, 0x9f, 0x04, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x2d, 0x0a, 0x22,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x44, 0x65, 0x62, 0x75,
-	0x67, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x44, 0x69, 0x61, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x10, 0xa2, 0x04, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x29, 0x0a, 0x1e, 0x4d,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x44, 0x65, 0x62, 0x75, 0x67,
-	0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x44, 0x69, 0x61, 0x67, 0x41, 0x63, 0x6b, 0x10, 0xa3, 0x04,
-	0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x2c, 0x0a, 0x21, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x47, 0x65, 0x74, 0x54,
-	0x78, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0xa6, 0x04, 0x1a, 0x04,
-	0x90, 0xb5, 0x18, 0x01, 0x12, 0x28, 0x0a, 0x1d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54,
-	0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x47, 0x65, 0x74, 0x54, 0x78, 0x4b,
-	0x65, 0x79, 0x41, 0x63, 0x6b, 0x10, 0xa7, 0x04, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x34,
-	0x0a, 0x29, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f,
-	0x6e, 0x65, 0x72, 0x6f, 0x4c, 0x69, 0x76, 0x65, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x53,
-	0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0xa8, 0x04, 0x1a, 0x04,
-	0x90, 0xb5, 0x18, 0x01, 0x12, 0x30, 0x0a, 0x25, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54,
-	0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x4c, 0x69, 0x76, 0x65, 0x52, 0x65,
-	0x66, 0x72, 0x65, 0x73, 0x68, 0x53, 0x74, 0x61, 0x72, 0x74, 0x41, 0x63, 0x6b, 0x10, 0xa9, 0x04,
-	0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x33, 0x0a, 0x28, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x4c, 0x69, 0x76, 0x65,
-	0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x53, 0x74, 0x65, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x10, 0xaa, 0x04, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x2f, 0x0a, 0x24, 0x4d,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72,
-	0x6f, 0x4c, 0x69, 0x76, 0x65, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x53, 0x74, 0x65, 0x70,
-	0x41, 0x63, 0x6b, 0x10, 0xab, 0x04, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x34, 0x0a, 0x29,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65,
-	0x72, 0x6f, 0x4c, 0x69, 0x76, 0x65, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x46, 0x69, 0x6e,
-	0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0xac, 0x04, 0x1a, 0x04, 0x90, 0xb5,
-	0x18, 0x01, 0x12, 0x30, 0x0a, 0x25, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70,
-	0x65, 0x5f, 0x4d, 0x6f, 0x6e, 0x65, 0x72, 0x6f, 0x4c, 0x69, 0x76, 0x65, 0x52, 0x65, 0x66, 0x72,
-	0x65, 0x73, 0x68, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x41, 0x63, 0x6b, 0x10, 0xad, 0x04, 0x1a, 0x04,
-	0x98, 0xb5, 0x18, 0x01, 0x12, 0x26, 0x0a, 0x1b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54,
-	0x79, 0x70, 0x65, 0x5f, 0x45, 0x6f, 0x73, 0x47, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63,
-	0x4b, 0x65, 0x79, 0x10, 0xd8, 0x04, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x23, 0x0a, 0x18,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x45, 0x6f, 0x73, 0x50,
-	0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x10, 0xd9, 0x04, 0x1a, 0x04, 0x98, 0xb5, 0x18,
-	0x01, 0x12, 0x20, 0x0a, 0x15, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65,
-	0x5f, 0x45, 0x6f, 0x73, 0x53, 0x69, 0x67, 0x6e, 0x54, 0x78, 0x10, 0xda, 0x04, 0x1a, 0x04, 0x90,
-	0xb5, 0x18, 0x01, 0x12, 0x29, 0x0a, 0x1e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79,
-	0x70, 0x65, 0x5f, 0x45, 0x6f, 0x73, 0x54, 0x78, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0xdb, 0x04, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x25,
-	0x0a, 0x1a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x45, 0x6f,
-	0x73, 0x54, 0x78, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x63, 0x6b, 0x10, 0xdc, 0x04, 0x1a,
-	0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x22, 0x0a, 0x17, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x54, 0x79, 0x70, 0x65, 0x5f, 0x45, 0x6f, 0x73, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x78,
-	0x10, 0xdd, 0x04, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x28, 0x0a, 0x1d, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x42, 0x69, 0x6e, 0x61, 0x6e, 0x63, 0x65,
-	0x47, 0x65, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x10, 0xbc, 0x05, 0x1a, 0x04, 0x90,
-	0xb5, 0x18, 0x01, 0x12, 0x25, 0x0a, 0x1a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79,
-	0x70, 0x65, 0x5f, 0x42, 0x69, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73,
-	0x73, 0x10, 0xbd, 0x05, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x2a, 0x0a, 0x1f, 0x4d, 0x65,
-	0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x42, 0x69, 0x6e, 0x61, 0x6e, 0x63,
-	0x65, 0x47, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x10, 0xbe, 0x05,
-	0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x27, 0x0a, 0x1c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x42, 0x69, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x50, 0x75, 0x62,
-	0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x10, 0xbf, 0x05, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12,
-	0x24, 0x0a, 0x19, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x42,
-	0x69, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x69, 0x67, 0x6e, 0x54, 0x78, 0x10, 0xc0, 0x05, 0x1a,
-	0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x27, 0x0a, 0x1c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x54, 0x79, 0x70, 0x65, 0x5f, 0x42, 0x69, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x78, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0xc1, 0x05, 0x1a, 0x04, 0x98, 0xb5, 0x18, 0x01, 0x12, 0x29,
-	0x0a, 0x1e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x42, 0x69,
-	0x6e, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4d, 0x73, 0x67,
-	0x10, 0xc2, 0x05, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x26, 0x0a, 0x1b, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x42, 0x69, 0x6e, 0x61, 0x6e, 0x63, 0x65,
-	0x4f, 0x72, 0x64, 0x65, 0x72, 0x4d, 0x73, 0x67, 0x10, 0xc3, 0x05, 0x1a, 0x04, 0x90, 0xb5, 0x18,
-	0x01, 0x12, 0x27, 0x0a, 0x1c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65,
-	0x5f, 0x42, 0x69, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x4d, 0x73,
-	0x67, 0x10, 0xc4, 0x05, 0x1a, 0x04, 0x90, 0xb5, 0x18, 0x01, 0x12, 0x26, 0x0a, 0x1b, 0x4d, 0x65,
-	0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x42, 0x69, 0x6e, 0x61, 0x6e, 0x63,
-	0x65, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x78, 0x10, 0xc5, 0x05, 0x1a, 0x04, 0x98, 0xb5,
-	0x18, 0x01, 0x3a, 0x3c, 0x0a, 0x07, 0x77, 0x69, 0x72, 0x65, 0x5f, 0x69, 0x6e, 0x12, 0x21, 0x2e,
-	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
-	0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
-	0x18, 0xd2, 0x86, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x77, 0x69, 0x72, 0x65, 0x49, 0x6e,
-	0x3a, 0x3e, 0x0a, 0x08, 0x77, 0x69, 0x72, 0x65, 0x5f, 0x6f, 0x75, 0x74, 0x12, 0x21, 0x2e, 0x67,
-	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45,
-	0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18,
-	0xd3, 0x86, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x77, 0x69, 0x72, 0x65, 0x4f, 0x75, 0x74,
-	0x3a, 0x47, 0x0a, 0x0d, 0x77, 0x69, 0x72, 0x65, 0x5f, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x69,
-	0x6e, 0x12, 0x21, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74,
-	0x69, 0x6f, 0x6e, 0x73, 0x18, 0xd4, 0x86, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x77, 0x69,
-	0x72, 0x65, 0x44, 0x65, 0x62, 0x75, 0x67, 0x49, 0x6e, 0x3a, 0x49, 0x0a, 0x0e, 0x77, 0x69, 0x72,
-	0x65, 0x5f, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x6f, 0x75, 0x74, 0x12, 0x21, 0x2e, 0x67, 0x6f,
-	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e,
-	0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xd5,
-	0x86, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x77, 0x69, 0x72, 0x65, 0x44, 0x65, 0x62, 0x75,
-	0x67, 0x4f, 0x75, 0x74, 0x3a, 0x40, 0x0a, 0x09, 0x77, 0x69, 0x72, 0x65, 0x5f, 0x74, 0x69, 0x6e,
-	0x79, 0x12, 0x21, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74,
-	0x69, 0x6f, 0x6e, 0x73, 0x18, 0xd6, 0x86, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x77, 0x69,
-	0x72, 0x65, 0x54, 0x69, 0x6e, 0x79, 0x3a, 0x4c, 0x0a, 0x0f, 0x77, 0x69, 0x72, 0x65, 0x5f, 0x62,
-	0x6f, 0x6f, 0x74, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x72, 0x12, 0x21, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
-	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d,
-	0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xd7, 0x86, 0x03,
-	0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x77, 0x69, 0x72, 0x65, 0x42, 0x6f, 0x6f, 0x74, 0x6c, 0x6f,
-	0x61, 0x64, 0x65, 0x72, 0x3a, 0x43, 0x0a, 0x0b, 0x77, 0x69, 0x72, 0x65, 0x5f, 0x6e, 0x6f, 0x5f,
-	0x66, 0x73, 0x6d, 0x12, 0x21, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f,
-	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xd8, 0x86, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09,
-	0x77, 0x69, 0x72, 0x65, 0x4e, 0x6f, 0x46, 0x73, 0x6d, 0x42, 0x6f, 0x0a, 0x23, 0x63, 0x6f, 0x6d,
-	0x2e, 0x73, 0x61, 0x74, 0x6f, 0x73, 0x68, 0x69, 0x6c, 0x61, 0x62, 0x73, 0x2e, 0x74, 0x72, 0x65,
-	0x7a, 0x6f, 0x72, 0x2e, 0x6c, 0x69, 0x62, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
-	0x42, 0x0d, 0x54, 0x72, 0x65, 0x7a, 0x6f, 0x72, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5a,
-	0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x65, 0x74, 0x68, 0x65,
-	0x72, 0x65, 0x75, 0x6d, 0x2f, 0x67, 0x6f, 0x2d, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d,
-	0x2f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x2f, 0x75, 0x73, 0x62, 0x77, 0x61, 0x6c,
-	0x6c, 0x65, 0x74, 0x2f, 0x74, 0x72, 0x65, 0x7a, 0x6f, 0x72,
+func init() {
+	proto.RegisterEnum("hw.trezor.messages.MessageType", MessageType_name, MessageType_value)
+	proto.RegisterExtension(E_WireIn)
+	proto.RegisterExtension(E_WireOut)
+	proto.RegisterExtension(E_WireDebugIn)
+	proto.RegisterExtension(E_WireDebugOut)
+	proto.RegisterExtension(E_WireTiny)
+	proto.RegisterExtension(E_WireBootloader)
+	proto.RegisterExtension(E_WireNoFsm)
 }

-var (
-	file_messages_proto_rawDescOnce sync.Once
-	file_messages_proto_rawDescData = file_messages_proto_rawDesc
-)
+func init() { proto.RegisterFile("messages.proto", fileDescriptor_4dc296cbfe5ffcd5) }

-func file_messages_proto_rawDescGZIP() []byte {
-	file_messages_proto_rawDescOnce.Do(func() {
-		file_messages_proto_rawDescData = protoimpl.X.CompressGZIP(file_messages_proto_rawDescData)
-	})
-	return file_messages_proto_rawDescData
-}
-
-var file_messages_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
-var file_messages_proto_goTypes = []any{
-	(MessageType)(0),                      // 0: hw.trezor.messages.MessageType
-	(*descriptorpb.EnumValueOptions)(nil), // 1: google.protobuf.EnumValueOptions
-}
-var file_messages_proto_depIdxs = []int32{
-	1, // 0: hw.trezor.messages.wire_in:extendee -> google.protobuf.EnumValueOptions
-	1, // 1: hw.trezor.messages.wire_out:extendee -> google.protobuf.EnumValueOptions
-	1, // 2: hw.trezor.messages.wire_debug_in:extendee -> google.protobuf.EnumValueOptions
-	1, // 3: hw.trezor.messages.wire_debug_out:extendee -> google.protobuf.EnumValueOptions
-	1, // 4: hw.trezor.messages.wire_tiny:extendee -> google.protobuf.EnumValueOptions
-	1, // 5: hw.trezor.messages.wire_bootloader:extendee -> google.protobuf.EnumValueOptions
-	1, // 6: hw.trezor.messages.wire_no_fsm:extendee -> google.protobuf.EnumValueOptions
-	7, // [7:7] is the sub-list for method output_type
-	7, // [7:7] is the sub-list for method input_type
-	7, // [7:7] is the sub-list for extension type_name
-	0, // [0:7] is the sub-list for extension extendee
-	0, // [0:0] is the sub-list for field type_name
-}
-
-func init() { file_messages_proto_init() }
-func file_messages_proto_init() {
-	if File_messages_proto != nil {
-		return
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_messages_proto_rawDesc,
-			NumEnums:      1,
-			NumMessages:   0,
-			NumExtensions: 7,
-			NumServices:   0,
-		},
-		GoTypes:           file_messages_proto_goTypes,
-		DependencyIndexes: file_messages_proto_depIdxs,
-		EnumInfos:         file_messages_proto_enumTypes,
-		ExtensionInfos:    file_messages_proto_extTypes,
-	}.Build()
-	File_messages_proto = out.File
-	file_messages_proto_rawDesc = nil
-	file_messages_proto_goTypes = nil
-	file_messages_proto_depIdxs = nil
+var fileDescriptor_4dc296cbfe5ffcd5 = []byte{
+	// 2430 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x9a, 0xd9, 0x73, 0x1c, 0xc5,
+	0x1d, 0xc7, 0xb3, 0xab, 0x11, 0x88, 0xf6, 0x41, 0x23, 0xb0, 0x2d, 0xaf, 0x2f, 0xf9, 0xc0, 0x96,
+	0x2f, 0xd9, 0x10, 0x0c, 0x44, 0x38, 0x60, 0x69, 0xb5, 0x12, 0x8a, 0xb5, 0x5a, 0x97, 0x76, 0xb1,
+	0x1f, 0x5d, 0xa3, 0x9d, 0xd6, 0x6e, 0x97, 0x67, 0x67, 0x86, 0x9e, 0x1e, 0x49, 0xeb, 0xa7, 0x9c,
+	0x3c, 0x13, 0x48, 0xc0, 0xb9, 0xa9, 0xa4, 0x2a, 0x21, 0x57, 0x85, 0x1c, 0x4e, 0x25, 0x55, 0x39,
+	0x08, 0x24, 0x2f, 0xc9, 0x43, 0x52, 0x9c, 0x86, 0x40, 0xee, 0x90, 0xe4, 0x0f, 0xc8, 0xc5, 0x91,
+	0xa4, 0x7a, 0xa6, 0xbb, 0xe7, 0xd8, 0xdf, 0xae, 0x36, 0x6f, 0x58, 0xf3, 0xf9, 0x7d, 0x7f, 0x47,
+	0xff, 0xfa, 0x37, 0xdd, 0xb3, 0xa0, 0xcd, 0x2d, 0xe2, 0xfb, 0x66, 0x83, 0xf8, 0xe3, 0x1e, 0x73,
+	0xb9, 0x3b, 0x3c, 0xdc, 0x5c, 0x1d, 0xe7, 0x8c, 0x5c, 0x76, 0xd9, 0xb8, 0x7a, 0x52, 0x18, 0x6d,
+	0xb8, 0x6e, 0xc3, 0x26, 0x27, 0x42, 0x62, 0x29, 0x58, 0x3e, 0x61, 0x11, 0xbf, 0xce, 0xa8, 0xc7,
+	0x5d, 0x16, 0x59, 0x1d, 0xf9, 0xfe, 0x7d, 0x68, 0x43, 0x39, 0xc2, 0x6b, 0x6d, 0x8f, 0x0c, 0x1f,
+	0x40, 0x5b, 0x13, 0xff, 0xbc, 0x38, 0xe7, 0x50, 0x4e, 0x4d, 0x9b, 0x5e, 0x26, 0xf8, 0x5d, 0x85,
+	0xa1, 0x87, 0xaf, 0x8e, 0xe4, 0x9e, 0xba, 0x3a, 0x92, 0x1b, 0x2e, 0x20, 0x9c, 0xa4, 0xce, 0x51,
+	0xa7, 0x81, 0x73, 0x05, 0x43, 0x3c, 0x1f, 0xde, 0x85, 0x6e, 0x4e, 0x3e, 0xab, 0x06, 0xf5, 0x3a,
+	0xf1, 0x7d, 0x9c, 0x2f, 0x18, 0x57, 0x80, 0xc7, 0x33, 0x26, 0xb5, 0x03, 0x46, 0xf0, 0x80, 0x7c,
+	0xbc, 0x07, 0x6d, 0x49, 0x3e, 0x2e, 0x36, 0x4d, 0xa7, 0x41, 0xce, 0x51, 0x07, 0x1b, 0x52, 0x7e,
+	0x34, 0x1d, 0xe0, 0x05, 0xea, 0x91, 0x69, 0xb2, 0x42, 0xeb, 0x04, 0x0f, 0xc2, 0xc4, 0x2c, 0xe1,
+	0x25, 0x87, 0x33, 0xd7, 0x6b, 0xe3, 0x1b, 0xe0, 0x10, 0xd5, 0x63, 0x24, 0x63, 0xc8, 0x08, 0xcc,
+	0xbb, 0xa6, 0x25, 0x5d, 0x6c, 0x92, 0x02, 0x7b, 0xd1, 0xb6, 0x24, 0xb1, 0x48, 0x7c, 0xc2, 0x25,
+	0xb2, 0x59, 0x22, 0xbb, 0xd1, 0x2d, 0xa9, 0x3c, 0x89, 0xc9, 0x03, 0x46, 0x7c, 0x7c, 0x93, 0x74,
+	0x72, 0x10, 0xed, 0xcc, 0x94, 0xb0, 0x6c, 0x72, 0x46, 0xd7, 0x16, 0xc9, 0x83, 0x01, 0xf1, 0x39,
+	0x1e, 0x96, 0xdc, 0x11, 0x34, 0x02, 0x72, 0x93, 0xf5, 0x4b, 0xf8, 0xe6, 0xc2, 0x46, 0xb5, 0x24,
+	0x4f, 0x47, 0x81, 0x0f, 0xa7, 0x8a, 0x67, 0x3a, 0x75, 0x62, 0xe3, 0x5b, 0x12, 0x0b, 0xb7, 0x2f,
+	0xad, 0x56, 0xb4, 0x89, 0xc9, 0xaa, 0xc4, 0xf7, 0xa9, 0xeb, 0xe0, 0x11, 0x19, 0xf9, 0x7e, 0xb4,
+	0x3d, 0xc9, 0x4c, 0x7a, 0x9e, 0xdd, 0xae, 0x12, 0xce, 0xa9, 0xd3, 0xf0, 0xf1, 0x76, 0x18, 0x9a,
+	0x0a, 0x38, 0x77, 0x1d, 0x15, 0x7b, 0x41, 0xc6, 0x7e, 0x28, 0xbd, 0x98, 0x11, 0x24, 0x02, 0xdf,
+	0xd1, 0x11, 0xf8, 0xd6, 0x0e, 0x97, 0x33, 0xb6, 0xd9, 0xf0, 0xf1, 0x4e, 0xe9, 0x2f, 0x13, 0xf8,
+	0x94, 0x59, 0xbf, 0x14, 0x78, 0xb2, 0xe4, 0xfb, 0x24, 0x73, 0x00, 0x15, 0x80, 0x65, 0x55, 0x41,
+	0xed, 0x87, 0x57, 0x57, 0x52, 0x22, 0xaa, 0x03, 0x52, 0xe7, 0x10, 0xda, 0x95, 0x2a, 0xb9, 0xe9,
+	0xfb, 0x5e, 0x93, 0x99, 0x3e, 0x51, 0x52, 0x87, 0xa5, 0xd4, 0xd1, 0x74, 0x11, 0x62, 0x50, 0xa8,
+	0x1d, 0xc9, 0xe4, 0x78, 0x0c, 0xed, 0x83, 0xe1, 0x2a, 0x37, 0xb9, 0x96, 0x2e, 0x4b, 0xe9, 0x93,
+	0x68, 0x77, 0x0f, 0x5a, 0xe8, 0x2f, 0x64, 0xf4, 0x33, 0xd9, 0x2f, 0x92, 0xba, 0xbb, 0x42, 0x58,
+	0x5b, 0xd6, 0xe8, 0x38, 0xdc, 0xb9, 0x17, 0x5c, 0x66, 0x29, 0xd7, 0xe3, 0xf0, 0x0e, 0x15, 0x88,
+	0xf0, 0x77, 0x02, 0x56, 0x98, 0x25, 0x5c, 0xf7, 0xf6, 0x5d, 0x70, 0x73, 0x54, 0x09, 0x7f, 0xe0,
+	0xf6, 0x99, 0xa2, 0x1b, 0x38, 0x9c, 0x30, 0x7c, 0x9f, 0xae, 0x72, 0x0a, 0x9a, 0xa1, 0xac, 0xb5,
+	0x6a, 0x32, 0x52, 0x12, 0x49, 0xe2, 0xeb, 0xa2, 0x9e, 0xfd, 0x9e, 0x00, 0xc7, 0xd2, 0x89, 0x29,
+	0xf0, 0x01, 0xcf, 0x76, 0x4d, 0x0b, 0x5f, 0x9f, 0x20, 0x0f, 0xa3, 0x1d, 0x10, 0xa9, 0x12, 0x1c,
+	0x2a, 0x0c, 0x5d, 0x51, 0xe8, 0xbe, 0xf4, 0xf6, 0xac, 0x12, 0x7b, 0xb9, 0x26, 0x98, 0xd1, 0x84,
+	0x5c, 0xa6, 0xe7, 0x66, 0x09, 0x3f, 0x17, 0x2c, 0xd9, 0xb4, 0x7e, 0x96, 0xb4, 0xf1, 0x06, 0x99,
+	0x45, 0x66, 0x5e, 0xc5, 0xc0, 0x46, 0x59, 0xcd, 0x9d, 0xe9, 0x3d, 0x59, 0xa5, 0x0d, 0xa7, 0xb6,
+	0x86, 0x6f, 0x84, 0xcd, 0x6b, 0x7a, 0xfb, 0x6f, 0x91, 0xe6, 0x3b, 0xd0, 0x4d, 0x69, 0x40, 0x2c,
+	0xc5, 0xd6, 0xae, 0x93, 0x6e, 0xd2, 0xb2, 0x98, 0x98, 0xb6, 0xbb, 0xe0, 0x49, 0xa7, 0x1e, 0xef,
+	0x96, 0xea, 0x99, 0xb5, 0x14, 0xc1, 0xc9, 0x7f, 0xe3, 0x83, 0xf0, 0x5a, 0x9e, 0x27, 0x8c, 0x2e,
+	0xb7, 0x15, 0x74, 0x48, 0x42, 0x99, 0x61, 0x26, 0xff, 0x5b, 0xc8, 0x85, 0x9d, 0x81, 0xc7, 0xa4,
+	0xbf, 0x4c, 0x8f, 0x16, 0xa9, 0xd7, 0x24, 0xec, 0x2c, 0x69, 0x9f, 0x37, 0xed, 0x80, 0xe0, 0x6d,
+	0xb0, 0x5a, 0x44, 0x11, 0x4b, 0x73, 0x27, 0xa5, 0x5a, 0x66, 0x7d, 0x84, 0xbb, 0x39, 0x8b, 0x38,
+	0x9c, 0xf2, 0x36, 0x3e, 0x05, 0xcf, 0x04, 0xc1, 0x10, 0x4b, 0x53, 0x77, 0xea, 0x41, 0xb5, 0x2b,
+	0xfb, 0xca, 0x28, 0x4e, 0xdf, 0x2f, 0x07, 0xa3, 0x58, 0xcd, 0xf7, 0x76, 0x19, 0x31, 0x69, 0xea,
+	0x5e, 0x78, 0xc4, 0x14, 0x5d, 0x9f, 0x16, 0xdd, 0x56, 0x8b, 0x72, 0x3c, 0x0b, 0xeb, 0xc4, 0x44,
+	0x8b, 0x38, 0x1c, 0xdf, 0x2f, 0x75, 0x32, 0xef, 0x10, 0x41, 0x89, 0x04, 0xf0, 0x1c, 0xbc, 0x36,
+	0xea, 0x79, 0x54, 0xf3, 0xf7, 0x49, 0x91, 0x13, 0xe9, 0xdc, 0xa6, 0xc9, 0x52, 0xd0, 0x98, 0xa7,
+	0xce, 0xa5, 0x69, 0x52, 0xa7, 0xe1, 0xdc, 0xb7, 0x0a, 0x1b, 0x9f, 0x48, 0x0e, 0x92, 0xa3, 0x5d,
+	0x0c, 0x66, 0x09, 0x0f, 0x87, 0x0f, 0x26, 0x85, 0x21, 0x65, 0x90, 0x4d, 0x44, 0xc3, 0x11, 0xb9,
+	0x5c, 0x30, 0x9e, 0x04, 0x02, 0x4d, 0x50, 0xae, 0x87, 0x1b, 0x05, 0xe3, 0x09, 0x60, 0x39, 0x35,
+	0x34, 0xef, 0x36, 0x70, 0x53, 0x0a, 0x1d, 0x46, 0x7b, 0x40, 0xa6, 0x4c, 0x5a, 0x2e, 0x6b, 0x2f,
+	0x12, 0xd3, 0xc2, 0x8e, 0x94, 0xbb, 0x35, 0x3d, 0x0c, 0x32, 0x28, 0x76, 0xa5, 0xe2, 0x11, 0x34,
+	0xda, 0x03, 0xbb, 0xc0, 0x28, 0x27, 0xd8, 0x93, 0x92, 0xdd, 0xbc, 0xcf, 0xd8, 0xa6, 0xdf, 0x8c,
+	0x06, 0xd7, 0x83, 0x12, 0x3d, 0x9a, 0x96, 0x2d, 0x71, 0xd1, 0xc2, 0x41, 0x2b, 0x35, 0x43, 0x9e,
+	0x19, 0x90, 0xeb, 0x38, 0x96, 0xae, 0xb8, 0x82, 0x63, 0xf2, 0x59, 0x75, 0x3c, 0x1a, 0x4b, 0xbf,
+	0x16, 0x12, 0xb2, 0x6a, 0x6b, 0xdf, 0x2d, 0x35, 0x33, 0xe9, 0x2b, 0x52, 0x61, 0xef, 0x81, 0x77,
+	0xa4, 0xc2, 0xe4, 0x98, 0x9a, 0x80, 0xdf, 0x88, 0x8a, 0x8a, 0xc7, 0xd5, 0x3d, 0x52, 0x2e, 0xb3,
+	0xd0, 0x31, 0x28, 0xc6, 0xd6, 0x69, 0xa9, 0x96, 0x29, 0x63, 0xd2, 0xa7, 0x1a, 0x2c, 0x67, 0x24,
+	0x7a, 0x14, 0xed, 0x85, 0xd0, 0xf4, 0x14, 0x9a, 0x94, 0xf0, 0x38, 0x3a, 0x00, 0xc1, 0x1d, 0xd3,
+	0x68, 0x0a, 0x0e, 0x76, 0xa1, 0x54, 0x4e, 0xd4, 0xb1, 0x08, 0xcf, 0xd8, 0x85, 0x52, 0x59, 0x11,
+	0xd3, 0xf0, 0x91, 0x75, 0xa1, 0x54, 0x96, 0xd5, 0x2b, 0xc1, 0x6f, 0x4c, 0x09, 0x10, 0xab, 0xb6,
+	0x86, 0x67, 0xe0, 0x01, 0xb4, 0x50, 0x2a, 0x4f, 0x93, 0x3a, 0x6b, 0x7b, 0x5c, 0xe5, 0x78, 0x16,
+	0xae, 0x5d, 0x0c, 0x12, 0x4b, 0xa1, 0xf3, 0xf0, 0xd2, 0xce, 0x53, 0xff, 0x52, 0x22, 0x3f, 0x06,
+	0x07, 0x27, 0x28, 0x85, 0xf8, 0x5d, 0xce, 0xc3, 0xd4, 0xbf, 0x24, 0x33, 0xe4, 0xf0, 0xe9, 0x4c,
+	0x11, 0x61, 0x8a, 0x81, 0x54, 0xc9, 0x34, 0xa4, 0x62, 0x54, 0xd4, 0x2b, 0x52, 0x2a, 0xb3, 0x1f,
+	0x05, 0xd6, 0xb1, 0x80, 0xab, 0x70, 0xd5, 0x04, 0x9b, 0xee, 0x8c, 0x35, 0xf8, 0x8d, 0x22, 0x4b,
+	0x11, 0xef, 0xaf, 0x36, 0x3c, 0x50, 0x05, 0x17, 0x43, 0x97, 0xf5, 0xc9, 0x3d, 0x95, 0x48, 0x8d,
+	0x5c, 0x76, 0xfd, 0x44, 0x61, 0x1f, 0xcb, 0x69, 0xb1, 0x91, 0x0e, 0x4e, 0x41, 0x8f, 0xe7, 0xf4,
+	0x3b, 0x6c, 0x5b, 0x07, 0x24, 0x8b, 0x7b, 0x25, 0xa7, 0x5f, 0x16, 0xdb, 0x41, 0x26, 0x2c, 0xef,
+	0x27, 0x72, 0x7a, 0x34, 0xec, 0x82, 0xc2, 0x8a, 0xe3, 0xff, 0x64, 0x4e, 0x8f, 0x86, 0x42, 0x07,
+	0x19, 0x63, 0x9f, 0xca, 0xe9, 0xfe, 0x49, 0x9f, 0xe2, 0x38, 0xb1, 0x6d, 0x93, 0xc9, 0xe0, 0x7e,
+	0x9e, 0xd3, 0x0d, 0xb9, 0x1b, 0xa0, 0x6a, 0x6b, 0x15, 0x4f, 0xcd, 0x86, 0x5f, 0x74, 0x89, 0x50,
+	0xa2, 0x89, 0xd2, 0xfd, 0xb2, 0x4b, 0x84, 0x92, 0x54, 0xd8, 0xaf, 0x94, 0xe0, 0xf1, 0xf4, 0x91,
+	0x5a, 0x62, 0x45, 0x46, 0xc2, 0x23, 0x72, 0x5d, 0x1c, 0x38, 0x2b, 0x1e, 0x7e, 0x2e, 0xa7, 0xa7,
+	0xd8, 0x4e, 0x00, 0x3f, 0x67, 0xb6, 0xc5, 0x4b, 0xb7, 0xe2, 0xe1, 0xe7, 0x73, 0x7a, 0xea, 0x8c,
+	0x82, 0x20, 0x6f, 0xc6, 0xf0, 0x0b, 0xbd, 0xe1, 0xb2, 0xe9, 0x98, 0x0d, 0x52, 0x59, 0x5e, 0x26,
+	0xac, 0xe2, 0xe1, 0x17, 0x15, 0x7c, 0x3b, 0x3a, 0xd4, 0x35, 0x62, 0x71, 0xc6, 0xa7, 0x2b, 0xda,
+	0xe6, 0xa5, 0x9c, 0xde, 0x11, 0x7b, 0xa0, 0x75, 0x20, 0xbc, 0xe2, 0x71, 0xea, 0x3a, 0x7e, 0xc5,
+	0xc3, 0x2f, 0xf7, 0x0e, 0x26, 0xba, 0x45, 0xd7, 0x58, 0xe0, 0x8b, 0xc8, 0xaf, 0xf5, 0x16, 0x9e,
+	0xb4, 0x6d, 0x77, 0x55, 0xb1, 0xaf, 0x28, 0xf6, 0x58, 0x7a, 0x10, 0x2b, 0x36, 0x2a, 0x72, 0x99,
+	0xb0, 0x06, 0xa9, 0x78, 0xf8, 0xd5, 0xde, 0xca, 0x51, 0x4d, 0xa6, 0x4d, 0x6e, 0x56, 0x3c, 0xfc,
+	0x5a, 0x6f, 0xe5, 0xa9, 0xa0, 0xe5, 0x55, 0x45, 0x03, 0x39, 0x75, 0xa1, 0xfc, 0x7a, 0x4e, 0xef,
+	0xe4, 0x1d, 0x5d, 0x9a, 0x32, 0xdc, 0x0d, 0x6f, 0xe4, 0xf4, 0xb4, 0x49, 0xf7, 0x38, 0x73, 0x9d,
+	0x44, 0xa3, 0xbd, 0x99, 0xd3, 0x83, 0x6b, 0x5b, 0x16, 0x53, 0xcc, 0x5b, 0x39, 0x7d, 0x48, 0xde,
+	0x9a, 0x65, 0xe4, 0x26, 0x78, 0xbb, 0xdb, 0x56, 0x97, 0x48, 0x18, 0xd2, 0x3b, 0x5d, 0xf6, 0x53,
+	0xd1, 0x64, 0x96, 0xe9, 0xb8, 0x52, 0xea, 0x1b, 0x79, 0xb8, 0x49, 0x25, 0x15, 0xbf, 0x69, 0x9f,
+	0xca, 0xeb, 0x0f, 0x03, 0x7b, 0x00, 0x30, 0xb5, 0xe3, 0xbf, 0xd9, 0x5b, 0x34, 0x06, 0xbf, 0x95,
+	0x87, 0xb7, 0x68, 0x2c, 0xaa, 0xaa, 0xf2, 0xed, 0x3c, 0xbc, 0x45, 0x25, 0xa9, 0xb0, 0xef, 0xe4,
+	0xf5, 0x3b, 0x76, 0x04, 0x4c, 0x47, 0x9c, 0x07, 0xae, 0xe6, 0xe1, 0x45, 0x4d, 0x54, 0x26, 0xac,
+	0xe0, 0x77, 0x95, 0x58, 0x66, 0xd6, 0x54, 0x1c, 0xee, 0xda, 0x6e, 0xa3, 0x9d, 0x08, 0xef, 0x37,
+	0x5d, 0x24, 0x15, 0xaa, 0xb8, 0xdf, 0xe6, 0xf5, 0x15, 0x7e, 0xb4, 0x8b, 0x64, 0x5c, 0x9d, 0xdf,
+	0xe5, 0xe1, 0x73, 0x9a, 0x82, 0x63, 0xf2, 0xf7, 0xeb, 0xc8, 0x86, 0x8b, 0xcd, 0x4c, 0xc7, 0x5f,
+	0x26, 0x0c, 0xff, 0x41, 0xc9, 0x66, 0xc6, 0x58, 0x12, 0x26, 0x96, 0xc6, 0xff, 0xa8, 0xb4, 0xc7,
+	0xd1, 0xfe, 0x6e, 0xf8, 0x05, 0xca, 0x9b, 0x16, 0x33, 0x57, 0x2b, 0x4e, 0x03, 0xff, 0x49, 0xc9,
+	0x9f, 0x44, 0xb7, 0x76, 0x97, 0x4f, 0x5a, 0xfc, 0x39, 0xaf, 0x3f, 0x3e, 0x74, 0xb5, 0xa8, 0x38,
+	0x7c, 0xce, 0x5a, 0x24, 0x0d, 0xea, 0x8b, 0xbb, 0xfc, 0x1b, 0x79, 0x78, 0xae, 0xa5, 0x7d, 0xa4,
+	0x6d, 0xfe, 0xa2, 0xbc, 0x9c, 0x42, 0x47, 0x7a, 0x7a, 0x99, 0xb4, 0xac, 0x49, 0xce, 0x19, 0x5d,
+	0x0a, 0x38, 0xf1, 0xf1, 0x5f, 0x95, 0xab, 0xbb, 0xd0, 0xb1, 0x75, 0x5c, 0xa5, 0x0d, 0xff, 0x96,
+	0xd7, 0xa7, 0x85, 0xd4, 0x26, 0x58, 0xa4, 0x9e, 0x67, 0x93, 0x44, 0xef, 0x3c, 0x3c, 0x00, 0xbf,
+	0x6f, 0x23, 0x50, 0x51, 0x1f, 0x1d, 0x80, 0x3b, 0x3b, 0xa2, 0xe4, 0x6e, 0x7e, 0x64, 0x00, 0xde,
+	0x25, 0x31, 0x14, 0x36, 0xf6, 0xa3, 0x0a, 0x7b, 0x37, 0x1a, 0x4b, 0xdd, 0x9f, 0x5d, 0x87, 0x30,
+	0x37, 0x5c, 0x79, 0xb3, 0x2e, 0x66, 0xfc, 0x9c, 0x43, 0xb9, 0x1a, 0x00, 0x7f, 0x1f, 0xd0, 0x17,
+	0xbb, 0x03, 0xeb, 0x1a, 0x89, 0x6d, 0xf6, 0x0f, 0x65, 0x90, 0xa9, 0x5c, 0x87, 0x41, 0x95, 0xf0,
+	0x39, 0xc7, 0x0b, 0xb4, 0xa7, 0x7f, 0x2a, 0xc3, 0xf5, 0xc2, 0x53, 0x86, 0xc2, 0xdb, 0xbf, 0x94,
+	0xd1, 0x19, 0x74, 0x6a, 0x9d, 0xf0, 0xbc, 0x80, 0xfb, 0xe7, 0x08, 0x6b, 0x05, 0xdc, 0x14, 0x7f,
+	0x50, 0x6e, 0xff, 0xad, 0x14, 0x4e, 0xa3, 0xdb, 0xfe, 0x3f, 0x05, 0xe1, 0xff, 0x4d, 0x65, 0x7d,
+	0x37, 0x3a, 0xbe, 0xbe, 0xf5, 0x79, 0xea, 0x50, 0xe5, 0xf7, 0x2d, 0x65, 0x79, 0x07, 0x3a, 0xdc,
+	0x9f, 0xa5, 0xf0, 0xf7, 0xb6, 0xb2, 0xba, 0x07, 0x9d, 0xec, 0x69, 0x35, 0x69, 0xdb, 0x51, 0xc0,
+	0x55, 0xa2, 0x2b, 0xfc, 0x4e, 0xbf, 0x4b, 0x93, 0x34, 0x16, 0x5e, 0xff, 0xd3, 0x6f, 0x96, 0xe2,
+	0x98, 0x10, 0xf0, 0xc4, 0xa2, 0xfe, 0xb7, 0xdf, 0x2c, 0xb5, 0xa5, 0xf0, 0xf7, 0x7e, 0xa3, 0x4f,
+	0x7f, 0x93, 0xb6, 0x5d, 0x09, 0x78, 0x22, 0xc5, 0x0f, 0x18, 0x7d, 0xfa, 0xd3, 0x96, 0xc2, 0xdf,
+	0x07, 0xfb, 0xf5, 0x17, 0x7e, 0xf4, 0x49, 0x36, 0xed, 0x87, 0xfa, 0xf5, 0xa7, 0x2d, 0x85, 0xbf,
+	0x0f, 0xf7, 0x6b, 0x35, 0x43, 0x1d, 0xd3, 0x56, 0xbe, 0x3e, 0x62, 0xc0, 0x03, 0x13, 0xb6, 0x12,
+	0x7e, 0x1e, 0x52, 0x16, 0x77, 0xa2, 0xa3, 0x9d, 0x16, 0x67, 0x49, 0x7b, 0xae, 0x65, 0x36, 0x48,
+	0x69, 0xcd, 0x73, 0x19, 0x4f, 0x6e, 0xfa, 0x47, 0x94, 0x5d, 0x66, 0xd0, 0x76, 0xb3, 0x13, 0xbe,
+	0x1e, 0xed, 0x99, 0x93, 0xb2, 0xa9, 0xb6, 0x9d, 0x7a, 0x95, 0x13, 0x7d, 0x5a, 0xff, 0x58, 0xcf,
+	0x9c, 0xb2, 0x56, 0xc2, 0xcf, 0xc7, 0x0d, 0x78, 0xa0, 0x77, 0x5a, 0xa4, 0x8a, 0xf7, 0x98, 0x32,
+	0xbb, 0x0d, 0x1d, 0xec, 0xc3, 0x4c, 0x78, 0x7a, 0xdc, 0x80, 0x47, 0x79, 0x64, 0x92, 0x18, 0xe5,
+	0x9f, 0x36, 0xe0, 0x51, 0x1e, 0x81, 0x8a, 0xfa, 0x8c, 0x01, 0x9f, 0x7a, 0xb4, 0xdc, 0x05, 0x93,
+	0xd7, 0x9b, 0xe2, 0xbd, 0xfe, 0x59, 0x03, 0x9e, 0xe7, 0x11, 0xa9, 0xb1, 0xcf, 0x19, 0xf0, 0xc5,
+	0x24, 0xfc, 0x50, 0x14, 0xb1, 0xd3, 0xd4, 0x6c, 0xa8, 0x0a, 0x7c, 0xde, 0x80, 0xef, 0x50, 0x19,
+	0x5c, 0x64, 0xfe, 0x05, 0xa5, 0x9c, 0x39, 0x2d, 0xeb, 0x50, 0x6b, 0x6b, 0x67, 0x89, 0xfe, 0xa9,
+	0xe3, 0x8b, 0x06, 0x7c, 0x60, 0x49, 0xd3, 0x42, 0xf7, 0x4b, 0x3d, 0x7b, 0x64, 0x9e, 0xae, 0x90,
+	0x45, 0xb2, 0xcc, 0x88, 0xdf, 0xac, 0x72, 0x93, 0xe9, 0x6e, 0x7c, 0xd2, 0x80, 0x8f, 0x16, 0xb0,
+	0x95, 0xf0, 0xf3, 0x65, 0xa3, 0xd7, 0xab, 0x24, 0x65, 0x11, 0xb7, 0xe2, 0x57, 0x94, 0x1b, 0xf0,
+	0x4d, 0x97, 0x31, 0x12, 0x5e, 0xbe, 0xda, 0x6f, 0x36, 0xa9, 0x46, 0xfc, 0x5a, 0xbf, 0xd9, 0xe8,
+	0x3e, 0xfc, 0xba, 0x01, 0x7f, 0x0a, 0x28, 0x65, 0x6e, 0xdc, 0xd7, 0x0c, 0xf8, 0x7e, 0x50, 0x4a,
+	0xde, 0xb7, 0x5f, 0x31, 0xf4, 0x67, 0x96, 0x2d, 0x19, 0x48, 0x9e, 0x26, 0x5e, 0xed, 0xd2, 0x27,
+	0x25, 0xd7, 0x17, 0x07, 0xe9, 0xe4, 0xbb, 0xf3, 0xd7, 0x06, 0x7c, 0xff, 0x49, 0xa0, 0x22, 0x81,
+	0xd7, 0x0c, 0xf8, 0xfe, 0x53, 0x4a, 0x7c, 0x58, 0x78, 0xbd, 0xcb, 0xee, 0x98, 0xa2, 0x8e, 0xe9,
+	0xd4, 0x93, 0x07, 0xa7, 0x1f, 0x0c, 0xc2, 0xbb, 0x43, 0x92, 0x0a, 0xfb, 0xe1, 0x20, 0x7c, 0x73,
+	0x89, 0x05, 0xe3, 0xa2, 0xfc, 0x68, 0x10, 0xbe, 0xb9, 0x48, 0x36, 0x06, 0x7f, 0x3c, 0x08, 0xdf,
+	0xae, 0x24, 0x28, 0x2b, 0xf8, 0x74, 0x6f, 0xb9, 0xf8, 0x76, 0xf5, 0x93, 0x41, 0xf8, 0xaa, 0xa1,
+	0x40, 0x79, 0x18, 0x2f, 0xfb, 0x0d, 0xfc, 0xcc, 0x20, 0x7c, 0xd5, 0x90, 0x68, 0x85, 0x59, 0x11,
+	0xf7, 0x6c, 0x6f, 0xdf, 0xd1, 0x8f, 0xb4, 0x02, 0xfc, 0x69, 0x6f, 0x41, 0xbd, 0x30, 0x3f, 0x93,
+	0x31, 0x4e, 0x9c, 0x46, 0xd7, 0xaf, 0x52, 0x46, 0x2e, 0x52, 0x67, 0x78, 0xef, 0x78, 0xf4, 0x4b,
+	0xff, 0xb8, 0xfa, 0xa5, 0x7f, 0xbc, 0xe4, 0x04, 0xad, 0xf0, 0xe7, 0x12, 0xf9, 0x95, 0x60, 0xe4,
+	0xb9, 0x87, 0x06, 0x46, 0x73, 0x63, 0x43, 0x8b, 0xd7, 0x09, 0x9b, 0x39, 0x67, 0xe2, 0x5e, 0x34,
+	0x14, 0x5a, 0xbb, 0x01, 0xef, 0xc7, 0xfc, 0x79, 0x69, 0x1e, 0xba, 0xac, 0x04, 0x7c, 0x62, 0x16,
+	0x6d, 0x0a, 0xed, 0x2d, 0x31, 0xad, 0xfa, 0x8c, 0xe1, 0x05, 0x29, 0xb2, 0x41, 0x58, 0x86, 0x63,
+	0x6e, 0xce, 0x99, 0x98, 0x43, 0x9b, 0x13, 0x42, 0x7d, 0x86, 0xf3, 0xa2, 0x54, 0xda, 0xa8, 0x95,
+	0x44, 0x4c, 0x67, 0xd0, 0x0d, 0xa1, 0x14, 0xa7, 0x4e, 0xbb, 0x1f, 0x95, 0x97, 0xa4, 0x4a, 0x58,
+	0x89, 0x1a, 0x75, 0xda, 0x13, 0xf3, 0xe8, 0xc6, 0x50, 0x61, 0xc9, 0x75, 0xb9, 0xed, 0x9a, 0x16,
+	0x61, 0xfd, 0xe8, 0xbc, 0x2c, 0x75, 0xc2, 0x44, 0xa6, 0xb4, 0xe9, 0x44, 0x11, 0x85, 0x99, 0x5e,
+	0x74, 0xdc, 0x8b, 0xcb, 0x7e, 0xab, 0x1f, 0xa5, 0x6b, 0x52, 0x29, 0xcc, 0x63, 0xc1, 0x9d, 0xf1,
+	0x5b, 0x53, 0x77, 0xa0, 0xfd, 0x75, 0xb7, 0x35, 0xee, 0x9b, 0xdc, 0xf5, 0x9b, 0xd4, 0x36, 0x97,
+	0x7c, 0xf5, 0xff, 0x79, 0xd8, 0x74, 0x49, 0x4b, 0x4d, 0x6d, 0xaa, 0x85, 0x7f, 0x94, 0x9d, 0xf3,
+	0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa3, 0x69, 0x67, 0x5d, 0x1f, 0x22, 0x00, 0x00,
 }
--- a/accounts/usbwallet/trezor/messages.proto
+++ b/accounts/usbwallet/trezor/messages.proto
@@ -9,13 +9,10 @@ package hw.trezor.messages;
 * Messages for TREZOR communication
 */

-option go_package  = "github.com/ethereum/go-ethereum/accounts/usbwallet/trezor";
-
 // Sugar for easier handling in Java
 option java_package = "com.satoshilabs.trezor.lib.protobuf";
 option java_outer_classname = "TrezorMessage";

-
 import "google/protobuf/descriptor.proto";

 /**
--- a/accounts/usbwallet/trezor/trezor.go
+++ b/accounts/usbwallet/trezor/trezor.go
@@ -39,10 +39,10 @@
 //   - Download the latest protoc https://github.com/protocolbuffers/protobuf/releases
 //   - Build with the usual `./configure && make` and ensure it's on your $PATH
 //   - Delete all the .proto and .pb.go files, pull in fresh ones from Trezor
-//   - Grab the latest Go plugin `go get -u google.golang.org/protobuf/cmd/protoc-gen-go`
-//   - Vendor in the latest Go plugin `govendor fetch google.golang.org/protobuf/...`
+//   - Grab the latest Go plugin `go get -u github.com/golang/protobuf/protoc-gen-go`
+//   - Vendor in the latest Go plugin `govendor fetch github.com/golang/protobuf/...`

-//go:generate protoc -I/usr/local/include:. --go_out=paths=source_relative:. messages.proto messages-common.proto messages-management.proto messages-ethereum.proto
+//go:generate protoc -I/usr/local/include:. --go_out=import_path=trezor:. messages.proto messages-common.proto messages-management.proto messages-ethereum.proto

 // Package trezor contains the wire protocol.
 package trezor
@@ -50,7 +50,7 @@ package trezor
 import (
 	"reflect"

-	"google.golang.org/protobuf/proto"
+	"github.com/golang/protobuf/proto"
 )

 // Type returns the protocol buffer type number of a specific message. If the
--- a/accounts/usbwallet/wallet.go
+++ b/accounts/usbwallet/wallet.go
@@ -31,7 +31,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/karalabe/hid"
+	"github.com/karalabe/usb"
 )

 // Maximum time between wallet health checks to detect USB unplugs.
@@ -79,8 +79,8 @@ type wallet struct {
 	driver driver        // Hardware implementation of the low level device operations
 	url    *accounts.URL // Textual URL uniquely identifying this wallet

-	info   hid.DeviceInfo // Known USB device infos about the wallet
-	device hid.Device     // USB device advertising itself as a hardware wallet
+	info   usb.DeviceInfo // Known USB device infos about the wallet
+	device usb.Device     // USB device advertising itself as a hardware wallet

 	accounts []accounts.Account                         // List of derive accounts pinned on the hardware wallet
 	paths    map[common.Address]accounts.DerivationPath // Known derivation paths for signing operations
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -24,12 +24,9 @@ for:
        - image: Ubuntu
    build_script:
      - go run build/ci.go lint
-      - go run build/ci.go check_tidy
-      - go run build/ci.go check_generate
-      - go run build/ci.go check_baddeps
      - go run build/ci.go install -dlgo
    test_script:
-      - go run build/ci.go test -dlgo -short
+      - go run build/ci.go test -dlgo

  # linux/386 is disabled.
  - matrix:
--- a/beacon/blsync/block_sync.go
+++ b/beacon/blsync/block_sync.go
@@ -1,163 +0,0 @@
-// Copyright 2023 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package blsync
-
-import (
-	"github.com/ethereum/go-ethereum/beacon/light/request"
-	"github.com/ethereum/go-ethereum/beacon/light/sync"
-	"github.com/ethereum/go-ethereum/beacon/params"
-	"github.com/ethereum/go-ethereum/beacon/types"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/lru"
-	"github.com/ethereum/go-ethereum/event"
-	"github.com/ethereum/go-ethereum/log"
-)
-
-// beaconBlockSync implements request.Module; it fetches the beacon blocks belonging
-// to the validated and prefetch heads.
-type beaconBlockSync struct {
-	recentBlocks *lru.Cache[common.Hash, *types.BeaconBlock]
-	locked       map[common.Hash]request.ServerAndID
-	serverHeads  map[request.Server]common.Hash
-	headTracker  headTracker
-
-	lastHeadInfo  types.HeadInfo
-	chainHeadFeed event.FeedOf[types.ChainHeadEvent]
-}
-
-type headTracker interface {
-	PrefetchHead() types.HeadInfo
-	ValidatedOptimistic() (types.OptimisticUpdate, bool)
-	ValidatedFinality() (types.FinalityUpdate, bool)
-}
-
-// newBeaconBlockSync returns a new beaconBlockSync.
-func newBeaconBlockSync(headTracker headTracker) *beaconBlockSync {
-	return &beaconBlockSync{
-		headTracker:  headTracker,
-		recentBlocks: lru.NewCache[common.Hash, *types.BeaconBlock](10),
-		locked:       make(map[common.Hash]request.ServerAndID),
-		serverHeads:  make(map[request.Server]common.Hash),
-	}
-}
-
-func (s *beaconBlockSync) SubscribeChainHead(ch chan<- types.ChainHeadEvent) event.Subscription {
-	return s.chainHeadFeed.Subscribe(ch)
-}
-
-// Process implements request.Module.
-func (s *beaconBlockSync) Process(requester request.Requester, events []request.Event) {
-	for _, event := range events {
-		switch event.Type {
-		case request.EvResponse, request.EvFail, request.EvTimeout:
-			sid, req, resp := event.RequestInfo()
-			blockRoot := common.Hash(req.(sync.ReqBeaconBlock))
-			log.Debug("Beacon block event", "type", event.Type.Name, "hash", blockRoot)
-			if resp != nil {
-				s.recentBlocks.Add(blockRoot, resp.(*types.BeaconBlock))
-			}
-			if s.locked[blockRoot] == sid {
-				delete(s.locked, blockRoot)
-			}
-		case sync.EvNewHead:
-			s.serverHeads[event.Server] = event.Data.(types.HeadInfo).BlockRoot
-		case request.EvUnregistered:
-			delete(s.serverHeads, event.Server)
-		}
-	}
-	s.updateEventFeed()
-	// request validated head block if unavailable and not yet requested
-	if vh, ok := s.headTracker.ValidatedOptimistic(); ok {
-		s.tryRequestBlock(requester, vh.Attested.Hash(), false)
-	}
-	// request prefetch head if the given server has announced it
-	if prefetchHead := s.headTracker.PrefetchHead().BlockRoot; prefetchHead != (common.Hash{}) {
-		s.tryRequestBlock(requester, prefetchHead, true)
-	}
-}
-
-func (s *beaconBlockSync) tryRequestBlock(requester request.Requester, blockRoot common.Hash, needSameHead bool) {
-	if _, ok := s.recentBlocks.Get(blockRoot); ok {
-		return
-	}
-	if _, ok := s.locked[blockRoot]; ok {
-		return
-	}
-	for _, server := range requester.CanSendTo() {
-		if needSameHead && (s.serverHeads[server] != blockRoot) {
-			continue
-		}
-		id := requester.Send(server, sync.ReqBeaconBlock(blockRoot))
-		s.locked[blockRoot] = request.ServerAndID{Server: server, ID: id}
-		return
-	}
-}
-
-func blockHeadInfo(block *types.BeaconBlock) types.HeadInfo {
-	if block == nil {
-		return types.HeadInfo{}
-	}
-	return types.HeadInfo{Slot: block.Slot(), BlockRoot: block.Root()}
-}
-
-func (s *beaconBlockSync) updateEventFeed() {
-	optimistic, ok := s.headTracker.ValidatedOptimistic()
-	if !ok {
-		return
-	}
-
-	validatedHead := optimistic.Attested.Hash()
-	headBlock, ok := s.recentBlocks.Get(validatedHead)
-	if !ok {
-		return
-	}
-
-	var finalizedHash common.Hash
-	if finality, ok := s.headTracker.ValidatedFinality(); ok {
-		he := optimistic.Attested.Epoch()
-		fe := finality.Attested.Header.Epoch()
-		switch {
-		case he == fe:
-			finalizedHash = finality.Finalized.PayloadHeader.BlockHash()
-		case he < fe:
-			return
-		case he == fe+1:
-			parent, ok := s.recentBlocks.Get(optimistic.Attested.ParentRoot)
-			if !ok || parent.Slot()/params.EpochLength == fe {
-				return // head is at first slot of next epoch, wait for finality update
-			}
-		}
-	}
-
-	headInfo := blockHeadInfo(headBlock)
-	if headInfo == s.lastHeadInfo {
-		return
-	}
-	s.lastHeadInfo = headInfo
-
-	// new head block and finality info available; extract executable data and send event to feed
-	execBlock, err := headBlock.ExecutionPayload()
-	if err != nil {
-		log.Error("Error extracting execution block from validated beacon block", "error", err)
-		return
-	}
-	s.chainHeadFeed.Send(types.ChainHeadEvent{
-		BeaconHead: optimistic.Attested.Header,
-		Block:      execBlock,
-		Finalized:  finalizedHash,
-	})
-}
--- a/beacon/blsync/block_sync_test.go
+++ b/beacon/blsync/block_sync_test.go
@@ -1,163 +0,0 @@
-// Copyright 2023 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package blsync
-
-import (
-	"testing"
-
-	"github.com/ethereum/go-ethereum/beacon/light/request"
-	"github.com/ethereum/go-ethereum/beacon/light/sync"
-	"github.com/ethereum/go-ethereum/beacon/types"
-	"github.com/ethereum/go-ethereum/common"
-	zrntcommon "github.com/protolambda/zrnt/eth2/beacon/common"
-	"github.com/protolambda/zrnt/eth2/beacon/deneb"
-)
-
-var (
-	testServer1 = testServer("testServer1")
-	testServer2 = testServer("testServer2")
-
-	testBlock1 = types.NewBeaconBlock(&deneb.BeaconBlock{
-		Slot: 123,
-		Body: deneb.BeaconBlockBody{
-			ExecutionPayload: deneb.ExecutionPayload{
-				BlockNumber: 456,
-				BlockHash:   zrntcommon.Hash32(common.HexToHash("905ac721c4058d9ed40b27b6b9c1bdd10d4333e4f3d9769100bf9dfb80e5d1f6")),
-			},
-		},
-	})
-	testBlock2 = types.NewBeaconBlock(&deneb.BeaconBlock{
-		Slot: 124,
-		Body: deneb.BeaconBlockBody{
-			ExecutionPayload: deneb.ExecutionPayload{
-				BlockNumber: 457,
-				BlockHash:   zrntcommon.Hash32(common.HexToHash("011703f39c664efc1c6cf5f49ca09b595581eec572d4dfddd3d6179a9e63e655")),
-			},
-		},
-	})
-)
-
-type testServer string
-
-func (t testServer) Name() string {
-	return string(t)
-}
-
-func TestBlockSync(t *testing.T) {
-	ht := &testHeadTracker{}
-	blockSync := newBeaconBlockSync(ht)
-	headCh := make(chan types.ChainHeadEvent, 16)
-	blockSync.SubscribeChainHead(headCh)
-	ts := sync.NewTestScheduler(t, blockSync)
-	ts.AddServer(testServer1, 1)
-	ts.AddServer(testServer2, 1)
-
-	expHeadBlock := func(expHead *types.BeaconBlock) {
-		t.Helper()
-		var expNumber, headNumber uint64
-		if expHead != nil {
-			p, err := expHead.ExecutionPayload()
-			if err != nil {
-				t.Fatalf("expHead.ExecutionPayload() failed: %v", err)
-			}
-			expNumber = p.NumberU64()
-		}
-		select {
-		case event := <-headCh:
-			headNumber = event.Block.NumberU64()
-		default:
-		}
-		if headNumber != expNumber {
-			t.Errorf("Wrong head block, expected block number %d, got %d)", expNumber, headNumber)
-		}
-	}
-
-	// no block requests expected until head tracker knows about a head
-	ts.Run(1)
-	expHeadBlock(nil)
-
-	// set block 1 as prefetch head, announced by server 2
-	head1 := blockHeadInfo(testBlock1)
-	ht.prefetch = head1
-	ts.ServerEvent(sync.EvNewHead, testServer2, head1)
-
-	// expect request to server 2 which has announced the head
-	ts.Run(2, testServer2, sync.ReqBeaconBlock(head1.BlockRoot))
-
-	// valid response
-	ts.RequestEvent(request.EvResponse, ts.Request(2, 1), testBlock1)
-	ts.AddAllowance(testServer2, 1)
-	ts.Run(3)
-	// head block still not expected as the fetched block is not the validated head yet
-	expHeadBlock(nil)
-
-	// set as validated head, expect no further requests but block 1 set as head block
-	ht.validated.Header = testBlock1.Header()
-	ts.Run(4)
-	expHeadBlock(testBlock1)
-
-	// set block 2 as prefetch head, announced by server 1
-	head2 := blockHeadInfo(testBlock2)
-	ht.prefetch = head2
-	ts.ServerEvent(sync.EvNewHead, testServer1, head2)
-	// expect request to server 1
-	ts.Run(5, testServer1, sync.ReqBeaconBlock(head2.BlockRoot))
-
-	// req2 fails, no further requests expected because server 2 has not announced it
-	ts.RequestEvent(request.EvFail, ts.Request(5, 1), nil)
-	ts.Run(6)
-
-	// set as validated head before retrieving block; now it's assumed to be available from server 2 too
-	ht.validated.Header = testBlock2.Header()
-	// expect req2 retry to server 2
-	ts.Run(7, testServer2, sync.ReqBeaconBlock(head2.BlockRoot))
-	// now head block should be unavailable again
-	expHeadBlock(nil)
-
-	// valid response, now head block should be block 2 immediately as it is already validated
-	ts.RequestEvent(request.EvResponse, ts.Request(7, 1), testBlock2)
-	ts.Run(8)
-	expHeadBlock(testBlock2)
-}
-
-type testHeadTracker struct {
-	prefetch  types.HeadInfo
-	validated types.SignedHeader
-}
-
-func (h *testHeadTracker) PrefetchHead() types.HeadInfo {
-	return h.prefetch
-}
-
-func (h *testHeadTracker) ValidatedOptimistic() (types.OptimisticUpdate, bool) {
-	return types.OptimisticUpdate{
-		Attested:      types.HeaderWithExecProof{Header: h.validated.Header},
-		Signature:     h.validated.Signature,
-		SignatureSlot: h.validated.SignatureSlot,
-	}, h.validated.Header != (types.Header{})
-}
-
-// TODO add test case for finality
-func (h *testHeadTracker) ValidatedFinality() (types.FinalityUpdate, bool) {
-	finalized := types.NewExecutionHeader(new(deneb.ExecutionPayloadHeader))
-	return types.FinalityUpdate{
-		Attested:      types.HeaderWithExecProof{Header: h.validated.Header},
-		Finalized:     types.HeaderWithExecProof{PayloadHeader: finalized},
-		Signature:     h.validated.Signature,
-		SignatureSlot: h.validated.SignatureSlot,
-	}, h.validated.Header != (types.Header{})
-}
--- a/beacon/blsync/client.go
+++ b/beacon/blsync/client.go
@@ -1,115 +0,0 @@
-// Copyright 2024 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package blsync
-
-import (
-	"strings"
-
-	"github.com/ethereum/go-ethereum/beacon/light"
-	"github.com/ethereum/go-ethereum/beacon/light/api"
-	"github.com/ethereum/go-ethereum/beacon/light/request"
-	"github.com/ethereum/go-ethereum/beacon/light/sync"
-	"github.com/ethereum/go-ethereum/beacon/types"
-	"github.com/ethereum/go-ethereum/cmd/utils"
-	"github.com/ethereum/go-ethereum/common/mclock"
-	"github.com/ethereum/go-ethereum/ethdb/memorydb"
-	"github.com/ethereum/go-ethereum/event"
-	"github.com/ethereum/go-ethereum/rpc"
-	"github.com/urfave/cli/v2"
-)
-
-type Client struct {
-	urls         []string
-	customHeader map[string]string
-	chainConfig  *lightClientConfig
-	scheduler    *request.Scheduler
-	blockSync    *beaconBlockSync
-	engineRPC    *rpc.Client
-
-	chainHeadSub event.Subscription
-	engineClient *engineClient
-}
-
-func NewClient(ctx *cli.Context) *Client {
-	if !ctx.IsSet(utils.BeaconApiFlag.Name) {
-		utils.Fatalf("Beacon node light client API URL not specified")
-	}
-	var (
-		chainConfig  = makeChainConfig(ctx)
-		customHeader = make(map[string]string)
-	)
-	for _, s := range ctx.StringSlice(utils.BeaconApiHeaderFlag.Name) {
-		kv := strings.Split(s, ":")
-		if len(kv) != 2 {
-			utils.Fatalf("Invalid custom API header entry: %s", s)
-		}
-		customHeader[strings.TrimSpace(kv[0])] = strings.TrimSpace(kv[1])
-	}
-
-	// create data structures
-	var (
-		db             = memorydb.New()
-		threshold      = ctx.Int(utils.BeaconThresholdFlag.Name)
-		committeeChain = light.NewCommitteeChain(db, chainConfig.ChainConfig, threshold, !ctx.Bool(utils.BeaconNoFilterFlag.Name))
-		headTracker    = light.NewHeadTracker(committeeChain, threshold)
-	)
-	headSync := sync.NewHeadSync(headTracker, committeeChain)
-
-	// set up scheduler and sync modules
-	scheduler := request.NewScheduler()
-	checkpointInit := sync.NewCheckpointInit(committeeChain, chainConfig.Checkpoint)
-	forwardSync := sync.NewForwardUpdateSync(committeeChain)
-	beaconBlockSync := newBeaconBlockSync(headTracker)
-	scheduler.RegisterTarget(headTracker)
-	scheduler.RegisterTarget(committeeChain)
-	scheduler.RegisterModule(checkpointInit, "checkpointInit")
-	scheduler.RegisterModule(forwardSync, "forwardSync")
-	scheduler.RegisterModule(headSync, "headSync")
-	scheduler.RegisterModule(beaconBlockSync, "beaconBlockSync")
-
-	return &Client{
-		scheduler:    scheduler,
-		urls:         ctx.StringSlice(utils.BeaconApiFlag.Name),
-		customHeader: customHeader,
-		chainConfig:  &chainConfig,
-		blockSync:    beaconBlockSync,
-	}
-}
-
-func (c *Client) SetEngineRPC(engine *rpc.Client) {
-	c.engineRPC = engine
-}
-
-func (c *Client) Start() error {
-	headCh := make(chan types.ChainHeadEvent, 16)
-	c.chainHeadSub = c.blockSync.SubscribeChainHead(headCh)
-	c.engineClient = startEngineClient(c.chainConfig, c.engineRPC, headCh)
-
-	c.scheduler.Start()
-	for _, url := range c.urls {
-		beaconApi := api.NewBeaconLightApi(url, c.customHeader)
-		c.scheduler.RegisterServer(request.NewServer(api.NewApiServer(beaconApi), &mclock.System{}))
-	}
-	return nil
-}
-
-func (c *Client) Stop() error {
-	c.engineClient.stop()
-	c.chainHeadSub.Unsubscribe()
-	c.scheduler.Stop()
-	return nil
-}
--- a/beacon/blsync/config.go
+++ b/beacon/blsync/config.go
@@ -1,129 +0,0 @@
-// Copyright 2022 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package blsync
-
-import (
-	"github.com/ethereum/go-ethereum/beacon/types"
-	"github.com/ethereum/go-ethereum/cmd/utils"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/urfave/cli/v2"
-)
-
-// lightClientConfig contains beacon light client configuration
-type lightClientConfig struct {
-	*types.ChainConfig
-	Checkpoint common.Hash
-}
-
-var (
-	MainnetConfig = lightClientConfig{
-		ChainConfig: (&types.ChainConfig{
-			GenesisValidatorsRoot: common.HexToHash("0x4b363db94e286120d76eb905340fdd4e54bfe9f06bf33ff6cf5ad27f511bfe95"),
-			GenesisTime:           1606824023,
-		}).
-			AddFork("GENESIS", 0, []byte{0, 0, 0, 0}).
-			AddFork("ALTAIR", 74240, []byte{1, 0, 0, 0}).
-			AddFork("BELLATRIX", 144896, []byte{2, 0, 0, 0}).
-			AddFork("CAPELLA", 194048, []byte{3, 0, 0, 0}).
-			AddFork("DENEB", 269568, []byte{4, 0, 0, 0}),
-		Checkpoint: common.HexToHash("0x6509b691f4de4f7b083f2784938fd52f0e131675432b3fd85ea549af9aebd3d0"),
-	}
-
-	SepoliaConfig = lightClientConfig{
-		ChainConfig: (&types.ChainConfig{
-			GenesisValidatorsRoot: common.HexToHash("0xd8ea171f3c94aea21ebc42a1ed61052acf3f9209c00e4efbaaddac09ed9b8078"),
-			GenesisTime:           1655733600,
-		}).
-			AddFork("GENESIS", 0, []byte{144, 0, 0, 105}).
-			AddFork("ALTAIR", 50, []byte{144, 0, 0, 112}).
-			AddFork("BELLATRIX", 100, []byte{144, 0, 0, 113}).
-			AddFork("CAPELLA", 56832, []byte{144, 0, 0, 114}).
-			AddFork("DENEB", 132608, []byte{144, 0, 0, 115}),
-		Checkpoint: common.HexToHash("0x456e85f5608afab3465a0580bff8572255f6d97af0c5f939e3f7536b5edb2d3f"),
-	}
-
-	HoleskyConfig = lightClientConfig{
-		ChainConfig: (&types.ChainConfig{
-			GenesisValidatorsRoot: common.HexToHash("0x9143aa7c615a7f7115e2b6aac319c03529df8242ae705fba9df39b79c59fa8b1"),
-			GenesisTime:           1695902400,
-		}).
-			AddFork("GENESIS", 0, []byte{1, 1, 112, 0}).
-			AddFork("ALTAIR", 0, []byte{2, 1, 112, 0}).
-			AddFork("BELLATRIX", 0, []byte{3, 1, 112, 0}).
-			AddFork("CAPELLA", 256, []byte{4, 1, 112, 0}).
-			AddFork("DENEB", 29696, []byte{5, 1, 112, 0}),
-		Checkpoint: common.HexToHash("0x6456a1317f54d4b4f2cb5bc9d153b5af0988fe767ef0609f0236cf29030bcff7"),
-	}
-)
-
-func makeChainConfig(ctx *cli.Context) lightClientConfig {
-	var config lightClientConfig
-	customConfig := ctx.IsSet(utils.BeaconConfigFlag.Name)
-	utils.CheckExclusive(ctx, utils.MainnetFlag, utils.SepoliaFlag, utils.HoleskyFlag, utils.BeaconConfigFlag)
-	switch {
-	case ctx.Bool(utils.MainnetFlag.Name):
-		config = MainnetConfig
-	case ctx.Bool(utils.SepoliaFlag.Name):
-		config = SepoliaConfig
-	case ctx.Bool(utils.HoleskyFlag.Name):
-		config = HoleskyConfig
-	default:
-		if !customConfig {
-			config = MainnetConfig
-		}
-	}
-	// Genesis root and time should always be specified together with custom chain config
-	if customConfig {
-		if !ctx.IsSet(utils.BeaconGenesisRootFlag.Name) {
-			utils.Fatalf("Custom beacon chain config is specified but genesis root is missing")
-		}
-		if !ctx.IsSet(utils.BeaconGenesisTimeFlag.Name) {
-			utils.Fatalf("Custom beacon chain config is specified but genesis time is missing")
-		}
-		if !ctx.IsSet(utils.BeaconCheckpointFlag.Name) {
-			utils.Fatalf("Custom beacon chain config is specified but checkpoint is missing")
-		}
-		config.ChainConfig = &types.ChainConfig{
-			GenesisTime: ctx.Uint64(utils.BeaconGenesisTimeFlag.Name),
-		}
-		if c, err := hexutil.Decode(ctx.String(utils.BeaconGenesisRootFlag.Name)); err == nil && len(c) <= 32 {
-			copy(config.GenesisValidatorsRoot[:len(c)], c)
-		} else {
-			utils.Fatalf("Invalid hex string", "beacon.genesis.gvroot", ctx.String(utils.BeaconGenesisRootFlag.Name), "error", err)
-		}
-		if err := config.ChainConfig.LoadForks(ctx.String(utils.BeaconConfigFlag.Name)); err != nil {
-			utils.Fatalf("Could not load beacon chain config file", "file name", ctx.String(utils.BeaconConfigFlag.Name), "error", err)
-		}
-	} else {
-		if ctx.IsSet(utils.BeaconGenesisRootFlag.Name) {
-			utils.Fatalf("Genesis root is specified but custom beacon chain config is missing")
-		}
-		if ctx.IsSet(utils.BeaconGenesisTimeFlag.Name) {
-			utils.Fatalf("Genesis time is specified but custom beacon chain config is missing")
-		}
-	}
-	// Checkpoint is required with custom chain config and is optional with pre-defined config
-	if ctx.IsSet(utils.BeaconCheckpointFlag.Name) {
-		if c, err := hexutil.Decode(ctx.String(utils.BeaconCheckpointFlag.Name)); err == nil && len(c) <= 32 {
-			copy(config.Checkpoint[:len(c)], c)
-		} else {
-			utils.Fatalf("Invalid hex string", "beacon.checkpoint", ctx.String(utils.BeaconCheckpointFlag.Name), "error", err)
-		}
-	}
-	return config
-}
--- a/beacon/blsync/engineclient.go
+++ b/beacon/blsync/engineclient.go
@@ -1,150 +0,0 @@
-// Copyright 2024 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package blsync
-
-import (
-	"context"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/ethereum/go-ethereum/beacon/engine"
-	"github.com/ethereum/go-ethereum/beacon/types"
-	"github.com/ethereum/go-ethereum/common"
-	ctypes "github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/rpc"
-)
-
-type engineClient struct {
-	config     *lightClientConfig
-	rpc        *rpc.Client
-	rootCtx    context.Context
-	cancelRoot context.CancelFunc
-	wg         sync.WaitGroup
-}
-
-func startEngineClient(config *lightClientConfig, rpc *rpc.Client, headCh <-chan types.ChainHeadEvent) *engineClient {
-	ctx, cancel := context.WithCancel(context.Background())
-	ec := &engineClient{
-		config:     config,
-		rpc:        rpc,
-		rootCtx:    ctx,
-		cancelRoot: cancel,
-	}
-	ec.wg.Add(1)
-	go ec.updateLoop(headCh)
-	return ec
-}
-
-func (ec *engineClient) stop() {
-	ec.cancelRoot()
-	ec.wg.Wait()
-}
-
-func (ec *engineClient) updateLoop(headCh <-chan types.ChainHeadEvent) {
-	defer ec.wg.Done()
-
-	for {
-		select {
-		case <-ec.rootCtx.Done():
-			log.Debug("Stopping engine API update loop")
-			return
-
-		case event := <-headCh:
-			if ec.rpc == nil { // dry run, no engine API specified
-				log.Info("New execution block retrieved", "number", event.Block.NumberU64(), "hash", event.Block.Hash(), "finalized", event.Finalized)
-				continue
-			}
-
-			fork := ec.config.ForkAtEpoch(event.BeaconHead.Epoch())
-			forkName := strings.ToLower(fork.Name)
-
-			log.Debug("Calling NewPayload", "number", event.Block.NumberU64(), "hash", event.Block.Hash())
-			if status, err := ec.callNewPayload(forkName, event); err == nil {
-				log.Info("Successful NewPayload", "number", event.Block.NumberU64(), "hash", event.Block.Hash(), "status", status)
-			} else {
-				log.Error("Failed NewPayload", "number", event.Block.NumberU64(), "hash", event.Block.Hash(), "error", err)
-			}
-
-			log.Debug("Calling ForkchoiceUpdated", "head", event.Block.Hash())
-			if status, err := ec.callForkchoiceUpdated(forkName, event); err == nil {
-				log.Info("Successful ForkchoiceUpdated", "head", event.Block.Hash(), "status", status)
-			} else {
-				log.Error("Failed ForkchoiceUpdated", "head", event.Block.Hash(), "error", err)
-			}
-		}
-	}
-}
-
-func (ec *engineClient) callNewPayload(fork string, event types.ChainHeadEvent) (string, error) {
-	execData := engine.BlockToExecutableData(event.Block, nil, nil, nil).ExecutionPayload
-
-	var (
-		method string
-		params = []any{execData}
-	)
-	switch fork {
-	case "deneb":
-		method = "engine_newPayloadV3"
-		parentBeaconRoot := event.BeaconHead.ParentRoot
-		blobHashes := collectBlobHashes(event.Block)
-		params = append(params, blobHashes, parentBeaconRoot)
-	case "capella":
-		method = "engine_newPayloadV2"
-	default:
-		method = "engine_newPayloadV1"
-	}
-
-	ctx, cancel := context.WithTimeout(ec.rootCtx, time.Second*5)
-	defer cancel()
-	var resp engine.PayloadStatusV1
-	err := ec.rpc.CallContext(ctx, &resp, method, params...)
-	return resp.Status, err
-}
-
-func collectBlobHashes(b *ctypes.Block) []common.Hash {
-	list := make([]common.Hash, 0)
-	for _, tx := range b.Transactions() {
-		list = append(list, tx.BlobHashes()...)
-	}
-	return list
-}
-
-func (ec *engineClient) callForkchoiceUpdated(fork string, event types.ChainHeadEvent) (string, error) {
-	update := engine.ForkchoiceStateV1{
-		HeadBlockHash:      event.Block.Hash(),
-		SafeBlockHash:      event.Finalized,
-		FinalizedBlockHash: event.Finalized,
-	}
-
-	var method string
-	switch fork {
-	case "deneb":
-		method = "engine_forkchoiceUpdatedV3"
-	case "capella":
-		method = "engine_forkchoiceUpdatedV2"
-	default:
-		method = "engine_forkchoiceUpdatedV1"
-	}
-
-	ctx, cancel := context.WithTimeout(ec.rootCtx, time.Second*5)
-	defer cancel()
-	var resp engine.ForkChoiceResponse
-	err := ec.rpc.CallContext(ctx, &resp, method, update, nil)
-	return resp.PayloadStatus.Status, err
-}
--- a/beacon/engine/gen_ed.go
+++ b/beacon/engine/gen_ed.go
@@ -34,7 +34,6 @@ func (e ExecutableData) MarshalJSON() ([]byte, error) {
 		Withdrawals   []*types.Withdrawal `json:"withdrawals"`
 		BlobGasUsed   *hexutil.Uint64     `json:"blobGasUsed"`
 		ExcessBlobGas *hexutil.Uint64     `json:"excessBlobGas"`
-		ExecutionWitness *types.ExecutionWitness `json:"executionWitness,omitempty"`
 	}
 	var enc ExecutableData
 	enc.ParentHash = e.ParentHash
@@ -59,7 +58,6 @@ func (e ExecutableData) MarshalJSON() ([]byte, error) {
 	enc.Withdrawals = e.Withdrawals
 	enc.BlobGasUsed = (*hexutil.Uint64)(e.BlobGasUsed)
 	enc.ExcessBlobGas = (*hexutil.Uint64)(e.ExcessBlobGas)
-	enc.ExecutionWitness = e.ExecutionWitness
 	return json.Marshal(&enc)
 }

@@ -83,7 +81,6 @@ func (e *ExecutableData) UnmarshalJSON(input []byte) error {
 		Withdrawals   []*types.Withdrawal `json:"withdrawals"`
 		BlobGasUsed   *hexutil.Uint64     `json:"blobGasUsed"`
 		ExcessBlobGas *hexutil.Uint64     `json:"excessBlobGas"`
-		ExecutionWitness *types.ExecutionWitness `json:"executionWitness,omitempty"`
 	}
 	var dec ExecutableData
 	if err := json.Unmarshal(input, &dec); err != nil {
@@ -157,8 +154,5 @@ func (e *ExecutableData) UnmarshalJSON(input []byte) error {
 	if dec.ExcessBlobGas != nil {
 		e.ExcessBlobGas = (*uint64)(dec.ExcessBlobGas)
 	}
-	if dec.ExecutionWitness != nil {
-		e.ExecutionWitness = dec.ExecutionWitness
-	}
 	return nil
 }
--- a/beacon/engine/gen_epe.go
+++ b/beacon/engine/gen_epe.go
@@ -18,22 +18,13 @@ func (e ExecutionPayloadEnvelope) MarshalJSON() ([]byte, error) {
 		ExecutionPayload *ExecutableData `json:"executionPayload"  gencodec:"required"`
 		BlockValue       *hexutil.Big    `json:"blockValue"  gencodec:"required"`
 		BlobsBundle      *BlobsBundleV1  `json:"blobsBundle"`
-		Requests         []hexutil.Bytes `json:"executionRequests"`
 		Override         bool            `json:"shouldOverrideBuilder"`
-		Witness          *hexutil.Bytes  `json:"witness,omitempty"`
 	}
 	var enc ExecutionPayloadEnvelope
 	enc.ExecutionPayload = e.ExecutionPayload
 	enc.BlockValue = (*hexutil.Big)(e.BlockValue)
 	enc.BlobsBundle = e.BlobsBundle
-	if e.Requests != nil {
-		enc.Requests = make([]hexutil.Bytes, len(e.Requests))
-		for k, v := range e.Requests {
-			enc.Requests[k] = v
-		}
-	}
 	enc.Override = e.Override
-	enc.Witness = e.Witness
 	return json.Marshal(&enc)
 }

@@ -43,9 +34,7 @@ func (e *ExecutionPayloadEnvelope) UnmarshalJSON(input []byte) error {
 		ExecutionPayload *ExecutableData `json:"executionPayload"  gencodec:"required"`
 		BlockValue       *hexutil.Big    `json:"blockValue"  gencodec:"required"`
 		BlobsBundle      *BlobsBundleV1  `json:"blobsBundle"`
-		Requests         []hexutil.Bytes `json:"executionRequests"`
 		Override         *bool           `json:"shouldOverrideBuilder"`
-		Witness          *hexutil.Bytes  `json:"witness,omitempty"`
 	}
 	var dec ExecutionPayloadEnvelope
 	if err := json.Unmarshal(input, &dec); err != nil {
@@ -62,17 +51,8 @@ func (e *ExecutionPayloadEnvelope) UnmarshalJSON(input []byte) error {
 	if dec.BlobsBundle != nil {
 		e.BlobsBundle = dec.BlobsBundle
 	}
-	if dec.Requests != nil {
-		e.Requests = make([][]byte, len(dec.Requests))
-		for k, v := range dec.Requests {
-			e.Requests[k] = v
-		}
-	}
 	if dec.Override != nil {
 		e.Override = *dec.Override
 	}
-	if dec.Witness != nil {
-		e.Witness = dec.Witness
-	}
 	return nil
 }
--- a/beacon/engine/types.go
+++ b/beacon/engine/types.go
@@ -19,12 +19,10 @@ package engine
 import (
 	"fmt"
 	"math/big"
-	"slices"

 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/trie"
 )

@@ -76,7 +74,6 @@ type ExecutableData struct {
 	Withdrawals   []*types.Withdrawal `json:"withdrawals"`
 	BlobGasUsed   *uint64             `json:"blobGasUsed"`
 	ExcessBlobGas *uint64             `json:"excessBlobGas"`
-	ExecutionWitness *types.ExecutionWitness `json:"executionWitness,omitempty"`
 }

 // JSON type overrides for executableData.
@@ -93,23 +90,13 @@ type executableDataMarshaling struct {
 	ExcessBlobGas *hexutil.Uint64
 }

-// StatelessPayloadStatusV1 is the result of a stateless payload execution.
-type StatelessPayloadStatusV1 struct {
-	Status          string      `json:"status"`
-	StateRoot       common.Hash `json:"stateRoot"`
-	ReceiptsRoot    common.Hash `json:"receiptsRoot"`
-	ValidationError *string     `json:"validationError"`
-}
-
 //go:generate go run github.com/fjl/gencodec -type ExecutionPayloadEnvelope -field-override executionPayloadEnvelopeMarshaling -out gen_epe.go

 type ExecutionPayloadEnvelope struct {
 	ExecutionPayload *ExecutableData `json:"executionPayload"  gencodec:"required"`
 	BlockValue       *big.Int        `json:"blockValue"  gencodec:"required"`
 	BlobsBundle      *BlobsBundleV1  `json:"blobsBundle"`
-	Requests         [][]byte        `json:"executionRequests"`
 	Override         bool            `json:"shouldOverrideBuilder"`
-	Witness          *hexutil.Bytes  `json:"witness,omitempty"`
 }

 type BlobsBundleV1 struct {
@@ -118,20 +105,13 @@ type BlobsBundleV1 struct {
 	Blobs       []hexutil.Bytes `json:"blobs"`
 }

-type BlobAndProofV1 struct {
-	Blob  hexutil.Bytes `json:"blob"`
-	Proof hexutil.Bytes `json:"proof"`
-}
-
 // JSON type overrides for ExecutionPayloadEnvelope.
 type executionPayloadEnvelopeMarshaling struct {
 	BlockValue *hexutil.Big
-	Requests   []hexutil.Bytes
 }

 type PayloadStatusV1 struct {
 	Status          string       `json:"status"`
-	Witness         *hexutil.Bytes `json:"witness"`
 	LatestValidHash *common.Hash `json:"latestValidHash"`
 	ValidationError *string      `json:"validationError"`
 }
@@ -152,7 +132,12 @@ func (b PayloadID) Version() PayloadVersion {

 // Is returns whether the identifier matches any of provided payload versions.
 func (b PayloadID) Is(versions ...PayloadVersion) bool {
-	return slices.Contains(versions, b.Version())
+	for _, v := range versions {
+		if v == b.Version() {
+			return true
+		}
+	}
+	return false
 }

 func (b PayloadID) String() string {
@@ -212,37 +197,23 @@ func decodeTransactions(enc [][]byte) ([]*types.Transaction, error) {
 //
 // and that the blockhash of the constructed block matches the parameters. Nil
 // Withdrawals value will propagate through the returned block. Empty
-// Withdrawals value must be passed via non-nil, length 0 value in data.
-func ExecutableDataToBlock(data ExecutableData, versionedHashes []common.Hash, beaconRoot *common.Hash, requests [][]byte) (*types.Block, error) {
-	block, err := ExecutableDataToBlockNoHash(data, versionedHashes, beaconRoot, requests)
+// Withdrawals value must be passed via non-nil, length 0 value in params.
+func ExecutableDataToBlock(params ExecutableData, versionedHashes []common.Hash, beaconRoot *common.Hash) (*types.Block, error) {
+	txs, err := decodeTransactions(params.Transactions)
 	if err != nil {
 		return nil, err
 	}
-	if block.Hash() != data.BlockHash {
-		return nil, fmt.Errorf("blockhash mismatch, want %x, got %x", data.BlockHash, block.Hash())
+	if len(params.ExtraData) > 32 {
+		return nil, fmt.Errorf("invalid extradata length: %v", len(params.ExtraData))
 	}
-	return block, nil
-}
-
-// ExecutableDataToBlockNoHash is analogous to ExecutableDataToBlock, but is used
-// for stateless execution, so it skips checking if the executable data hashes to
-// the requested hash (stateless has to *compute* the root hash, it's not given).
-func ExecutableDataToBlockNoHash(data ExecutableData, versionedHashes []common.Hash, beaconRoot *common.Hash, requests [][]byte) (*types.Block, error) {
-	txs, err := decodeTransactions(data.Transactions)
-	if err != nil {
-		return nil, err
-	}
-	if len(data.ExtraData) > int(params.MaximumExtraDataSize) {
-		return nil, fmt.Errorf("invalid extradata length: %v", len(data.ExtraData))
-	}
-	if len(data.LogsBloom) != 256 {
-		return nil, fmt.Errorf("invalid logsBloom length: %v", len(data.LogsBloom))
+	if len(params.LogsBloom) != 256 {
+		return nil, fmt.Errorf("invalid logsBloom length: %v", len(params.LogsBloom))
 	}
 	// Check that baseFeePerGas is not negative or too big
-	if data.BaseFeePerGas != nil && (data.BaseFeePerGas.Sign() == -1 || data.BaseFeePerGas.BitLen() > 256) {
-		return nil, fmt.Errorf("invalid baseFeePerGas: %v", data.BaseFeePerGas)
+	if params.BaseFeePerGas != nil && (params.BaseFeePerGas.Sign() == -1 || params.BaseFeePerGas.BitLen() > 256) {
+		return nil, fmt.Errorf("invalid baseFeePerGas: %v", params.BaseFeePerGas)
 	}
-	var blobHashes = make([]common.Hash, 0, len(txs))
+	var blobHashes []common.Hash
 	for _, tx := range txs {
 		blobHashes = append(blobHashes, tx.BlobHashes()...)
 	}
@@ -258,56 +229,41 @@ func ExecutableDataToBlockNoHash(data ExecutableData, versionedHashes []common.H
 	// ExecutableData before withdrawals are enabled by marshaling
 	// Withdrawals as the json null value.
 	var withdrawalsRoot *common.Hash
-	if data.Withdrawals != nil {
-		h := types.DeriveSha(types.Withdrawals(data.Withdrawals), trie.NewStackTrie(nil))
+	if params.Withdrawals != nil {
+		h := types.DeriveSha(types.Withdrawals(params.Withdrawals), trie.NewStackTrie(nil))
 		withdrawalsRoot = &h
 	}
-
-	var requestsHash *common.Hash
-	if requests != nil {
-		// Put back request type byte.
-		typedRequests := make([][]byte, len(requests))
-		for i, reqdata := range requests {
-			typedReqdata := make([]byte, len(reqdata)+1)
-			typedReqdata[0] = byte(i)
-			copy(typedReqdata[1:], reqdata)
-			typedRequests[i] = typedReqdata
-		}
-		h := types.CalcRequestsHash(typedRequests)
-		requestsHash = &h
-	}
-
 	header := &types.Header{
-		ParentHash:       data.ParentHash,
+		ParentHash:       params.ParentHash,
 		UncleHash:        types.EmptyUncleHash,
-		Coinbase:         data.FeeRecipient,
-		Root:             data.StateRoot,
+		Coinbase:         params.FeeRecipient,
+		Root:             params.StateRoot,
 		TxHash:           types.DeriveSha(types.Transactions(txs), trie.NewStackTrie(nil)),
-		ReceiptHash:      data.ReceiptsRoot,
-		Bloom:            types.BytesToBloom(data.LogsBloom),
+		ReceiptHash:      params.ReceiptsRoot,
+		Bloom:            types.BytesToBloom(params.LogsBloom),
 		Difficulty:       common.Big0,
-		Number:           new(big.Int).SetUint64(data.Number),
-		GasLimit:         data.GasLimit,
-		GasUsed:          data.GasUsed,
-		Time:             data.Timestamp,
-		BaseFee:          data.BaseFeePerGas,
-		Extra:            data.ExtraData,
-		MixDigest:        data.Random,
+		Number:           new(big.Int).SetUint64(params.Number),
+		GasLimit:         params.GasLimit,
+		GasUsed:          params.GasUsed,
+		Time:             params.Timestamp,
+		BaseFee:          params.BaseFeePerGas,
+		Extra:            params.ExtraData,
+		MixDigest:        params.Random,
 		WithdrawalsHash:  withdrawalsRoot,
-		ExcessBlobGas:    data.ExcessBlobGas,
-		BlobGasUsed:      data.BlobGasUsed,
+		ExcessBlobGas:    params.ExcessBlobGas,
+		BlobGasUsed:      params.BlobGasUsed,
 		ParentBeaconRoot: beaconRoot,
-		RequestsHash:     requestsHash,
 	}
-	return types.NewBlockWithHeader(header).
-			WithBody(types.Body{Transactions: txs, Uncles: nil, Withdrawals: data.Withdrawals}).
-			WithWitness(data.ExecutionWitness),
-		nil
+	block := types.NewBlockWithHeader(header).WithBody(txs, nil /* uncles */).WithWithdrawals(params.Withdrawals)
+	if block.Hash() != params.BlockHash {
+		return nil, fmt.Errorf("blockhash mismatch, want %x, got %x", params.BlockHash, block.Hash())
+	}
+	return block, nil
 }

 // BlockToExecutableData constructs the ExecutableData structure by filling the
 // fields from the given block. It assumes the given block is post-merge block.
-func BlockToExecutableData(block *types.Block, fees *big.Int, sidecars []*types.BlobTxSidecar, requests [][]byte) *ExecutionPayloadEnvelope {
+func BlockToExecutableData(block *types.Block, fees *big.Int, sidecars []*types.BlobTxSidecar) *ExecutionPayloadEnvelope {
 	data := &ExecutableData{
 		BlockHash:     block.Hash(),
 		ParentHash:    block.ParentHash(),
@@ -326,10 +282,7 @@ func BlockToExecutableData(block *types.Block, fees *big.Int, sidecars []*types.
 		Withdrawals:   block.Withdrawals(),
 		BlobGasUsed:   block.BlobGasUsed(),
 		ExcessBlobGas: block.ExcessBlobGas(),
-		ExecutionWitness: block.ExecutionWitness(),
 	}
-
-	// Add blobs.
 	bundle := BlobsBundleV1{
 		Commitments: make([]hexutil.Bytes, 0),
 		Blobs:       make([]hexutil.Bytes, 0),
@@ -342,27 +295,11 @@ func BlockToExecutableData(block *types.Block, fees *big.Int, sidecars []*types.
 			bundle.Proofs = append(bundle.Proofs, hexutil.Bytes(sidecar.Proofs[j][:]))
 		}
 	}
-
-	// Remove type byte in requests.
-	var plainRequests [][]byte
-	if requests != nil {
-		plainRequests = make([][]byte, len(requests))
-		for i, reqdata := range requests {
-			plainRequests[i] = reqdata[1:]
-		}
-	}
-
-	return &ExecutionPayloadEnvelope{
-		ExecutionPayload: data,
-		BlockValue:       fees,
-		BlobsBundle:      &bundle,
-		Requests:         plainRequests,
-		Override:         false,
-	}
+	return &ExecutionPayloadEnvelope{ExecutionPayload: data, BlockValue: fees, BlobsBundle: &bundle, Override: false}
 }

-// ExecutionPayloadBody is used in the response to GetPayloadBodiesByHash and GetPayloadBodiesByRange
-type ExecutionPayloadBody struct {
+// ExecutionPayloadBodyV1 is used in the response to GetPayloadBodiesByHashV1 and GetPayloadBodiesByRangeV1
+type ExecutionPayloadBodyV1 struct {
 	TransactionData []hexutil.Bytes     `json:"transactions"`
 	Withdrawals     []*types.Withdrawal `json:"withdrawals"`
 }
@@ -376,7 +313,7 @@ const (
 // ClientVersionV1 contains information which identifies a client implementation.
 type ClientVersionV1 struct {
 	Code    string `json:"code"`
-	Name    string `json:"name"`
+	Name    string `json:"clientName"`
 	Version string `json:"version"`
 	Commit  string `json:"commit"`
 }
--- a/beacon/light/api/api_server.go
+++ b/beacon/light/api/api_server.go
@@ -1,114 +0,0 @@
-// Copyright 2023 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package api
-
-import (
-	"reflect"
-
-	"github.com/ethereum/go-ethereum/beacon/light/request"
-	"github.com/ethereum/go-ethereum/beacon/light/sync"
-	"github.com/ethereum/go-ethereum/beacon/types"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/log"
-)
-
-// ApiServer is a wrapper around BeaconLightApi that implements request.requestServer.
-type ApiServer struct {
-	api           *BeaconLightApi
-	eventCallback func(event request.Event)
-	unsubscribe   func()
-}
-
-// NewApiServer creates a new ApiServer.
-func NewApiServer(api *BeaconLightApi) *ApiServer {
-	return &ApiServer{api: api}
-}
-
-// Subscribe implements request.requestServer.
-func (s *ApiServer) Subscribe(eventCallback func(event request.Event)) {
-	s.eventCallback = eventCallback
-	listener := HeadEventListener{
-		OnNewHead: func(slot uint64, blockRoot common.Hash) {
-			log.Debug("New head received", "slot", slot, "blockRoot", blockRoot)
-			eventCallback(request.Event{Type: sync.EvNewHead, Data: types.HeadInfo{Slot: slot, BlockRoot: blockRoot}})
-		},
-		OnOptimistic: func(update types.OptimisticUpdate) {
-			log.Debug("New optimistic update received", "slot", update.Attested.Slot, "blockRoot", update.Attested.Hash(), "signerCount", update.Signature.SignerCount())
-			eventCallback(request.Event{Type: sync.EvNewOptimisticUpdate, Data: update})
-		},
-		OnFinality: func(update types.FinalityUpdate) {
-			log.Debug("New finality update received", "slot", update.Attested.Slot, "blockRoot", update.Attested.Hash(), "signerCount", update.Signature.SignerCount())
-			eventCallback(request.Event{Type: sync.EvNewFinalityUpdate, Data: update})
-		},
-		OnError: func(err error) {
-			log.Warn("Head event stream error", "err", err)
-		},
-	}
-	s.unsubscribe = s.api.StartHeadListener(listener)
-}
-
-// SendRequest implements request.requestServer.
-func (s *ApiServer) SendRequest(id request.ID, req request.Request) {
-	go func() {
-		var resp request.Response
-		var err error
-		switch data := req.(type) {
-		case sync.ReqUpdates:
-			log.Debug("Beacon API: requesting light client update", "reqid", id, "period", data.FirstPeriod, "count", data.Count)
-			var r sync.RespUpdates
-			r.Updates, r.Committees, err = s.api.GetBestUpdatesAndCommittees(data.FirstPeriod, data.Count)
-			resp = r
-		case sync.ReqHeader:
-			var r sync.RespHeader
-			log.Debug("Beacon API: requesting header", "reqid", id, "hash", common.Hash(data))
-			r.Header, r.Canonical, r.Finalized, err = s.api.GetHeader(common.Hash(data))
-			resp = r
-		case sync.ReqCheckpointData:
-			log.Debug("Beacon API: requesting checkpoint data", "reqid", id, "hash", common.Hash(data))
-			resp, err = s.api.GetCheckpointData(common.Hash(data))
-		case sync.ReqBeaconBlock:
-			log.Debug("Beacon API: requesting block", "reqid", id, "hash", common.Hash(data))
-			resp, err = s.api.GetBeaconBlock(common.Hash(data))
-		case sync.ReqFinality:
-			log.Debug("Beacon API: requesting finality update")
-			resp, err = s.api.GetFinalityUpdate()
-		default:
-		}
-
-		if err != nil {
-			log.Warn("Beacon API request failed", "type", reflect.TypeOf(req), "reqid", id, "err", err)
-			s.eventCallback(request.Event{Type: request.EvFail, Data: request.RequestResponse{ID: id, Request: req}})
-		} else {
-			log.Debug("Beacon API request answered", "type", reflect.TypeOf(req), "reqid", id)
-			s.eventCallback(request.Event{Type: request.EvResponse, Data: request.RequestResponse{ID: id, Request: req, Response: resp}})
-		}
-	}()
-}
-
-// Unsubscribe implements request.requestServer.
-// Note: Unsubscribe should not be called concurrently with Subscribe.
-func (s *ApiServer) Unsubscribe() {
-	if s.unsubscribe != nil {
-		s.unsubscribe()
-		s.unsubscribe = nil
-	}
-}
-
-// Name implements request.Server
-func (s *ApiServer) Name() string {
-	return s.api.url
-}
--- a/beacon/light/api/light_api.go
+++ b/beacon/light/api/light_api.go
@@ -1,599 +0,0 @@
-// Copyright 2022 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more detaiapi.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package api
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strconv"
-	"sync"
-	"time"
-
-	"github.com/donovanhide/eventsource"
-	"github.com/ethereum/go-ethereum/beacon/merkle"
-	"github.com/ethereum/go-ethereum/beacon/params"
-	"github.com/ethereum/go-ethereum/beacon/types"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/log"
-)
-
-var (
-	ErrNotFound = errors.New("404 Not Found")
-	ErrInternal = errors.New("500 Internal Server Error")
-)
-
-type CommitteeUpdate struct {
-	Version           string
-	Update            types.LightClientUpdate
-	NextSyncCommittee types.SerializedSyncCommittee
-}
-
-// See data structure definition here:
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/light-client/sync-protocol.md#lightclientupdate
-type committeeUpdateJson struct {
-	Version string              `json:"version"`
-	Data    committeeUpdateData `json:"data"`
-}
-
-type committeeUpdateData struct {
-	Header                  jsonBeaconHeader              `json:"attested_header"`
-	NextSyncCommittee       types.SerializedSyncCommittee `json:"next_sync_committee"`
-	NextSyncCommitteeBranch merkle.Values                 `json:"next_sync_committee_branch"`
-	FinalizedHeader         *jsonBeaconHeader             `json:"finalized_header,omitempty"`
-	FinalityBranch          merkle.Values                 `json:"finality_branch,omitempty"`
-	SyncAggregate           types.SyncAggregate           `json:"sync_aggregate"`
-	SignatureSlot           common.Decimal                `json:"signature_slot"`
-}
-
-type jsonBeaconHeader struct {
-	Beacon types.Header `json:"beacon"`
-}
-
-type jsonHeaderWithExecProof struct {
-	Beacon          types.Header    `json:"beacon"`
-	Execution       json.RawMessage `json:"execution"`
-	ExecutionBranch merkle.Values   `json:"execution_branch"`
-}
-
-// UnmarshalJSON unmarshals from JSON.
-func (u *CommitteeUpdate) UnmarshalJSON(input []byte) error {
-	var dec committeeUpdateJson
-	if err := json.Unmarshal(input, &dec); err != nil {
-		return err
-	}
-	u.Version = dec.Version
-	u.NextSyncCommittee = dec.Data.NextSyncCommittee
-	u.Update = types.LightClientUpdate{
-		AttestedHeader: types.SignedHeader{
-			Header:        dec.Data.Header.Beacon,
-			Signature:     dec.Data.SyncAggregate,
-			SignatureSlot: uint64(dec.Data.SignatureSlot),
-		},
-		NextSyncCommitteeRoot:   u.NextSyncCommittee.Root(),
-		NextSyncCommitteeBranch: dec.Data.NextSyncCommitteeBranch,
-		FinalityBranch:          dec.Data.FinalityBranch,
-	}
-	if dec.Data.FinalizedHeader != nil {
-		u.Update.FinalizedHeader = &dec.Data.FinalizedHeader.Beacon
-	}
-	return nil
-}
-
-// fetcher is an interface useful for debug-harnessing the http api.
-type fetcher interface {
-	Do(req *http.Request) (*http.Response, error)
-}
-
-// BeaconLightApi requests light client information from a beacon node REST API.
-// Note: all required API endpoints are currently only implemented by Lodestar.
-type BeaconLightApi struct {
-	url           string
-	client        fetcher
-	customHeaders map[string]string
-}
-
-func NewBeaconLightApi(url string, customHeaders map[string]string) *BeaconLightApi {
-	return &BeaconLightApi{
-		url: url,
-		client: &http.Client{
-			Timeout: time.Second * 10,
-		},
-		customHeaders: customHeaders,
-	}
-}
-
-func (api *BeaconLightApi) httpGet(path string, params url.Values) ([]byte, error) {
-	uri, err := api.buildURL(path, params)
-	if err != nil {
-		return nil, err
-	}
-	req, err := http.NewRequest("GET", uri, nil)
-	if err != nil {
-		return nil, err
-	}
-	for k, v := range api.customHeaders {
-		req.Header.Set(k, v)
-	}
-	resp, err := api.client.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	switch resp.StatusCode {
-	case 200:
-		return io.ReadAll(resp.Body)
-	case 404:
-		return nil, ErrNotFound
-	case 500:
-		return nil, ErrInternal
-	default:
-		return nil, fmt.Errorf("unexpected error from API endpoint \"%s\": status code %d", path, resp.StatusCode)
-	}
-}
-
-// GetBestUpdatesAndCommittees fetches and validates LightClientUpdate for given
-// period and full serialized committee for the next period (committee root hash
-// equals update.NextSyncCommitteeRoot).
-// Note that the results are validated but the update signature should be verified
-// by the caller as its validity depends on the update chain.
-func (api *BeaconLightApi) GetBestUpdatesAndCommittees(firstPeriod, count uint64) ([]*types.LightClientUpdate, []*types.SerializedSyncCommittee, error) {
-	resp, err := api.httpGet("/eth/v1/beacon/light_client/updates", map[string][]string{
-		"start_period": {strconv.FormatUint(firstPeriod, 10)},
-		"count":        {strconv.FormatUint(count, 10)},
-	})
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var data []CommitteeUpdate
-	if err := json.Unmarshal(resp, &data); err != nil {
-		return nil, nil, err
-	}
-	if len(data) != int(count) {
-		return nil, nil, errors.New("invalid number of committee updates")
-	}
-	updates := make([]*types.LightClientUpdate, int(count))
-	committees := make([]*types.SerializedSyncCommittee, int(count))
-	for i, d := range data {
-		if d.Update.AttestedHeader.Header.SyncPeriod() != firstPeriod+uint64(i) {
-			return nil, nil, errors.New("wrong committee update header period")
-		}
-		if err := d.Update.Validate(); err != nil {
-			return nil, nil, err
-		}
-		if d.NextSyncCommittee.Root() != d.Update.NextSyncCommitteeRoot {
-			return nil, nil, errors.New("wrong sync committee root")
-		}
-		updates[i], committees[i] = new(types.LightClientUpdate), new(types.SerializedSyncCommittee)
-		*updates[i], *committees[i] = d.Update, d.NextSyncCommittee
-	}
-	return updates, committees, nil
-}
-
-// GetOptimisticUpdate fetches the latest available optimistic update.
-// Note that the signature should be verified by the caller as its validity
-// depends on the update chain.
-//
-// See data structure definition here:
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/light-client/sync-protocol.md#lightclientoptimisticupdate
-func (api *BeaconLightApi) GetOptimisticUpdate() (types.OptimisticUpdate, error) {
-	resp, err := api.httpGet("/eth/v1/beacon/light_client/optimistic_update", nil)
-	if err != nil {
-		return types.OptimisticUpdate{}, err
-	}
-	return decodeOptimisticUpdate(resp)
-}
-
-func decodeOptimisticUpdate(enc []byte) (types.OptimisticUpdate, error) {
-	var data struct {
-		Version string
-		Data    struct {
-			Attested      jsonHeaderWithExecProof `json:"attested_header"`
-			Aggregate     types.SyncAggregate     `json:"sync_aggregate"`
-			SignatureSlot common.Decimal          `json:"signature_slot"`
-		} `json:"data"`
-	}
-	if err := json.Unmarshal(enc, &data); err != nil {
-		return types.OptimisticUpdate{}, err
-	}
-	// Decode the execution payload headers.
-	attestedExecHeader, err := types.ExecutionHeaderFromJSON(data.Version, data.Data.Attested.Execution)
-	if err != nil {
-		return types.OptimisticUpdate{}, fmt.Errorf("invalid attested header: %v", err)
-	}
-	if data.Data.Attested.Beacon.StateRoot == (common.Hash{}) {
-		// workaround for different event encoding format in Lodestar
-		if err := json.Unmarshal(enc, &data.Data); err != nil {
-			return types.OptimisticUpdate{}, err
-		}
-	}
-
-	if len(data.Data.Aggregate.Signers) != params.SyncCommitteeBitmaskSize {
-		return types.OptimisticUpdate{}, errors.New("invalid sync_committee_bits length")
-	}
-	if len(data.Data.Aggregate.Signature) != params.BLSSignatureSize {
-		return types.OptimisticUpdate{}, errors.New("invalid sync_committee_signature length")
-	}
-	return types.OptimisticUpdate{
-		Attested: types.HeaderWithExecProof{
-			Header:        data.Data.Attested.Beacon,
-			PayloadHeader: attestedExecHeader,
-			PayloadBranch: data.Data.Attested.ExecutionBranch,
-		},
-		Signature:     data.Data.Aggregate,
-		SignatureSlot: uint64(data.Data.SignatureSlot),
-	}, nil
-}
-
-// GetFinalityUpdate fetches the latest available finality update.
-//
-// See data structure definition here:
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/light-client/sync-protocol.md#lightclientfinalityupdate
-func (api *BeaconLightApi) GetFinalityUpdate() (types.FinalityUpdate, error) {
-	resp, err := api.httpGet("/eth/v1/beacon/light_client/finality_update", nil)
-	if err != nil {
-		return types.FinalityUpdate{}, err
-	}
-	return decodeFinalityUpdate(resp)
-}
-
-func decodeFinalityUpdate(enc []byte) (types.FinalityUpdate, error) {
-	var data struct {
-		Version string
-		Data    struct {
-			Attested       jsonHeaderWithExecProof `json:"attested_header"`
-			Finalized      jsonHeaderWithExecProof `json:"finalized_header"`
-			FinalityBranch merkle.Values           `json:"finality_branch"`
-			Aggregate      types.SyncAggregate     `json:"sync_aggregate"`
-			SignatureSlot  common.Decimal          `json:"signature_slot"`
-		}
-	}
-	if err := json.Unmarshal(enc, &data); err != nil {
-		return types.FinalityUpdate{}, err
-	}
-	// Decode the execution payload headers.
-	attestedExecHeader, err := types.ExecutionHeaderFromJSON(data.Version, data.Data.Attested.Execution)
-	if err != nil {
-		return types.FinalityUpdate{}, fmt.Errorf("invalid attested header: %v", err)
-	}
-	finalizedExecHeader, err := types.ExecutionHeaderFromJSON(data.Version, data.Data.Finalized.Execution)
-	if err != nil {
-		return types.FinalityUpdate{}, fmt.Errorf("invalid finalized header: %v", err)
-	}
-	// Perform sanity checks.
-	if len(data.Data.Aggregate.Signers) != params.SyncCommitteeBitmaskSize {
-		return types.FinalityUpdate{}, errors.New("invalid sync_committee_bits length")
-	}
-	if len(data.Data.Aggregate.Signature) != params.BLSSignatureSize {
-		return types.FinalityUpdate{}, errors.New("invalid sync_committee_signature length")
-	}
-
-	return types.FinalityUpdate{
-		Attested: types.HeaderWithExecProof{
-			Header:        data.Data.Attested.Beacon,
-			PayloadHeader: attestedExecHeader,
-			PayloadBranch: data.Data.Attested.ExecutionBranch,
-		},
-		Finalized: types.HeaderWithExecProof{
-			Header:        data.Data.Finalized.Beacon,
-			PayloadHeader: finalizedExecHeader,
-			PayloadBranch: data.Data.Finalized.ExecutionBranch,
-		},
-		FinalityBranch: data.Data.FinalityBranch,
-		Signature:      data.Data.Aggregate,
-		SignatureSlot:  uint64(data.Data.SignatureSlot),
-	}, nil
-}
-
-// GetHeader fetches and validates the beacon header with the given blockRoot.
-// If blockRoot is null hash then the latest head header is fetched.
-// The values of the canonical and finalized flags are also returned. Note that
-// these flags are not validated.
-func (api *BeaconLightApi) GetHeader(blockRoot common.Hash) (types.Header, bool, bool, error) {
-	var blockId string
-	if blockRoot == (common.Hash{}) {
-		blockId = "head"
-	} else {
-		blockId = blockRoot.Hex()
-	}
-	resp, err := api.httpGet(fmt.Sprintf("/eth/v1/beacon/headers/%s", blockId), nil)
-	if err != nil {
-		return types.Header{}, false, false, err
-	}
-
-	var data struct {
-		Finalized bool `json:"finalized"`
-		Data      struct {
-			Root      common.Hash `json:"root"`
-			Canonical bool        `json:"canonical"`
-			Header    struct {
-				Message   types.Header  `json:"message"`
-				Signature hexutil.Bytes `json:"signature"`
-			} `json:"header"`
-		} `json:"data"`
-	}
-	if err := json.Unmarshal(resp, &data); err != nil {
-		return types.Header{}, false, false, err
-	}
-	header := data.Data.Header.Message
-	if blockRoot == (common.Hash{}) {
-		blockRoot = data.Data.Root
-	}
-	if header.Hash() != blockRoot {
-		return types.Header{}, false, false, errors.New("retrieved beacon header root does not match")
-	}
-	return header, data.Data.Canonical, data.Finalized, nil
-}
-
-// GetCheckpointData fetches and validates bootstrap data belonging to the given checkpoint.
-func (api *BeaconLightApi) GetCheckpointData(checkpointHash common.Hash) (*types.BootstrapData, error) {
-	resp, err := api.httpGet(fmt.Sprintf("/eth/v1/beacon/light_client/bootstrap/0x%x", checkpointHash[:]), nil)
-	if err != nil {
-		return nil, err
-	}
-
-	// See data structure definition here:
-	// https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/light-client/sync-protocol.md#lightclientbootstrap
-	type bootstrapData struct {
-		Data struct {
-			Header          jsonBeaconHeader               `json:"header"`
-			Committee       *types.SerializedSyncCommittee `json:"current_sync_committee"`
-			CommitteeBranch merkle.Values                  `json:"current_sync_committee_branch"`
-		} `json:"data"`
-	}
-
-	var data bootstrapData
-	if err := json.Unmarshal(resp, &data); err != nil {
-		return nil, err
-	}
-	if data.Data.Committee == nil {
-		return nil, errors.New("sync committee is missing")
-	}
-	header := data.Data.Header.Beacon
-	if header.Hash() != checkpointHash {
-		return nil, fmt.Errorf("invalid checkpoint block header, have %v want %v", header.Hash(), checkpointHash)
-	}
-	checkpoint := &types.BootstrapData{
-		Header:          header,
-		CommitteeBranch: data.Data.CommitteeBranch,
-		CommitteeRoot:   data.Data.Committee.Root(),
-		Committee:       data.Data.Committee,
-	}
-	if err := checkpoint.Validate(); err != nil {
-		return nil, fmt.Errorf("invalid checkpoint: %w", err)
-	}
-	if checkpoint.Header.Hash() != checkpointHash {
-		return nil, errors.New("wrong checkpoint hash")
-	}
-	return checkpoint, nil
-}
-
-func (api *BeaconLightApi) GetBeaconBlock(blockRoot common.Hash) (*types.BeaconBlock, error) {
-	resp, err := api.httpGet(fmt.Sprintf("/eth/v2/beacon/blocks/0x%x", blockRoot), nil)
-	if err != nil {
-		return nil, err
-	}
-
-	var beaconBlockMessage struct {
-		Version string
-		Data    struct {
-			Message json.RawMessage `json:"message"`
-		}
-	}
-	if err := json.Unmarshal(resp, &beaconBlockMessage); err != nil {
-		return nil, fmt.Errorf("invalid block json data: %v", err)
-	}
-	block, err := types.BlockFromJSON(beaconBlockMessage.Version, beaconBlockMessage.Data.Message)
-	if err != nil {
-		return nil, err
-	}
-	computedRoot := block.Root()
-	if computedRoot != blockRoot {
-		return nil, fmt.Errorf("Beacon block root hash mismatch (expected: %x, got: %x)", blockRoot, computedRoot)
-	}
-	return block, nil
-}
-
-func decodeHeadEvent(enc []byte) (uint64, common.Hash, error) {
-	var data struct {
-		Slot  common.Decimal `json:"slot"`
-		Block common.Hash    `json:"block"`
-	}
-	if err := json.Unmarshal(enc, &data); err != nil {
-		return 0, common.Hash{}, err
-	}
-	return uint64(data.Slot), data.Block, nil
-}
-
-type HeadEventListener struct {
-	OnNewHead    func(slot uint64, blockRoot common.Hash)
-	OnOptimistic func(head types.OptimisticUpdate)
-	OnFinality   func(head types.FinalityUpdate)
-	OnError      func(err error)
-}
-
-// StartHeadListener creates an event subscription for heads and signed (optimistic)
-// head updates and calls the specified callback functions when they are received.
-// The callbacks are also called for the current head and optimistic head at startup.
-// They are never called concurrently.
-func (api *BeaconLightApi) StartHeadListener(listener HeadEventListener) func() {
-	var (
-		ctx, closeCtx = context.WithCancel(context.Background())
-		streamCh      = make(chan *eventsource.Stream, 1)
-		wg            sync.WaitGroup
-	)
-
-	// When connected to a Lodestar node the subscription blocks until the first actual
-	// event arrives; therefore we create the subscription in a separate goroutine while
-	// letting the main goroutine sync up to the current head.
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		stream := api.startEventStream(ctx, &listener)
-		if stream == nil {
-			// This case happens when the context was closed.
-			return
-		}
-		// Stream was opened, wait for close signal.
-		streamCh <- stream
-		<-ctx.Done()
-		stream.Close()
-	}()
-
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-
-		// Request initial data.
-		log.Trace("Requesting initial head header")
-		if head, _, _, err := api.GetHeader(common.Hash{}); err == nil {
-			log.Trace("Retrieved initial head header", "slot", head.Slot, "hash", head.Hash())
-			listener.OnNewHead(head.Slot, head.Hash())
-		} else {
-			log.Debug("Failed to retrieve initial head header", "error", err)
-		}
-		log.Trace("Requesting initial optimistic update")
-		if optimisticUpdate, err := api.GetOptimisticUpdate(); err == nil {
-			log.Trace("Retrieved initial optimistic update", "slot", optimisticUpdate.Attested.Slot, "hash", optimisticUpdate.Attested.Hash())
-			listener.OnOptimistic(optimisticUpdate)
-		} else {
-			log.Debug("Failed to retrieve initial optimistic update", "error", err)
-		}
-		log.Trace("Requesting initial finality update")
-		if finalityUpdate, err := api.GetFinalityUpdate(); err == nil {
-			log.Trace("Retrieved initial finality update", "slot", finalityUpdate.Finalized.Slot, "hash", finalityUpdate.Finalized.Hash())
-			listener.OnFinality(finalityUpdate)
-		} else {
-			log.Debug("Failed to retrieve initial finality update", "error", err)
-		}
-
-		log.Trace("Starting event stream processing loop")
-		// Receive the stream.
-		var stream *eventsource.Stream
-		select {
-		case stream = <-streamCh:
-		case <-ctx.Done():
-			log.Trace("Stopping event stream processing loop")
-			return
-		}
-
-		for {
-			select {
-			case event, ok := <-stream.Events:
-				if !ok {
-					log.Trace("Event stream closed")
-					return
-				}
-				log.Trace("New event received from event stream", "type", event.Event())
-				switch event.Event() {
-				case "head":
-					slot, blockRoot, err := decodeHeadEvent([]byte(event.Data()))
-					if err == nil {
-						listener.OnNewHead(slot, blockRoot)
-					} else {
-						listener.OnError(fmt.Errorf("error decoding head event: %v", err))
-					}
-				case "light_client_optimistic_update":
-					optimisticUpdate, err := decodeOptimisticUpdate([]byte(event.Data()))
-					if err == nil {
-						listener.OnOptimistic(optimisticUpdate)
-					} else {
-						listener.OnError(fmt.Errorf("error decoding optimistic update event: %v", err))
-					}
-				case "light_client_finality_update":
-					finalityUpdate, err := decodeFinalityUpdate([]byte(event.Data()))
-					if err == nil {
-						listener.OnFinality(finalityUpdate)
-					} else {
-						listener.OnError(fmt.Errorf("error decoding finality update event: %v", err))
-					}
-				default:
-					listener.OnError(fmt.Errorf("unexpected event: %s", event.Event()))
-				}
-
-			case err, ok := <-stream.Errors:
-				if !ok {
-					return
-				}
-				listener.OnError(err)
-			}
-		}
-	}()
-
-	return func() {
-		closeCtx()
-		wg.Wait()
-	}
-}
-
-// startEventStream establishes an event stream. This will keep retrying until the stream has been
-// established. It can only return nil when the context is canceled.
-func (api *BeaconLightApi) startEventStream(ctx context.Context, listener *HeadEventListener) *eventsource.Stream {
-	for retry := true; retry; retry = ctxSleep(ctx, 5*time.Second) {
-		log.Trace("Sending event subscription request")
-		uri, err := api.buildURL("/eth/v1/events", map[string][]string{"topics": {"head", "light_client_finality_update", "light_client_optimistic_update"}})
-		if err != nil {
-			listener.OnError(fmt.Errorf("error creating event subscription URL: %v", err))
-			continue
-		}
-		req, err := http.NewRequestWithContext(ctx, "GET", uri, nil)
-		if err != nil {
-			listener.OnError(fmt.Errorf("error creating event subscription request: %v", err))
-			continue
-		}
-		for k, v := range api.customHeaders {
-			req.Header.Set(k, v)
-		}
-		stream, err := eventsource.SubscribeWithRequest("", req)
-		if err != nil {
-			listener.OnError(fmt.Errorf("error creating event subscription: %v", err))
-			continue
-		}
-		log.Trace("Successfully created event stream")
-		return stream
-	}
-	return nil
-}
-
-func ctxSleep(ctx context.Context, timeout time.Duration) (ok bool) {
-	timer := time.NewTimer(timeout)
-	defer timer.Stop()
-	select {
-	case <-timer.C:
-		return true
-	case <-ctx.Done():
-		return false
-	}
-}
-
-func (api *BeaconLightApi) buildURL(path string, params url.Values) (string, error) {
-	uri, err := url.Parse(api.url)
-	if err != nil {
-		return "", err
-	}
-	uri = uri.JoinPath(path)
-	if params != nil {
-		uri.RawQuery = params.Encode()
-	}
-	return uri.String(), nil
-}
--- a/beacon/light/committee_chain.go
+++ b/beacon/light/committee_chain.go
@@ -70,13 +70,13 @@ type CommitteeChain struct {
 	committees          *canonicalStore[*types.SerializedSyncCommittee]
 	fixedCommitteeRoots *canonicalStore[common.Hash]
 	committeeCache      *lru.Cache[uint64, syncCommittee] // cache deserialized committees
-	changeCounter       uint64

 	clock       mclock.Clock         // monotonic clock (simulated clock in tests)
 	unixNano    func() int64         // system clock (simulated clock in tests)
 	sigVerifier committeeSigVerifier // BLS sig verifier (dummy verifier in tests)

 	config             *types.ChainConfig
+	signerThreshold    int
 	minimumUpdateScore types.UpdateScore
 	enforceTime        bool // enforceTime specifies whether the age of a signed header should be checked
 }
@@ -86,11 +86,6 @@ func NewCommitteeChain(db ethdb.KeyValueStore, config *types.ChainConfig, signer
 	return newCommitteeChain(db, config, signerThreshold, enforceTime, blsVerifier{}, &mclock.System{}, func() int64 { return time.Now().UnixNano() })
 }

-// NewTestCommitteeChain creates a new CommitteeChain for testing.
-func NewTestCommitteeChain(db ethdb.KeyValueStore, config *types.ChainConfig, signerThreshold int, enforceTime bool, clock *mclock.Simulated) *CommitteeChain {
-	return newCommitteeChain(db, config, signerThreshold, enforceTime, dummyVerifier{}, clock, func() int64 { return int64(clock.Now()) })
-}
-
 // newCommitteeChain creates a new CommitteeChain with the option of replacing the
 // clock source and signature verification for testing purposes.
 func newCommitteeChain(db ethdb.KeyValueStore, config *types.ChainConfig, signerThreshold int, enforceTime bool, sigVerifier committeeSigVerifier, clock mclock.Clock, unixNano func() int64) *CommitteeChain {
@@ -101,6 +96,7 @@ func newCommitteeChain(db ethdb.KeyValueStore, config *types.ChainConfig, signer
 		clock:           clock,
 		unixNano:        unixNano,
 		config:          config,
+		signerThreshold: signerThreshold,
 		enforceTime:     enforceTime,
 		minimumUpdateScore: types.UpdateScore{
 			SignerCount:    uint32(signerThreshold),
@@ -185,20 +181,20 @@ func (s *CommitteeChain) Reset() {
 	if err := s.rollback(0); err != nil {
 		log.Error("Error writing batch into chain database", "error", err)
 	}
-	s.changeCounter++
 }

-// CheckpointInit initializes a CommitteeChain based on a checkpoint.
+// CheckpointInit initializes a CommitteeChain based on the checkpoint.
 // Note: if the chain is already initialized and the committees proven by the
 // checkpoint do match the existing chain then the chain is retained and the
 // new checkpoint becomes fixed.
-func (s *CommitteeChain) CheckpointInit(bootstrap types.BootstrapData) error {
+func (s *CommitteeChain) CheckpointInit(bootstrap *types.BootstrapData) error {
 	s.chainmu.Lock()
 	defer s.chainmu.Unlock()

 	if err := bootstrap.Validate(); err != nil {
 		return err
 	}
+
 	period := bootstrap.Header.SyncPeriod()
 	if err := s.deleteFixedCommitteeRootsFrom(period + 2); err != nil {
 		s.Reset()
@@ -219,7 +215,6 @@ func (s *CommitteeChain) CheckpointInit(bootstrap types.BootstrapData) error {
 		s.Reset()
 		return err
 	}
-	s.changeCounter++
 	return nil
 }

@@ -372,7 +367,6 @@ func (s *CommitteeChain) InsertUpdate(update *types.LightClientUpdate, nextCommi
 			return ErrWrongCommitteeRoot
 		}
 	}
-	s.changeCounter++
 	if reorg {
 		if err := s.rollback(period + 1); err != nil {
 			return err
@@ -411,13 +405,6 @@ func (s *CommitteeChain) NextSyncPeriod() (uint64, bool) {
 	return s.committees.periods.End - 1, true
 }

-func (s *CommitteeChain) ChangeCounter() uint64 {
-	s.chainmu.RLock()
-	defer s.chainmu.RUnlock()
-
-	return s.changeCounter
-}
-
 // rollback removes all committees and fixed roots from the given period and updates
 // starting from the previous period.
 func (s *CommitteeChain) rollback(period uint64) error {
@@ -465,12 +452,12 @@ func (s *CommitteeChain) getSyncCommittee(period uint64) (syncCommittee, error)
 	if sc, ok := s.committees.get(s.db, period); ok {
 		c, err := s.sigVerifier.deserializeSyncCommittee(sc)
 		if err != nil {
-			return nil, fmt.Errorf("sync committee #%d deserialization error: %v", period, err)
+			return nil, fmt.Errorf("Sync committee #%d deserialization error: %v", period, err)
 		}
 		s.committeeCache.Add(period, c)
 		return c, nil
 	}
-	return nil, fmt.Errorf("missing serialized sync committee #%d", period)
+	return nil, fmt.Errorf("Missing serialized sync committee #%d", period)
 }

 // VerifySignedHeader returns true if the given signed header has a valid signature
--- a/beacon/light/committee_chain_test.go
+++ b/beacon/light/committee_chain_test.go
@@ -241,12 +241,12 @@ func newCommitteeChainTest(t *testing.T, config types.ChainConfig, signerThresho
 		signerThreshold: signerThreshold,
 		enforceTime:     enforceTime,
 	}
-	c.chain = NewTestCommitteeChain(c.db, &config, signerThreshold, enforceTime, c.clock)
+	c.chain = newCommitteeChain(c.db, &config, signerThreshold, enforceTime, dummyVerifier{}, c.clock, func() int64 { return int64(c.clock.Now()) })
 	return c
 }

 func (c *committeeChainTest) reloadChain() {
-	c.chain = NewTestCommitteeChain(c.db, &c.config, c.signerThreshold, c.enforceTime, c.clock)
+	c.chain = newCommitteeChain(c.db, &c.config, c.signerThreshold, c.enforceTime, dummyVerifier{}, c.clock, func() int64 { return int64(c.clock.Now()) })
 }

 func (c *committeeChainTest) setClockPeriod(period float64) {
--- a/beacon/light/head_tracker.go
+++ b/beacon/light/head_tracker.go
@@ -1,163 +0,0 @@
-// Copyright 2023 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package light
-
-import (
-	"errors"
-	"sync"
-	"time"
-
-	"github.com/ethereum/go-ethereum/beacon/types"
-	"github.com/ethereum/go-ethereum/log"
-)
-
-// HeadTracker keeps track of the latest validated head and the "prefetch" head
-// which is the (not necessarily validated) head announced by the majority of
-// servers.
-type HeadTracker struct {
-	lock                sync.RWMutex
-	committeeChain      *CommitteeChain
-	minSignerCount      int
-	optimisticUpdate    types.OptimisticUpdate
-	hasOptimisticUpdate bool
-	finalityUpdate      types.FinalityUpdate
-	hasFinalityUpdate   bool
-	prefetchHead        types.HeadInfo
-	changeCounter       uint64
-}
-
-// NewHeadTracker creates a new HeadTracker.
-func NewHeadTracker(committeeChain *CommitteeChain, minSignerCount int) *HeadTracker {
-	return &HeadTracker{
-		committeeChain: committeeChain,
-		minSignerCount: minSignerCount,
-	}
-}
-
-// ValidatedOptimistic returns the latest validated optimistic update.
-func (h *HeadTracker) ValidatedOptimistic() (types.OptimisticUpdate, bool) {
-	h.lock.RLock()
-	defer h.lock.RUnlock()
-
-	return h.optimisticUpdate, h.hasOptimisticUpdate
-}
-
-// ValidatedFinality returns the latest validated finality update.
-func (h *HeadTracker) ValidatedFinality() (types.FinalityUpdate, bool) {
-	h.lock.RLock()
-	defer h.lock.RUnlock()
-
-	return h.finalityUpdate, h.hasFinalityUpdate
-}
-
-// ValidateOptimistic validates the given optimistic update. If the update is
-// successfully validated and it is better than the old validated update (higher
-// slot or same slot and more signers) then ValidatedOptimistic is updated.
-// The boolean return flag signals if ValidatedOptimistic has been changed.
-func (h *HeadTracker) ValidateOptimistic(update types.OptimisticUpdate) (bool, error) {
-	if err := update.Validate(); err != nil {
-		return false, err
-	}
-
-	h.lock.Lock()
-	defer h.lock.Unlock()
-
-	replace, err := h.validate(update.SignedHeader(), h.optimisticUpdate.SignedHeader())
-	if replace {
-		h.optimisticUpdate, h.hasOptimisticUpdate = update, true
-		h.changeCounter++
-	}
-	return replace, err
-}
-
-// ValidateFinality validates the given finality update. If the update is
-// successfully validated and it is better than the old validated update (higher
-// slot or same slot and more signers) then ValidatedFinality is updated.
-// The boolean return flag signals if ValidatedFinality has been changed.
-func (h *HeadTracker) ValidateFinality(update types.FinalityUpdate) (bool, error) {
-	if err := update.Validate(); err != nil {
-		return false, err
-	}
-
-	h.lock.Lock()
-	defer h.lock.Unlock()
-
-	replace, err := h.validate(update.SignedHeader(), h.finalityUpdate.SignedHeader())
-	if replace {
-		h.finalityUpdate, h.hasFinalityUpdate = update, true
-		h.changeCounter++
-	}
-	return replace, err
-}
-
-func (h *HeadTracker) validate(head, oldHead types.SignedHeader) (bool, error) {
-	signerCount := head.Signature.SignerCount()
-	if signerCount < h.minSignerCount {
-		return false, errors.New("low signer count")
-	}
-	if head.Header.Slot < oldHead.Header.Slot || (head.Header.Slot == oldHead.Header.Slot && signerCount <= oldHead.Signature.SignerCount()) {
-		return false, nil
-	}
-	sigOk, age, err := h.committeeChain.VerifySignedHeader(head)
-	if err != nil {
-		return false, err
-	}
-	if age < 0 {
-		log.Warn("Future signed head received", "age", age)
-	}
-	if age > time.Minute*2 {
-		log.Warn("Old signed head received", "age", age)
-	}
-	if !sigOk {
-		return false, errors.New("invalid header signature")
-	}
-	return true, nil
-}
-
-// PrefetchHead returns the latest known prefetch head's head info.
-// This head can be used to start fetching related data hoping that it will be
-// validated soon.
-// Note that the prefetch head cannot be validated cryptographically so it should
-// only be used as a performance optimization hint.
-func (h *HeadTracker) PrefetchHead() types.HeadInfo {
-	h.lock.RLock()
-	defer h.lock.RUnlock()
-
-	return h.prefetchHead
-}
-
-// SetPrefetchHead sets the prefetch head info.
-// Note that HeadTracker does not verify the prefetch head, just acts as a thread
-// safe bulletin board.
-func (h *HeadTracker) SetPrefetchHead(head types.HeadInfo) {
-	h.lock.Lock()
-	defer h.lock.Unlock()
-
-	if head == h.prefetchHead {
-		return
-	}
-	h.prefetchHead = head
-	h.changeCounter++
-}
-
-// ChangeCounter implements request.targetData
-func (h *HeadTracker) ChangeCounter() uint64 {
-	h.lock.RLock()
-	defer h.lock.RUnlock()
-
-	return h.changeCounter
-}
--- a/beacon/light/request/scheduler.go
+++ b/beacon/light/request/scheduler.go
@@ -1,403 +0,0 @@
-// Copyright 2023 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package request
-
-import (
-	"sync"
-
-	"github.com/ethereum/go-ethereum/log"
-)
-
-// Module represents a mechanism which is typically responsible for downloading
-// and updating a passive data structure. It does not directly interact with the
-// servers. It can start requests using the Requester interface, maintain its
-// internal state by receiving and processing Events and update its target data
-// structure based on the obtained data.
-// It is the Scheduler's responsibility to feed events to the modules, call
-// Process as long as there might be something to process and then generate request
-// candidates using MakeRequest and start the best possible requests.
-// Modules are called by Scheduler whenever a global trigger is fired. All events
-// fire the trigger. Changing a target data structure also triggers a next
-// processing round as it could make further actions possible either by the same
-// or another Module.
-type Module interface {
-	// Process is a non-blocking function responsible for starting requests,
-	// processing events and updating the target data structures(s) and the
-	// internal state of the module. Module state typically consists of information
-	// about pending requests and registered servers.
-	// Process is always called after an event is received or after a target data
-	// structure has been changed.
-	//
-	// Note: Process functions of different modules are never called concurrently;
-	// they are called by Scheduler in the same order of priority as they were
-	// registered in.
-	Process(Requester, []Event)
-}
-
-// Requester allows Modules to obtain the list of momentarily available servers,
-// start new requests and report server failure when a response has been proven
-// to be invalid in the processing phase.
-// Note that all Requester functions should be safe to call from Module.Process.
-type Requester interface {
-	CanSendTo() []Server
-	Send(Server, Request) ID
-	Fail(Server, string)
-}
-
-// Scheduler is a modular network data retrieval framework that coordinates multiple
-// servers and retrieval mechanisms (modules). It implements a trigger mechanism
-// that calls the Process function of registered modules whenever either the state
-// of existing data structures or events coming from registered servers could
-// allow new operations.
-type Scheduler struct {
-	lock    sync.Mutex
-	modules []Module // first has the highest priority
-	names   map[Module]string
-	servers map[server]struct{}
-	targets map[targetData]uint64
-
-	requesterLock sync.RWMutex
-	serverOrder   []server
-	pending       map[ServerAndID]pendingRequest
-
-	// eventLock guards access to the events list. Note that eventLock can be
-	// locked either while lock is locked or unlocked but lock cannot be locked
-	// while eventLock is locked.
-	eventLock sync.Mutex
-	events    []Event
-	stopCh    chan chan struct{}
-
-	triggerCh chan struct{} // restarts waiting sync loop
-	// if trigger has already been fired then send to testWaitCh blocks until
-	// the triggered processing round is finished
-	testWaitCh chan struct{}
-}
-
-type (
-	// Server identifies a server without allowing any direct interaction.
-	// Note: server interface is used by Scheduler and Tracker but not used by
-	// the modules that do not interact with them directly.
-	// In order to make module testing easier, Server interface is used in
-	// events and modules.
-	Server interface {
-		Name() string
-	}
-	Request     any
-	Response    any
-	ID          uint64
-	ServerAndID struct {
-		Server Server
-		ID     ID
-	}
-)
-
-// targetData represents a registered target data structure that increases its
-// ChangeCounter whenever it has been changed.
-type targetData interface {
-	ChangeCounter() uint64
-}
-
-// pendingRequest keeps track of sent and not yet finalized requests and their
-// sender modules.
-type pendingRequest struct {
-	request Request
-	module  Module
-}
-
-// NewScheduler creates a new Scheduler.
-func NewScheduler() *Scheduler {
-	s := &Scheduler{
-		servers: make(map[server]struct{}),
-		names:   make(map[Module]string),
-		pending: make(map[ServerAndID]pendingRequest),
-		targets: make(map[targetData]uint64),
-		stopCh:  make(chan chan struct{}),
-		// Note: testWaitCh should not have capacity in order to ensure
-		// that after a trigger happens testWaitCh will block until the resulting
-		// processing round has been finished
-		triggerCh:  make(chan struct{}, 1),
-		testWaitCh: make(chan struct{}),
-	}
-	return s
-}
-
-// RegisterTarget registers a target data structure, ensuring that any changes
-// made to it trigger a new round of Module.Process calls, giving a chance to
-// modules to react to the changes.
-func (s *Scheduler) RegisterTarget(t targetData) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	s.targets[t] = 0
-}
-
-// RegisterModule registers a module. Should be called before starting the scheduler.
-// In each processing round the order of module processing depends on the order of
-// registration.
-func (s *Scheduler) RegisterModule(m Module, name string) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	s.modules = append(s.modules, m)
-	s.names[m] = name
-}
-
-// RegisterServer registers a new server.
-func (s *Scheduler) RegisterServer(server server) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	s.addEvent(Event{Type: EvRegistered, Server: server})
-	server.subscribe(func(event Event) {
-		event.Server = server
-		s.addEvent(event)
-	})
-}
-
-// UnregisterServer removes a registered server.
-func (s *Scheduler) UnregisterServer(server server) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	server.unsubscribe()
-	s.addEvent(Event{Type: EvUnregistered, Server: server})
-}
-
-// Start starts the scheduler. It should be called after registering all modules
-// and before registering any servers.
-func (s *Scheduler) Start() {
-	go s.syncLoop()
-}
-
-// Stop stops the scheduler.
-func (s *Scheduler) Stop() {
-	stop := make(chan struct{})
-	s.stopCh <- stop
-	<-stop
-	s.lock.Lock()
-	for server := range s.servers {
-		server.unsubscribe()
-	}
-	s.servers = nil
-	s.lock.Unlock()
-}
-
-// syncLoop is the main event loop responsible for event/data processing and
-// sending new requests.
-// A round of processing starts whenever the global trigger is fired. Triggers
-// fired during a processing round ensure that there is going to be a next round.
-func (s *Scheduler) syncLoop() {
-	for {
-		s.lock.Lock()
-		s.processRound()
-		s.lock.Unlock()
-	loop:
-		for {
-			select {
-			case stop := <-s.stopCh:
-				close(stop)
-				return
-			case <-s.triggerCh:
-				break loop
-			case <-s.testWaitCh:
-			}
-		}
-	}
-}
-
-// targetChanged returns true if a registered target data structure has been
-// changed since the last call to this function.
-func (s *Scheduler) targetChanged() (changed bool) {
-	for target, counter := range s.targets {
-		if newCounter := target.ChangeCounter(); newCounter != counter {
-			s.targets[target] = newCounter
-			changed = true
-		}
-	}
-	return
-}
-
-// processRound runs an entire processing round. It calls the Process functions
-// of all modules, passing all relevant events and repeating Process calls as
-// long as any changes have been made to the registered target data structures.
-// Once all events have been processed and a stable state has been achieved,
-// requests are generated and sent if necessary and possible.
-func (s *Scheduler) processRound() {
-	for {
-		log.Trace("Processing modules")
-		filteredEvents := s.filterEvents()
-		for _, module := range s.modules {
-			log.Trace("Processing module", "name", s.names[module], "events", len(filteredEvents[module]))
-			module.Process(requester{s, module}, filteredEvents[module])
-		}
-		if !s.targetChanged() {
-			break
-		}
-	}
-}
-
-// Trigger starts a new processing round. If fired during processing, it ensures
-// another full round of processing all modules.
-func (s *Scheduler) Trigger() {
-	select {
-	case s.triggerCh <- struct{}{}:
-	default:
-	}
-}
-
-// addEvent adds an event to be processed in the next round. Note that it can be
-// called regardless of the state of the lock mutex, making it safe for use in
-// the server event callback.
-func (s *Scheduler) addEvent(event Event) {
-	s.eventLock.Lock()
-	s.events = append(s.events, event)
-	s.eventLock.Unlock()
-	s.Trigger()
-}
-
-// filterEvent sorts each Event either as a request event or a server event,
-// depending on its type. Request events are also sorted in a map based on the
-// module that originally initiated the request. It also ensures that no events
-// related to a server are returned before EvRegistered or after EvUnregistered.
-// In case of an EvUnregistered server event it also closes all pending requests
-// to the given server by adding a failed request event (EvFail), ensuring that
-// all requests get finalized and thereby allowing the module logic to be safe
-// and simple.
-func (s *Scheduler) filterEvents() map[Module][]Event {
-	s.eventLock.Lock()
-	events := s.events
-	s.events = nil
-	s.eventLock.Unlock()
-
-	s.requesterLock.Lock()
-	defer s.requesterLock.Unlock()
-
-	filteredEvents := make(map[Module][]Event)
-	for _, event := range events {
-		server := event.Server.(server)
-		if _, ok := s.servers[server]; !ok && event.Type != EvRegistered {
-			continue // before EvRegister or after EvUnregister, discard
-		}
-
-		if event.IsRequestEvent() {
-			sid, _, _ := event.RequestInfo()
-			pending, ok := s.pending[sid]
-			if !ok {
-				continue // request already closed, ignore further events
-			}
-			if event.Type == EvResponse || event.Type == EvFail {
-				delete(s.pending, sid) // final event, close pending request
-			}
-			filteredEvents[pending.module] = append(filteredEvents[pending.module], event)
-		} else {
-			switch event.Type {
-			case EvRegistered:
-				s.servers[server] = struct{}{}
-				s.serverOrder = append(s.serverOrder, nil)
-				copy(s.serverOrder[1:], s.serverOrder[:len(s.serverOrder)-1])
-				s.serverOrder[0] = server
-			case EvUnregistered:
-				s.closePending(event.Server, filteredEvents)
-				delete(s.servers, server)
-				for i, srv := range s.serverOrder {
-					if srv == server {
-						copy(s.serverOrder[i:len(s.serverOrder)-1], s.serverOrder[i+1:])
-						s.serverOrder = s.serverOrder[:len(s.serverOrder)-1]
-						break
-					}
-				}
-			}
-			for _, module := range s.modules {
-				filteredEvents[module] = append(filteredEvents[module], event)
-			}
-		}
-	}
-	return filteredEvents
-}
-
-// closePending closes all pending requests to the given server and adds an EvFail
-// event to properly finalize them
-func (s *Scheduler) closePending(server Server, filteredEvents map[Module][]Event) {
-	for sid, pending := range s.pending {
-		if sid.Server == server {
-			filteredEvents[pending.module] = append(filteredEvents[pending.module], Event{
-				Type:   EvFail,
-				Server: server,
-				Data: RequestResponse{
-					ID:      sid.ID,
-					Request: pending.request,
-				},
-			})
-			delete(s.pending, sid)
-		}
-	}
-}
-
-// requester implements Requester. Note that while requester basically wraps
-// Scheduler (with the added information of the currently processed Module), all
-// functions are safe to call from Module.Process which is running while
-// the Scheduler.lock mutex is held.
-type requester struct {
-	*Scheduler
-	module Module
-}
-
-// CanSendTo returns the list of currently available servers. It also returns
-// them in an order of least to most recently used, ensuring a round-robin usage
-// of suitable servers if the module always chooses the first suitable one.
-func (s requester) CanSendTo() []Server {
-	s.requesterLock.RLock()
-	defer s.requesterLock.RUnlock()
-
-	list := make([]Server, 0, len(s.serverOrder))
-	for _, server := range s.serverOrder {
-		if server.canRequestNow() {
-			list = append(list, server)
-		}
-	}
-	return list
-}
-
-// Send sends a request and adds an entry to Scheduler.pending map, ensuring that
-// related request events will be delivered to the sender Module.
-func (s requester) Send(srv Server, req Request) ID {
-	s.requesterLock.Lock()
-	defer s.requesterLock.Unlock()
-
-	server := srv.(server)
-	id := server.sendRequest(req)
-	sid := ServerAndID{Server: srv, ID: id}
-	s.pending[sid] = pendingRequest{request: req, module: s.module}
-	for i, ss := range s.serverOrder {
-		if ss == server {
-			copy(s.serverOrder[i:len(s.serverOrder)-1], s.serverOrder[i+1:])
-			s.serverOrder[len(s.serverOrder)-1] = server
-			return id
-		}
-	}
-	log.Error("Target server not found in ordered list of registered servers")
-	return id
-}
-
-// Fail should be called when a server delivers invalid or useless information.
-// Calling Fail disables the given server for a period that is initially short
-// but is exponentially growing if it happens frequently. This results in a
-// somewhat fault tolerant operation that avoids hammering servers with requests
-// that they cannot serve but still gives them a chance periodically.
-func (s requester) Fail(srv Server, desc string) {
-	srv.(server).fail(desc)
-}
--- a/beacon/light/request/scheduler_test.go
+++ b/beacon/light/request/scheduler_test.go
@@ -1,126 +0,0 @@
-package request
-
-import (
-	"reflect"
-	"testing"
-)
-
-func TestEventFilter(t *testing.T) {
-	s := NewScheduler()
-	module1 := &testModule{name: "module1"}
-	module2 := &testModule{name: "module2"}
-	s.RegisterModule(module1, "module1")
-	s.RegisterModule(module2, "module2")
-	s.Start()
-	// startup process round without events
-	s.testWaitCh <- struct{}{}
-	module1.expProcess(t, nil)
-	module2.expProcess(t, nil)
-	srv := &testServer{}
-	// register server; both modules should receive server event
-	s.RegisterServer(srv)
-	s.testWaitCh <- struct{}{}
-	module1.expProcess(t, []Event{
-		{Type: EvRegistered, Server: srv},
-	})
-	module2.expProcess(t, []Event{
-		{Type: EvRegistered, Server: srv},
-	})
-	// let module1 send a request
-	srv.canRequest = 1
-	module1.sendReq = testRequest
-	s.Trigger()
-	// in first triggered round module1 sends the request, no events yet
-	s.testWaitCh <- struct{}{}
-	module1.expProcess(t, nil)
-	module2.expProcess(t, nil)
-	// server emits EvTimeout; only module1 should receive it
-	srv.eventCb(Event{Type: EvTimeout, Data: RequestResponse{ID: 1, Request: testRequest}})
-	s.testWaitCh <- struct{}{}
-	module1.expProcess(t, []Event{
-		{Type: EvTimeout, Server: srv, Data: RequestResponse{ID: 1, Request: testRequest}},
-	})
-	module2.expProcess(t, nil)
-	// unregister server; both modules should receive server event
-	s.UnregisterServer(srv)
-	s.testWaitCh <- struct{}{}
-	module1.expProcess(t, []Event{
-		// module1 should also receive EvFail on its pending request
-		{Type: EvFail, Server: srv, Data: RequestResponse{ID: 1, Request: testRequest}},
-		{Type: EvUnregistered, Server: srv},
-	})
-	module2.expProcess(t, []Event{
-		{Type: EvUnregistered, Server: srv},
-	})
-	// response after server unregistered; should be discarded
-	srv.eventCb(Event{Type: EvResponse, Data: RequestResponse{ID: 1, Request: testRequest, Response: testResponse}})
-	s.testWaitCh <- struct{}{}
-	module1.expProcess(t, nil)
-	module2.expProcess(t, nil)
-	// no more process rounds expected; shut down
-	s.testWaitCh <- struct{}{}
-	module1.expNoMoreProcess(t)
-	module2.expNoMoreProcess(t)
-	s.Stop()
-}
-
-type testServer struct {
-	eventCb    func(Event)
-	lastID     ID
-	canRequest int
-}
-
-func (s *testServer) Name() string {
-	return ""
-}
-
-func (s *testServer) subscribe(eventCb func(Event)) {
-	s.eventCb = eventCb
-}
-
-func (s *testServer) canRequestNow() bool {
-	return s.canRequest > 0
-}
-
-func (s *testServer) sendRequest(req Request) ID {
-	s.canRequest--
-	s.lastID++
-	return s.lastID
-}
-
-func (s *testServer) fail(string)  {}
-func (s *testServer) unsubscribe() {}
-
-type testModule struct {
-	name      string
-	processed [][]Event
-	sendReq   Request
-}
-
-func (m *testModule) Process(requester Requester, events []Event) {
-	m.processed = append(m.processed, events)
-	if m.sendReq != nil {
-		if cs := requester.CanSendTo(); len(cs) > 0 {
-			requester.Send(cs[0], m.sendReq)
-		}
-	}
-}
-
-func (m *testModule) expProcess(t *testing.T, expEvents []Event) {
-	if len(m.processed) == 0 {
-		t.Errorf("Missing call to %s.Process", m.name)
-		return
-	}
-	events := m.processed[0]
-	m.processed = m.processed[1:]
-	if !reflect.DeepEqual(events, expEvents) {
-		t.Errorf("Call to %s.Process with wrong events (expected %v, got %v)", m.name, expEvents, events)
-	}
-}
-
-func (m *testModule) expNoMoreProcess(t *testing.T) {
-	for len(m.processed) > 0 {
-		t.Errorf("Unexpected call to %s.Process with events %v", m.name, m.processed[0])
-		m.processed = m.processed[1:]
-	}
-}
--- a/beacon/light/request/server.go
+++ b/beacon/light/request/server.go
@@ -1,451 +0,0 @@
-// Copyright 2023 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package request
-
-import (
-	"math"
-	"sync"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common/mclock"
-	"github.com/ethereum/go-ethereum/log"
-)
-
-var (
-	// request events
-	EvResponse = &EventType{Name: "response", requestEvent: true} // data: RequestResponse; sent by requestServer
-	EvFail     = &EventType{Name: "fail", requestEvent: true}     // data: RequestResponse; sent by requestServer
-	EvTimeout  = &EventType{Name: "timeout", requestEvent: true}  // data: RequestResponse; sent by serverWithTimeout
-	// server events
-	EvRegistered      = &EventType{Name: "registered"}      // data: nil; sent by Scheduler
-	EvUnregistered    = &EventType{Name: "unregistered"}    // data: nil; sent by Scheduler
-	EvCanRequestAgain = &EventType{Name: "canRequestAgain"} // data: nil; sent by serverWithLimits
-)
-
-const (
-	softRequestTimeout = time.Second      // allow resending request to a different server but do not cancel yet
-	hardRequestTimeout = time.Second * 10 // cancel request
-)
-
-const (
-	// serverWithLimits parameters
-	parallelAdjustUp     = 0.1                    // adjust parallelLimit up in case of success under full load
-	parallelAdjustDown   = 1                      // adjust parallelLimit down in case of timeout/failure
-	minParallelLimit     = 1                      // parallelLimit lower bound
-	defaultParallelLimit = 3                      // parallelLimit initial value
-	minFailureDelay      = time.Millisecond * 100 // minimum disable time in case of request failure
-	maxFailureDelay      = time.Minute            // maximum disable time in case of request failure
-	maxServerEventBuffer = 5                      // server event allowance buffer limit
-	maxServerEventRate   = time.Second            // server event allowance buffer recharge rate
-)
-
-// requestServer can send requests in a non-blocking way and feed back events
-// through the event callback. After each request it should send back either
-// EvResponse or EvFail. Additionally, it may also send application-defined
-// events that the Modules can interpret.
-type requestServer interface {
-	Name() string
-	Subscribe(eventCallback func(Event))
-	SendRequest(ID, Request)
-	Unsubscribe()
-}
-
-// server is implemented by a requestServer wrapped into serverWithTimeout and
-// serverWithLimits and is used by Scheduler.
-// In addition to requestServer functionality, server can also handle timeouts,
-// limit the number of parallel in-flight requests and temporarily disable
-// new requests based on timeouts and response failures.
-type server interface {
-	Server
-	subscribe(eventCallback func(Event))
-	canRequestNow() bool
-	sendRequest(Request) ID
-	fail(string)
-	unsubscribe()
-}
-
-// NewServer wraps a requestServer and returns a server
-func NewServer(rs requestServer, clock mclock.Clock) server {
-	s := &serverWithLimits{}
-	s.parent = rs
-	s.serverWithTimeout.init(clock)
-	s.init()
-	return s
-}
-
-// EventType identifies an event type, either related to a request or the server
-// in general. Server events can also be externally defined.
-type EventType struct {
-	Name         string
-	requestEvent bool // all request events are pre-defined in request package
-}
-
-// Event describes an event where the type of Data depends on Type.
-// Server field is not required when sent through the event callback; it is filled
-// out when processed by the Scheduler. Note that the Scheduler can also create
-// and send events (EvRegistered, EvUnregistered) directly.
-type Event struct {
-	Type   *EventType
-	Server Server // filled by Scheduler
-	Data   any
-}
-
-// IsRequestEvent returns true if the event is a request event
-func (e *Event) IsRequestEvent() bool {
-	return e.Type.requestEvent
-}
-
-// RequestInfo assumes that the event is a request event and returns its contents
-// in a convenient form.
-func (e *Event) RequestInfo() (ServerAndID, Request, Response) {
-	data := e.Data.(RequestResponse)
-	return ServerAndID{Server: e.Server, ID: data.ID}, data.Request, data.Response
-}
-
-// RequestResponse is the Data type of request events.
-type RequestResponse struct {
-	ID       ID
-	Request  Request
-	Response Response
-}
-
-// serverWithTimeout wraps a requestServer and introduces timeouts.
-// The request's lifecycle is concluded if EvResponse or EvFail emitted by the
-// parent requestServer. If this does not happen until softRequestTimeout then
-// EvTimeout is emitted, after which the final EvResponse or EvFail is still
-// guaranteed to follow.
-// If the parent fails to send this final event for hardRequestTimeout then
-// serverWithTimeout emits EvFail and discards any further events from the
-// parent related to the given request.
-type serverWithTimeout struct {
-	parent       requestServer
-	lock         sync.Mutex
-	clock        mclock.Clock
-	childEventCb func(event Event)
-	timeouts     map[ID]mclock.Timer
-	lastID       ID
-}
-
-// Name implements request.Server
-func (s *serverWithTimeout) Name() string {
-	return s.parent.Name()
-}
-
-// init initializes serverWithTimeout
-func (s *serverWithTimeout) init(clock mclock.Clock) {
-	s.clock = clock
-	s.timeouts = make(map[ID]mclock.Timer)
-}
-
-// subscribe subscribes to events which include parent (requestServer) events
-// plus EvTimeout.
-func (s *serverWithTimeout) subscribe(eventCallback func(event Event)) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	s.childEventCb = eventCallback
-	s.parent.Subscribe(s.eventCallback)
-}
-
-// sendRequest generated a new request ID, emits EvRequest, sets up the timeout
-// timer, then sends the request through the parent (requestServer).
-func (s *serverWithTimeout) sendRequest(request Request) (reqId ID) {
-	s.lock.Lock()
-	s.lastID++
-	id := s.lastID
-	s.startTimeout(RequestResponse{ID: id, Request: request})
-	s.lock.Unlock()
-	s.parent.SendRequest(id, request)
-	return id
-}
-
-// eventCallback is called by parent (requestServer) event subscription.
-func (s *serverWithTimeout) eventCallback(event Event) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	switch event.Type {
-	case EvResponse, EvFail:
-		id := event.Data.(RequestResponse).ID
-		if timer, ok := s.timeouts[id]; ok {
-			// Note: if stopping the timer is unsuccessful then the resulting AfterFunc
-			// call will just do nothing
-			timer.Stop()
-			delete(s.timeouts, id)
-			if s.childEventCb != nil {
-				s.childEventCb(event)
-			}
-		}
-	default:
-		if s.childEventCb != nil {
-			s.childEventCb(event)
-		}
-	}
-}
-
-// startTimeout starts a timeout timer for the given request.
-func (s *serverWithTimeout) startTimeout(reqData RequestResponse) {
-	id := reqData.ID
-	s.timeouts[id] = s.clock.AfterFunc(softRequestTimeout, func() {
-		s.lock.Lock()
-		if _, ok := s.timeouts[id]; !ok {
-			s.lock.Unlock()
-			return
-		}
-		s.timeouts[id] = s.clock.AfterFunc(hardRequestTimeout-softRequestTimeout, func() {
-			s.lock.Lock()
-			if _, ok := s.timeouts[id]; !ok {
-				s.lock.Unlock()
-				return
-			}
-			delete(s.timeouts, id)
-			childEventCb := s.childEventCb
-			s.lock.Unlock()
-			if childEventCb != nil {
-				childEventCb(Event{Type: EvFail, Data: reqData})
-			}
-		})
-		childEventCb := s.childEventCb
-		s.lock.Unlock()
-		if childEventCb != nil {
-			childEventCb(Event{Type: EvTimeout, Data: reqData})
-		}
-	})
-}
-
-// unsubscribe stops all goroutines associated with the server.
-func (s *serverWithTimeout) unsubscribe() {
-	s.lock.Lock()
-	for _, timer := range s.timeouts {
-		if timer != nil {
-			timer.Stop()
-		}
-	}
-	s.lock.Unlock()
-	s.parent.Unsubscribe()
-}
-
-// serverWithLimits wraps serverWithTimeout and implements server. It limits the
-// number of parallel in-flight requests and prevents sending new requests when a
-// pending one has already timed out. Server events are also rate limited.
-// It also implements a failure delay mechanism that adds an exponentially growing
-// delay each time a request fails (wrong answer or hard timeout). This makes the
-// syncing mechanism less brittle as temporary failures of the server might happen
-// sometimes, but still avoids hammering a non-functional server with requests.
-type serverWithLimits struct {
-	serverWithTimeout
-	lock                       sync.Mutex
-	childEventCb               func(event Event)
-	softTimeouts               map[ID]struct{}
-	pendingCount, timeoutCount int
-	parallelLimit              float32
-	sendEvent                  bool
-	delayTimer                 mclock.Timer
-	delayCounter               int
-	failureDelayEnd            mclock.AbsTime
-	failureDelay               float64
-	serverEventBuffer          int
-	eventBufferUpdated         mclock.AbsTime
-}
-
-// init initializes serverWithLimits
-func (s *serverWithLimits) init() {
-	s.softTimeouts = make(map[ID]struct{})
-	s.parallelLimit = defaultParallelLimit
-	s.serverEventBuffer = maxServerEventBuffer
-}
-
-// subscribe subscribes to events which include parent (serverWithTimeout) events
-// plus EvCanRequestAgain.
-func (s *serverWithLimits) subscribe(eventCallback func(event Event)) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	s.childEventCb = eventCallback
-	s.serverWithTimeout.subscribe(s.eventCallback)
-}
-
-// eventCallback is called by parent (serverWithTimeout) event subscription.
-func (s *serverWithLimits) eventCallback(event Event) {
-	s.lock.Lock()
-	var sendCanRequestAgain bool
-	passEvent := true
-	switch event.Type {
-	case EvTimeout:
-		id := event.Data.(RequestResponse).ID
-		s.softTimeouts[id] = struct{}{}
-		s.timeoutCount++
-		s.parallelLimit -= parallelAdjustDown
-		if s.parallelLimit < minParallelLimit {
-			s.parallelLimit = minParallelLimit
-		}
-		log.Debug("Server timeout", "count", s.timeoutCount, "parallelLimit", s.parallelLimit)
-	case EvResponse, EvFail:
-		id := event.Data.(RequestResponse).ID
-		if _, ok := s.softTimeouts[id]; ok {
-			delete(s.softTimeouts, id)
-			s.timeoutCount--
-			log.Debug("Server timeout finalized", "count", s.timeoutCount, "parallelLimit", s.parallelLimit)
-		}
-		if event.Type == EvResponse && s.pendingCount >= int(s.parallelLimit) {
-			s.parallelLimit += parallelAdjustUp
-		}
-		s.pendingCount--
-		if s.canRequest() {
-			sendCanRequestAgain = s.sendEvent
-			s.sendEvent = false
-		}
-		if event.Type == EvFail {
-			s.failLocked("failed request")
-		}
-	default:
-		// server event; check rate limit
-		if s.serverEventBuffer < maxServerEventBuffer {
-			now := s.clock.Now()
-			sinceUpdate := time.Duration(now - s.eventBufferUpdated)
-			if sinceUpdate >= maxServerEventRate*time.Duration(maxServerEventBuffer-s.serverEventBuffer) {
-				s.serverEventBuffer = maxServerEventBuffer
-				s.eventBufferUpdated = now
-			} else {
-				addBuffer := int(sinceUpdate / maxServerEventRate)
-				s.serverEventBuffer += addBuffer
-				s.eventBufferUpdated += mclock.AbsTime(maxServerEventRate * time.Duration(addBuffer))
-			}
-		}
-		if s.serverEventBuffer > 0 {
-			s.serverEventBuffer--
-		} else {
-			passEvent = false
-		}
-	}
-	childEventCb := s.childEventCb
-	s.lock.Unlock()
-	if passEvent && childEventCb != nil {
-		childEventCb(event)
-	}
-	if sendCanRequestAgain && childEventCb != nil {
-		childEventCb(Event{Type: EvCanRequestAgain})
-	}
-}
-
-// sendRequest sends a request through the parent (serverWithTimeout).
-func (s *serverWithLimits) sendRequest(request Request) (reqId ID) {
-	s.lock.Lock()
-	s.pendingCount++
-	s.lock.Unlock()
-	return s.serverWithTimeout.sendRequest(request)
-}
-
-// unsubscribe stops all goroutines associated with the server.
-func (s *serverWithLimits) unsubscribe() {
-	s.lock.Lock()
-	if s.delayTimer != nil {
-		s.delayTimer.Stop()
-		s.delayTimer = nil
-	}
-	s.childEventCb = nil
-	s.lock.Unlock()
-	s.serverWithTimeout.unsubscribe()
-}
-
-// canRequest checks whether a new request can be started.
-func (s *serverWithLimits) canRequest() bool {
-	if s.delayTimer != nil || s.pendingCount >= int(s.parallelLimit) || s.timeoutCount > 0 {
-		return false
-	}
-	if s.parallelLimit < minParallelLimit {
-		s.parallelLimit = minParallelLimit
-	}
-	return true
-}
-
-// canRequestNow checks whether a new request can be started, according to the
-// current in-flight request count and parallelLimit, and also the failure delay
-// timer.
-// If it returns false then it is guaranteed that an EvCanRequestAgain will be
-// sent whenever the server becomes available for requesting again.
-func (s *serverWithLimits) canRequestNow() bool {
-	var sendCanRequestAgain bool
-	s.lock.Lock()
-	canRequest := s.canRequest()
-	if canRequest {
-		sendCanRequestAgain = s.sendEvent
-		s.sendEvent = false
-	}
-	childEventCb := s.childEventCb
-	s.lock.Unlock()
-	if sendCanRequestAgain && childEventCb != nil {
-		childEventCb(Event{Type: EvCanRequestAgain})
-	}
-	return canRequest
-}
-
-// delay sets the delay timer to the given duration, disabling new requests for
-// the given period.
-func (s *serverWithLimits) delay(delay time.Duration) {
-	if s.delayTimer != nil {
-		// Note: if stopping the timer is unsuccessful then the resulting AfterFunc
-		// call will just do nothing
-		s.delayTimer.Stop()
-		s.delayTimer = nil
-	}
-
-	s.delayCounter++
-	delayCounter := s.delayCounter
-	log.Debug("Server delay started", "length", delay)
-	s.delayTimer = s.clock.AfterFunc(delay, func() {
-		log.Debug("Server delay ended", "length", delay)
-		var sendCanRequestAgain bool
-		s.lock.Lock()
-		if s.delayTimer != nil && s.delayCounter == delayCounter { // do nothing if there is a new timer now
-			s.delayTimer = nil
-			if s.canRequest() {
-				sendCanRequestAgain = s.sendEvent
-				s.sendEvent = false
-			}
-		}
-		childEventCb := s.childEventCb
-		s.lock.Unlock()
-		if sendCanRequestAgain && childEventCb != nil {
-			childEventCb(Event{Type: EvCanRequestAgain})
-		}
-	})
-}
-
-// fail reports that a response from the server was found invalid by the processing
-// Module, disabling new requests for a dynamically adjusted time period.
-func (s *serverWithLimits) fail(desc string) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	s.failLocked(desc)
-}
-
-// failLocked calculates the dynamic failure delay and applies it.
-func (s *serverWithLimits) failLocked(desc string) {
-	log.Debug("Server error", "description", desc)
-	s.failureDelay *= 2
-	now := s.clock.Now()
-	if now > s.failureDelayEnd {
-		s.failureDelay *= math.Pow(2, -float64(now-s.failureDelayEnd)/float64(maxFailureDelay))
-	}
-	if s.failureDelay < float64(minFailureDelay) {
-		s.failureDelay = float64(minFailureDelay)
-	}
-	s.failureDelayEnd = now + mclock.AbsTime(s.failureDelay)
-	s.delay(time.Duration(s.failureDelay))
-}
--- a/beacon/light/request/server_test.go
+++ b/beacon/light/request/server_test.go
@@ -1,182 +0,0 @@
-package request
-
-import (
-	"testing"
-
-	"github.com/ethereum/go-ethereum/common/mclock"
-)
-
-const (
-	testRequest  = "Life, the Universe, and Everything"
-	testResponse = 42
-)
-
-var testEventType = &EventType{Name: "testEvent"}
-
-func TestServerEvents(t *testing.T) {
-	rs := &testRequestServer{}
-	clock := &mclock.Simulated{}
-	srv := NewServer(rs, clock)
-	var lastEventType *EventType
-	srv.subscribe(func(event Event) { lastEventType = event.Type })
-	evTypeName := func(evType *EventType) string {
-		if evType == nil {
-			return "none"
-		}
-		return evType.Name
-	}
-	expEvent := func(expType *EventType) {
-		if lastEventType != expType {
-			t.Errorf("Wrong event type (expected %s, got %s)", evTypeName(expType), evTypeName(lastEventType))
-		}
-		lastEventType = nil
-	}
-	// user events should simply be passed through
-	rs.eventCb(Event{Type: testEventType})
-	expEvent(testEventType)
-	// send request, soft timeout, then valid response
-	srv.sendRequest(testRequest)
-	clock.WaitForTimers(1)
-	clock.Run(softRequestTimeout)
-	expEvent(EvTimeout)
-	rs.eventCb(Event{Type: EvResponse, Data: RequestResponse{ID: 1, Request: testRequest, Response: testResponse}})
-	expEvent(EvResponse)
-	// send request, hard timeout (response after hard timeout should be ignored)
-	srv.sendRequest(testRequest)
-	clock.WaitForTimers(1)
-	clock.Run(softRequestTimeout)
-	expEvent(EvTimeout)
-	clock.WaitForTimers(1)
-	clock.Run(hardRequestTimeout)
-	expEvent(EvFail)
-	rs.eventCb(Event{Type: EvResponse, Data: RequestResponse{ID: 1, Request: testRequest, Response: testResponse}})
-	expEvent(nil)
-	srv.unsubscribe()
-}
-
-func TestServerParallel(t *testing.T) {
-	rs := &testRequestServer{}
-	srv := NewServer(rs, &mclock.Simulated{})
-	srv.subscribe(func(event Event) {})
-
-	expSend := func(expSent int) {
-		var sent int
-		for sent <= expSent {
-			if !srv.canRequestNow() {
-				break
-			}
-			sent++
-			srv.sendRequest(testRequest)
-		}
-		if sent != expSent {
-			t.Errorf("Wrong number of parallel requests accepted (expected %d, got %d)", expSent, sent)
-		}
-	}
-	// max out parallel allowance
-	expSend(defaultParallelLimit)
-	// 1 answered, should accept 1 more
-	rs.eventCb(Event{Type: EvResponse, Data: RequestResponse{ID: 1, Request: testRequest, Response: testResponse}})
-	expSend(1)
-	// 2 answered, should accept 2 more
-	rs.eventCb(Event{Type: EvResponse, Data: RequestResponse{ID: 2, Request: testRequest, Response: testResponse}})
-	rs.eventCb(Event{Type: EvResponse, Data: RequestResponse{ID: 3, Request: testRequest, Response: testResponse}})
-	expSend(2)
-	// failed request, should decrease allowance and not accept more
-	rs.eventCb(Event{Type: EvFail, Data: RequestResponse{ID: 4, Request: testRequest}})
-	expSend(0)
-	srv.unsubscribe()
-}
-
-func TestServerFail(t *testing.T) {
-	rs := &testRequestServer{}
-	clock := &mclock.Simulated{}
-	srv := NewServer(rs, clock)
-	srv.subscribe(func(event Event) {})
-	expCanRequest := func(expCanRequest bool) {
-		if canRequest := srv.canRequestNow(); canRequest != expCanRequest {
-			t.Errorf("Wrong result for canRequestNow (expected %v, got %v)", expCanRequest, canRequest)
-		}
-	}
-	// timed out request
-	expCanRequest(true)
-	srv.sendRequest(testRequest)
-	clock.WaitForTimers(1)
-	expCanRequest(true)
-	clock.Run(softRequestTimeout)
-	expCanRequest(false) // cannot request when there is a timed out request
-	rs.eventCb(Event{Type: EvResponse, Data: RequestResponse{ID: 1, Request: testRequest, Response: testResponse}})
-	expCanRequest(true)
-	// explicit server.Fail
-	srv.fail("")
-	clock.WaitForTimers(1)
-	expCanRequest(false) // cannot request for a while after a failure
-	clock.Run(minFailureDelay)
-	expCanRequest(true)
-	// request returned with EvFail
-	srv.sendRequest(testRequest)
-	rs.eventCb(Event{Type: EvFail, Data: RequestResponse{ID: 2, Request: testRequest}})
-	clock.WaitForTimers(1)
-	expCanRequest(false) // EvFail should also start failure delay
-	clock.Run(minFailureDelay)
-	expCanRequest(false) // second failure delay is longer, should still be disabled
-	clock.Run(minFailureDelay)
-	expCanRequest(true)
-	srv.unsubscribe()
-}
-
-func TestServerEventRateLimit(t *testing.T) {
-	rs := &testRequestServer{}
-	clock := &mclock.Simulated{}
-	srv := NewServer(rs, clock)
-	var eventCount int
-	srv.subscribe(func(event Event) {
-		eventCount++
-	})
-	expEvents := func(send, expAllowed int) {
-		eventCount = 0
-		for sent := 0; sent < send; sent++ {
-			rs.eventCb(Event{Type: testEventType})
-		}
-		if eventCount != expAllowed {
-			t.Errorf("Wrong number of server events passing rate limitation (sent %d, expected %d, got %d)", send, expAllowed, eventCount)
-		}
-	}
-	expEvents(maxServerEventBuffer+5, maxServerEventBuffer)
-	clock.Run(maxServerEventRate)
-	expEvents(5, 1)
-	clock.Run(maxServerEventRate * maxServerEventBuffer * 2)
-	expEvents(maxServerEventBuffer+5, maxServerEventBuffer)
-	srv.unsubscribe()
-}
-
-func TestServerUnsubscribe(t *testing.T) {
-	rs := &testRequestServer{}
-	clock := &mclock.Simulated{}
-	srv := NewServer(rs, clock)
-	var eventCount int
-	srv.subscribe(func(event Event) {
-		eventCount++
-	})
-	eventCb := rs.eventCb
-	eventCb(Event{Type: testEventType})
-	if eventCount != 1 {
-		t.Errorf("Server event callback not called before unsubscribe")
-	}
-	srv.unsubscribe()
-	if rs.eventCb != nil {
-		t.Errorf("Server event callback not removed after unsubscribe")
-	}
-	eventCb(Event{Type: testEventType})
-	if eventCount != 1 {
-		t.Errorf("Server event callback called after unsubscribe")
-	}
-}
-
-type testRequestServer struct {
-	eventCb func(Event)
-}
-
-func (rs *testRequestServer) Name() string                  { return "" }
-func (rs *testRequestServer) Subscribe(eventCb func(Event)) { rs.eventCb = eventCb }
-func (rs *testRequestServer) SendRequest(ID, Request)       {}
-func (rs *testRequestServer) Unsubscribe()                  { rs.eventCb = nil }
--- a/beacon/light/sync/head_sync.go
+++ b/beacon/light/sync/head_sync.go
@@ -1,202 +0,0 @@
-// Copyright 2023 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package sync
-
-import (
-	"github.com/ethereum/go-ethereum/beacon/light/request"
-	"github.com/ethereum/go-ethereum/beacon/types"
-	"github.com/ethereum/go-ethereum/log"
-)
-
-type headTracker interface {
-	ValidateOptimistic(update types.OptimisticUpdate) (bool, error)
-	ValidateFinality(head types.FinalityUpdate) (bool, error)
-	ValidatedFinality() (types.FinalityUpdate, bool)
-	SetPrefetchHead(head types.HeadInfo)
-}
-
-// HeadSync implements request.Module; it updates the validated and prefetch
-// heads of HeadTracker based on the EvHead and EvSignedHead events coming from
-// registered servers.
-// It can also postpone the validation of the latest announced signed head
-// until the committee chain is synced up to at least the required period.
-type HeadSync struct {
-	headTracker           headTracker
-	chain                 committeeChain
-	nextSyncPeriod        uint64
-	chainInit             bool
-	unvalidatedOptimistic map[request.Server]types.OptimisticUpdate
-	unvalidatedFinality   map[request.Server]types.FinalityUpdate
-	serverHeads           map[request.Server]types.HeadInfo
-	reqFinalityEpoch      map[request.Server]uint64 // next epoch to request finality update
-	headServerCount       map[types.HeadInfo]headServerCount
-	headCounter           uint64
-	prefetchHead          types.HeadInfo
-}
-
-// headServerCount is associated with most recently seen head infos; it counts
-// the number of servers currently having the given head info as their announced
-// head and a counter signaling how recent that head is.
-// This data is used for selecting the prefetch head.
-type headServerCount struct {
-	serverCount int
-	headCounter uint64
-}
-
-// NewHeadSync creates a new HeadSync.
-func NewHeadSync(headTracker headTracker, chain committeeChain) *HeadSync {
-	s := &HeadSync{
-		headTracker:           headTracker,
-		chain:                 chain,
-		unvalidatedOptimistic: make(map[request.Server]types.OptimisticUpdate),
-		unvalidatedFinality:   make(map[request.Server]types.FinalityUpdate),
-		serverHeads:           make(map[request.Server]types.HeadInfo),
-		headServerCount:       make(map[types.HeadInfo]headServerCount),
-		reqFinalityEpoch:      make(map[request.Server]uint64),
-	}
-	return s
-}
-
-// Process implements request.Module.
-func (s *HeadSync) Process(requester request.Requester, events []request.Event) {
-	nextPeriod, chainInit := s.chain.NextSyncPeriod()
-	if nextPeriod != s.nextSyncPeriod || chainInit != s.chainInit {
-		s.nextSyncPeriod, s.chainInit = nextPeriod, chainInit
-		s.processUnvalidatedUpdates()
-	}
-
-	for _, event := range events {
-		switch event.Type {
-		case EvNewHead:
-			s.setServerHead(event.Server, event.Data.(types.HeadInfo))
-		case EvNewOptimisticUpdate:
-			update := event.Data.(types.OptimisticUpdate)
-			s.newOptimisticUpdate(event.Server, update)
-			epoch := update.Attested.Epoch()
-			if epoch < s.reqFinalityEpoch[event.Server] {
-				continue
-			}
-			if finality, ok := s.headTracker.ValidatedFinality(); ok && finality.Attested.Header.Epoch() >= epoch {
-				continue
-			}
-			requester.Send(event.Server, ReqFinality{})
-			s.reqFinalityEpoch[event.Server] = epoch + 1
-		case EvNewFinalityUpdate:
-			s.newFinalityUpdate(event.Server, event.Data.(types.FinalityUpdate))
-		case request.EvResponse:
-			_, _, resp := event.RequestInfo()
-			s.newFinalityUpdate(event.Server, resp.(types.FinalityUpdate))
-		case request.EvUnregistered:
-			s.setServerHead(event.Server, types.HeadInfo{})
-			delete(s.serverHeads, event.Server)
-			delete(s.unvalidatedOptimistic, event.Server)
-			delete(s.unvalidatedFinality, event.Server)
-		}
-	}
-}
-
-// newOptimisticUpdate handles received optimistic update; either validates it if
-// the chain is properly synced or stores it for further validation.
-func (s *HeadSync) newOptimisticUpdate(server request.Server, optimisticUpdate types.OptimisticUpdate) {
-	if !s.chainInit || types.SyncPeriod(optimisticUpdate.SignatureSlot) > s.nextSyncPeriod {
-		s.unvalidatedOptimistic[server] = optimisticUpdate
-		return
-	}
-	if _, err := s.headTracker.ValidateOptimistic(optimisticUpdate); err != nil {
-		log.Debug("Error validating optimistic update", "error", err)
-	}
-}
-
-// newFinalityUpdate handles received finality update; either validates it if
-// the chain is properly synced or stores it for further validation.
-func (s *HeadSync) newFinalityUpdate(server request.Server, finalityUpdate types.FinalityUpdate) {
-	if !s.chainInit || types.SyncPeriod(finalityUpdate.SignatureSlot) > s.nextSyncPeriod {
-		s.unvalidatedFinality[server] = finalityUpdate
-		return
-	}
-	if _, err := s.headTracker.ValidateFinality(finalityUpdate); err != nil {
-		log.Debug("Error validating finality update", "error", err)
-	}
-}
-
-// processUnvalidatedUpdates iterates the list of unvalidated updates and validates
-// those which can be validated.
-func (s *HeadSync) processUnvalidatedUpdates() {
-	if !s.chainInit {
-		return
-	}
-	for server, optimisticUpdate := range s.unvalidatedOptimistic {
-		if types.SyncPeriod(optimisticUpdate.SignatureSlot) <= s.nextSyncPeriod {
-			if _, err := s.headTracker.ValidateOptimistic(optimisticUpdate); err != nil {
-				log.Debug("Error validating deferred optimistic update", "error", err)
-			}
-			delete(s.unvalidatedOptimistic, server)
-		}
-	}
-	for server, finalityUpdate := range s.unvalidatedFinality {
-		if types.SyncPeriod(finalityUpdate.SignatureSlot) <= s.nextSyncPeriod {
-			if _, err := s.headTracker.ValidateFinality(finalityUpdate); err != nil {
-				log.Debug("Error validating deferred finality update", "error", err)
-			}
-			delete(s.unvalidatedFinality, server)
-		}
-	}
-}
-
-// setServerHead processes non-validated server head announcements and updates
-// the prefetch head if necessary.
-func (s *HeadSync) setServerHead(server request.Server, head types.HeadInfo) bool {
-	if oldHead, ok := s.serverHeads[server]; ok {
-		if head == oldHead {
-			return false
-		}
-		h := s.headServerCount[oldHead]
-		if h.serverCount--; h.serverCount > 0 {
-			s.headServerCount[oldHead] = h
-		} else {
-			delete(s.headServerCount, oldHead)
-		}
-	}
-	if head != (types.HeadInfo{}) {
-		h, ok := s.headServerCount[head]
-		if !ok {
-			s.headCounter++
-			h.headCounter = s.headCounter
-		}
-		h.serverCount++
-		s.headServerCount[head] = h
-		s.serverHeads[server] = head
-	} else {
-		delete(s.serverHeads, server)
-	}
-	var (
-		bestHead     types.HeadInfo
-		bestHeadInfo headServerCount
-	)
-	for head, headServerCount := range s.headServerCount {
-		if headServerCount.serverCount > bestHeadInfo.serverCount ||
-			(headServerCount.serverCount == bestHeadInfo.serverCount && headServerCount.headCounter > bestHeadInfo.headCounter) {
-			bestHead, bestHeadInfo = head, headServerCount
-		}
-	}
-	if bestHead == s.prefetchHead {
-		return false
-	}
-	s.prefetchHead = bestHead
-	s.headTracker.SetPrefetchHead(bestHead)
-	return true
-}
--- a/beacon/light/sync/head_sync_test.go
+++ b/beacon/light/sync/head_sync_test.go
@@ -1,183 +0,0 @@
-// Copyright 2023 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package sync
-
-import (
-	"testing"
-
-	"github.com/ethereum/go-ethereum/beacon/light/request"
-	"github.com/ethereum/go-ethereum/beacon/types"
-	"github.com/ethereum/go-ethereum/common"
-)
-
-var (
-	testServer1 = testServer("testServer1")
-	testServer2 = testServer("testServer2")
-	testServer3 = testServer("testServer3")
-	testServer4 = testServer("testServer4")
-	testServer5 = testServer("testServer5")
-
-	testHead0 = types.HeadInfo{}
-	testHead1 = types.HeadInfo{Slot: 123, BlockRoot: common.Hash{1}}
-	testHead2 = types.HeadInfo{Slot: 124, BlockRoot: common.Hash{2}}
-	testHead3 = types.HeadInfo{Slot: 124, BlockRoot: common.Hash{3}}
-	testHead4 = types.HeadInfo{Slot: 125, BlockRoot: common.Hash{4}}
-
-	testOptUpdate1 = types.OptimisticUpdate{SignatureSlot: 0x0124, Attested: types.HeaderWithExecProof{Header: types.Header{Slot: 0x0123, StateRoot: common.Hash{1}}}}
-	testOptUpdate2 = types.OptimisticUpdate{SignatureSlot: 0x2010, Attested: types.HeaderWithExecProof{Header: types.Header{Slot: 0x200e, StateRoot: common.Hash{2}}}}
-	// testOptUpdate3 is at the end of period 1 but signed in period 2
-	testOptUpdate3 = types.OptimisticUpdate{SignatureSlot: 0x4000, Attested: types.HeaderWithExecProof{Header: types.Header{Slot: 0x3fff, StateRoot: common.Hash{3}}}}
-	testOptUpdate4 = types.OptimisticUpdate{SignatureSlot: 0x6444, Attested: types.HeaderWithExecProof{Header: types.Header{Slot: 0x6443, StateRoot: common.Hash{4}}}}
-)
-
-func finality(opt types.OptimisticUpdate) types.FinalityUpdate {
-	return types.FinalityUpdate{
-		SignatureSlot: opt.SignatureSlot,
-		Attested:      opt.Attested,
-		Finalized:     types.HeaderWithExecProof{Header: types.Header{Slot: (opt.Attested.Header.Slot - 64) & uint64(0xffffffffffffffe0)}},
-	}
-}
-
-type testServer string
-
-func (t testServer) Name() string {
-	return string(t)
-}
-
-func TestValidatedHead(t *testing.T) {
-	chain := &TestCommitteeChain{}
-	ht := &TestHeadTracker{}
-	headSync := NewHeadSync(ht, chain)
-	ts := NewTestScheduler(t, headSync)
-
-	ht.ExpValidated(t, 0, nil)
-
-	ts.AddServer(testServer1, 1)
-	ts.ServerEvent(EvNewOptimisticUpdate, testServer1, testOptUpdate1)
-	ts.Run(1, testServer1, ReqFinality{})
-	// announced head should be queued because of uninitialized chain
-	ht.ExpValidated(t, 1, nil)
-
-	chain.SetNextSyncPeriod(0) // initialize chain
-	ts.Run(2)
-	// expect previously queued head to be validated
-	ht.ExpValidated(t, 2, []types.OptimisticUpdate{testOptUpdate1})
-
-	chain.SetNextSyncPeriod(1)
-	ts.ServerEvent(EvNewFinalityUpdate, testServer1, finality(testOptUpdate2))
-	ts.ServerEvent(EvNewOptimisticUpdate, testServer1, testOptUpdate2)
-	ts.AddServer(testServer2, 1)
-	ts.ServerEvent(EvNewOptimisticUpdate, testServer2, testOptUpdate2)
-	ts.Run(3)
-	// expect both head announcements to be validated instantly
-	ht.ExpValidated(t, 3, []types.OptimisticUpdate{testOptUpdate2, testOptUpdate2})
-
-	ts.ServerEvent(EvNewOptimisticUpdate, testServer1, testOptUpdate3)
-	ts.AddServer(testServer3, 1)
-	ts.ServerEvent(EvNewOptimisticUpdate, testServer3, testOptUpdate4)
-	// finality should be requested from both servers
-	ts.Run(4, testServer1, ReqFinality{}, testServer3, ReqFinality{})
-	// future period announced heads should be queued
-	ht.ExpValidated(t, 4, nil)
-
-	chain.SetNextSyncPeriod(2)
-	ts.Run(5)
-	// testOptUpdate3 can be validated now but not testOptUpdate4
-	ht.ExpValidated(t, 5, []types.OptimisticUpdate{testOptUpdate3})
-
-	ts.AddServer(testServer4, 1)
-	ts.ServerEvent(EvNewOptimisticUpdate, testServer4, testOptUpdate3)
-	// new server joined with recent optimistic update but still no finality; should be requested
-	ts.Run(6, testServer4, ReqFinality{})
-	ht.ExpValidated(t, 6, []types.OptimisticUpdate{testOptUpdate3})
-
-	ts.AddServer(testServer5, 1)
-	ts.RequestEvent(request.EvResponse, ts.Request(6, 1), finality(testOptUpdate3))
-	ts.ServerEvent(EvNewOptimisticUpdate, testServer5, testOptUpdate3)
-	// finality update request answered; new server should not be requested
-	ts.Run(7)
-	ht.ExpValidated(t, 7, []types.OptimisticUpdate{testOptUpdate3})
-
-	// server 3 disconnected without proving period 3, its announced head should be dropped
-	ts.RemoveServer(testServer3)
-	ts.Run(8)
-	ht.ExpValidated(t, 8, nil)
-
-	chain.SetNextSyncPeriod(3)
-	ts.Run(9)
-	// testOptUpdate4 could be validated now but it's not queued by any registered server
-	ht.ExpValidated(t, 9, nil)
-
-	ts.ServerEvent(EvNewFinalityUpdate, testServer2, finality(testOptUpdate4))
-	ts.ServerEvent(EvNewOptimisticUpdate, testServer2, testOptUpdate4)
-	ts.Run(10)
-	// now testOptUpdate4 should be validated
-	ht.ExpValidated(t, 10, []types.OptimisticUpdate{testOptUpdate4})
-}
-
-func TestPrefetchHead(t *testing.T) {
-	chain := &TestCommitteeChain{}
-	ht := &TestHeadTracker{}
-	headSync := NewHeadSync(ht, chain)
-	ts := NewTestScheduler(t, headSync)
-
-	ht.ExpPrefetch(t, 0, testHead0) // no servers registered
-
-	ts.AddServer(testServer1, 1)
-	ts.ServerEvent(EvNewHead, testServer1, testHead1)
-	ts.Run(1)
-	ht.ExpPrefetch(t, 1, testHead1) // s1: h1
-
-	ts.AddServer(testServer2, 1)
-	ts.ServerEvent(EvNewHead, testServer2, testHead2)
-	ts.Run(2)
-	ht.ExpPrefetch(t, 2, testHead2) // s1: h1, s2: h2
-
-	ts.ServerEvent(EvNewHead, testServer1, testHead2)
-	ts.Run(3)
-	ht.ExpPrefetch(t, 3, testHead2) // s1: h2, s2: h2
-
-	ts.AddServer(testServer3, 1)
-	ts.ServerEvent(EvNewHead, testServer3, testHead3)
-	ts.Run(4)
-	ht.ExpPrefetch(t, 4, testHead2) // s1: h2, s2: h2, s3: h3
-
-	ts.AddServer(testServer4, 1)
-	ts.ServerEvent(EvNewHead, testServer4, testHead4)
-	ts.Run(5)
-	ht.ExpPrefetch(t, 5, testHead2) // s1: h2, s2: h2, s3: h3, s4: h4
-
-	ts.ServerEvent(EvNewHead, testServer2, testHead3)
-	ts.Run(6)
-	ht.ExpPrefetch(t, 6, testHead3) // s1: h2, s2: h3, s3: h3, s4: h4
-
-	ts.RemoveServer(testServer3)
-	ts.Run(7)
-	ht.ExpPrefetch(t, 7, testHead4) // s1: h2, s2: h3, s4: h4
-
-	ts.RemoveServer(testServer1)
-	ts.Run(8)
-	ht.ExpPrefetch(t, 8, testHead4) // s2: h3, s4: h4
-
-	ts.RemoveServer(testServer4)
-	ts.Run(9)
-	ht.ExpPrefetch(t, 9, testHead3) // s2: h3
-
-	ts.RemoveServer(testServer2)
-	ts.Run(10)
-	ht.ExpPrefetch(t, 10, testHead0) // no servers registered
-}
--- a/beacon/light/sync/test_helpers.go
+++ b/beacon/light/sync/test_helpers.go
@@ -1,259 +0,0 @@
-// Copyright 2023 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package sync
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/beacon/light"
-	"github.com/ethereum/go-ethereum/beacon/light/request"
-	"github.com/ethereum/go-ethereum/beacon/types"
-)
-
-type requestWithID struct {
-	sid     request.ServerAndID
-	request request.Request
-}
-
-type TestScheduler struct {
-	t         *testing.T
-	module    request.Module
-	events    []request.Event
-	servers   []request.Server
-	allowance map[request.Server]int
-	sent      map[int][]requestWithID
-	testIndex int
-	expFail   map[request.Server]int // expected Server.Fail calls during next Run
-	lastId    request.ID
-}
-
-func NewTestScheduler(t *testing.T, module request.Module) *TestScheduler {
-	return &TestScheduler{
-		t:         t,
-		module:    module,
-		allowance: make(map[request.Server]int),
-		expFail:   make(map[request.Server]int),
-		sent:      make(map[int][]requestWithID),
-	}
-}
-
-func (ts *TestScheduler) Run(testIndex int, exp ...any) {
-	expReqs := make([]requestWithID, len(exp)/2)
-	id := ts.lastId
-	for i := range expReqs {
-		id++
-		expReqs[i] = requestWithID{
-			sid:     request.ServerAndID{Server: exp[i*2].(request.Server), ID: id},
-			request: exp[i*2+1].(request.Request),
-		}
-	}
-	if len(expReqs) == 0 {
-		expReqs = nil
-	}
-
-	ts.testIndex = testIndex
-	ts.module.Process(ts, ts.events)
-	ts.events = nil
-
-	for server, count := range ts.expFail {
-		delete(ts.expFail, server)
-		if count == 0 {
-			continue
-		}
-		ts.t.Errorf("Missing %d Server.Fail(s) from server %s in test case #%d", count, server.Name(), testIndex)
-	}
-
-	if !reflect.DeepEqual(ts.sent[testIndex], expReqs) {
-		ts.t.Errorf("Wrong sent requests in test case #%d (expected %v, got %v)", testIndex, expReqs, ts.sent[testIndex])
-	}
-}
-
-func (ts *TestScheduler) CanSendTo() (cs []request.Server) {
-	for _, server := range ts.servers {
-		if ts.allowance[server] > 0 {
-			cs = append(cs, server)
-		}
-	}
-	return
-}
-
-func (ts *TestScheduler) Send(server request.Server, req request.Request) request.ID {
-	ts.lastId++
-	ts.sent[ts.testIndex] = append(ts.sent[ts.testIndex], requestWithID{
-		sid:     request.ServerAndID{Server: server, ID: ts.lastId},
-		request: req,
-	})
-	ts.allowance[server]--
-	return ts.lastId
-}
-
-func (ts *TestScheduler) Fail(server request.Server, desc string) {
-	if ts.expFail[server] == 0 {
-		ts.t.Errorf("Unexpected Fail from server %s in test case #%d: %s", server.Name(), ts.testIndex, desc)
-		return
-	}
-	ts.expFail[server]--
-}
-
-func (ts *TestScheduler) Request(testIndex, reqIndex int) requestWithID {
-	if len(ts.sent[testIndex]) < reqIndex {
-		ts.t.Errorf("Missing request from test case %d index %d", testIndex, reqIndex)
-		return requestWithID{}
-	}
-	return ts.sent[testIndex][reqIndex-1]
-}
-
-func (ts *TestScheduler) ServerEvent(evType *request.EventType, server request.Server, data any) {
-	ts.events = append(ts.events, request.Event{
-		Type:   evType,
-		Server: server,
-		Data:   data,
-	})
-}
-
-func (ts *TestScheduler) RequestEvent(evType *request.EventType, req requestWithID, resp request.Response) {
-	if req.request == nil {
-		return
-	}
-	ts.events = append(ts.events, request.Event{
-		Type:   evType,
-		Server: req.sid.Server,
-		Data: request.RequestResponse{
-			ID:       req.sid.ID,
-			Request:  req.request,
-			Response: resp,
-		},
-	})
-}
-
-func (ts *TestScheduler) AddServer(server request.Server, allowance int) {
-	ts.servers = append(ts.servers, server)
-	ts.allowance[server] = allowance
-	ts.ServerEvent(request.EvRegistered, server, nil)
-}
-
-func (ts *TestScheduler) RemoveServer(server request.Server) {
-	ts.servers = append(ts.servers, server)
-	for i, s := range ts.servers {
-		if s == server {
-			copy(ts.servers[i:len(ts.servers)-1], ts.servers[i+1:])
-			ts.servers = ts.servers[:len(ts.servers)-1]
-			break
-		}
-	}
-	delete(ts.allowance, server)
-	ts.ServerEvent(request.EvUnregistered, server, nil)
-}
-
-func (ts *TestScheduler) AddAllowance(server request.Server, allowance int) {
-	ts.allowance[server] += allowance
-}
-
-func (ts *TestScheduler) ExpFail(server request.Server) {
-	ts.expFail[server]++
-}
-
-type TestCommitteeChain struct {
-	fsp, nsp uint64
-	init     bool
-}
-
-func (tc *TestCommitteeChain) CheckpointInit(bootstrap types.BootstrapData) error {
-	tc.fsp, tc.nsp, tc.init = bootstrap.Header.SyncPeriod(), bootstrap.Header.SyncPeriod()+2, true
-	return nil
-}
-
-func (tc *TestCommitteeChain) InsertUpdate(update *types.LightClientUpdate, nextCommittee *types.SerializedSyncCommittee) error {
-	period := update.AttestedHeader.Header.SyncPeriod()
-	if period < tc.fsp || period > tc.nsp || !tc.init {
-		return light.ErrInvalidPeriod
-	}
-	if period == tc.nsp {
-		tc.nsp++
-	}
-	return nil
-}
-
-func (tc *TestCommitteeChain) NextSyncPeriod() (uint64, bool) {
-	return tc.nsp, tc.init
-}
-
-func (tc *TestCommitteeChain) ExpInit(t *testing.T, ExpInit bool) {
-	if tc.init != ExpInit {
-		t.Errorf("Incorrect init flag (expected %v, got %v)", ExpInit, tc.init)
-	}
-}
-
-func (tc *TestCommitteeChain) SetNextSyncPeriod(nsp uint64) {
-	tc.init, tc.nsp = true, nsp
-}
-
-func (tc *TestCommitteeChain) ExpNextSyncPeriod(t *testing.T, expNsp uint64) {
-	tc.ExpInit(t, true)
-	if tc.nsp != expNsp {
-		t.Errorf("Incorrect NextSyncPeriod (expected %d, got %d)", expNsp, tc.nsp)
-	}
-}
-
-type TestHeadTracker struct {
-	phead     types.HeadInfo
-	validated []types.OptimisticUpdate
-	finality  types.FinalityUpdate
-}
-
-func (ht *TestHeadTracker) ValidateOptimistic(update types.OptimisticUpdate) (bool, error) {
-	ht.validated = append(ht.validated, update)
-	return true, nil
-}
-
-func (ht *TestHeadTracker) ValidateFinality(update types.FinalityUpdate) (bool, error) {
-	ht.finality = update
-	return true, nil
-}
-
-func (ht *TestHeadTracker) ValidatedFinality() (types.FinalityUpdate, bool) {
-	return ht.finality, ht.finality.Attested.Header != (types.Header{})
-}
-
-func (ht *TestHeadTracker) ExpValidated(t *testing.T, tci int, expHeads []types.OptimisticUpdate) {
-	for i, expHead := range expHeads {
-		if i >= len(ht.validated) {
-			t.Errorf("Missing validated head in test case #%d index #%d (expected {slot %d blockRoot %x}, got none)", tci, i, expHead.Attested.Header.Slot, expHead.Attested.Header.Hash())
-			continue
-		}
-		if !reflect.DeepEqual(ht.validated[i], expHead) {
-			vhead := ht.validated[i].Attested.Header
-			t.Errorf("Wrong validated head in test case #%d index #%d (expected {slot %d blockRoot %x}, got {slot %d blockRoot %x})", tci, i, expHead.Attested.Header.Slot, expHead.Attested.Header.Hash(), vhead.Slot, vhead.Hash())
-		}
-	}
-	for i := len(expHeads); i < len(ht.validated); i++ {
-		vhead := ht.validated[i].Attested.Header
-		t.Errorf("Unexpected validated head in test case #%d index #%d (expected none, got {slot %d blockRoot %x})", tci, i, vhead.Slot, vhead.Hash())
-	}
-	ht.validated = nil
-}
-
-func (ht *TestHeadTracker) SetPrefetchHead(head types.HeadInfo) {
-	ht.phead = head
-}
-
-func (ht *TestHeadTracker) ExpPrefetch(t *testing.T, tci int, exp types.HeadInfo) {
-	if ht.phead != exp {
-		t.Errorf("Wrong prefetch head in test case #%d (expected {slot %d blockRoot %x}, got {slot %d blockRoot %x})", tci, exp.Slot, exp.BlockRoot, ht.phead.Slot, ht.phead.BlockRoot)
-	}
-}
--- a/beacon/light/sync/types.go
+++ b/beacon/light/sync/types.go
@@ -1,47 +0,0 @@
-// Copyright 2023 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package sync
-
-import (
-	"github.com/ethereum/go-ethereum/beacon/light/request"
-	"github.com/ethereum/go-ethereum/beacon/types"
-	"github.com/ethereum/go-ethereum/common"
-)
-
-var (
-	EvNewHead             = &request.EventType{Name: "newHead"}             // data: types.HeadInfo
-	EvNewOptimisticUpdate = &request.EventType{Name: "newOptimisticUpdate"} // data: types.OptimisticUpdate
-	EvNewFinalityUpdate   = &request.EventType{Name: "newFinalityUpdate"}   // data: types.FinalityUpdate
-)
-
-type (
-	ReqUpdates struct {
-		FirstPeriod, Count uint64
-	}
-	RespUpdates struct {
-		Updates    []*types.LightClientUpdate
-		Committees []*types.SerializedSyncCommittee
-	}
-	ReqHeader  common.Hash
-	RespHeader struct {
-		Header               types.Header
-		Canonical, Finalized bool
-	}
-	ReqCheckpointData common.Hash
-	ReqBeaconBlock    common.Hash
-	ReqFinality       struct{}
-)
--- a/beacon/light/sync/update_sync.go
+++ b/beacon/light/sync/update_sync.go
@@ -1,398 +0,0 @@
-// Copyright 2023 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package sync
-
-import (
-	"sort"
-
-	"github.com/ethereum/go-ethereum/beacon/light"
-	"github.com/ethereum/go-ethereum/beacon/light/request"
-	"github.com/ethereum/go-ethereum/beacon/params"
-	"github.com/ethereum/go-ethereum/beacon/types"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/log"
-)
-
-const maxUpdateRequest = 8 // maximum number of updates requested in a single request
-
-type committeeChain interface {
-	CheckpointInit(bootstrap types.BootstrapData) error
-	InsertUpdate(update *types.LightClientUpdate, nextCommittee *types.SerializedSyncCommittee) error
-	NextSyncPeriod() (uint64, bool)
-}
-
-// CheckpointInit implements request.Module; it fetches the light client bootstrap
-// data belonging to the given checkpoint hash and initializes the committee chain
-// if successful.
-type CheckpointInit struct {
-	chain          committeeChain
-	checkpointHash common.Hash
-	locked         request.ServerAndID
-	initialized    bool
-	// per-server state is used to track the state of requesting checkpoint header
-	// info. Part of this info (canonical and finalized state) is not validated
-	// and therefore it is requested from each server separately after it has
-	// reported a missing checkpoint (which is also not validated info).
-	serverState map[request.Server]serverState
-	// the following fields are used to determine whether the checkpoint is on
-	// epoch boundary. This information is validated and therefore stored globally.
-	parentHash                  common.Hash
-	hasEpochInfo, epochBoundary bool
-	cpSlot, parentSlot          uint64
-}
-
-const (
-	ssDefault         = iota // no action yet or checkpoint requested
-	ssNeedHeader             // checkpoint req failed, need cp header
-	ssHeaderRequested        // cp header requested
-	ssNeedParent             // cp header slot %32 != 0, need parent to check epoch boundary
-	ssParentRequested        // cp parent header requested
-	ssPrintStatus            // has all necessary info, print log message if init still not successful
-	ssDone                   // log message printed, no more action required
-)
-
-type serverState struct {
-	state                           int
-	hasHeader, canonical, finalized bool // stored per server because not validated
-}
-
-// NewCheckpointInit creates a new CheckpointInit.
-func NewCheckpointInit(chain committeeChain, checkpointHash common.Hash) *CheckpointInit {
-	return &CheckpointInit{
-		chain:          chain,
-		checkpointHash: checkpointHash,
-		serverState:    make(map[request.Server]serverState),
-	}
-}
-
-// Process implements request.Module.
-func (s *CheckpointInit) Process(requester request.Requester, events []request.Event) {
-	if s.initialized {
-		return
-	}
-
-	for _, event := range events {
-		switch event.Type {
-		case request.EvResponse, request.EvFail, request.EvTimeout:
-			sid, req, resp := event.RequestInfo()
-			if s.locked == sid {
-				s.locked = request.ServerAndID{}
-			}
-			if event.Type == request.EvTimeout {
-				continue
-			}
-			switch s.serverState[sid.Server].state {
-			case ssDefault:
-				if resp != nil {
-					if checkpoint := resp.(*types.BootstrapData); checkpoint.Header.Hash() == common.Hash(req.(ReqCheckpointData)) {
-						s.chain.CheckpointInit(*checkpoint)
-						s.initialized = true
-						return
-					}
-					requester.Fail(event.Server, "invalid checkpoint data")
-				}
-				s.serverState[sid.Server] = serverState{state: ssNeedHeader}
-			case ssHeaderRequested:
-				if resp == nil {
-					s.serverState[sid.Server] = serverState{state: ssPrintStatus}
-					continue
-				}
-				newState := serverState{
-					hasHeader: true,
-					canonical: resp.(RespHeader).Canonical,
-					finalized: resp.(RespHeader).Finalized,
-				}
-				s.cpSlot, s.parentHash = resp.(RespHeader).Header.Slot, resp.(RespHeader).Header.ParentRoot
-				if s.cpSlot%params.EpochLength == 0 {
-					s.hasEpochInfo, s.epochBoundary = true, true
-				}
-				if s.hasEpochInfo {
-					newState.state = ssPrintStatus
-				} else {
-					newState.state = ssNeedParent
-				}
-				s.serverState[sid.Server] = newState
-			case ssParentRequested:
-				s.parentSlot = resp.(RespHeader).Header.Slot
-				s.hasEpochInfo, s.epochBoundary = true, s.cpSlot/params.EpochLength > s.parentSlot/params.EpochLength
-				newState := s.serverState[sid.Server]
-				newState.state = ssPrintStatus
-				s.serverState[sid.Server] = newState
-			}
-
-		case request.EvUnregistered:
-			delete(s.serverState, event.Server)
-		}
-	}
-
-	// start a request if possible
-	for _, server := range requester.CanSendTo() {
-		switch s.serverState[server].state {
-		case ssDefault:
-			if s.locked == (request.ServerAndID{}) {
-				id := requester.Send(server, ReqCheckpointData(s.checkpointHash))
-				s.locked = request.ServerAndID{Server: server, ID: id}
-			}
-		case ssNeedHeader:
-			requester.Send(server, ReqHeader(s.checkpointHash))
-			newState := s.serverState[server]
-			newState.state = ssHeaderRequested
-			s.serverState[server] = newState
-		case ssNeedParent:
-			requester.Send(server, ReqHeader(s.parentHash))
-			newState := s.serverState[server]
-			newState.state = ssParentRequested
-			s.serverState[server] = newState
-		}
-	}
-
-	// print log message if necessary
-	for server, state := range s.serverState {
-		if state.state != ssPrintStatus {
-			continue
-		}
-		switch {
-		case !state.hasHeader:
-			log.Error("blsync: checkpoint block is not available, reported as unknown", "server", server.Name())
-		case !state.canonical:
-			log.Error("blsync: checkpoint block is not available, reported as non-canonical", "server", server.Name())
-		case !s.hasEpochInfo:
-			// should be available if hasHeader is true and state is ssPrintStatus
-			panic("checkpoint epoch info not available when printing retrieval status")
-		case !s.epochBoundary:
-			log.Error("blsync: checkpoint block is not first of epoch", "slot", s.cpSlot, "parent", s.parentSlot, "server", server.Name())
-		case !state.finalized:
-			log.Error("blsync: checkpoint block is reported as non-finalized", "server", server.Name())
-		default:
-			log.Error("blsync: checkpoint not available, but reported as finalized; specified checkpoint hash might be too old", "server", server.Name())
-		}
-		s.serverState[server] = serverState{state: ssDone}
-	}
-}
-
-// ForwardUpdateSync implements request.Module; it fetches updates between the
-// committee chain head and each server's announced head. Updates are fetched
-// in batches and multiple batches can also be requested in parallel.
-// Out of order responses are also handled; if a batch of updates cannot be added
-// to the chain immediately because of a gap then the future updates are
-// remembered until they can be processed.
-type ForwardUpdateSync struct {
-	chain          committeeChain
-	rangeLock      rangeLock
-	lockedIDs      map[request.ServerAndID]struct{}
-	processQueue   []updateResponse
-	nextSyncPeriod map[request.Server]uint64
-}
-
-// NewForwardUpdateSync creates a new ForwardUpdateSync.
-func NewForwardUpdateSync(chain committeeChain) *ForwardUpdateSync {
-	return &ForwardUpdateSync{
-		chain:          chain,
-		rangeLock:      make(rangeLock),
-		lockedIDs:      make(map[request.ServerAndID]struct{}),
-		nextSyncPeriod: make(map[request.Server]uint64),
-	}
-}
-
-// rangeLock allows locking sections of an integer space, preventing the syncing
-// mechanism from making requests again for sections where a not timed out request
-// is already pending or where already fetched and unprocessed data is available.
-type rangeLock map[uint64]int
-
-// lock locks or unlocks the given section, depending on the sign of the add parameter.
-func (r rangeLock) lock(first, count uint64, add int) {
-	for i := first; i < first+count; i++ {
-		if v := r[i] + add; v > 0 {
-			r[i] = v
-		} else {
-			delete(r, i)
-		}
-	}
-}
-
-// firstUnlocked returns the first unlocked section starting at or after start
-// and not longer than maxCount.
-func (r rangeLock) firstUnlocked(start, maxCount uint64) (first, count uint64) {
-	first = start
-	for {
-		if _, ok := r[first]; !ok {
-			break
-		}
-		first++
-	}
-	for {
-		count++
-		if count == maxCount {
-			break
-		}
-		if _, ok := r[first+count]; ok {
-			break
-		}
-	}
-	return
-}
-
-// lockRange locks the range belonging to the given update request, unless the
-// same request has already been locked
-func (s *ForwardUpdateSync) lockRange(sid request.ServerAndID, req ReqUpdates) {
-	if _, ok := s.lockedIDs[sid]; ok {
-		return
-	}
-	s.lockedIDs[sid] = struct{}{}
-	s.rangeLock.lock(req.FirstPeriod, req.Count, 1)
-}
-
-// unlockRange unlocks the range belonging to the given update request, unless
-// same request has already been unlocked
-func (s *ForwardUpdateSync) unlockRange(sid request.ServerAndID, req ReqUpdates) {
-	if _, ok := s.lockedIDs[sid]; !ok {
-		return
-	}
-	delete(s.lockedIDs, sid)
-	s.rangeLock.lock(req.FirstPeriod, req.Count, -1)
-}
-
-// verifyRange returns true if the number of updates and the individual update
-// periods in the response match the requested section.
-func (s *ForwardUpdateSync) verifyRange(request ReqUpdates, response RespUpdates) bool {
-	if uint64(len(response.Updates)) != request.Count || uint64(len(response.Committees)) != request.Count {
-		return false
-	}
-	for i, update := range response.Updates {
-		if update.AttestedHeader.Header.SyncPeriod() != request.FirstPeriod+uint64(i) {
-			return false
-		}
-	}
-	return true
-}
-
-// updateResponse is a response that has passed initial verification and has been
-// queued for processing. Note that an update response cannot be processed until
-// the previous updates have also been added to the chain.
-type updateResponse struct {
-	sid      request.ServerAndID
-	request  ReqUpdates
-	response RespUpdates
-}
-
-// updateResponseList implements sort.Sort and sorts update request/response events by FirstPeriod.
-type updateResponseList []updateResponse
-
-func (u updateResponseList) Len() int      { return len(u) }
-func (u updateResponseList) Swap(i, j int) { u[i], u[j] = u[j], u[i] }
-func (u updateResponseList) Less(i, j int) bool {
-	return u[i].request.FirstPeriod < u[j].request.FirstPeriod
-}
-
-// Process implements request.Module.
-func (s *ForwardUpdateSync) Process(requester request.Requester, events []request.Event) {
-	for _, event := range events {
-		switch event.Type {
-		case request.EvResponse, request.EvFail, request.EvTimeout:
-			sid, rq, rs := event.RequestInfo()
-			req := rq.(ReqUpdates)
-			var queued bool
-			if event.Type == request.EvResponse {
-				resp := rs.(RespUpdates)
-				if s.verifyRange(req, resp) {
-					// there is a response with a valid format; put it in the process queue
-					s.processQueue = append(s.processQueue, updateResponse{sid: sid, request: req, response: resp})
-					s.lockRange(sid, req)
-					queued = true
-				} else {
-					requester.Fail(event.Server, "invalid update range")
-				}
-			}
-			if !queued {
-				s.unlockRange(sid, req)
-			}
-		case EvNewOptimisticUpdate:
-			update := event.Data.(types.OptimisticUpdate)
-			s.nextSyncPeriod[event.Server] = types.SyncPeriod(update.SignatureSlot + 256)
-		case request.EvUnregistered:
-			delete(s.nextSyncPeriod, event.Server)
-		}
-	}
-
-	// try processing ordered list of available responses
-	sort.Sort(updateResponseList(s.processQueue))
-	for s.processQueue != nil {
-		u := s.processQueue[0]
-		if !s.processResponse(requester, u) {
-			break
-		}
-		s.unlockRange(u.sid, u.request)
-		s.processQueue = s.processQueue[1:]
-		if len(s.processQueue) == 0 {
-			s.processQueue = nil
-		}
-	}
-
-	// start new requests if possible
-	startPeriod, chainInit := s.chain.NextSyncPeriod()
-	if !chainInit {
-		return
-	}
-	for {
-		firstPeriod, maxCount := s.rangeLock.firstUnlocked(startPeriod, maxUpdateRequest)
-		var (
-			sendTo    request.Server
-			bestCount uint64
-		)
-		for _, server := range requester.CanSendTo() {
-			nextPeriod := s.nextSyncPeriod[server]
-			if nextPeriod <= firstPeriod {
-				continue
-			}
-			count := maxCount
-			if nextPeriod < firstPeriod+maxCount {
-				count = nextPeriod - firstPeriod
-			}
-			if count > bestCount {
-				sendTo, bestCount = server, count
-			}
-		}
-		if sendTo == nil {
-			return
-		}
-		req := ReqUpdates{FirstPeriod: firstPeriod, Count: bestCount}
-		id := requester.Send(sendTo, req)
-		s.lockRange(request.ServerAndID{Server: sendTo, ID: id}, req)
-	}
-}
-
-// processResponse adds the fetched updates and committees to the committee chain.
-// Returns true in case of full or partial success.
-func (s *ForwardUpdateSync) processResponse(requester request.Requester, u updateResponse) (success bool) {
-	for i, update := range u.response.Updates {
-		if err := s.chain.InsertUpdate(update, u.response.Committees[i]); err != nil {
-			if err == light.ErrInvalidPeriod {
-				// there is a gap in the update periods; stop processing without
-				// failing and try again next time
-				return
-			}
-			if err == light.ErrInvalidUpdate || err == light.ErrWrongCommitteeRoot || err == light.ErrCannotReorg {
-				requester.Fail(u.sid.Server, "invalid update received")
-			} else {
-				log.Error("Unexpected InsertUpdate error", "error", err)
-			}
-			return
-		}
-		success = true
-	}
-	return
-}
--- a/beacon/light/sync/update_sync_test.go
+++ b/beacon/light/sync/update_sync_test.go
@@ -1,247 +0,0 @@
-// Copyright 2024 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package sync
-
-import (
-	"testing"
-
-	"github.com/ethereum/go-ethereum/beacon/light/request"
-	"github.com/ethereum/go-ethereum/beacon/types"
-)
-
-func TestCheckpointInit(t *testing.T) {
-	chain := &TestCommitteeChain{}
-	checkpoint := &types.BootstrapData{Header: types.Header{Slot: 0x2000*4 + 0x1000}} // period 4
-	checkpointHash := checkpoint.Header.Hash()
-	chkInit := NewCheckpointInit(chain, checkpointHash)
-	ts := NewTestScheduler(t, chkInit)
-	// add 2 servers
-	ts.AddServer(testServer1, 1)
-	ts.AddServer(testServer2, 1)
-
-	// expect bootstrap request to server 1
-	ts.Run(1, testServer1, ReqCheckpointData(checkpointHash))
-
-	// server 1 times out; expect request to server 2
-	ts.RequestEvent(request.EvTimeout, ts.Request(1, 1), nil)
-	ts.Run(2, testServer2, ReqCheckpointData(checkpointHash))
-
-	// invalid response from server 2; expect init state to still be false
-	ts.RequestEvent(request.EvResponse, ts.Request(2, 1), &types.BootstrapData{Header: types.Header{Slot: 123456}})
-	ts.ExpFail(testServer2)
-	ts.Run(3)
-	chain.ExpInit(t, false)
-
-	// server 1 fails (hard timeout)
-	ts.RequestEvent(request.EvFail, ts.Request(1, 1), nil)
-	ts.Run(4)
-	chain.ExpInit(t, false)
-
-	// server 3 is registered; expect bootstrap request to server 3
-	ts.AddServer(testServer3, 1)
-	ts.Run(5, testServer3, ReqCheckpointData(checkpointHash))
-
-	// valid response from server 3; expect chain to be initialized
-	ts.RequestEvent(request.EvResponse, ts.Request(5, 1), checkpoint)
-	ts.Run(6)
-	chain.ExpInit(t, true)
-}
-
-func TestUpdateSyncParallel(t *testing.T) {
-	chain := &TestCommitteeChain{}
-	chain.SetNextSyncPeriod(0)
-	updateSync := NewForwardUpdateSync(chain)
-	ts := NewTestScheduler(t, updateSync)
-	// add 2 servers, head at period 100; allow 3-3 parallel requests for each
-	ts.AddServer(testServer1, 3)
-	ts.ServerEvent(EvNewOptimisticUpdate, testServer1, types.OptimisticUpdate{SignatureSlot: 0x2000*100 + 0x1000})
-	ts.AddServer(testServer2, 3)
-	ts.ServerEvent(EvNewOptimisticUpdate, testServer2, types.OptimisticUpdate{SignatureSlot: 0x2000*100 + 0x1000})
-
-	// expect 6 requests to be sent
-	ts.Run(1,
-		testServer1, ReqUpdates{FirstPeriod: 0, Count: 8},
-		testServer1, ReqUpdates{FirstPeriod: 8, Count: 8},
-		testServer1, ReqUpdates{FirstPeriod: 16, Count: 8},
-		testServer2, ReqUpdates{FirstPeriod: 24, Count: 8},
-		testServer2, ReqUpdates{FirstPeriod: 32, Count: 8},
-		testServer2, ReqUpdates{FirstPeriod: 40, Count: 8})
-
-	// valid response to request 1; expect 8 periods synced and a new request started
-	ts.RequestEvent(request.EvResponse, ts.Request(1, 1), testRespUpdate(ts.Request(1, 1)))
-	ts.AddAllowance(testServer1, 1)
-	ts.Run(2, testServer1, ReqUpdates{FirstPeriod: 48, Count: 8})
-	chain.ExpNextSyncPeriod(t, 8)
-
-	// valid response to requests 4 and 5
-	ts.RequestEvent(request.EvResponse, ts.Request(1, 4), testRespUpdate(ts.Request(1, 4)))
-	ts.RequestEvent(request.EvResponse, ts.Request(1, 5), testRespUpdate(ts.Request(1, 5)))
-	ts.AddAllowance(testServer2, 2)
-	// expect 2 more requests but no sync progress (responses 4 and 5 cannot be added before 2 and 3)
-	ts.Run(3,
-		testServer2, ReqUpdates{FirstPeriod: 56, Count: 8},
-		testServer2, ReqUpdates{FirstPeriod: 64, Count: 8})
-	chain.ExpNextSyncPeriod(t, 8)
-
-	// soft timeout for requests 2 and 3 (server 1 is overloaded)
-	ts.RequestEvent(request.EvTimeout, ts.Request(1, 2), nil)
-	ts.RequestEvent(request.EvTimeout, ts.Request(1, 3), nil)
-	// no allowance, no more requests
-	ts.Run(4)
-
-	// valid response to requests 6 and 8 and 9
-	ts.RequestEvent(request.EvResponse, ts.Request(1, 6), testRespUpdate(ts.Request(1, 6)))
-	ts.RequestEvent(request.EvResponse, ts.Request(3, 1), testRespUpdate(ts.Request(3, 1)))
-	ts.RequestEvent(request.EvResponse, ts.Request(3, 2), testRespUpdate(ts.Request(3, 2)))
-	ts.AddAllowance(testServer2, 3)
-	// server 2 can now resend requests 2 and 3 (timed out by server 1) and also send a new one
-	ts.Run(5,
-		testServer2, ReqUpdates{FirstPeriod: 8, Count: 8},
-		testServer2, ReqUpdates{FirstPeriod: 16, Count: 8},
-		testServer2, ReqUpdates{FirstPeriod: 72, Count: 8})
-
-	// server 1 finally answers timed out request 2
-	ts.RequestEvent(request.EvResponse, ts.Request(1, 2), testRespUpdate(ts.Request(1, 2)))
-	ts.AddAllowance(testServer1, 1)
-	// expect sync progress and one new request
-	ts.Run(6, testServer1, ReqUpdates{FirstPeriod: 80, Count: 8})
-	chain.ExpNextSyncPeriod(t, 16)
-
-	// server 2 answers requests 11 and 12 (resends of requests 2 and 3)
-	ts.RequestEvent(request.EvResponse, ts.Request(5, 1), testRespUpdate(ts.Request(5, 1)))
-	ts.RequestEvent(request.EvResponse, ts.Request(5, 2), testRespUpdate(ts.Request(5, 2)))
-	ts.AddAllowance(testServer2, 2)
-	ts.Run(7,
-		testServer2, ReqUpdates{FirstPeriod: 88, Count: 8},
-		testServer2, ReqUpdates{FirstPeriod: 96, Count: 4})
-	// finally the gap is filled, update can process responses up to req6
-	chain.ExpNextSyncPeriod(t, 48)
-
-	// all remaining requests are answered
-	ts.RequestEvent(request.EvResponse, ts.Request(1, 3), testRespUpdate(ts.Request(1, 3)))
-	ts.RequestEvent(request.EvResponse, ts.Request(2, 1), testRespUpdate(ts.Request(2, 1)))
-	ts.RequestEvent(request.EvResponse, ts.Request(5, 3), testRespUpdate(ts.Request(5, 3)))
-	ts.RequestEvent(request.EvResponse, ts.Request(6, 1), testRespUpdate(ts.Request(6, 1)))
-	ts.RequestEvent(request.EvResponse, ts.Request(7, 1), testRespUpdate(ts.Request(7, 1)))
-	ts.RequestEvent(request.EvResponse, ts.Request(7, 2), testRespUpdate(ts.Request(7, 2)))
-	ts.Run(8)
-	// expect chain to be fully synced
-	chain.ExpNextSyncPeriod(t, 100)
-}
-
-func TestUpdateSyncDifferentHeads(t *testing.T) {
-	chain := &TestCommitteeChain{}
-	chain.SetNextSyncPeriod(10)
-	updateSync := NewForwardUpdateSync(chain)
-	ts := NewTestScheduler(t, updateSync)
-	// add 3 servers with different announced head periods
-	ts.AddServer(testServer1, 1)
-	ts.ServerEvent(EvNewOptimisticUpdate, testServer1, types.OptimisticUpdate{SignatureSlot: 0x2000*15 + 0x1000})
-	ts.AddServer(testServer2, 1)
-	ts.ServerEvent(EvNewOptimisticUpdate, testServer2, types.OptimisticUpdate{SignatureSlot: 0x2000*16 + 0x1000})
-	ts.AddServer(testServer3, 1)
-	ts.ServerEvent(EvNewOptimisticUpdate, testServer3, types.OptimisticUpdate{SignatureSlot: 0x2000*17 + 0x1000})
-
-	// expect request to the best announced head
-	ts.Run(1, testServer3, ReqUpdates{FirstPeriod: 10, Count: 7})
-
-	// request times out, expect request to the next best head
-	ts.RequestEvent(request.EvTimeout, ts.Request(1, 1), nil)
-	ts.Run(2, testServer2, ReqUpdates{FirstPeriod: 10, Count: 6})
-
-	// request times out, expect request to the last available server
-	ts.RequestEvent(request.EvTimeout, ts.Request(2, 1), nil)
-	ts.Run(3, testServer1, ReqUpdates{FirstPeriod: 10, Count: 5})
-
-	// valid response to request 3, expect chain synced to period 15
-	ts.RequestEvent(request.EvResponse, ts.Request(3, 1), testRespUpdate(ts.Request(3, 1)))
-	ts.AddAllowance(testServer1, 1)
-	ts.Run(4)
-	chain.ExpNextSyncPeriod(t, 15)
-
-	// invalid response to request 1, server can only deliver updates up to period 15 despite announced head
-	truncated := ts.Request(1, 1)
-	truncated.request = ReqUpdates{FirstPeriod: 10, Count: 5}
-	ts.RequestEvent(request.EvResponse, ts.Request(1, 1), testRespUpdate(truncated))
-	ts.ExpFail(testServer3)
-	ts.Run(5)
-	// expect no progress of chain head
-	chain.ExpNextSyncPeriod(t, 15)
-
-	// valid response to request 2, expect chain synced to period 16
-	ts.RequestEvent(request.EvResponse, ts.Request(2, 1), testRespUpdate(ts.Request(2, 1)))
-	ts.AddAllowance(testServer2, 1)
-	ts.Run(6)
-	chain.ExpNextSyncPeriod(t, 16)
-
-	// a new server is registered with announced head period 17
-	ts.AddServer(testServer4, 1)
-	ts.ServerEvent(EvNewOptimisticUpdate, testServer4, types.OptimisticUpdate{SignatureSlot: 0x2000*17 + 0x1000})
-	// expect request to sync one more period
-	ts.Run(7, testServer4, ReqUpdates{FirstPeriod: 16, Count: 1})
-
-	// valid response, expect chain synced to period 17
-	ts.RequestEvent(request.EvResponse, ts.Request(7, 1), testRespUpdate(ts.Request(7, 1)))
-	ts.AddAllowance(testServer4, 1)
-	ts.Run(8)
-	chain.ExpNextSyncPeriod(t, 17)
-}
-
-func TestRangeLock(t *testing.T) {
-	r := make(rangeLock)
-
-	// Lock from 0 to 99.
-	r.lock(0, 100, 1)
-	for i := 0; i < 100; i++ {
-		if v, ok := r[uint64(i)]; v <= 0 || !ok {
-			t.Fatalf("integer space: %d not locked", i)
-		}
-	}
-
-	// Unlock from 0 to 99.
-	r.lock(0, 100, -1)
-	for i := 0; i < 100; i++ {
-		if v, ok := r[uint64(i)]; v > 0 || ok {
-			t.Fatalf("integer space: %d is locked", i)
-		}
-	}
-
-	// Lock from 0 to 99 then unlock from 10 to 59.
-	r.lock(0, 100, 1)
-	r.lock(10, 50, -1)
-	first, count := r.firstUnlocked(0, 100)
-	if first != 10 || count != 50 {
-		t.Fatalf("unexpected first: %d or count: %d", first, count)
-	}
-}
-
-func testRespUpdate(request requestWithID) request.Response {
-	var resp RespUpdates
-	if request.request == nil {
-		return resp
-	}
-	req := request.request.(ReqUpdates)
-	resp.Updates = make([]*types.LightClientUpdate, int(req.Count))
-	resp.Committees = make([]*types.SerializedSyncCommittee, int(req.Count))
-	period := req.FirstPeriod
-	for i := range resp.Updates {
-		resp.Updates[i] = &types.LightClientUpdate{AttestedHeader: types.SignedHeader{Header: types.Header{Slot: 0x2000*period + 0x1000}}}
-		resp.Committees[i] = new(types.SerializedSyncCommittee)
-		period++
-	}
-	return resp
-}
--- a/beacon/params/params.go
+++ b/beacon/params/params.go
@@ -41,6 +41,4 @@ const (
 	StateIndexNextSyncCommittee = 55
 	StateIndexExecPayload       = 56
 	StateIndexExecHead          = 908
-
-	BodyIndexExecPayload = 25
 )
--- a/beacon/types/beacon_block.go
+++ b/beacon/types/beacon_block.go
@@ -1,110 +0,0 @@
-// Copyright 2024 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package types
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/protolambda/zrnt/eth2/beacon/capella"
-	zrntcommon "github.com/protolambda/zrnt/eth2/beacon/common"
-	"github.com/protolambda/zrnt/eth2/beacon/deneb"
-	"github.com/protolambda/zrnt/eth2/configs"
-	"github.com/protolambda/ztyp/tree"
-)
-
-type blockObject interface {
-	HashTreeRoot(spec *zrntcommon.Spec, hFn tree.HashFn) zrntcommon.Root
-	Header(spec *zrntcommon.Spec) *zrntcommon.BeaconBlockHeader
-}
-
-// BeaconBlock represents a full block in the beacon chain.
-type BeaconBlock struct {
-	blockObj blockObject
-}
-
-// BlockFromJSON decodes a beacon block from JSON.
-func BlockFromJSON(forkName string, data []byte) (*BeaconBlock, error) {
-	var obj blockObject
-	switch forkName {
-	case "deneb":
-		obj = new(deneb.BeaconBlock)
-	case "capella":
-		obj = new(capella.BeaconBlock)
-	default:
-		return nil, fmt.Errorf("unsupported fork: %s", forkName)
-	}
-	if err := json.Unmarshal(data, obj); err != nil {
-		return nil, err
-	}
-	return &BeaconBlock{obj}, nil
-}
-
-// NewBeaconBlock wraps a ZRNT block.
-func NewBeaconBlock(obj blockObject) *BeaconBlock {
-	switch obj := obj.(type) {
-	case *capella.BeaconBlock:
-		return &BeaconBlock{obj}
-	case *deneb.BeaconBlock:
-		return &BeaconBlock{obj}
-	default:
-		panic(fmt.Errorf("unsupported block type %T", obj))
-	}
-}
-
-// Slot returns the slot number of the block.
-func (b *BeaconBlock) Slot() uint64 {
-	switch obj := b.blockObj.(type) {
-	case *capella.BeaconBlock:
-		return uint64(obj.Slot)
-	case *deneb.BeaconBlock:
-		return uint64(obj.Slot)
-	default:
-		panic(fmt.Errorf("unsupported block type %T", b.blockObj))
-	}
-}
-
-// ExecutionPayload parses and returns the execution payload of the block.
-func (b *BeaconBlock) ExecutionPayload() (*types.Block, error) {
-	switch obj := b.blockObj.(type) {
-	case *capella.BeaconBlock:
-		return convertPayload(&obj.Body.ExecutionPayload, &obj.ParentRoot)
-	case *deneb.BeaconBlock:
-		return convertPayload(&obj.Body.ExecutionPayload, &obj.ParentRoot)
-	default:
-		panic(fmt.Errorf("unsupported block type %T", b.blockObj))
-	}
-}
-
-// Header returns the block's header data.
-func (b *BeaconBlock) Header() Header {
-	switch obj := b.blockObj.(type) {
-	case *capella.BeaconBlock:
-		return headerFromZRNT(obj.Header(configs.Mainnet))
-	case *deneb.BeaconBlock:
-		return headerFromZRNT(obj.Header(configs.Mainnet))
-	default:
-		panic(fmt.Errorf("unsupported block type %T", b.blockObj))
-	}
-}
-
-// Root computes the SSZ root hash of the block.
-func (b *BeaconBlock) Root() common.Hash {
-	return common.Hash(b.blockObj.HashTreeRoot(configs.Mainnet, tree.GetHashFn()))
-}
--- a/beacon/types/beacon_block_test.go
+++ b/beacon/types/beacon_block_test.go
@@ -1,77 +0,0 @@
-// Copyright 2024 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package types
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/common"
-)
-
-func TestBlockFromJSON(t *testing.T) {
-	type blocktest struct {
-		file            string
-		version         string
-		wantSlot        uint64
-		wantBlockNumber uint64
-		wantBlockHash   common.Hash
-	}
-	tests := []blocktest{
-		{
-			file:            "block_deneb.json",
-			version:         "deneb",
-			wantSlot:        8631513,
-			wantBlockNumber: 19431837,
-			wantBlockHash:   common.HexToHash("0x4cf7d9108fc01b50023ab7cab9b372a96068fddcadec551630393b65acb1f34c"),
-		},
-		{
-			file:            "block_capella.json",
-			version:         "capella",
-			wantSlot:        7378495,
-			wantBlockNumber: 18189758,
-			wantBlockHash:   common.HexToHash("0x802acf5c350f4252e31d83c431fcb259470250fa0edf49e8391cfee014239820"),
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.file, func(t *testing.T) {
-			data, err := os.ReadFile(filepath.Join("testdata", test.file))
-			if err != nil {
-				t.Fatal(err)
-			}
-			beaconBlock, err := BlockFromJSON(test.version, data)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if beaconBlock.Slot() != test.wantSlot {
-				t.Errorf("wrong slot number %d", beaconBlock.Slot())
-			}
-			execBlock, err := beaconBlock.ExecutionPayload()
-			if err != nil {
-				t.Fatalf("payload extraction failed: %v", err)
-			}
-			if execBlock.NumberU64() != test.wantBlockNumber {
-				t.Errorf("wrong block number: %v", execBlock.NumberU64())
-			}
-			if execBlock.Hash() != test.wantBlockHash {
-				t.Errorf("wrong block hash: %v", execBlock.Hash())
-			}
-		})
-	}
-}
--- a/beacon/types/config.go
+++ b/beacon/types/config.go
@@ -19,9 +19,7 @@ package types
 import (
 	"crypto/sha256"
 	"fmt"
-	"math"
 	"os"
-	"slices"
 	"sort"
 	"strconv"
 	"strings"
@@ -29,7 +27,6 @@ import (
 	"github.com/ethereum/go-ethereum/beacon/merkle"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/log"
 	"gopkg.in/yaml.v3"
 )

@@ -37,12 +34,10 @@ import (
 // across signing different data structures.
 const syncCommitteeDomain = 7

-var knownForks = []string{"GENESIS", "ALTAIR", "BELLATRIX", "CAPELLA", "DENEB"}
-
 // Fork describes a single beacon chain fork and also stores the calculated
 // signature domain used after this fork.
 type Fork struct {
-	// Name of the fork in the chain config (config.yaml) file
+	// Name of the fork in the chain config (config.yaml) file{
 	Name string

 	// Epoch when given fork version is activated
@@ -51,9 +46,6 @@ type Fork struct {
 	// Fork version, see https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#custom-types
 	Version []byte

-	// index in list of known forks or MaxInt if unknown
-	knownIndex int
-
 	// calculated by computeDomain, based on fork version and genesis validators root
 	domain merkle.Value
 }
@@ -109,12 +101,7 @@ func (f Forks) SigningRoot(header Header) (common.Hash, error) {

 func (f Forks) Len() int           { return len(f) }
 func (f Forks) Swap(i, j int)      { f[i], f[j] = f[j], f[i] }
-func (f Forks) Less(i, j int) bool {
-	if f[i].Epoch != f[j].Epoch {
-		return f[i].Epoch < f[j].Epoch
-	}
-	return f[i].knownIndex < f[j].knownIndex
-}
+func (f Forks) Less(i, j int) bool { return f[i].Epoch < f[j].Epoch }

 // ChainConfig contains the beacon chain configuration.
 type ChainConfig struct {
@@ -123,34 +110,18 @@ type ChainConfig struct {
 	Forks                 Forks
 }

-// ForkAtEpoch returns the latest active fork at the given epoch.
-func (c *ChainConfig) ForkAtEpoch(epoch uint64) Fork {
-	for i := len(c.Forks) - 1; i >= 0; i-- {
-		if c.Forks[i].Epoch <= epoch {
-			return *c.Forks[i]
-		}
-	}
-	return Fork{}
-}
-
 // AddFork adds a new item to the list of forks.
 func (c *ChainConfig) AddFork(name string, epoch uint64, version []byte) *ChainConfig {
-	knownIndex := slices.Index(knownForks, name)
-	if knownIndex == -1 {
-		knownIndex = math.MaxInt // assume that the unknown fork happens after the known ones
-		if epoch != math.MaxUint64 {
-			log.Warn("Unknown fork in config.yaml", "fork name", name, "known forks", knownForks)
-		}
-	}
 	fork := &Fork{
 		Name:    name,
 		Epoch:   epoch,
 		Version: version,
-		knownIndex: knownIndex,
 	}
 	fork.computeDomain(c.GenesisValidatorsRoot)
+
 	c.Forks = append(c.Forks, fork)
 	sort.Sort(c.Forks)
+
 	return c
 }

@@ -200,5 +171,6 @@ func (c *ChainConfig) LoadForks(path string) error {
 	for name := range versions {
 		return fmt.Errorf("epoch number missing for fork %q in beacon chain config file", name)
 	}
+	sort.Sort(c.Forks)
 	return nil
 }
--- a/beacon/types/exec_header.go
+++ b/beacon/types/exec_header.go
@@ -1,80 +0,0 @@
-// Copyright 2024 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package types
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"github.com/ethereum/go-ethereum/beacon/merkle"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/protolambda/zrnt/eth2/beacon/capella"
-	zrntcommon "github.com/protolambda/zrnt/eth2/beacon/common"
-	"github.com/protolambda/zrnt/eth2/beacon/deneb"
-	"github.com/protolambda/ztyp/tree"
-)
-
-type headerObject interface {
-	HashTreeRoot(hFn tree.HashFn) zrntcommon.Root
-}
-
-type ExecutionHeader struct {
-	obj headerObject
-}
-
-// ExecutionHeaderFromJSON decodes an execution header from JSON data provided by
-// the beacon chain API.
-func ExecutionHeaderFromJSON(forkName string, data []byte) (*ExecutionHeader, error) {
-	var obj headerObject
-	switch forkName {
-	case "capella":
-		obj = new(capella.ExecutionPayloadHeader)
-	case "deneb":
-		obj = new(deneb.ExecutionPayloadHeader)
-	default:
-		return nil, fmt.Errorf("unsupported fork: %s", forkName)
-	}
-	if err := json.Unmarshal(data, obj); err != nil {
-		return nil, err
-	}
-	return &ExecutionHeader{obj: obj}, nil
-}
-
-func NewExecutionHeader(obj headerObject) *ExecutionHeader {
-	switch obj.(type) {
-	case *capella.ExecutionPayloadHeader:
-	case *deneb.ExecutionPayloadHeader:
-	default:
-		panic(fmt.Errorf("unsupported ExecutionPayloadHeader type %T", obj))
-	}
-	return &ExecutionHeader{obj: obj}
-}
-
-func (eh *ExecutionHeader) PayloadRoot() merkle.Value {
-	return merkle.Value(eh.obj.HashTreeRoot(tree.GetHashFn()))
-}
-
-func (eh *ExecutionHeader) BlockHash() common.Hash {
-	switch obj := eh.obj.(type) {
-	case *capella.ExecutionPayloadHeader:
-		return common.Hash(obj.BlockHash)
-	case *deneb.ExecutionPayloadHeader:
-		return common.Hash(obj.BlockHash)
-	default:
-		panic(fmt.Errorf("unsupported ExecutionPayloadHeader type %T", obj))
-	}
-}
--- a/beacon/types/exec_payload.go
+++ b/beacon/types/exec_payload.go
@@ -1,141 +0,0 @@
-// Copyright 2024 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package types
-
-import (
-	"fmt"
-	"math/big"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/trie"
-	"github.com/holiman/uint256"
-	"github.com/protolambda/zrnt/eth2/beacon/capella"
-	zrntcommon "github.com/protolambda/zrnt/eth2/beacon/common"
-	"github.com/protolambda/zrnt/eth2/beacon/deneb"
-)
-
-type payloadType interface {
-	*capella.ExecutionPayload | *deneb.ExecutionPayload
-}
-
-// convertPayload converts a beacon chain execution payload to types.Block.
-func convertPayload[T payloadType](payload T, parentRoot *zrntcommon.Root) (*types.Block, error) {
-	var (
-		header       types.Header
-		transactions []*types.Transaction
-		withdrawals  []*types.Withdrawal
-		expectedHash [32]byte
-		err          error
-	)
-	switch p := any(payload).(type) {
-	case *capella.ExecutionPayload:
-		convertCapellaHeader(p, &header)
-		transactions, err = convertTransactions(p.Transactions, &header)
-		if err != nil {
-			return nil, err
-		}
-		withdrawals = convertWithdrawals(p.Withdrawals, &header)
-		expectedHash = p.BlockHash
-	case *deneb.ExecutionPayload:
-		convertDenebHeader(p, common.Hash(*parentRoot), &header)
-		transactions, err = convertTransactions(p.Transactions, &header)
-		if err != nil {
-			return nil, err
-		}
-		withdrawals = convertWithdrawals(p.Withdrawals, &header)
-		expectedHash = p.BlockHash
-	default:
-		panic("unsupported block type")
-	}
-
-	block := types.NewBlockWithHeader(&header).WithBody(types.Body{Transactions: transactions, Withdrawals: withdrawals})
-	if hash := block.Hash(); hash != expectedHash {
-		return nil, fmt.Errorf("sanity check failed, payload hash does not match (expected %x, got %x)", expectedHash, hash)
-	}
-	return block, nil
-}
-
-func convertCapellaHeader(payload *capella.ExecutionPayload, h *types.Header) {
-	// note: h.TxHash is set in convertTransactions
-	h.ParentHash = common.Hash(payload.ParentHash)
-	h.UncleHash = types.EmptyUncleHash
-	h.Coinbase = common.Address(payload.FeeRecipient)
-	h.Root = common.Hash(payload.StateRoot)
-	h.ReceiptHash = common.Hash(payload.ReceiptsRoot)
-	h.Bloom = types.Bloom(payload.LogsBloom)
-	h.Difficulty = common.Big0
-	h.Number = new(big.Int).SetUint64(uint64(payload.BlockNumber))
-	h.GasLimit = uint64(payload.GasLimit)
-	h.GasUsed = uint64(payload.GasUsed)
-	h.Time = uint64(payload.Timestamp)
-	h.Extra = []byte(payload.ExtraData)
-	h.MixDigest = common.Hash(payload.PrevRandao)
-	h.Nonce = types.BlockNonce{}
-	h.BaseFee = (*uint256.Int)(&payload.BaseFeePerGas).ToBig()
-}
-
-func convertDenebHeader(payload *deneb.ExecutionPayload, parentRoot common.Hash, h *types.Header) {
-	// note: h.TxHash is set in convertTransactions
-	h.ParentHash = common.Hash(payload.ParentHash)
-	h.UncleHash = types.EmptyUncleHash
-	h.Coinbase = common.Address(payload.FeeRecipient)
-	h.Root = common.Hash(payload.StateRoot)
-	h.ReceiptHash = common.Hash(payload.ReceiptsRoot)
-	h.Bloom = types.Bloom(payload.LogsBloom)
-	h.Difficulty = common.Big0
-	h.Number = new(big.Int).SetUint64(uint64(payload.BlockNumber))
-	h.GasLimit = uint64(payload.GasLimit)
-	h.GasUsed = uint64(payload.GasUsed)
-	h.Time = uint64(payload.Timestamp)
-	h.Extra = []byte(payload.ExtraData)
-	h.MixDigest = common.Hash(payload.PrevRandao)
-	h.Nonce = types.BlockNonce{}
-	h.BaseFee = (*uint256.Int)(&payload.BaseFeePerGas).ToBig()
-	// new in deneb
-	h.BlobGasUsed = (*uint64)(&payload.BlobGasUsed)
-	h.ExcessBlobGas = (*uint64)(&payload.ExcessBlobGas)
-	h.ParentBeaconRoot = &parentRoot
-}
-
-func convertTransactions(list zrntcommon.PayloadTransactions, execHeader *types.Header) ([]*types.Transaction, error) {
-	txs := make([]*types.Transaction, len(list))
-	for i, opaqueTx := range list {
-		var tx types.Transaction
-		if err := tx.UnmarshalBinary(opaqueTx); err != nil {
-			return nil, fmt.Errorf("failed to parse tx %d: %v", i, err)
-		}
-		txs[i] = &tx
-	}
-	execHeader.TxHash = types.DeriveSha(types.Transactions(txs), trie.NewStackTrie(nil))
-	return txs, nil
-}
-
-func convertWithdrawals(list zrntcommon.Withdrawals, execHeader *types.Header) []*types.Withdrawal {
-	withdrawals := make([]*types.Withdrawal, len(list))
-	for i, w := range list {
-		withdrawals[i] = &types.Withdrawal{
-			Index:     uint64(w.Index),
-			Validator: uint64(w.ValidatorIndex),
-			Address:   common.Address(w.Address),
-			Amount:    uint64(w.Amount),
-		}
-	}
-	wroot := types.DeriveSha(types.Withdrawals(withdrawals), trie.NewStackTrie(nil))
-	execHeader.WithdrawalsHash = &wroot
-	return withdrawals
-}
--- a/beacon/types/header.go
+++ b/beacon/types/header.go
@@ -24,7 +24,6 @@ import (
 	"github.com/ethereum/go-ethereum/beacon/merkle"
 	"github.com/ethereum/go-ethereum/beacon/params"
 	"github.com/ethereum/go-ethereum/common"
-	zrntcommon "github.com/protolambda/zrnt/eth2/beacon/common"
 )

 //go:generate go run github.com/fjl/gencodec -type Header -field-override headerMarshaling -out gen_header_json.go
@@ -58,16 +57,6 @@ type Header struct {
 	BodyRoot common.Hash `gencodec:"required" json:"body_root"`
 }

-func headerFromZRNT(zh *zrntcommon.BeaconBlockHeader) Header {
-	return Header{
-		Slot:          uint64(zh.Slot),
-		ProposerIndex: uint64(zh.ProposerIndex),
-		ParentRoot:    common.Hash(zh.ParentRoot),
-		StateRoot:     common.Hash(zh.StateRoot),
-		BodyRoot:      common.Hash(zh.BodyRoot),
-	}
-}
-
 // headerMarshaling is a field type overrides for gencodec.
 type headerMarshaling struct {
 	Slot          common.Decimal
--- a/beacon/types/light_sync.go
+++ b/beacon/types/light_sync.go
@@ -23,15 +23,8 @@ import (
 	"github.com/ethereum/go-ethereum/beacon/merkle"
 	"github.com/ethereum/go-ethereum/beacon/params"
 	"github.com/ethereum/go-ethereum/common"
-	ctypes "github.com/ethereum/go-ethereum/core/types"
 )

-// HeadInfo represents an unvalidated new head announcement.
-type HeadInfo struct {
-	Slot      uint64
-	BlockRoot common.Hash
-}
-
 // BootstrapData contains a sync committee where light sync can be started,
 // together with a proof through a beacon header and corresponding state.
 // Note: BootstrapData is fetched from a server based on a known checkpoint hash.
@@ -141,96 +134,3 @@ func (u UpdateScore) BetterThan(w UpdateScore) bool {
 	}
 	return u.SignerCount > w.SignerCount
 }
-
-// HeaderWithExecProof contains a beacon header and proves the belonging execution
-// payload header with a Merkle proof.
-type HeaderWithExecProof struct {
-	Header
-	PayloadHeader *ExecutionHeader
-	PayloadBranch merkle.Values
-}
-
-// Validate verifies the Merkle proof of the execution payload header.
-func (h *HeaderWithExecProof) Validate() error {
-	return merkle.VerifyProof(h.BodyRoot, params.BodyIndexExecPayload, h.PayloadBranch, h.PayloadHeader.PayloadRoot())
-}
-
-// OptimisticUpdate proves sync committee commitment on the attested beacon header.
-// It also proves the belonging execution payload header with a Merkle proof.
-//
-// See data structure definition here:
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/light-client/sync-protocol.md#lightclientoptimisticupdate
-type OptimisticUpdate struct {
-	Attested HeaderWithExecProof
-	// Sync committee BLS signature aggregate
-	Signature SyncAggregate
-	// Slot in which the signature has been created (newer than Header.Slot,
-	// determines the signing sync committee)
-	SignatureSlot uint64
-}
-
-// SignedHeader returns the signed attested header of the update.
-func (u *OptimisticUpdate) SignedHeader() SignedHeader {
-	return SignedHeader{
-		Header:        u.Attested.Header,
-		Signature:     u.Signature,
-		SignatureSlot: u.SignatureSlot,
-	}
-}
-
-// Validate verifies the Merkle proof proving the execution payload header.
-// Note that the sync committee signature of the attested header should be
-// verified separately by a synced committee chain.
-func (u *OptimisticUpdate) Validate() error {
-	return u.Attested.Validate()
-}
-
-// FinalityUpdate proves a finalized beacon header by a sync committee commitment
-// on an attested beacon header, referring to the latest finalized header with a
-// Merkle proof.
-// It also proves the execution payload header belonging to both the attested and
-// the finalized beacon header with Merkle proofs.
-//
-// See data structure definition here:
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/light-client/sync-protocol.md#lightclientfinalityupdate
-type FinalityUpdate struct {
-	Attested, Finalized HeaderWithExecProof
-	FinalityBranch      merkle.Values
-	// Sync committee BLS signature aggregate
-	Signature SyncAggregate
-	// Slot in which the signature has been created (newer than Header.Slot,
-	// determines the signing sync committee)
-	SignatureSlot uint64
-}
-
-// SignedHeader returns the signed attested header of the update.
-func (u *FinalityUpdate) SignedHeader() SignedHeader {
-	return SignedHeader{
-		Header:        u.Attested.Header,
-		Signature:     u.Signature,
-		SignatureSlot: u.SignatureSlot,
-	}
-}
-
-// Validate verifies the Merkle proofs proving the finalized beacon header and
-// the execution payload headers belonging to the attested and finalized headers.
-// Note that the sync committee signature of the attested header should be
-// verified separately by a synced committee chain.
-func (u *FinalityUpdate) Validate() error {
-	if err := u.Attested.Validate(); err != nil {
-		return err
-	}
-	if err := u.Finalized.Validate(); err != nil {
-		return err
-	}
-	return merkle.VerifyProof(u.Attested.StateRoot, params.StateIndexFinalBlock, u.FinalityBranch, merkle.Value(u.Finalized.Hash()))
-}
-
-// ChainHeadEvent returns an authenticated execution payload associated with the
-// latest accepted head of the beacon chain, along with the hash of the latest
-// finalized execution block.
-type ChainHeadEvent struct {
-	BeaconHead Header
-	Block      *ctypes.Block
-	Finalized  common.Hash
-}
--- a/beacon/types/testdata/block_capella.json
+++ b/beacon/types/testdata/block_capella.json
--- a/beacon/types/testdata/block_deneb.json
+++ b/beacon/types/testdata/block_deneb.json
--- a/build/checksums.txt
+++ b/build/checksums.txt
@@ -5,123 +5,61 @@
 # https://github.com/ethereum/execution-spec-tests/releases/download/v2.1.0/
 ca89c76851b0900bfcc3cbb9a26cbece1f3d7c64a3bed38723e914713290df6c  fixtures_develop.tar.gz

-# version:golang 1.23.2
+# version:golang 1.21.6
 # https://go.dev/dl/
-36930162a93df417d90bd22c6e14daff4705baac2b02418edda671cdfa9cd07f  go1.23.2.src.tar.gz
-025d77f1780906142023a364c31a572afd7d56d3a3be1e4e562e367ca88d3267  go1.23.2.freebsd-amd64.tar.gz
-0d50bade977b84e173cb350946087f5de8c75f8df19456c3b60c5d58e186089d  go1.23.2.windows-arm64.zip
-0edd985dbd6de64d9c88dbc8835bae21203c58444bf26fce0739cbec4eb1b610  go1.23.2.windows-arm64.msi
-2283d12dfe7c8c8a46a41bbf7d11fe007434e7590cd1b89e221e478640b7ee3a  go1.23.2.linux-mips64le.tar.gz
-2293c5c3ffc595418308b4059ce214b99f0383cba83232e47a1a8c3b710c24e8  go1.23.2.linux-loong64.tar.gz
-23b93144e754bbcf5eda700e9decbdbd44d29ceedb1bf1de75f95e8a6ea986bb  go1.23.2.openbsd-arm64.tar.gz
-2734a5b54905cea45f136c28249e626d0241b865b0637fa1db64bf533d9d843e  go1.23.2.netbsd-amd64.tar.gz
-28af3c40687afdda6b33b300833b6d662716cc2d624fb9fd61a49bdad44cd869  go1.23.2.freebsd-arm.tar.gz
-367d522b47c7ce7761a671efcb8b12c8af8f509db1cd6160c91f410ef3201987  go1.23.2.windows-arm.msi
-36b7228bae235eee6c8193f5a956e1a9a17874955affb86b3564709b0fab5874  go1.23.2.linux-mipsle.tar.gz
-3bd1130a08195d23960b154d2e6eaa80ac7325ebd9d01d74c58b6d12580e6b12  go1.23.2.linux-mips.tar.gz
-3bf66879b38a233c5cbb5d2eb982004117f05d6bf06279e886e087d7c504427d  go1.23.2.openbsd-riscv64.tar.gz
-3e80b943d70c7e1633822b42c1aa7234e61da14f13ff8efff7ee6e1347f37648  go1.23.2.netbsd-arm64.tar.gz
-40c0b61971a1a74fd4566c536f682c9d4976fa71d40d9daabc875c06113d0fee  go1.23.2.darwin-amd64.pkg
-445c0ef19d8692283f4c3a92052cc0568f5a048f4e546105f58e991d4aea54f5  go1.23.2.darwin-amd64.tar.gz
-542d3c1705f1c6a1c5a80d5dc62e2e45171af291e755d591c5e6531ef63b454e  go1.23.2.linux-amd64.tar.gz
-560aff7fe1eeadc32248db35ed5c0a81e190d171b6ecec404cf46d808c13e92f  go1.23.2.aix-ppc64.tar.gz
-5611cd648f5100b73a7d6fd85589a481af18fdbaf9c153a92de9a8e39a6e061f  go1.23.2.darwin-arm64.pkg
-695aac64532da8d9a243601ffa0411cd763be891fcf7fd2e857eea4ab10b8bcc  go1.23.2.plan9-386.tar.gz
-69b31edcd3d4f7d8bbf9aee2b25cafba30b444ef19bc7a033e15026f7d0cc5c2  go1.23.2.netbsd-arm.tar.gz
-6ffa4ac1f4368a3121a032917577a4e0a3feaf696c3e98f213b74ac04c318bc4  go1.23.2.plan9-arm.tar.gz
-72a6def70300cc804c70073d8b579603d9b39b39b02b3b5d340968d9e7e0e9d4  go1.23.2.windows-386.msi
-791ca685ee5ca0f6fe849dc078145cb1323d0ea9dd308e9cca9ba2e7186dbb3d  go1.23.2.linux-ppc64.tar.gz
-86b5de91fdf7bd9b52c77c62f8762518cf3fc256fe912af9bbff1d073054aa5b  go1.23.2.plan9-amd64.tar.gz
-8734c7cd464a0620f6605bd3f9256bed062f262d0d58e4f45099c329a08ed966  go1.23.2.openbsd-amd64.tar.gz
-980ceb889915695d94b166ca1300250dba76fa37a2d41eca2c5e7727dcb4fb7f  go1.23.2.openbsd-arm.tar.gz
-a0cf25f236a0fa0a465816fe7f5c930f3b0b90c5c247b09c43a6adeff654e6ae  go1.23.2.linux-mips64.tar.gz
-a13cc0d621af4f35afd90b886c60b1bf66f771939d226dc36fa61a337d90eb30  go1.23.2.openbsd-ppc64.tar.gz
-b29ff163b34cb4943c521fcfc1d956eaa6286561089042051a3fab22e79e9283  go1.23.2.windows-arm.zip
-bc28fe3002cd65cec65d0e4f6000584dacb8c71bfaff8801dfb532855ca42513  go1.23.2.windows-amd64.zip
-c164ce7d894b10fd861d7d7b96f1dbea3f993663d9f0c30bc4f8ae3915db8b0c  go1.23.2.linux-ppc64le.tar.gz
-c4ae1087dce4daf45a837f5fca36ac0e29a02ada9addf857f1c426e60bce6f21  go1.23.2.netbsd-386.tar.gz
-c80cbc5e66d6fb8b0c3300b0dda1fe925c429e199954d3327da2933d9870b041  go1.23.2.windows-amd64.msi
-cb1ed4410f68d8be1156cee0a74fcfbdcd9bca377c83db3a9e1b07eebc6d71ef  go1.23.2.linux-386.tar.gz
-d1fde255843fec1f7f0611d468effd98e1f4309f589ac13037db07b032f9da35  go1.23.2.openbsd-386.tar.gz
-d47e40366cd6c6b6ee14b811554cd7dde0351309f4a8a4569ec5ba2bd7689437  go1.23.2.illumos-amd64.tar.gz
-d87031194fe3e01abdcaf3c7302148ade97a7add6eac3fec26765bcb3207b80f  go1.23.2.darwin-arm64.tar.gz
-de1f94d7dd3548ba3036de1ea97eb8243881c22a88fcc04cc08c704ded769e02  go1.23.2.linux-s390x.tar.gz
-e3286bdde186077e65e961cbe18874d42a461e5b9c472c26572b8d4a98d15c40  go1.23.2.linux-armv6l.tar.gz
-e4d9a1319dfdaa827407855e406c43e85c878a1f93f4f3984c85dce969c8bf70  go1.23.2.freebsd-386.tar.gz
-ea8ab49c5c04c9f94a3f4894d1b030fbce8d10413905fa399f6c39c0a44d5556  go1.23.2.linux-riscv64.tar.gz
-eaa3bc377badbdcae144633f8b29bf2680475b72dcd4c135343d3bdc0ba7671e  go1.23.2.windows-386.zip
-f11b9b4d4a0679909202fc5e88093d6ff720a8a417bfe6a34d502c3862367039  go1.23.2.freebsd-riscv64.tar.gz
-f163b99b03e4bbc64cd30363f1694a08fcd44094415db1f092f13f9d1bb7c28e  go1.23.2.dragonfly-amd64.tar.gz
-f45af3e1434175ff85620a74c07fb41d6844655f1f2cd2389c5fca6de000f58c  go1.23.2.freebsd-arm64.tar.gz
-f626cdd92fc21a88b31c1251f419c17782933a42903db87a174ce74eeecc66a9  go1.23.2.linux-arm64.tar.gz
-fa70d39ddeb6b55241a30b48d7af4e681c6a7d7104e8326c3bc1b12a75e091cc  go1.23.2.solaris-amd64.tar.gz
+124926a62e45f78daabbaedb9c011d97633186a33c238ffc1e25320c02046248  go1.21.6.src.tar.gz
+31d6ecca09010ab351e51343a5af81d678902061fee871f912bdd5ef4d778850  go1.21.6.darwin-amd64.tar.gz
+0ff541fb37c38e5e5c5bcecc8f4f43c5ffd5e3a6c33a5d3e4003ded66fcfb331  go1.21.6.darwin-arm64.tar.gz
+a1d1a149b34bf0f53965a237682c6da1140acabb131bf0e597240e4a140b0e5e  go1.21.6.freebsd-386.tar.gz
+de59e1217e4398b1522eed8dddabab2fa1b97aecbdca3af08e34832b4f0e3f81  go1.21.6.freebsd-amd64.tar.gz
+05d09041b5a1193c14e4b2db3f7fcc649b236c567f5eb93305c537851b72dd95  go1.21.6.linux-386.tar.gz
+3f934f40ac360b9c01f616a9aa1796d227d8b0328bf64cb045c7b8c4ee9caea4  go1.21.6.linux-amd64.tar.gz
+e2e8aa88e1b5170a0d495d7d9c766af2b2b6c6925a8f8956d834ad6b4cacbd9a  go1.21.6.linux-arm64.tar.gz
+6a8eda6cc6a799ff25e74ce0c13fdc1a76c0983a0bb07c789a2a3454bf6ec9b2  go1.21.6.linux-armv6l.tar.gz
+e872b1e9a3f2f08fd4554615a32ca9123a4ba877ab6d19d36abc3424f86bc07f  go1.21.6.linux-ppc64le.tar.gz
+92894d0f732d3379bc414ffdd617eaadad47e1d72610e10d69a1156db03fc052  go1.21.6.linux-s390x.tar.gz
+65b38857135cf45c80e1d267e0ce4f80fe149326c68835217da4f2da9b7943fe  go1.21.6.windows-386.zip
+27ac9dd6e66fb3fd0acfa6792ff053c86e7d2c055b022f4b5d53bfddec9e3301  go1.21.6.windows-amd64.zip
+b93aff8f3c882c764c66a39b7a1483b0460e051e9992bf3435479129e5051bcd  go1.21.6.windows-arm64.zip

-# version:golangci 1.61.0
+# version:golangci 1.55.2
 # https://github.com/golangci/golangci-lint/releases/
-# https://github.com/golangci/golangci-lint/releases/download/v1.61.0/
-5c280ef3284f80c54fd90d73dc39ca276953949da1db03eb9dd0fbf868cc6e55  golangci-lint-1.61.0-darwin-amd64.tar.gz
-544334890701e4e04a6e574bc010bea8945205c08c44cced73745a6378012d36  golangci-lint-1.61.0-darwin-arm64.tar.gz
-e885a6f561092055930ebd298914d80e8fd2e10d2b1e9942836c2c6a115301fa  golangci-lint-1.61.0-freebsd-386.tar.gz
-b13f6a3f11f65e7ff66b734d7554df3bbae0f485768848424e7554ed289e19c2  golangci-lint-1.61.0-freebsd-amd64.tar.gz
-cd8e7bbe5b8f33ed1597aa1cc588da96a3b9f22e1b9ae60d93511eae1a0ee8c5  golangci-lint-1.61.0-freebsd-armv6.tar.gz
-7ade524dbd88bd250968f45e190af90e151fa5ee63dd6aa7f7bb90e8155db61d  golangci-lint-1.61.0-freebsd-armv7.tar.gz
-0fe3cd8a1ed8d9f54f48670a5af3df056d6040d94017057f0f4d65c930660ad9  golangci-lint-1.61.0-illumos-amd64.tar.gz
-b463fc5053a612abd26393ebaff1d85d7d56058946f4f0f7bf25ed44ea899415  golangci-lint-1.61.0-linux-386.tar.gz
-77cb0af99379d9a21d5dc8c38364d060e864a01bd2f3e30b5e8cc550c3a54111  golangci-lint-1.61.0-linux-amd64.tar.gz
-af60ac05566d9351615cb31b4cc070185c25bf8cbd9b09c1873aa5ec6f3cc17e  golangci-lint-1.61.0-linux-arm64.tar.gz
-1f307f2fcc5d7d674062a967a0d83a7091e300529aa237ec6ad2b3dd14c897f5  golangci-lint-1.61.0-linux-armv6.tar.gz
-3ad8cbaae75a547450844811300f99c4cd290277398e43d22b9eb1792d15af4c  golangci-lint-1.61.0-linux-armv7.tar.gz
-9be2ca67d961d7699079739cf6f7c8291c5183d57e34d1677de21ca19d0bd3ed  golangci-lint-1.61.0-linux-loong64.tar.gz
-90d005e1648115ebf0861b408eab9c936079a24763e883058b0a227cd3135d31  golangci-lint-1.61.0-linux-mips64.tar.gz
-6d2ed4f49407115460b8c10ccfc40fd177e0887a48864a2879dd16e84ba2a48c  golangci-lint-1.61.0-linux-mips64le.tar.gz
-633089589af5a58b7430afb6eee107d4e9c99e8d91711ddc219eb13a07e8d3b8  golangci-lint-1.61.0-linux-ppc64le.tar.gz
-4c1a097d9e0d1b4a8144dae6a1f5583a38d662f3bdc1498c4e954b6ed856be98  golangci-lint-1.61.0-linux-riscv64.tar.gz
-30581d3c987d287b7064617f1a2694143e10dffc40bc25be6636006ee82d7e1c  golangci-lint-1.61.0-linux-s390x.tar.gz
-42530bf8100bd43c07f5efe6d92148ba6c5a7a712d510c6f24be85af6571d5eb  golangci-lint-1.61.0-netbsd-386.tar.gz
-b8bb07c920f6601edf718d5e82ec0784fd590b0992b42b6ec18da99f26013ed4  golangci-lint-1.61.0-netbsd-amd64.tar.gz
-353a51527c60bd0776b0891b03f247c791986f625fca689d121972c624e54198  golangci-lint-1.61.0-netbsd-arm64.tar.gz
-957a6272c3137910514225704c5dac0723b9c65eb7d9587366a997736e2d7580  golangci-lint-1.61.0-netbsd-armv6.tar.gz
-a89eb28ff7f18f5cd52b914739360fa95cf2f643de4adeca46e26bec3a07e8d8  golangci-lint-1.61.0-netbsd-armv7.tar.gz
-d8d74c43600b271393000717a4ed157d7a15bb85bab7db2efad9b63a694d4634  golangci-lint-1.61.0-windows-386.zip
-e7bc2a81929a50f830244d6d2e657cce4f19a59aff49fa9000176ff34fda64ce  golangci-lint-1.61.0-windows-amd64.zip
-ed97c221596dd771e3dd9344872c140340bee2e819cd7a90afa1de752f1f2e0f  golangci-lint-1.61.0-windows-arm64.zip
-4b365233948b13d02d45928a5c390045e00945e919747b9887b5f260247541ae  golangci-lint-1.61.0-windows-armv6.zip
-595538fb64d152173959d28f6235227f9cd969a828e5af0c4e960d02af4ffd0e  golangci-lint-1.61.0-windows-armv7.zip
+# https://github.com/golangci/golangci-lint/releases/download/v1.55.2/
+632e96e6d5294fbbe7b2c410a49c8fa01c60712a0af85a567de85bcc1623ea21  golangci-lint-1.55.2-darwin-amd64.tar.gz
+234463f059249f82045824afdcdd5db5682d0593052f58f6a3039a0a1c3899f6  golangci-lint-1.55.2-darwin-arm64.tar.gz
+2bdd105e2d4e003a9058c33a22bb191a1e0f30fa0790acca0d8fbffac1d6247c  golangci-lint-1.55.2-freebsd-386.tar.gz
+e75056e8b082386676ce23eba455cf893931a792c0d87e1e3743c0aec33c7fb5  golangci-lint-1.55.2-freebsd-amd64.tar.gz
+5789b933facaf6136bd23f1d50add67b79bbcf8dfdfc9069a37f729395940a66  golangci-lint-1.55.2-freebsd-armv6.tar.gz
+7f21ab1008d05f32c954f99470fc86a83a059e530fe2add1d0b7d8ed4d8992a7  golangci-lint-1.55.2-freebsd-armv7.tar.gz
+33ab06139b9219a28251f10821da94423db30285cc2af97494cbb2a281927de9  golangci-lint-1.55.2-illumos-amd64.tar.gz
+57ce6f8ce3ad6ee45d7cc3d9a047545a851c2547637834a3fcb086c7b40b1e6b  golangci-lint-1.55.2-linux-386.tar.gz
+ca21c961a33be3bc15e4292dc40c98c8dcc5463a7b6768a3afc123761630c09c  golangci-lint-1.55.2-linux-amd64.tar.gz
+8eb0cee9b1dbf0eaa49871798c7f8a5b35f2960c52d776a5f31eb7d886b92746  golangci-lint-1.55.2-linux-arm64.tar.gz
+3195f3e0f37d353fd5bd415cabcd4e263f5c29d3d0ffb176c26ff3d2c75eb3bb  golangci-lint-1.55.2-linux-armv6.tar.gz
+c823ee36eb1a719e171de1f2f5ca3068033dce8d9817232fd10ed71fd6650406  golangci-lint-1.55.2-linux-armv7.tar.gz
+758a5d2a356dc494bd13ed4c0d4bf5a54a4dc91267ea5ecdd87b86c7ca0624e7  golangci-lint-1.55.2-linux-loong64.tar.gz
+2c7b9abdce7cae802a67d583cd7c6dca520bff6d0e17c8535a918e2f2b437aa0  golangci-lint-1.55.2-linux-mips64.tar.gz
+024e0a15b85352cc27271285526e16a4ab66d3e67afbbe446c9808c06cb8dbed  golangci-lint-1.55.2-linux-mips64le.tar.gz
+6b00f89ba5506c1de1efdd9fa17c54093013a294fefd8b9b31534db626a672ee  golangci-lint-1.55.2-linux-ppc64le.tar.gz
+0faa0d047d9bf7b703ed3ea65b6117043c93504f9ca1de25ae929d3901c73d4a  golangci-lint-1.55.2-linux-riscv64.tar.gz
+30dec9b22e7d5bb4e9d5ccea96da20f71cd7db3c8cf30b8ddc7cb9174c4d742a  golangci-lint-1.55.2-linux-s390x.tar.gz
+5a0ede48f79ad707902fdb29be8cd2abd8302dc122b65ebae3fdfc86751c7698  golangci-lint-1.55.2-netbsd-386.tar.gz
+95af20a2e617126dd5b08122ece7819101070e1582a961067ce8c41172f901ad  golangci-lint-1.55.2-netbsd-amd64.tar.gz
+94fb7dacb7527847cc95d7120904e19a2a0a81a0d50d61766c9e0251da72ab9d  golangci-lint-1.55.2-netbsd-armv6.tar.gz
+ca906bce5fee9619400e4a321c56476fe4a4efb6ac4fc989d340eb5563348873  golangci-lint-1.55.2-netbsd-armv7.tar.gz
+45b442f69fc8915c4500201c0247b7f3f69544dbc9165403a61f9095f2c57355  golangci-lint-1.55.2-windows-386.zip
+f57d434d231d43417dfa631587522f8c1991220b43c8ffadb9c7bd279508bf81  golangci-lint-1.55.2-windows-amd64.zip
+fd7dc8f4c6829ee6fafb252a4d81d2155cd35da7833665cbb25d53ce7cecd990  golangci-lint-1.55.2-windows-arm64.zip
+1892c3c24f9e7ef44b02f6750c703864b6dc350129f3ec39510300007b2376f1  golangci-lint-1.55.2-windows-armv6.zip
+a5e68ae73d38748b5269fad36ac7575e3c162a5dc63ef58abdea03cc5da4522a  golangci-lint-1.55.2-windows-armv7.zip

 # This is the builder on PPA that will build Go itself (inception-y), don't modify!
 #
 # This version is fine to be old and full of security holes, we just use it
-# to build the latest Go. Don't change it.
+# to build the latest Go. Don't change it. If it ever becomes insufficient,
+# we need to switch over to a recursive builder to jump across supported
+# versions.
 #
-# version:ppa-builder-1 1.19.6
+# version:ppa-builder 1.19.6
 # https://go.dev/dl/
 d7f0013f82e6d7f862cc6cb5c8cdb48eef5f2e239b35baa97e2f1a7466043767  go1.19.6.src.tar.gz
-
-# version:ppa-builder-2 1.21.9
-# https://go.dev/dl/
-58f0c5ced45a0012bce2ff7a9df03e128abcc8818ebabe5027bb92bafe20e421  go1.21.9.src.tar.gz
-
-# version:protoc 27.1
-# https://github.com/protocolbuffers/protobuf/releases/
-# https://github.com/protocolbuffers/protobuf/releases/download/v27.1/
-8809c2ec85368c6b6e9af161b6771a153aa92670a24adbe46dd34fa02a04df2f  protoc-27.1-linux-aarch_64.zip
-5d21979a6d27475e810b76b88863d1e784fa01ffb15e511a3ec5bd1924d89426  protoc-27.1-linux-ppcle_64.zip
-84d8852750ed186dc4a057a1a86bcac409be5362d6af04770f42367fee6b7bc1  protoc-27.1-linux-s390_64.zip
-2f028796ff5741691650e0eea290e61ff2f1c0d87f8d31fe45ef47fd967cef0c  protoc-27.1-linux-x86_32.zip
-8970e3d8bbd67d53768fe8c2e3971bdd71e51cfe2001ca06dacad17258a7dae3  protoc-27.1-linux-x86_64.zip
-03b7af1bf469e7285dc51976ee5fa99412704dbd1c017105114852a37b165c12  protoc-27.1-osx-aarch_64.zip
-f14d3973cf13283d07c520ed6f4c12405ad41b9efd18089a1c74897037d742b5  protoc-27.1-osx-universal_binary.zip
-8520d944f3a3890fa296a3b3b0d4bb18337337e2526bbbf1b507eeea3c2a1ec4  protoc-27.1-osx-x86_64.zip
-6263718ff96547b8392a079f6fdf02a4156f2e8d13cd51649a0d03fb7afa2de8  protoc-27.1-win32.zip
-da531c51ccd1290d8d34821f0ce4e219c7fbaa6f9825f5a3fb092a9d03fe6206  protoc-27.1-win64.zip
-
-# version:protoc-gen-go 1.34.2
-# https://github.com/protocolbuffers/protobuf-go/releases/
-# https://github.com/protocolbuffers/protobuf-go/releases/download/v1.34.2/
-9b48d8f90add02e8e94e14962fed74e7ce2b2d6bda4dd42f1f4fbccf0f766f1a  protoc-gen-go.v1.34.2.darwin.amd64.tar.gz
-17aca7f948dbb624049030cf841e35895cf34183ba006e721247fdeb95ff2780  protoc-gen-go.v1.34.2.darwin.arm64.tar.gz
-a191849433fd489f1d44f37788d762658f3f5fb225f3a85d4ce6ba32666703ed  protoc-gen-go.v1.34.2.linux.386.tar.gz
-b87bc134dee55576a842141bf0ed27761c635d746780fce5dee038c6dd16554f  protoc-gen-go.v1.34.2.linux.amd64.tar.gz
-63d400167e75ab9f6690688f6fdc6a9455aa20bc1faa71e32149dbd322f7f198  protoc-gen-go.v1.34.2.linux.arm64.tar.gz
-56e7675816db6e62be4f833a51544d5716b8420c462515579e05ca8444ab06ed  protoc-gen-go.v1.34.2.windows.386.zip
-abafd39612177dd4e9a65207cadd5374a9352d8611e8e040f8462fcfa3010daf  protoc-gen-go.v1.34.2.windows.amd64.zip
--- a/build/ci.go
+++ b/build/ci.go
@@ -24,14 +24,9 @@ Usage: go run build/ci.go <command> <command flags/arguments>

 Available commands are:

-	lint           -- runs certain pre-selected linters
-	check_tidy     -- verifies that everything is 'go mod tidy'-ed
-	check_generate -- verifies that everything is 'go generate'-ed
-	check_baddeps  -- verifies that certain dependencies are avoided
-
 	install    [ -arch architecture ] [ -cc compiler ] [ packages... ]                          -- builds packages and executables
 	test       [ -coverage ] [ packages... ]                                                    -- runs the tests
-
+	lint                                                                                        -- runs certain pre-selected linters
 	archive    [ -arch architecture ] [ -type zip|tar ] [ -signer key-envvar ] [ -signify key-envvar ] [ -upload dest ] -- archives build artifacts
 	importkeys                                                                                  -- imports signing keys from env
 	debsrc     [ -signer key-id ] [ -upload dest ]                                              -- creates a debian source package
@@ -53,13 +48,15 @@ import (
 	"path"
 	"path/filepath"
 	"runtime"
+	"strconv"
 	"strings"
 	"time"

 	"github.com/cespare/cp"
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto/signify"
 	"github.com/ethereum/go-ethereum/internal/build"
-	"github.com/ethereum/go-ethereum/internal/version"
+	"github.com/ethereum/go-ethereum/params"
 )

 var (
@@ -111,7 +108,7 @@ var (
 	// A debian package is created for all executables listed here.
 	debEthereum = debPackage{
 		Name:        "ethereum",
-		Version:     version.Semantic,
+		Version:     params.Version,
 		Executables: debExecutables,
 	}

@@ -120,14 +117,23 @@ var (
 		debEthereum,
 	}

-	// Distros for which packages are created
-	debDistros = []string{
-		"xenial",   // 16.04, EOL: 04/2026
-		"bionic",   // 18.04, EOL: 04/2028
-		"focal",    // 20.04, EOL: 04/2030
-		"jammy",    // 22.04, EOL: 04/2032
-		"noble",    // 24.04, EOL: 04/2034
-		"oracular", // 24.10, EOL: 07/2025
+	// Distros for which packages are created.
+	// Note: vivid is unsupported because there is no golang-1.6 package for it.
+	// Note: the following Ubuntu releases have been officially deprecated on Launchpad:
+	//   wily, yakkety, zesty, artful, cosmic, disco, eoan, groovy, hirsuite, impish,
+	//   kinetic, lunar
+	debDistroGoBoots = map[string]string{
+		"trusty": "golang-1.11", // 14.04, EOL: 04/2024
+		"xenial": "golang-go",   // 16.04, EOL: 04/2026
+		"bionic": "golang-go",   // 18.04, EOL: 04/2028
+		"focal":  "golang-go",   // 20.04, EOL: 04/2030
+		"jammy":  "golang-go",   // 22.04, EOL: 04/2032
+		"mantic": "golang-go",   // 23.10, EOL: 07/2024
+	}
+
+	debGoBootPaths = map[string]string{
+		"golang-1.11": "/usr/lib/go-1.11",
+		"golang-go":   "/usr/lib/go",
 	}

 	// This is where the tests should be unpacked.
@@ -146,7 +152,7 @@ func executablePath(name string) string {
 func main() {
 	log.SetFlags(log.Lshortfile)

-	if !build.FileExist(filepath.Join("build", "ci.go")) {
+	if !common.FileExist(filepath.Join("build", "ci.go")) {
 		log.Fatal("this script must be run from the root of the repository")
 	}
 	if len(os.Args) < 2 {
@@ -159,16 +165,10 @@ func main() {
 		doTest(os.Args[2:])
 	case "lint":
 		doLint(os.Args[2:])
-	case "check_tidy":
-		doCheckTidy()
-	case "check_generate":
-		doCheckGenerate()
-	case "check_baddeps":
-		doCheckBadDeps()
 	case "archive":
 		doArchive(os.Args[2:])
-	case "dockerx":
-		doDockerBuildx(os.Args[2:])
+	case "docker":
+		doDocker(os.Args[2:])
 	case "debsrc":
 		doDebianSource(os.Args[2:])
 	case "nsis":
@@ -211,6 +211,12 @@ func doInstall(cmdline []string) {
 	// Configure the build.
 	gobuild := tc.Go("build", buildFlags(env, *staticlink, buildTags)...)

+	// arm64 CI builders are memory-constrained and can't handle concurrent builds,
+	// better disable it. This check isn't the best, it should probably
+	// check for something in env instead.
+	if env.CI && runtime.GOARCH == "arm64" {
+		gobuild.Args = append(gobuild.Args, "-p", "1")
+	}
 	// We use -trimpath to avoid leaking local paths into the built executables.
 	gobuild.Args = append(gobuild.Args, "-trimpath")

@@ -237,10 +243,6 @@ func doInstall(cmdline []string) {
 // buildFlags returns the go tool flags for building.
 func buildFlags(env build.Environment, staticLinking bool, buildTags []string) (flags []string) {
 	var ld []string
-	// See https://github.com/golang/go/issues/33772#issuecomment-528176001
-	// We need to set --buildid to the linker here, and also pass --build-id to the
-	// cgo-linker further down.
-	ld = append(ld, "--buildid=none")
 	if env.Commit != "" {
 		ld = append(ld, "-X", "github.com/ethereum/go-ethereum/internal/version.gitCommit="+env.Commit)
 		ld = append(ld, "-X", "github.com/ethereum/go-ethereum/internal/version.gitDate="+env.Date)
@@ -253,11 +255,7 @@ func buildFlags(env build.Environment, staticLinking bool, buildTags []string) (
 	if runtime.GOOS == "linux" {
 		// Enforce the stacksize to 8M, which is the case on most platforms apart from
 		// alpine Linux.
-		// See https://sourceware.org/binutils/docs-2.23.1/ld/Options.html#Options
-		// regarding the options --build-id=none and --strip-all. It is needed for
-		// reproducible builds; removing references to temporary files in C-land, and
-		// making build-id reproducably absent.
-		extld := []string{"-Wl,-z,stack-size=0x800000,--build-id=none,--strip-all"}
+		extld := []string{"-Wl,-z,stack-size=0x800000"}
 		if staticLinking {
 			extld = append(extld, "-static")
 			// Under static linking, use of certain glibc features must be
@@ -304,7 +302,7 @@ func doTest(cmdline []string) {
 	gotest := tc.Go("test")

 	// CI needs a bit more time for the statetests (default 10m).
-	gotest.Args = append(gotest.Args, "-timeout=30m")
+	gotest.Args = append(gotest.Args, "-timeout=20m")

 	// Enable CKZG backend in CI.
 	gotest.Args = append(gotest.Args, "-tags=ckzg")
@@ -355,95 +353,6 @@ func downloadSpecTestFixtures(csdb *build.ChecksumDB, cachedir string) string {
 	return filepath.Join(cachedir, base)
 }

-// doCheckTidy assets that the Go modules files are tidied already.
-func doCheckTidy() {
-	targets := []string{"go.mod", "go.sum"}
-
-	hashes, err := build.HashFiles(targets)
-	if err != nil {
-		log.Fatalf("failed to hash go.mod/go.sum: %v", err)
-	}
-	build.MustRun(new(build.GoToolchain).Go("mod", "tidy"))
-
-	tidied, err := build.HashFiles(targets)
-	if err != nil {
-		log.Fatalf("failed to rehash go.mod/go.sum: %v", err)
-	}
-	if updates := build.DiffHashes(hashes, tidied); len(updates) > 0 {
-		log.Fatalf("files changed on running 'go mod tidy': %v", updates)
-	}
-	fmt.Println("No untidy module files detected.")
-}
-
-// doCheckGenerate ensures that re-generating generated files does not cause
-// any mutations in the source file tree.
-func doCheckGenerate() {
-	var (
-		cachedir = flag.String("cachedir", "./build/cache", "directory for caching binaries.")
-	)
-	// Compute the origin hashes of all the files
-	var hashes map[string][32]byte
-
-	var err error
-	hashes, err = build.HashFolder(".", []string{"tests/testdata", "build/cache"})
-	if err != nil {
-		log.Fatal("Error computing hashes", "err", err)
-	}
-	// Run any go generate steps we might be missing
-	var (
-		protocPath      = downloadProtoc(*cachedir)
-		protocGenGoPath = downloadProtocGenGo(*cachedir)
-	)
-	c := new(build.GoToolchain).Go("generate", "./...")
-	pathList := []string{filepath.Join(protocPath, "bin"), protocGenGoPath, os.Getenv("PATH")}
-	c.Env = append(c.Env, "PATH="+strings.Join(pathList, string(os.PathListSeparator)))
-	build.MustRun(c)
-
-	// Check if generate file hashes have changed
-	generated, err := build.HashFolder(".", []string{"tests/testdata", "build/cache"})
-	if err != nil {
-		log.Fatalf("Error re-computing hashes: %v", err)
-	}
-	updates := build.DiffHashes(hashes, generated)
-	for _, file := range updates {
-		log.Printf("File changed: %s", file)
-	}
-	if len(updates) != 0 {
-		log.Fatal("One or more generated files were updated by running 'go generate ./...'")
-	}
-	fmt.Println("No stale files detected.")
-}
-
-// doCheckBadDeps verifies whether certain unintended dependencies between some
-// packages leak into the codebase due to a refactor. This is not an exhaustive
-// list, rather something we build up over time at sensitive places.
-func doCheckBadDeps() {
-	baddeps := [][2]string{
-		// Rawdb tends to be a dumping ground for db utils, sometimes leaking the db itself
-		{"github.com/ethereum/go-ethereum/core/rawdb", "github.com/ethereum/go-ethereum/ethdb/leveldb"},
-		{"github.com/ethereum/go-ethereum/core/rawdb", "github.com/ethereum/go-ethereum/ethdb/pebbledb"},
-	}
-	tc := new(build.GoToolchain)
-
-	var failed bool
-	for _, rule := range baddeps {
-		out, err := tc.Go("list", "-deps", rule[0]).CombinedOutput()
-		if err != nil {
-			log.Fatalf("Failed to list '%s' dependencies: %v", rule[0], err)
-		}
-		for _, line := range strings.Split(string(out), "\n") {
-			if strings.TrimSpace(line) == rule[1] {
-				log.Printf("Found bad dependency '%s' -> '%s'", rule[0], rule[1])
-				failed = true
-			}
-		}
-	}
-	if failed {
-		log.Fatalf("Bad dependencies detected.")
-	}
-	fmt.Println("No bad dependencies detected.")
-}
-
 // doLint runs golangci-lint on requested packages.
 func doLint(cmdline []string) {
 	var (
@@ -489,96 +398,6 @@ func downloadLinter(cachedir string) string {
 	return filepath.Join(cachedir, base, "golangci-lint")
 }

-// protocArchiveBaseName returns the name of the protoc archive file for
-// the current system, stripped of version and file suffix.
-func protocArchiveBaseName() (string, error) {
-	switch runtime.GOOS + "-" + runtime.GOARCH {
-	case "windows-amd64":
-		return "win64", nil
-	case "windows-386":
-		return "win32", nil
-	case "linux-arm64":
-		return "linux-aarch_64", nil
-	case "linux-386":
-		return "linux-x86_32", nil
-	case "linux-amd64":
-		return "linux-x86_64", nil
-	case "darwin-arm64":
-		return "osx-aarch_64", nil
-	case "darwin-amd64":
-		return "osx-x86_64", nil
-	default:
-		return "", fmt.Errorf("no prebuilt release of protoc available for this system (os: %s, arch: %s)", runtime.GOOS, runtime.GOARCH)
-	}
-}
-
-// downloadProtocGenGo downloads protoc-gen-go, which is used by protoc
-// in the generate command.  It returns the full path of the directory
-// containing the 'protoc-gen-go' executable.
-func downloadProtocGenGo(cachedir string) string {
-	csdb := build.MustLoadChecksums("build/checksums.txt")
-	version, err := build.Version(csdb, "protoc-gen-go")
-	if err != nil {
-		log.Fatal(err)
-	}
-	baseName := fmt.Sprintf("protoc-gen-go.v%s.%s.%s", version, runtime.GOOS, runtime.GOARCH)
-	archiveName := baseName
-	if runtime.GOOS == "windows" {
-		archiveName += ".zip"
-	} else {
-		archiveName += ".tar.gz"
-	}
-
-	url := fmt.Sprintf("https://github.com/protocolbuffers/protobuf-go/releases/download/v%s/%s", version, archiveName)
-
-	archivePath := path.Join(cachedir, archiveName)
-	if err := csdb.DownloadFile(url, archivePath); err != nil {
-		log.Fatal(err)
-	}
-	extractDest := filepath.Join(cachedir, baseName)
-	if err := build.ExtractArchive(archivePath, extractDest); err != nil {
-		log.Fatal(err)
-	}
-	extractDest, err = filepath.Abs(extractDest)
-	if err != nil {
-		log.Fatal("error resolving absolute path for protoc", "err", err)
-	}
-	return extractDest
-}
-
-// downloadProtoc downloads the prebuilt protoc binary used to lint generated
-// files as a CI step.  It returns the full path to the directory containing
-// the protoc executable.
-func downloadProtoc(cachedir string) string {
-	csdb := build.MustLoadChecksums("build/checksums.txt")
-	version, err := build.Version(csdb, "protoc")
-	if err != nil {
-		log.Fatal(err)
-	}
-	baseName, err := protocArchiveBaseName()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	fileName := fmt.Sprintf("protoc-%s-%s", version, baseName)
-	archiveFileName := fileName + ".zip"
-	url := fmt.Sprintf("https://github.com/protocolbuffers/protobuf/releases/download/v%s/%s", version, archiveFileName)
-	archivePath := filepath.Join(cachedir, archiveFileName)
-
-	if err := csdb.DownloadFile(url, archivePath); err != nil {
-		log.Fatal(err)
-	}
-	extractDest := filepath.Join(cachedir, fileName)
-	if err := build.ExtractArchive(archivePath, extractDest); err != nil {
-		log.Fatal(err)
-	}
-	extractDest, err = filepath.Abs(extractDest)
-	if err != nil {
-		log.Fatal("error resolving absolute path for protoc", "err", err)
-	}
-	return extractDest
-}
-
 // Release Packaging
 func doArchive(cmdline []string) {
 	var (
@@ -601,7 +420,7 @@ func doArchive(cmdline []string) {

 	var (
 		env      = build.Env()
-		basegeth = archiveBasename(*arch, version.Archive(env.Commit))
+		basegeth = archiveBasename(*arch, params.ArchiveVersion(env.Commit))
 		geth     = "geth-" + basegeth + ext
 		alltools = "geth-alltools-" + basegeth + ext
 	)
@@ -686,9 +505,10 @@ func maybeSkipArchive(env build.Environment) {
 }

 // Builds the docker images and optionally uploads them to Docker Hub.
-func doDockerBuildx(cmdline []string) {
+func doDocker(cmdline []string) {
 	var (
-		platform = flag.String("platform", "", `Push a multi-arch docker image for the specified architectures (usually "linux/amd64,linux/arm64")`)
+		image    = flag.Bool("image", false, `Whether to build and push an arch specific docker image`)
+		manifest = flag.String("manifest", "", `Push a multi-arch docker image for the specified architectures (usually "amd64,arm64")`)
 		upload   = flag.String("upload", "", `Where to upload the docker image (usually "ethereum/client-go")`)
 	)
 	flag.CommandLine.Parse(cmdline)
@@ -721,28 +541,131 @@ func doDockerBuildx(cmdline []string) {
 	case env.Branch == "master":
 		tags = []string{"latest"}
 	case strings.HasPrefix(env.Tag, "v1."):
-		tags = []string{"stable", fmt.Sprintf("release-%v", version.Family), "v" + version.Semantic}
+		tags = []string{"stable", fmt.Sprintf("release-1.%d", params.VersionMinor), "v" + params.Version}
 	}
-	// Need to create a mult-arch builder
-	build.MustRunCommand("docker", "buildx", "create", "--use", "--name", "multi-arch-builder", "--platform", *platform)
+	// If architecture specific image builds are requested, build and push them
+	if *image {
+		build.MustRunCommand("docker", "build", "--build-arg", "COMMIT="+env.Commit, "--build-arg", "VERSION="+params.VersionWithMeta, "--build-arg", "BUILDNUM="+env.Buildnum, "--tag", fmt.Sprintf("%s:TAG", *upload), ".")
+		build.MustRunCommand("docker", "build", "--build-arg", "COMMIT="+env.Commit, "--build-arg", "VERSION="+params.VersionWithMeta, "--build-arg", "BUILDNUM="+env.Buildnum, "--tag", fmt.Sprintf("%s:alltools-TAG", *upload), "-f", "Dockerfile.alltools", ".")

-	for _, spec := range []struct {
-		file string
-		base string
-	}{
-		{file: "Dockerfile", base: fmt.Sprintf("%s:", *upload)},
-		{file: "Dockerfile.alltools", base: fmt.Sprintf("%s:alltools-", *upload)},
-	} {
-		for _, tag := range tags { // latest, stable etc
-			gethImage := fmt.Sprintf("%s%s", spec.base, tag)
-			build.MustRunCommand("docker", "buildx", "build",
-				"--build-arg", "COMMIT="+env.Commit,
-				"--build-arg", "VERSION="+version.WithMeta,
-				"--build-arg", "BUILDNUM="+env.Buildnum,
-				"--tag", gethImage,
-				"--platform", *platform,
-				"--push",
-				"--file", spec.file, ".")
+		// Tag and upload the images to Docker Hub
+		for _, tag := range tags {
+			gethImage := fmt.Sprintf("%s:%s-%s", *upload, tag, runtime.GOARCH)
+			toolImage := fmt.Sprintf("%s:alltools-%s-%s", *upload, tag, runtime.GOARCH)
+
+			// If the image already exists (non version tag), check the build
+			// number to prevent overwriting a newer commit if concurrent builds
+			// are running. This is still a tiny bit racey if two published are
+			// done at the same time, but that's extremely unlikely even on the
+			// master branch.
+			for _, img := range []string{gethImage, toolImage} {
+				if exec.Command("docker", "pull", img).Run() != nil {
+					continue // Generally the only failure is a missing image, which is good
+				}
+				buildnum, err := exec.Command("docker", "inspect", "--format", "{{index .Config.Labels \"buildnum\"}}", img).CombinedOutput()
+				if err != nil {
+					log.Fatalf("Failed to inspect container: %v\nOutput: %s", err, string(buildnum))
+				}
+				buildnum = bytes.TrimSpace(buildnum)
+
+				if len(buildnum) > 0 && len(env.Buildnum) > 0 {
+					oldnum, err := strconv.Atoi(string(buildnum))
+					if err != nil {
+						log.Fatalf("Failed to parse old image build number: %v", err)
+					}
+					newnum, err := strconv.Atoi(env.Buildnum)
+					if err != nil {
+						log.Fatalf("Failed to parse current build number: %v", err)
+					}
+					if oldnum > newnum {
+						log.Fatalf("Current build number %d not newer than existing %d", newnum, oldnum)
+					} else {
+						log.Printf("Updating %s from build %d to %d", img, oldnum, newnum)
+					}
+				}
+			}
+			build.MustRunCommand("docker", "image", "tag", fmt.Sprintf("%s:TAG", *upload), gethImage)
+			build.MustRunCommand("docker", "image", "tag", fmt.Sprintf("%s:alltools-TAG", *upload), toolImage)
+			build.MustRunCommand("docker", "push", gethImage)
+			build.MustRunCommand("docker", "push", toolImage)
+		}
+	}
+	// If multi-arch image manifest push is requested, assemble it
+	if len(*manifest) != 0 {
+		// Since different architectures are pushed by different builders, wait
+		// until all required images are updated.
+		var mismatch bool
+		for i := 0; i < 2; i++ { // 2 attempts, second is race check
+			mismatch = false // hope there's no mismatch now
+
+			for _, tag := range tags {
+				for _, arch := range strings.Split(*manifest, ",") {
+					gethImage := fmt.Sprintf("%s:%s-%s", *upload, tag, arch)
+					toolImage := fmt.Sprintf("%s:alltools-%s-%s", *upload, tag, arch)
+
+					for _, img := range []string{gethImage, toolImage} {
+						if out, err := exec.Command("docker", "pull", img).CombinedOutput(); err != nil {
+							log.Printf("Required image %s unavailable: %v\nOutput: %s", img, err, out)
+							mismatch = true
+							break
+						}
+						buildnum, err := exec.Command("docker", "inspect", "--format", "{{index .Config.Labels \"buildnum\"}}", img).CombinedOutput()
+						if err != nil {
+							log.Fatalf("Failed to inspect container: %v\nOutput: %s", err, string(buildnum))
+						}
+						buildnum = bytes.TrimSpace(buildnum)
+
+						if string(buildnum) != env.Buildnum {
+							log.Printf("Build number mismatch on %s: want %s, have %s", img, env.Buildnum, buildnum)
+							mismatch = true
+							break
+						}
+					}
+					if mismatch {
+						break
+					}
+				}
+				if mismatch {
+					break
+				}
+			}
+			if mismatch {
+				// Build numbers mismatching, retry in a short time to
+				// avoid concurrent fails in both publisher images. If
+				// however the retry failed too, it means the concurrent
+				// builder is still crunching, let that do the publish.
+				if i == 0 {
+					time.Sleep(30 * time.Second)
+				}
+				continue
+			}
+			break
+		}
+		if mismatch {
+			log.Println("Relinquishing publish to other builder")
+			return
+		}
+		// Assemble and push the Geth manifest image
+		for _, tag := range tags {
+			gethImage := fmt.Sprintf("%s:%s", *upload, tag)
+
+			var gethSubImages []string
+			for _, arch := range strings.Split(*manifest, ",") {
+				gethSubImages = append(gethSubImages, gethImage+"-"+arch)
+			}
+			build.MustRunCommand("docker", append([]string{"manifest", "create", gethImage}, gethSubImages...)...)
+			build.MustRunCommand("docker", "manifest", "push", gethImage)
+		}
+		// Assemble and push the alltools manifest image
+		for _, tag := range tags {
+			toolImage := fmt.Sprintf("%s:alltools-%s", *upload, tag)
+
+			var toolSubImages []string
+			for _, arch := range strings.Split(*manifest, ",") {
+				toolSubImages = append(toolSubImages, toolImage+"-"+arch)
+			}
+			build.MustRunCommand("docker", append([]string{"manifest", "create", toolImage}, toolSubImages...)...)
+			build.MustRunCommand("docker", "manifest", "push", toolImage)
 		}
 	}
 }
@@ -771,7 +694,7 @@ func doDebianSource(cmdline []string) {
 	}
 	// Download and verify the Go source packages.
 	var (
-		gobootbundles = downloadGoBootstrapSources(*cachedir)
+		gobootbundle = downloadGoBootstrapSources(*cachedir)
 		gobundle     = downloadGoSources(*cachedir)
 	)
 	// Download all the dependencies needed to build the sources and run the ci script
@@ -785,20 +708,18 @@ func doDebianSource(cmdline []string) {

 	// Create Debian packages and upload them.
 	for _, pkg := range debPackages {
-		for _, distro := range debDistros {
+		for distro, goboot := range debDistroGoBoots {
 			// Prepare the debian package with the go-ethereum sources.
-			meta := newDebMetadata(distro, *signer, env, now, pkg.Name, pkg.Version, pkg.Executables)
+			meta := newDebMetadata(distro, goboot, *signer, env, now, pkg.Name, pkg.Version, pkg.Executables)
 			pkgdir := stageDebianSource(*workdir, meta)

 			// Add bootstrapper Go source code
-			for i, gobootbundle := range gobootbundles {
 			if err := build.ExtractArchive(gobootbundle, pkgdir); err != nil {
 				log.Fatalf("Failed to extract bootstrapper Go sources: %v", err)
 			}
-				if err := os.Rename(filepath.Join(pkgdir, "go"), filepath.Join(pkgdir, fmt.Sprintf(".goboot-%d", i+1))); err != nil {
+			if err := os.Rename(filepath.Join(pkgdir, "go"), filepath.Join(pkgdir, ".goboot")); err != nil {
 				log.Fatalf("Failed to rename bootstrapper Go source folder: %v", err)
 			}
-			}
 			// Add builder Go source code
 			if err := build.ExtractArchive(gobundle, pkgdir); err != nil {
 				log.Fatalf("Failed to extract builder Go sources: %v", err)
@@ -833,14 +754,11 @@ func doDebianSource(cmdline []string) {
 	}
 }

-// downloadGoBootstrapSources downloads the Go source tarball(s) that will be used
+// downloadGoBootstrapSources downloads the Go source tarball that will be used
 // to bootstrap the builder Go.
-func downloadGoBootstrapSources(cachedir string) []string {
+func downloadGoBootstrapSources(cachedir string) string {
 	csdb := build.MustLoadChecksums("build/checksums.txt")
-
-	var bundles []string
-	for _, booter := range []string{"ppa-builder-1", "ppa-builder-2"} {
-		gobootVersion, err := build.Version(csdb, booter)
+	gobootVersion, err := build.Version(csdb, "ppa-builder")
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -850,9 +768,7 @@ func downloadGoBootstrapSources(cachedir string) []string {
 	if err := csdb.DownloadFile(url, dst); err != nil {
 		log.Fatal(err)
 	}
-		bundles = append(bundles, dst)
-	}
-	return bundles
+	return dst
 }

 // downloadGoSources downloads the Go source tarball.
@@ -884,7 +800,7 @@ func ppaUpload(workdir, ppa, sshUser string, files []string) {
 	var idfile string
 	if sshkey := getenvBase64("PPA_SSH_KEY"); len(sshkey) > 0 {
 		idfile = filepath.Join(workdir, "sshkey")
-		if !build.FileExist(idfile) {
+		if !common.FileExist(idfile) {
 			os.WriteFile(idfile, sshkey, 0600)
 		}
 	}
@@ -931,6 +847,9 @@ type debPackage struct {

 type debMetadata struct {
 	Env           build.Environment
+	GoBootPackage string
+	GoBootPath    string
+
 	PackageName string

 	// go-ethereum version being built. Note that this
@@ -958,12 +877,14 @@ func (d debExecutable) Package() string {
 	return d.BinaryName
 }

-func newDebMetadata(distro, author string, env build.Environment, t time.Time, name string, version string, exes []debExecutable) debMetadata {
+func newDebMetadata(distro, goboot, author string, env build.Environment, t time.Time, name string, version string, exes []debExecutable) debMetadata {
 	if author == "" {
 		// No signing key, use default author.
 		author = "Ethereum Builds <fjl@ethereum.org>"
 	}
 	return debMetadata{
+		GoBootPackage: goboot,
+		GoBootPath:    debGoBootPaths[goboot],
 		PackageName:   name,
 		Env:           env,
 		Author:        author,
@@ -1109,19 +1030,19 @@ func doWindowsInstaller(cmdline []string) {
 	// Build the installer. This assumes that all the needed files have been previously
 	// built (don't mix building and packaging to keep cross compilation complexity to a
 	// minimum).
-	ver := strings.Split(version.Semantic, ".")
+	version := strings.Split(params.Version, ".")
 	if env.Commit != "" {
-		ver[2] += "-" + env.Commit[:8]
+		version[2] += "-" + env.Commit[:8]
 	}
-	installer, err := filepath.Abs("geth-" + archiveBasename(*arch, version.Archive(env.Commit)) + ".exe")
+	installer, err := filepath.Abs("geth-" + archiveBasename(*arch, params.ArchiveVersion(env.Commit)) + ".exe")
 	if err != nil {
 		log.Fatalf("Failed to convert installer file path: %v", err)
 	}
 	build.MustRunCommand("makensis.exe",
 		"/DOUTPUTFILE="+installer,
-		"/DMAJORVERSION="+ver[0],
-		"/DMINORVERSION="+ver[1],
-		"/DBUILDVERSION="+ver[2],
+		"/DMAJORVERSION="+version[0],
+		"/DMINORVERSION="+version[1],
+		"/DBUILDVERSION="+version[2],
 		"/DARCH="+*arch,
 		filepath.Join(*workdir, "geth.nsi"),
 	)
--- a/build/deb/ethereum/deb.control
+++ b/build/deb/ethereum/deb.control
@@ -2,7 +2,7 @@ Source: {{.Name}}
 Section: science
 Priority: extra
 Maintainer: {{.Author}}
-Build-Depends: debhelper (>= 8.0.0), golang-go
+Build-Depends: debhelper (>= 8.0.0), {{.GoBootPackage}}
 Standards-Version: 3.9.5
 Homepage: https://ethereum.org
 Vcs-Git: https://github.com/ethereum/go-ethereum.git
--- a/build/deb/ethereum/deb.rules
+++ b/build/deb/ethereum/deb.rules
@@ -7,7 +7,7 @@
 # Launchpad rejects Go's access to $HOME, use custom folders
 export GOCACHE=/tmp/go-build
 export GOPATH=/tmp/gopath
-export GOROOT_BOOTSTRAP=/usr/lib/go
+export GOROOT_BOOTSTRAP={{.GoBootPath}}

 override_dh_auto_clean:
 	# Don't try to be smart Launchpad, we know our build rules better than you
@@ -19,9 +19,8 @@ override_dh_auto_build:
 	#
 	# We're also shipping the bootstrapper as of Go 1.20 as it had minimum version
 	# requirements opposed to older versions of Go.
-	(mv .goboot-1 ../ && cd ../.goboot-1/src && ./make.bash)
-	(mv .goboot-2 ../ && cd ../.goboot-2/src && GOROOT_BOOTSTRAP=`pwd`/../../.goboot-1 ./make.bash)
-	(mv .go ../ && cd ../.go/src && GOROOT_BOOTSTRAP=`pwd`/../../.goboot-2 ./make.bash)
+	(mv .goboot ../ && cd ../.goboot/src && ./make.bash)
+	(mv .go ../ && cd ../.go/src && GOROOT_BOOTSTRAP=`pwd`/../../.goboot ./make.bash)

 	# We can't download external go modules within Launchpad, so we're shipping the
 	# entire dependency source cache with go-ethereum.
--- a/build/tools/tools.go
+++ b/build/tools/tools.go
@@ -22,6 +22,6 @@ package tools
 import (
 	// Tool imports for go:generate.
 	_ "github.com/fjl/gencodec"
+	_ "github.com/golang/protobuf/protoc-gen-go"
 	_ "golang.org/x/tools/cmd/stringer"
-	_ "google.golang.org/protobuf/cmd/protoc-gen-go"
 )
--- a/build/update-license.go
+++ b/build/update-license.go
@@ -46,12 +46,13 @@ import (
 	"path/filepath"
 	"regexp"
 	"runtime"
-	"slices"
 	"strconv"
 	"strings"
 	"sync"
 	"text/template"
 	"time"
+
+	"golang.org/x/exp/slices"
 )

 var (
@@ -291,8 +292,8 @@ func writeAuthors(files []string) {
 		}
 	}
 	// Write sorted list of authors back to the file.
-	slices.SortFunc(list, func(a, b string) int {
-		return strings.Compare(strings.ToLower(a), strings.ToLower(b))
+	slices.SortFunc(list, func(a, b string) bool {
+		return strings.ToLower(a) < strings.ToLower(b)
 	})
 	content := new(bytes.Buffer)
 	content.WriteString(authorsFileHeader)
--- a/cmd/blsync/main.go
+++ b/cmd/blsync/main.go
@@ -1,105 +0,0 @@
-// Copyright 2022 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"slices"
-
-	"github.com/ethereum/go-ethereum/beacon/blsync"
-	"github.com/ethereum/go-ethereum/cmd/utils"
-	"github.com/ethereum/go-ethereum/internal/debug"
-	"github.com/ethereum/go-ethereum/internal/flags"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/node"
-	"github.com/ethereum/go-ethereum/rpc"
-	"github.com/urfave/cli/v2"
-)
-
-func main() {
-	app := flags.NewApp("beacon light syncer tool")
-	app.Flags = slices.Concat([]cli.Flag{
-		utils.BeaconApiFlag,
-		utils.BeaconApiHeaderFlag,
-		utils.BeaconThresholdFlag,
-		utils.BeaconNoFilterFlag,
-		utils.BeaconConfigFlag,
-		utils.BeaconGenesisRootFlag,
-		utils.BeaconGenesisTimeFlag,
-		utils.BeaconCheckpointFlag,
-		//TODO datadir for optional permanent database
-		utils.MainnetFlag,
-		utils.SepoliaFlag,
-		utils.HoleskyFlag,
-		utils.BlsyncApiFlag,
-		utils.BlsyncJWTSecretFlag,
-	},
-		debug.Flags,
-	)
-	app.Before = func(ctx *cli.Context) error {
-		flags.MigrateGlobalFlags(ctx)
-		return debug.Setup(ctx)
-	}
-	app.After = func(ctx *cli.Context) error {
-		debug.Exit()
-		return nil
-	}
-	app.Action = sync
-
-	if err := app.Run(os.Args); err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-}
-
-func sync(ctx *cli.Context) error {
-	// set up blsync
-	client := blsync.NewClient(ctx)
-	client.SetEngineRPC(makeRPCClient(ctx))
-	client.Start()
-
-	// run until stopped
-	<-ctx.Done()
-	client.Stop()
-	return nil
-}
-
-func makeRPCClient(ctx *cli.Context) *rpc.Client {
-	if !ctx.IsSet(utils.BlsyncApiFlag.Name) {
-		log.Warn("No engine API target specified, performing a dry run")
-		return nil
-	}
-	if !ctx.IsSet(utils.BlsyncJWTSecretFlag.Name) {
-		utils.Fatalf("JWT secret parameter missing") //TODO use default if datadir is specified
-	}
-
-	engineApiUrl, jwtFileName := ctx.String(utils.BlsyncApiFlag.Name), ctx.String(utils.BlsyncJWTSecretFlag.Name)
-	var jwtSecret [32]byte
-	if jwt, err := node.ObtainJWTSecret(jwtFileName); err == nil {
-		copy(jwtSecret[:], jwt)
-	} else {
-		utils.Fatalf("Error loading or generating JWT secret: %v", err)
-	}
-	auth := node.NewJWTAuth(jwtSecret)
-	cl, err := rpc.DialOptions(context.Background(), engineApiUrl, rpc.WithHTTPAuth(auth))
-	if err != nil {
-		utils.Fatalf("Could not create RPC client: %v", err)
-	}
-	return cl
-}
--- a/cmd/clef/README.md
+++ b/cmd/clef/README.md
@@ -29,7 +29,7 @@ GLOBAL OPTIONS:
   --loglevel value        log level to emit to the screen (default: 4)
   --keystore value        Directory for the keystore (default: "$HOME/.ethereum/keystore")
   --configdir value       Directory for Clef configuration (default: "$HOME/.clef")
-   --chainid value         Chain id to use for signing (1=mainnet, 17000=Holesky) (default: 1)
+   --chainid value         Chain id to use for signing (1=mainnet, 5=Goerli) (default: 1)
   --lightkdf              Reduce key-derivation RAM & CPU usage at some expense of KDF strength
   --nousb                 Disables monitoring for and managing USB hardware wallets
   --pcscdpath value       Path to the smartcard daemon (pcscd) socket file (default: "/run/pcscd/pcscd.comm")
@@ -225,7 +225,7 @@ Response
     - `value` [number:optional]: amount of Wei to send with the transaction
     - `data` [data:optional]:  input data
     - `nonce` [number]: account nonce
-  2. method signature [string:optional]
+  1. method signature [string:optional]
     - The method signature, if present, is to aid decoding the calldata. Should consist of `methodname(paramtype,...)`, e.g. `transfer(uint256,address)`. The signer may use this data to parse the supplied calldata, and show the user. The data, however, is considered totally untrusted, and reliability is not expected.


@@ -916,7 +916,7 @@ There are a couple of implementation for a UI. We'll try to keep this list up to

 | Name | Repo | UI type| No external resources| Blocky support| Verifies permissions | Hash information | No secondary storage | Statically linked| Can modify parameters|
 | ---- | ---- | -------| ---- | ---- | ---- |---- | ---- | ---- | ---- |
-| QtSigner| https://github.com/holiman/qtsigner/ | Python3/QT-based| :+1:| :+1:| :+1:| :+1:| :+1:| :x: |  :+1: (partially)|
-| GtkSigner| https://github.com/holiman/gtksigner | Python3/GTK-based| :+1:| :x:| :x:| :+1:| :+1:| :x: |  :x: |
-| Frame | https://github.com/floating/frame/commits/go-signer | Electron-based| :x:| :x:| :x:| :x:| ?| :x: |  :x: |
-| Clef UI| https://github.com/ethereum/clef-ui | Golang/QT-based| :+1:| :+1:| :x:| :+1:| :+1:| :x: |  :+1: (approve tx only)|
+| QtSigner| https://github.com/holiman/qtsigner/| Python3/QT-based| :+1:| :+1:| :+1:| :+1:| :+1:| :x: |  :+1: (partially)|
+| GtkSigner| https://github.com/holiman/gtksigner| Python3/GTK-based| :+1:| :x:| :x:| :+1:| :+1:| :x: |  :x: |
+| Frame | https://github.com/floating/frame/commits/go-signer| Electron-based| :x:| :x:| :x:| :x:| ?| :x: |  :x: |
+| Clef UI| https://github.com/ethereum/clef-ui| Golang/QT-based| :+1:| :+1:| :x:| :+1:| :+1:| :x: |  :+1: (approve tx only)|
--- a/cmd/clef/consolecmd_test.go
+++ b/cmd/clef/consolecmd_test.go
@@ -27,8 +27,9 @@ import (
 // TestImportRaw tests clef --importraw
 func TestImportRaw(t *testing.T) {
 	t.Parallel()
-	keyPath := filepath.Join(t.TempDir(), fmt.Sprintf("%v-tempkey.test", t.Name()))
+	keyPath := filepath.Join(os.TempDir(), fmt.Sprintf("%v-tempkey.test", t.Name()))
 	os.WriteFile(keyPath, []byte("0102030405060708090a0102030405060708090a0102030405060708090a0102"), 0777)
+	t.Cleanup(func() { os.Remove(keyPath) })

 	t.Run("happy-path", func(t *testing.T) {
 		t.Parallel()
@@ -67,8 +68,9 @@ func TestImportRaw(t *testing.T) {
 // TestListAccounts tests clef --list-accounts
 func TestListAccounts(t *testing.T) {
 	t.Parallel()
-	keyPath := filepath.Join(t.TempDir(), fmt.Sprintf("%v-tempkey.test", t.Name()))
+	keyPath := filepath.Join(os.TempDir(), fmt.Sprintf("%v-tempkey.test", t.Name()))
 	os.WriteFile(keyPath, []byte("0102030405060708090a0102030405060708090a0102030405060708090a0102"), 0777)
+	t.Cleanup(func() { os.Remove(keyPath) })

 	t.Run("no-accounts", func(t *testing.T) {
 		t.Parallel()
@@ -95,8 +97,9 @@ func TestListAccounts(t *testing.T) {
 // TestListWallets tests clef --list-wallets
 func TestListWallets(t *testing.T) {
 	t.Parallel()
-	keyPath := filepath.Join(t.TempDir(), fmt.Sprintf("%v-tempkey.test", t.Name()))
+	keyPath := filepath.Join(os.TempDir(), fmt.Sprintf("%v-tempkey.test", t.Name()))
 	os.WriteFile(keyPath, []byte("0102030405060708090a0102030405060708090a0102030405060708090a0102"), 0777)
+	t.Cleanup(func() { os.Remove(keyPath) })

 	t.Run("no-accounts", func(t *testing.T) {
 		t.Parallel()
--- a/cmd/clef/main.go
+++ b/cmd/clef/main.go
@@ -100,7 +100,7 @@ var (
 	chainIdFlag = &cli.Int64Flag{
 		Name:  "chainid",
 		Value: params.MainnetChainConfig.ChainID.Int64(),
-		Usage: "Chain id to use for signing (1=mainnet, 17000=Holesky)",
+		Usage: "Chain id to use for signing (1=mainnet, 5=Goerli)",
 	}
 	rpcPortFlag = &cli.IntFlag{
 		Name:     "http.port",
@@ -552,7 +552,7 @@ func listWallets(c *cli.Context) error {
 // accountImport imports a raw hexadecimal private key via CLI.
 func accountImport(c *cli.Context) error {
 	if c.Args().Len() != 1 {
-		return errors.New("<keyfile> must be given as first argument")
+		return errors.New("<keyfile> must be given as first argument.")
 	}
 	internalApi, ui, err := initInternalApi(c)
 	if err != nil {
--- a/cmd/clef/rules.md
+++ b/cmd/clef/rules.md
@@ -9,14 +9,14 @@ It enables usecases like the following:

 The two main features that are required for this to work well are;

-1. Rule Implementation: how to create, manage, and interpret rules in a flexible but secure manner
-2. Credential management and credentials; how to provide auto-unlock without exposing keys unnecessarily.
+1. Rule Implementation: how to create, manage and interpret rules in a flexible but secure manner
+2. Credential managements and credentials; how to provide auto-unlock without exposing keys unnecessarily.

 The section below deals with both of them

 ## Rule Implementation

-A ruleset file is implemented as a `js` file. Under the hood, the ruleset engine is a `SignerUI`, implementing the same methods as the `json-rpc` methods
+A ruleset file is implemented as a `js` file. Under the hood, the ruleset-engine is a `SignerUI`, implementing the same methods as the `json-rpc` methods
 defined in the UI protocol. Example:

 ```js
@@ -27,7 +27,7 @@ function asBig(str) {
 	return new BigNumber(str)
 }

-// Approve transactions to a certain contract if the value is below a certain limit
+// Approve transactions to a certain contract if value is below a certain limit
 function ApproveTx(req) {
 	var limit = big.Newint("0xb1a2bc2ec50000")
 	var value = asBig(req.transaction.value);
@@ -70,7 +70,7 @@ The Otto vm has a few [caveats](https://github.com/robertkrimen/otto):
 Additionally, a few more have been added

 * The rule execution cannot load external javascript files.
-* The only preloaded library is [`bignumber.js`](https://github.com/MikeMcl/bignumber.js) version `2.0.3`. This one is fairly old, and is not aligned with the documentation at the GitHub repository.
+* The only preloaded library is [`bignumber.js`](https://github.com/MikeMcl/bignumber.js) version `2.0.3`. This one is fairly old, and is not aligned with the documentation at the github repository.
 * Each invocation is made in a fresh virtual machine. This means that you cannot store data in global variables between invocations. This is a deliberate choice -- if you want to store data, use the disk-backed `storage`, since rules should not rely on ephemeral data.
 * Javascript API parameters are _always_ an object. This is also a design choice, to ensure that parameters are accessed by _key_ and not by order. This is to prevent mistakes due to missing parameters or parameter changes.
 * The JS engine has access to `storage` and `console`.
@@ -88,8 +88,8 @@ Some security precautions can be made, such as:

 ##### Security of implementation

-The drawback of this very flexible solution is that the `signer` needs to contain a javascript engine. This is pretty simple to implement since it's already
-implemented for `geth`. There are no known security vulnerabilities in it, nor have we had any security problems with it so far.
+The drawbacks of this very flexible solution is that the `signer` needs to contain a javascript engine. This is pretty simple to implement, since it's already
+implemented for `geth`. There are no known security vulnerabilities in, nor have we had any security-problems with it so far.

 The javascript engine would be an added attack surface; but if the validation of `rulesets` is made good (with hash-based attestation), the actual javascript cannot be considered
 an attack surface -- if an attacker can control the ruleset, a much simpler attack would be to implement an "always-approve" rule instead of exploiting the js vm. The only benefit
@@ -105,7 +105,7 @@ It's unclear whether any other DSL could be more secure; since there's always th

 ## Credential management

-The ability to auto-approve transactions means that the signer needs to have the necessary credentials to decrypt keyfiles. These passwords are hereafter called `ksp` (keystore pass).
+The ability to auto-approve transaction means that the signer needs to have necessary credentials to decrypt keyfiles. These passwords are hereafter called `ksp` (keystore pass).

 ### Example implementation

@@ -127,8 +127,8 @@ The `vault.dat` would be an encrypted container storing the following informatio

 ### Security considerations

-This would leave it up to the user to ensure that the `path/to/masterseed` is handled securely. It's difficult to get around this, although one could
-imagine leveraging OS-level keychains where supported. The setup is however, in general, similar to how ssh-keys are stored in `.ssh/`.
+This would leave it up to the user to ensure that the `path/to/masterseed` is handled in a secure way. It's difficult to get around this, although one could
+imagine leveraging OS-level keychains where supported. The setup is however in general similar to how ssh-keys are  stored in `.ssh/`.


 # Implementation status
@@ -149,7 +149,7 @@ function big(str) {
 // Time window: 1 week
 var window = 1000* 3600*24*7;

-// Limit: 1 ether
+// Limit : 1 ether
 var limit = new BigNumber("1e18");

 function isLimitOk(transaction) {
@@ -163,7 +163,7 @@ function isLimitOk(transaction) {
 	if (stored != "") {
 		txs = JSON.parse(stored)
 	}
-	// First, remove all that has passed out of the time window
+	// First, remove all that have passed out of the time-window
 	var newtxs = txs.filter(function(tx){return tx.tstamp > windowstart});
 	console.log(txs, newtxs.length);

@@ -174,7 +174,7 @@ function isLimitOk(transaction) {
 	console.log("ApproveTx > Sum so far", sum);
 	console.log("ApproveTx > Requested", value.toNumber());

-	// Would we exceed the weekly limit ?
+	// Would we exceed weekly limit ?
 	return sum.plus(value).lt(limit)

 }
--- a/cmd/devp2p/README.md
+++ b/cmd/devp2p/README.md
@@ -44,7 +44,7 @@ set to standard output. The following filters are supported:
 - `-limit <N>` limits the output set to N entries, taking the top N nodes by score
 - `-ip <CIDR>` filters nodes by IP subnet
 - `-min-age <duration>` filters nodes by 'first seen' time
- `-eth-network <mainnet/sepolia/holesky>` filters nodes by "eth" ENR entry
+- `-eth-network <mainnet/goerli/sepolia/holesky>` filters nodes by "eth" ENR entry
 - `-les-server` filters nodes by LES server support
 - `-snap` filters nodes by snap protocol support

--- a/cmd/devp2p/discv4cmd.go
+++ b/cmd/devp2p/discv4cmd.go
@@ -20,8 +20,6 @@ import (
 	"errors"
 	"fmt"
 	"net"
-	"net/http"
-	"slices"
 	"strconv"
 	"strings"
 	"time"
@@ -29,11 +27,10 @@ import (
 	"github.com/ethereum/go-ethereum/cmd/devp2p/internal/v4test"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/internal/flags"
 	"github.com/ethereum/go-ethereum/p2p/discover"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/params"
-	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/urfave/cli/v2"
 )

@@ -48,7 +45,6 @@ var (
 			discv4ResolveJSONCommand,
 			discv4CrawlCommand,
 			discv4TestCommand,
-			discv4ListenCommand,
 		},
 	}
 	discv4PingCommand = &cli.Command{
@@ -79,19 +75,11 @@ var (
 		Flags:     discoveryNodeFlags,
 		ArgsUsage: "<nodes.json file>",
 	}
-	discv4ListenCommand = &cli.Command{
-		Name:   "listen",
-		Usage:  "Runs a discovery node",
-		Action: discv4Listen,
-		Flags: slices.Concat(discoveryNodeFlags, []cli.Flag{
-			httpAddrFlag,
-		}),
-	}
 	discv4CrawlCommand = &cli.Command{
 		Name:   "crawl",
 		Usage:  "Updates a nodes.json file with random nodes found in the DHT",
 		Action: discv4Crawl,
-		Flags:  slices.Concat(discoveryNodeFlags, []cli.Flag{crawlTimeoutFlag, crawlParallelismFlag}),
+		Flags:  flags.Merge(discoveryNodeFlags, []cli.Flag{crawlTimeoutFlag, crawlParallelismFlag}),
 	}
 	discv4TestCommand = &cli.Command{
 		Name:   "test",
@@ -143,10 +131,6 @@ var (
 		Usage:   "Enode of the remote node under test",
 		EnvVars: []string{"REMOTE_ENODE"},
 	}
-	httpAddrFlag = &cli.StringFlag{
-		Name:  "rpc",
-		Usage: "HTTP server listening address",
-	}
 )

 var discoveryNodeFlags = []cli.Flag{
@@ -170,27 +154,6 @@ func discv4Ping(ctx *cli.Context) error {
 	return nil
 }

-func discv4Listen(ctx *cli.Context) error {
-	disc, _ := startV4(ctx)
-	defer disc.Close()
-
-	fmt.Println(disc.Self())
-
-	httpAddr := ctx.String(httpAddrFlag.Name)
-	if httpAddr == "" {
-		// Non-HTTP mode.
-		select {}
-	}
-
-	api := &discv4API{disc}
-	log.Info("Starting RPC API server", "addr", httpAddr)
-	srv := rpc.NewServer()
-	srv.RegisterName("discv4", api)
-	http.DefaultServeMux.Handle("/", srv)
-	httpsrv := http.Server{Addr: httpAddr, Handler: http.DefaultServeMux}
-	return httpsrv.ListenAndServe()
-}
-
 func discv4RequestRecord(ctx *cli.Context) error {
 	n := getNodeArg(ctx)
 	disc, _ := startV4(ctx)
@@ -399,23 +362,3 @@ func parseBootnodes(ctx *cli.Context) ([]*enode.Node, error) {
 	}
 	return nodes, nil
 }
-
-type discv4API struct {
-	host *discover.UDPv4
-}
-
-func (api *discv4API) LookupRandom(n int) (ns []*enode.Node) {
-	it := api.host.RandomNodes()
-	for len(ns) < n && it.Next() {
-		ns = append(ns, it.Node())
-	}
-	return ns
-}
-
-func (api *discv4API) Buckets() [][]discover.BucketNode {
-	return api.host.TableBuckets()
-}
-
-func (api *discv4API) Self() *enode.Node {
-	return api.host.Self()
-}
--- a/cmd/devp2p/discv5cmd.go
+++ b/cmd/devp2p/discv5cmd.go
@@ -19,11 +19,11 @@ package main
 import (
 	"errors"
 	"fmt"
-	"slices"
 	"time"

 	"github.com/ethereum/go-ethereum/cmd/devp2p/internal/v5test"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/internal/flags"
 	"github.com/ethereum/go-ethereum/p2p/discover"
 	"github.com/urfave/cli/v2"
 )
@@ -56,7 +56,7 @@ var (
 		Name:   "crawl",
 		Usage:  "Updates a nodes.json file with random nodes found in the DHT",
 		Action: discv5Crawl,
-		Flags: slices.Concat(discoveryNodeFlags, []cli.Flag{
+		Flags: flags.Merge(discoveryNodeFlags, []cli.Flag{
 			crawlTimeoutFlag,
 		}),
 	}
--- a/cmd/devp2p/dns_cloudflare.go
+++ b/cmd/devp2p/dns_cloudflare.go
@@ -88,8 +88,7 @@ func (c *cloudflareClient) checkZone(name string) error {
 	if !strings.HasSuffix(name, "."+zone.Name) {
 		return fmt.Errorf("CloudFlare zone name %q does not match name %q to be deployed", zone.Name, name)
 	}
-	// Necessary permissions for Cloudlare management - Zone:Read, DNS:Read, Zone:Edit, DNS:Edit
-	needPerms := map[string]bool{"#zone:edit": false, "#zone:read": false, "#dns_records:read": false, "#dns_records:edit": false}
+	needPerms := map[string]bool{"#zone:edit": false, "#zone:read": false}
 	for _, perm := range zone.Permissions {
 		if _, ok := needPerms[perm]; ok {
 			needPerms[perm] = true
--- a/cmd/devp2p/dns_route53.go
+++ b/cmd/devp2p/dns_route53.go
@@ -20,7 +20,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"slices"
 	"strconv"
 	"strings"
 	"time"
@@ -33,6 +32,7 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/p2p/dnsdisc"
 	"github.com/urfave/cli/v2"
+	"golang.org/x/exp/slices"
 )

 const (
--- a/cmd/devp2p/enrcmd.go
+++ b/cmd/devp2p/enrcmd.go
@@ -183,8 +183,8 @@ var attrFormatters = map[string]func(rlp.RawValue) (string, bool){
 }

 func formatAttrRaw(v rlp.RawValue) (string, bool) {
-	content, _, err := rlp.SplitString(v)
-	return hex.EncodeToString(content), err == nil
+	s := hex.EncodeToString(v)
+	return s, true
 }

 func formatAttrString(v rlp.RawValue) (string, bool) {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Felix Lange	7f131dcbc9	Merge branch 'master' into release/1.13	2024-02-21 15:48:38 +01:00
Martin HS	02eb36afc2	all: release go-ethereum v1.13.12 (#28961 ) all: release go-ethereum v1.13.12	2024-02-09 07:58:48 +01:00
Martin HS	8f7eb9ccd9	all: release go-ethereum v1.13.11 (#28868 ) Release 1.13.11	2024-01-24 11:52:24 +01:00
Péter Szilágyi	bc0be1b106	Merge branch 'master' into release/1.13	2024-01-11 19:21:29 +02:00
Felix Lange	dd938d103d	Merge branch 'master' into release/1.13	2024-01-10 17:31:15 +01:00
Martin HS	b20b4a7159	all: release go-ethereum v1.13.8 Release 1.13.8	2023-12-22 13:44:46 +01:00
Felix Lange	c3d9ca62c1	all: release go-ethereum v1.13.7	2023-12-19 13:30:06 +01:00
Felix Lange	da6cdaf635	all: release go-ethereum v1.13.6	2023-12-18 19:06:41 +01:00
Felix Lange	5ba3d578ee	Merge branch 'release/1.13' into release-1.13.6	2023-12-18 18:55:38 +01:00
Péter Szilágyi	916d6a441a	params: release Geth v1.15.5	2023-11-14 15:02:24 +03:00