chore: rialto network for testing

fix: compare headers' number in Big.Int rather than Uint64 (#2158 )
chore: fix lint issue (#2139 )
2024-01-16 11:31:17 +08:00 · 2024-01-15 10:54:54 +08:00 · 2024-01-08 12:06:27 +08:00 · 2024-01-08 11:49:07 +08:00 · 2024-01-08 11:37:58 +08:00 · 2024-01-08 11:15:14 +08:00
720 changed files with 27238 additions and 49816 deletions
--- a/.github/workflows/build-test.yml
+++ b/.github/workflows/build-test.yml
@@ -15,7 +15,7 @@ jobs:
  unit-test:
    strategy:
      matrix:
-        go-version: [1.21.x]
+        go-version: [1.20.x]
        os: [ubuntu-latest]
    runs-on: ${{ matrix.os }}
    steps:
--- a/.github/workflows/evm-tests.yml
+++ b/.github/workflows/evm-tests.yml
@@ -1,56 +0,0 @@
-name: EVM Test
-
-on:
-  push:
-    branches: 
-      - master
-      - develop
-
-  pull_request:
-    branches: 
-      - master
-      - develop
-
-jobs:
-  evm-test:
-    strategy:
-      matrix:
-        go-version: [1.21.x]
-        os: [ubuntu-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Install Go
-      uses: actions/setup-go@v3
-      with:
-        go-version: ${{ matrix.go-version }}
-        
-    - name: Checkout code
-      uses: actions/checkout@v3
-
-    - uses: actions/cache@v3
-      with:
-        # In order:
-        # * Module download cache
-        # * Build cache (Linux)
-        # * Build cache (Mac)
-        # * Build cache (Windows)
-        path: |
-          ~/go/pkg/mod
-          ~/.cache/go-build
-          ~/Library/Caches/go-build
-          ~\AppData\Local\go-build
-        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-        restore-keys: |
-          ${{ runner.os }}-go-
-
-    - name: EVM Test
-      env:
-        CGO_CFLAGS: "-O -D__BLST_PORTABLE__"
-        CGO_CFLAGS_ALLOW: "-O -D__BLST_PORTABLE__"
-        ANDROID_HOME: "" # Skip android test
-      run: |
-        git submodule update --init --depth 1 --recursive
-        go mod download
-        cd tests
-        sed -i -e 's/\/\/ bt.skipLoad/bt.skipLoad/g' block_test.go
-        bash -x run-evm-tests.sh
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -15,7 +15,7 @@ jobs:
  golang-lint:
    strategy:
      matrix:
-        go-version: [1.21.x]
+        go-version: [1.20.x]
        os: [ubuntu-latest]
    runs-on: ${{ matrix.os }}
    steps:
@@ -50,7 +50,7 @@ jobs:
      uses: golangci/golangci-lint-action@v3
      with:
        # Optional: version of golangci-lint to use in form of v1.2 or v1.2.3 or `latest` to use the latest version
-        version: v1.55.2
+        version: v1.52.2
        working-directory: ./
        skip-pkg-cache: true
        skip-cache: true
--- a/.github/workflows/nancy.yml
+++ b/.github/workflows/nancy.yml
@@ -1,37 +0,0 @@
-name: Go Nancy
-
-on:
-    # Scan changed files in PRs (diff-aware scanning):
-    pull_request: {}
-    # Scan on-demand through GitHub Actions interface:
-    workflow_dispatch: {}
-    # Scan mainline branches and report all findings:
-    push:
-      branches: ["master", "develop"]
-
-jobs:
-  build:
-    strategy:
-        matrix:
-          go-version: [1.21.x]
-          os: [ubuntu-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Check out code into the Go module directory
-      uses: actions/checkout@v2
-
-    - name: Set up Go 1.x in order to write go.list file
-      uses: actions/setup-go@v2
-      with:
-        go-version: ${{ matrix.go-version }}
-    
-    - name: Go mod tidy
-      run: go mod tidy
-
-    - name: WriteGoList
-      run:  go list -json -deps ./... > go.list
-
-    - name: Nancy
-      uses: sonatype-nexus-community/nancy-github-action@main
-      with:
-        nancyCommand: sleuth --loud
--- a/.github/workflows/pre-release.yml
+++ b/.github/workflows/pre-release.yml
@@ -15,7 +15,7 @@ jobs:
    name: Build Release
    strategy:
      matrix:
-        go-version: [1.21.x]
+        go-version: [1.20.x]
        os: [ubuntu-latest, macos-latest, windows-latest]
    runs-on: ${{ matrix.os }}
    steps:
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -14,7 +14,7 @@ jobs:
    name: Build Release
    strategy:
      matrix:
-        go-version: [1.21.x]
+        go-version: [1.20.x]
        os: [ubuntu-latest, macos-latest, windows-latest]
    runs-on: ${{ matrix.os }}
    steps:
--- a/.github/workflows/unit-test.yml
+++ b/.github/workflows/unit-test.yml
@@ -15,7 +15,7 @@ jobs:
  unit-test:
    strategy:
      matrix:
-        go-version: [1.21.x]
+        go-version: [1.20.x]
        os: [ubuntu-latest]
    runs-on: ${{ matrix.os }}
    steps:
@@ -49,5 +49,6 @@ jobs:
        CGO_CFLAGS_ALLOW: "-O -D__BLST_PORTABLE__"
        ANDROID_HOME: "" # Skip android test
      run: |
+        git submodule update --init --depth 1 --recursive
        go mod download
        make test
--- a/.gitignore
+++ b/.gitignore
@@ -52,5 +52,3 @@ cmd/geth/__debug_bin
 cmd/bootnode/bootnode
 graphql/__debug_bin
 logs/
-
-tests/spec-tests/
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -15,6 +15,7 @@ output:
 linters:
  disable-all: true
  enable:
+    - goconst
    - goimports
    - gosimple
    - govet
@@ -41,6 +42,9 @@ linters:
 linters-settings:
  gofmt:
    simplify: true
+  goconst:
+    min-len: 3 # minimum length of string constant
+    min-occurrences: 6 # minimum number of occurrences

 issues:
  exclude-rules:
--- a/.travis.yml
+++ b/.travis.yml
@@ -9,6 +9,18 @@ jobs:
        - azure-osx

  include:
+    # This builder only tests code linters on latest version of Go
+    - stage: lint
+      os: linux
+      dist: bionic
+      go: 1.20.x
+      env:
+        - lint
+      git:
+        submodules: false # avoid cloning ethereum/tests
+      script:
+        - go run build/ci.go lint
+
    # 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
@@ -16,7 +28,7 @@ jobs:
      os: linux
      arch: amd64
      dist: bionic
-      go: 1.21.x
+      go: 1.20.x
      env:
        - docker
      services:
@@ -33,7 +45,7 @@ jobs:
      os: linux
      arch: arm64
      dist: bionic
-      go: 1.21.x
+      go: 1.20.x
      env:
        - docker
      services:
@@ -51,9 +63,10 @@ jobs:
      os: linux
      dist: bionic
      sudo: required
-      go: 1.21.x
+      go: 1.20.x
      env:
        - azure-linux
+        - GO111MODULE=on
      git:
        submodules: false # avoid cloning ethereum/tests
      addons:
@@ -84,51 +97,56 @@ jobs:
    - stage: build
      if: type = push
      os: osx
-      osx_image: xcode14.2
-      go: 1.21.x
+      go: 1.20.x
      env:
        - azure-osx
+        - GO111MODULE=on
      git:
        submodules: false # avoid cloning ethereum/tests
      script:
        - 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
-        - go run build/ci.go archive -arch arm64 -type tar -signer OSX_SIGNING_KEY -signify SIGNIFY_KEY -upload gethstore/builds

    # These builders run the tests
    - stage: build
      os: linux
      arch: amd64
      dist: bionic
-      go: 1.21.x
+      go: 1.20.x
+      env:
+        - GO111MODULE=on
      script:
-        - travis_wait 30 go run build/ci.go test $TEST_PACKAGES
+        - go run build/ci.go test $TEST_PACKAGES

    - stage: build
      if: type = pull_request
      os: linux
      arch: arm64
      dist: bionic
-      go: 1.20.x
+      go: 1.19.x
+      env:
+        - GO111MODULE=on
      script:
-        - travis_wait 30 go run build/ci.go test $TEST_PACKAGES
+        - go run build/ci.go test $TEST_PACKAGES

    - stage: build
      os: linux
      dist: bionic
-      go: 1.20.x
+      go: 1.19.x
+      env:
+        - GO111MODULE=on
      script:
-        - travis_wait 30 go run build/ci.go test $TEST_PACKAGES
+        - 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: bionic
-      go: 1.21.x
+      go: 1.20.x
      env:
        - ubuntu-ppa
+        - GO111MODULE=on
      git:
        submodules: false # avoid cloning ethereum/tests
      addons:
@@ -149,9 +167,10 @@ jobs:
      if: type = cron
      os: linux
      dist: bionic
-      go: 1.21.x
+      go: 1.20.x
      env:
        - azure-purge
+        - GO111MODULE=on
      git:
        submodules: false # avoid cloning ethereum/tests
      script:
@@ -162,7 +181,9 @@ jobs:
      if: type = cron
      os: linux
      dist: bionic
-      go: 1.21.x
+      go: 1.20.x
+      env:
+        - GO111MODULE=on
      script:
-        - travis_wait 30 go run build/ci.go test  -race $TEST_PACKAGES
+        - go run build/ci.go test  -race $TEST_PACKAGES

--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,137 +1,4 @@
 # Changelog
-## v1.4.0
-#### RPC
-[internal/ethapi: implement eth_getBlockReceipts (#27702)](https://github.com/bnb-chain/bsc/commit/f1801a9feda8f81532c92077d2c9a8b785fd699b)
-[eth, rpc: add configurable option for wsMessageSizeLimit (#27801)](https://github.com/bnb-chain/bsc/commit/705a51e566bc9215975d08f27d23ddab7baa9dd7)
-[api/bind: add CallOpts.BlockHash to allow calling contracts at a specific block hash (#28084)](https://github.com/bnb-chain/bsc/commit/b85c86022e130a76eeb588a5b36e97149b342188)
-[internal/ethapi: eth_call block parameter is optional (#28165)](https://github.com/bnb-chain/bsc/commit/adb9b319c9c61f092755000bf0fc4b3349f5cbbc)
-[internal/ethapi: ethSendTransaction check baseFee (#27834)](https://github.com/bnb-chain/bsc/commit/54a400ee717caf44603fac390314747c5592ee1b)
-#### Command
-[cmd/utils: fix a startup issue on deleted chaindata but dangling ancients(#27989)](https://github.com/bnb-chain/bsc/commit/00fead91c4f58bc7f56f81512280d3120860989c)
-[cmd/geth, internal/flags, go.mod: colorize cli help, support env vars(#28103)](https://github.com/bnb-chain/bsc/commit/d9fbb71d631d1ad0fb1846042e4c50ab893a6fbf)
-[cmd/rlpdump: add -pos flag, displaying byte positions (#28785)](https://github.com/bnb-chain/bsc/commit/1485814f89d8206bb4a1c8e10a4a2893920f683a)
-[cmd/geth: make it possible to autopilot removedb (#28725)](https://github.com/bnb-chain/bsc/commit/1010a79c7cbcdb4741e9f30e8cdc19c679ad7377)
-#### Flag
-[cmd/utils: restore support for txlookuplimit flag (#27917)](https://github.com/bnb-chain/bsc/commit/68855216c903eea9f952a1a7a56e69ea285f284b)
-[cmd/utils, eth: disallow invalid snap sync / snapshot flag combos (#28657)](https://github.com/bnb-chain/bsc/commit/d98d70f670297a4bfa86db1a67a9c024f7186f43)
-#### Client
-[ethclient: use 'input', not 'data' as field for transaction input (#28078)](https://github.com/bnb-chain/bsc/commit/5cf53f51ac556cfff2aee9d405efd336298a3aca)
-[ethclient: fix forwarding 1559 gas fields (#28462)](https://github.com/bnb-chain/bsc/commit/e91cdb49beb4b2a3872b5f2548bf2d6559e4f561)
-[ethclient/simulated: implement new sim backend (#28202)](https://github.com/bnb-chain/bsc/commit/2d08c9900996b5e798f40a3cc6b47f4e51dc487d)
-[ethclient: apply accessList field in toCallArg (#28832)](https://github.com/bnb-chain/bsc/commit/1c488298c807f4daa3cbe260efb88b81902a903d) 
-#### Tracer
-[eth/tracers: add position field for callTracer logs (#28389)](https://github.com/bnb-chain/bsc/commit/b1cec853bef98acc750298b1c9b8165f2ac6ce5a)
-[eth/tracers: tx-level state in debug_traceCall (#28460)](https://github.com/bnb-chain/bsc/commit/5fb8ebc9ecb226b84181420b9871c5f61cf4f77d)
-#### Txpool
-[eth/fetcher: allow underpriced transactions in after timeout (#28097)](https://github.com/bnb-chain/bsc/commit/2b7bc2c36b0d0efc83e62ba8e13723b943c4fa6e)
-#### Sync
-[eth/downloader: prevent pivot moves after state commit (#28126)](https://github.com/bnb-chain/bsc/commit/4fa3db49a1e485b8d110c87de6a44f460b45bb9a)
-[core, eth/downloader: fix genesis state missing due to state sync (#28124)](https://github.com/bnb-chain/bsc/commit/c53b0fef2ab8e2a00257b898cad5174e6b73f5fc)
-[core, accounts, eth, trie: handle genesis state missing (#28171)](https://github.com/bnb-chain/bsc/commit/73f5bcb75b562fcb3c109dd9c51f21956bc1f1f4)
-[eth/protocols/snap: fix snap sync failure on empty storage range (#28306)](https://github.com/bnb-chain/bsc/commit/1cb3b6aee4a16ab8e684da63f3cfcd9b961c43af)
-[core, eth, trie: filter out boundary nodes and remove dangling nodes in stacktrie (#28327)](https://github.com/bnb-chain/bsc/commit/ab04aeb855605de51dd1e933f45eb84ad877e715)
-[core, core/rawdb, eth/sync: no tx indexing during snap sync (#28703)](https://github.com/bnb-chain/bsc/commit/78a3c32ef4deb7755e3367e183639b66242654f7)
-#### PBSS Related
-[core/rawdb: skip pathdb state inspection in hashdb mode (#28108)](https://github.com/bnb-chain/bsc/commit/8d38b1fe62950e8675795abf63b7c978415ab7ba)
-[eth: abort on api operations not available in pbss-mode (#28104)](https://github.com/bnb-chain/bsc/commit/b9b99a12e5159c746ef04b7c8febc4db66817b72)
-[trie: remove internal nodes between shortNode and child in path mode (#28163)](https://github.com/bnb-chain/bsc/commit/4773dcbc81aac9d330df29446283361f5a7062c7)
-[trie/triedb/pathdb: improve dirty node flushing trigger (#28426)](https://github.com/bnb-chain/bsc/commit/ea2e66a58e48ef63566d5274c4a875e817a1cd39) 
-[core/rawdb: fsync the index file after each freezer write (#28483)](https://github.com/bnb-chain/bsc/commit/326fa00759d959061035becc9514660c24897053) 
-[trie: remove inconsistent trie nodes during sync in path mode (#28595)](https://github.com/bnb-chain/bsc/commit/e206d3f8975bd98cc86d14055dca40f996bacc60)
-[core, cmd, trie: fix the condition of pathdb initialization (#28718)](https://github.com/bnb-chain/bsc/commit/cca94792a4112687ce23e7041b95ccc7f4bf6123) 
-#### GraphQL
-[graphql: validate block params (#27876](https://github.com/bnb-chain/bsc/commit/5e89ff4d6b0df4bd54d20d90bee5a16abef6b9bc)
-[graphql: always set content-type to application/json (#28417)](https://github.com/bnb-chain/bsc/commit/2d7dba024d76603398907a595da98ad4df81b858)
-#### Cancun
-[core/types: support for optional blob sidecar in BlobTx (#27841)](https://github.com/bnb-chain/bsc/commit/2a6beb6a39d7cb3c5906dd4465d65da6efcc73cd)
-[core, params, beacon/engine: implement EIP 4788 BeaconRoot (#27849)](https://github.com/bnb-chain/bsc/commit/b8d38e76ef07c99d338c7bcd485881850382a58f) 
-[miner: add to build block with EIP-4844 blobs (#27875)](https://github.com/bnb-chain/bsc/commit/feb8f416acc3f067ecc8cbdabb8e70679547737a)
-[core: implement BLOBBASEFEE opcode (0x4a) (#28098)](https://github.com/bnb-chain/bsc/commit/c39cbc1a78aa275523c1b0ff9d21b16ba7bfa486)
-[core, eth, miner: start propagating and consuming blob txs (#28243)](https://github.com/bnb-chain/bsc/commit/a8a9c8e4b00c5b9f84242181839234b8e9fd54e3)
-[eth/fetcher: throttle tx fetches to 128KB responses (#28304)](https://github.com/bnb-chain/bsc/commit/a6deb2d994e644300bac43455b1c954976e7382e)
-[crypto/kzg4844: use the new trusted setup file and format (#28383)](https://github.com/bnb-chain/bsc/commit/a6a0ae45b69a95b38b7cb2d085e7833c88b72164)
-[internal/ethapi: handle blobs in API methods (#28786)](https://github.com/bnb-chain/bsc/commit/e5d5e09faae48dac3723634e2b1813e4f2e89535)
-#### P2P
-[cmd/devp2p, eth: drop eth/66 (#28239)](https://github.com/bnb-chain/bsc/commit/bc6d184872889224480cf9df58b0539b210ffa9e) 
-[cmd/devp2p: use bootnodes as crawl input (#28139)](https://github.com/bnb-chain/bsc/commit/41a0ad9f03ae8e8389fbe40131f4e6930b5beac5)
-[p2p/discover: add liveness check in collectTableNodes (#28686)](https://github.com/bnb-chain/bsc/commit/5b22a472d6aaaa17daf0543b5914ca1f2f5518a7)
-#### Test
-[build, tests: add execution-spec-tests (#26985)](https://github.com/bnb-chain/bsc/commit/f174ddba7af5c150ecad37430c167194d66d75f1) 
-[tests/fuzzers: update fuzzers to be based on go-native fuzzing (#28352)](https://github.com/bnb-chain/bsc/commit/d10a2f6ab727f79a0acff29c8147d54c5e4689ec) 
-[tests/fuzzers: move fuzzers into native packages (#28467)](https://github.com/bnb-chain/bsc/commit/2391fbc676d7464bd42e248155558a2bcd6ecf64)
-#### Clear Up
-[eth/downloader: remove header rollback mechanism (#28147)](https://github.com/bnb-chain/bsc/commit/b85c183ea7417e973dbbccd27b3fb7d7097b87dd)
-#### Others
-[core/forkid: correctly compute forkid when timestamp fork is activated in genesis (#27895)](https://github.com/bnb-chain/bsc/commit/32fde3f838d604fdeb7a3ada4f8e02d78301b83d)
-[core/vm/runtime: Add Random field to config (#28001)](https://github.com/bnb-chain/bsc/commit/0ba2d3cfa4e4a0a76cd457b8dc0f49bf1a79b723)
-[core/rawdb: no need to run truncateFile for readonly mode (#28145)](https://github.com/bnb-chain/bsc/commit/545f4c5547178bc8bde6af08b3ccaf68ca27f2c0)
-[core/bloombits: fix deadlock when matcher session hits an error (#28184)](https://github.com/bnb-chain/bsc/commit/c2cfe35f121cb88650b4d90c958bcc4214d0ce7f) 
-[core/state, tests: fix memory leak via fastcache (#28387)](https://github.com/bnb-chain/bsc/commit/c1d5a012ea4b824e902db14e47bf147d727c2657)
-[internal/ethapi: compact db missing key starts with 0xff (#28207)](https://github.com/bnb-chain/bsc/commit/46c850a9411d7ff15c1a0342fe29f359e6c390ae)
-[internal/ethapi: fix codehash lookup in eth_getProof (#28357)](https://github.com/bnb-chain/bsc/commit/8b99ad46027a455971ccf9bd1f425b9c58ec5855) 
-[eth: set networkID to chainID by default (#28250)](https://github.com/bnb-chain/bsc/commit/4d9f3cd5d751efccd501b08ab6cf38a83b5e2858)
-[eth: fix potential hang in waitSnapExtension (#28744)](https://github.com/bnb-chain/bsc/commit/18e154eaa24d5f7a8b3c48983ad591e6c10963ca)
-[metrics, cmd/geth: informational metrics (prometheus, influxdb, opentsb (#24877)](https://github.com/bnb-chain/bsc/commit/53f3c2ae656cd860a700751b6c5f81ca9c66503d)
-[ethdb/pebble: don't double-close iterator inside pebbleIterator (#28566)](https://github.com/bnb-chain/bsc/commit/6489a0dd1f98e9ce1c64c2eae93c8a88df7ae674)
-[trie/triedb/hashdb: take lock around access to dirties cache (#28542)](https://github.com/bnb-chain/bsc/commit/fa0df76f3cfd186a1f06f2b80aa5dbb89555b009) 
-[accounts: properly close managed wallets when closing manager (#28710)](https://github.com/bnb-chain/bsc/commit/d3452a22cc871306c62de52d19295914141863c0)
-[event: fix Resubscribe deadlock when unsubscribing after inner sub ends (#28359)](https://github.com/bnb-chain/bsc/commit/ffc6a0f36edda396a8421cf7a3c0feb88be20d0b)
-[all: replace log15 with slog (#28187)](https://github.com/bnb-chain/bsc/commit/28e73717016cdc9ebdb5fdb3474cfbd3bd2d2524)
-
-## v1.3.10
-FEATURE
-* [\#2047](https://github.com/bnb-chain/bsc/pull/2047) feat: add new fork block and precompile contract for BEP294 and BEP299
-
-## v1.3.9
-FEATURE
-* [\#2186](https://github.com/bnb-chain/bsc/pull/2186) log: support maxBackups in config.toml
-
-BUGFIX
-* [\#2160](https://github.com/bnb-chain/bsc/pull/2160) cmd: fix dump cli cannot work in path mode
-* [\#2183](https://github.com/bnb-chain/bsc/pull/2183) p2p: resolved deadlock on p2p server shutdown
-
-IMPROVEMENT
-* [\#2177](https://github.com/bnb-chain/bsc/pull/0000) build(deps): bump github.com/quic-go/quic-go from 0.39.3 to 0.39.4
-* [\#2185](https://github.com/bnb-chain/bsc/pull/2185) consensus/parlia: set nonce before evm run
-* [\#2190](https://github.com/bnb-chain/bsc/pull/2190) fix(legacypool): deprecate already known error
-* [\#2195](https://github.com/bnb-chain/bsc/pull/2195) eth/fetcher: downgrade state tx log
-
-## v1.3.8
-FEATURE
-* [\#2074](https://github.com/bnb-chain/bsc/pull/2074) faucet: new faucet client
-* [\#2082](https://github.com/bnb-chain/bsc/pull/2082) cmd/dbcmd: add inspect trie tool
-* [\#2140](https://github.com/bnb-chain/bsc/pull/2140) eth/fetcher: allow underpriced transactions in after timeout
-* [\#2115](https://github.com/bnb-chain/bsc/pull/2115) p2p: no peer reconnect if explicitly disconnected
-* [\#2128](https://github.com/bnb-chain/bsc/pull/2128) go.mod: upgrade prysm to support built with go@v1.21
-* [\#2151](https://github.com/bnb-chain/bsc/pull/2151) feat: enable NoDial should still dial static nodes
-* [\#2144](https://github.com/bnb-chain/bsc/pull/2144) p2p: reset disconnect set with magic enode ID
-
-BUGFIX
-* [\#2095](https://github.com/bnb-chain/bsc/pull/2095) rpc: fix ns/µs mismatch in metrics
-* [\#2083](https://github.com/bnb-chain/bsc/pull/2083) triedb/pathdb: fix async node buffer diskroot mismatches when journaling
-* [\#2120](https://github.com/bnb-chain/bsc/pull/2120) ethdb/pebble: cap memory table size as maxMemTableSize-1
-* [\#2107](https://github.com/bnb-chain/bsc/pull/2107) cmd/geth: fix parse state scheme
-* [\#2121](https://github.com/bnb-chain/bsc/pull/2121) parlia: fix verifyVoteAttestation when verify a batch of headers
-* [\#2132](https://github.com/bnb-chain/bsc/pull/2132) core: fix systemcontracts.GenesisHash when run bsc firstly without init
-* [\#2155](https://github.com/bnb-chain/bsc/pull/2155) cmd, core: resolve scheme from a read-write database and refactor resolveChainFreezerDir func
-
-IMPROVEMENT
-* [\#2099](https://github.com/bnb-chain/bsc/pull/2099) params/config: remove useless toml tag for hardforks
-* [\#2100](https://github.com/bnb-chain/bsc/pull/2100) core/genesis: support chapel to run without geth init
-* [\#2101](https://github.com/bnb-chain/bsc/pull/2101) core: add metrics for bad block
-* [\#2109](https://github.com/bnb-chain/bsc/pull/2109) cmd/geth: tidy flags for geth command
-* [\#1953](https://github.com/bnb-chain/bsc/pull/1953) build(deps): bump github.com/docker/docker
-* [\#2086](https://github.com/bnb-chain/bsc/pull/2086) build(deps): bump golang.org/x/crypto from 0.12.0 to 0.17.0
-* [\#2106](https://github.com/bnb-chain/bsc/pull/2106) params: use rialto to test builtin network logic
-* [\#2098](https://github.com/bnb-chain/bsc/pull/2098) cmd, les, tests: remove light client code
-* [\#2114](https://github.com/bnb-chain/bsc/pull/2114) p2p: add serve metrics
-* [\#2123](https://github.com/bnb-chain/bsc/pull/2123) p2p, eth: improve logs
-* [\#2116](https://github.com/bnb-chain/bsc/pull/2116) tests: revive evm test cases
-* [\#2161](https://github.com/bnb-chain/bsc/pull/2161) code: remove IsEuler check from worker.go
-* [\#2167](https://github.com/bnb-chain/bsc/pull/2167) improve: increase SystemTxsGas from 1,500,000 to 5,000,000
-* [\#2172](https://github.com/bnb-chain/bsc/pull/2172) improve: remove sharedpool from miner
-* [\#1332](https://github.com/bnb-chain/bsc/pull/1332) core/state: no need to prune block if the same
-
 ## v1.3.7
 FEATURE
 * [\#2067](https://github.com/bnb-chain/bsc/pull/2067) cmd/geth: add check func to validate state scheme
--- a/2
+++ b/2
@@ -4,7 +4,7 @@ ARG VERSION=""
 ARG BUILDNUM=""

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

 RUN apk add --no-cache make cmake gcc musl-dev linux-headers git bash build-base libc-dev
 # Get dependencies - will also be cached if we won't change go.mod/go.sum
--- 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.21-alpine as builder
+FROM golang:1.20-alpine as builder

 RUN apk add --no-cache gcc musl-dev linux-headers git
 # Get dependencies - will also be cached if we won't change go.mod/go.sum
--- a/4
+++ b/4
@@ -7,7 +7,7 @@

 GOBIN = ./build/bin
 GO ?= latest
-GORUN = go run
+GORUN = env GO111MODULE=on go run
 GIT_COMMIT=$(shell git rev-parse HEAD)
 GIT_COMMIT_DATE=$(shell git log -n1 --pretty='format:%cd' --date=format:'%Y%m%d')

@@ -36,7 +36,7 @@ lint: ## Run linters.
 	$(GORUN) build/ci.go lint

 clean:
-	go clean -cache
+	env GO111MODULE=on go clean -cache
 	rm -fr build/_workspace/pkg/ $(GOBIN)/*

 # The devtools target installs tools required for 'go generate'.
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@ The goal of BNB Smart Chain is to bring programmability and interoperability to
 BNB Smart Chain starts its development based on go-ethereum fork. So you may see many toolings, binaries and also docs are based on Ethereum ones, such as the name “geth”.

 [![API Reference](
-https://pkg.go.dev/badge/github.com/ethereum/go-ethereum
+https://camo.githubusercontent.com/915b7be44ada53c290eb157634330494ebe3e30a/68747470733a2f2f676f646f632e6f72672f6769746875622e636f6d2f676f6c616e672f6764646f3f7374617475732e737667
 )](https://pkg.go.dev/github.com/ethereum/go-ethereum?tab=doc)
 [![Discord](https://img.shields.io/badge/discord-join%20chat-blue.svg)](https://discord.gg/z2VpC455eU)

@@ -61,7 +61,7 @@ Many of the below are the same as or similar to go-ethereum.

 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.21 or later) and a C compiler (GCC 5 or higher). You can install
+Building `geth` requires both a Go (version 1.20 or later) and a C compiler (GCC 5 or higher). You can install
 them using your favourite package manager. Once the dependencies are installed, run

 ```shell
--- a/accounts/abi/abi.go
+++ b/accounts/abi/abi.go
@@ -22,7 +22,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"math/big"

 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
@@ -247,37 +246,17 @@ func (abi *ABI) HasReceive() bool {
 // revertSelector is a special function selector for revert reason unpacking.
 var revertSelector = crypto.Keccak256([]byte("Error(string)"))[:4]

-// panicSelector is a special function selector for panic reason unpacking.
-var panicSelector = crypto.Keccak256([]byte("Panic(uint256)"))[:4]
-
-// panicReasons map is for readable panic codes
-// see this linkage for the details
-// https://docs.soliditylang.org/en/v0.8.21/control-structures.html#panic-via-assert-and-error-via-require
-// the reason string list is copied from ether.js
-// https://github.com/ethers-io/ethers.js/blob/fa3a883ff7c88611ce766f58bdd4b8ac90814470/src.ts/abi/interface.ts#L207-L218
-var panicReasons = map[uint64]string{
-	0x00: "generic panic",
-	0x01: "assert(false)",
-	0x11: "arithmetic underflow or overflow",
-	0x12: "division or modulo by zero",
-	0x21: "enum overflow",
-	0x22: "invalid encoded storage byte array accessed",
-	0x31: "out-of-bounds array access; popping on an empty array",
-	0x32: "out-of-bounds access of an array or bytesN",
-	0x41: "out of memory",
-	0x51: "uninitialized function",
-}
-
 // UnpackRevert resolves the abi-encoded revert reason. According to the solidity
 // spec https://solidity.readthedocs.io/en/latest/control-structures.html#revert,
-// the provided revert reason is abi-encoded as if it were a call to function
-// `Error(string)` or `Panic(uint256)`. So it's a special tool for it.
+// the provided revert reason is abi-encoded as if it were a call to a function
+// `Error(string)`. So it's a special tool for it.
 func UnpackRevert(data []byte) (string, error) {
 	if len(data) < 4 {
 		return "", errors.New("invalid data for unpacking")
 	}
-	switch {
-	case bytes.Equal(data[:4], revertSelector):
+	if !bytes.Equal(data[:4], revertSelector) {
+		return "", errors.New("invalid data for unpacking")
+	}
 	typ, err := NewType("string", "", nil)
 	if err != nil {
 		return "", err
@@ -287,25 +266,4 @@ func UnpackRevert(data []byte) (string, error) {
 		return "", err
 	}
 	return unpacked[0].(string), nil
-	case bytes.Equal(data[:4], panicSelector):
-		typ, err := NewType("uint256", "", nil)
-		if err != nil {
-			return "", err
-		}
-		unpacked, err := (Arguments{{Type: typ}}).Unpack(data[4:])
-		if err != nil {
-			return "", err
-		}
-		pCode := unpacked[0].(*big.Int)
-		// uint64 safety check for future
-		// but the code is not bigger than MAX(uint64) now
-		if pCode.IsUint64() {
-			if reason, ok := panicReasons[pCode.Uint64()]; ok {
-				return reason, nil
-			}
-		}
-		return fmt.Sprintf("unknown panic code: %#x", pCode), nil
-	default:
-		return "", errors.New("invalid data for unpacking")
-	}
 }
--- a/accounts/abi/abi_test.go
+++ b/accounts/abi/abi_test.go
@@ -120,7 +120,6 @@ var methods = map[string]Method{
 }

 func TestReader(t *testing.T) {
-	t.Parallel()
 	abi := ABI{
 		Methods: methods,
 	}
@@ -152,7 +151,6 @@ func TestReader(t *testing.T) {
 }

 func TestInvalidABI(t *testing.T) {
-	t.Parallel()
 	json := `[{ "type" : "function", "name" : "", "constant" : fals }]`
 	_, err := JSON(strings.NewReader(json))
 	if err == nil {
@@ -172,7 +170,6 @@ func TestInvalidABI(t *testing.T) {
 //		constructor(uint256 a, uint256 b) public{}
 //	}
 func TestConstructor(t *testing.T) {
-	t.Parallel()
 	json := `[{	"inputs": [{"internalType": "uint256","name": "a","type": "uint256"	},{	"internalType": "uint256","name": "b","type": "uint256"}],"stateMutability": "nonpayable","type": "constructor"}]`
 	method := NewMethod("", "", Constructor, "nonpayable", false, false, []Argument{{"a", Uint256, false}, {"b", Uint256, false}}, nil)
 	// Test from JSON
@@ -202,7 +199,6 @@ func TestConstructor(t *testing.T) {
 }

 func TestTestNumbers(t *testing.T) {
-	t.Parallel()
 	abi, err := JSON(strings.NewReader(jsondata))
 	if err != nil {
 		t.Fatal(err)
@@ -240,7 +236,6 @@ func TestTestNumbers(t *testing.T) {
 }

 func TestMethodSignature(t *testing.T) {
-	t.Parallel()
 	m := NewMethod("foo", "foo", Function, "", false, false, []Argument{{"bar", String, false}, {"baz", String, false}}, nil)
 	exp := "foo(string,string)"
 	if m.Sig != exp {
@@ -279,7 +274,6 @@ func TestMethodSignature(t *testing.T) {
 }

 func TestOverloadedMethodSignature(t *testing.T) {
-	t.Parallel()
 	json := `[{"constant":true,"inputs":[{"name":"i","type":"uint256"},{"name":"j","type":"uint256"}],"name":"foo","outputs":[],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[{"name":"i","type":"uint256"}],"name":"foo","outputs":[],"payable":false,"stateMutability":"pure","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"i","type":"uint256"}],"name":"bar","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"i","type":"uint256"},{"indexed":false,"name":"j","type":"uint256"}],"name":"bar","type":"event"}]`
 	abi, err := JSON(strings.NewReader(json))
 	if err != nil {
@@ -303,7 +297,6 @@ func TestOverloadedMethodSignature(t *testing.T) {
 }

 func TestCustomErrors(t *testing.T) {
-	t.Parallel()
 	json := `[{ "inputs": [	{ "internalType": "uint256", "name": "", "type": "uint256" } ],"name": "MyError", "type": "error"} ]`
 	abi, err := JSON(strings.NewReader(json))
 	if err != nil {
@@ -318,7 +311,6 @@ func TestCustomErrors(t *testing.T) {
 }

 func TestMultiPack(t *testing.T) {
-	t.Parallel()
 	abi, err := JSON(strings.NewReader(jsondata))
 	if err != nil {
 		t.Fatal(err)
@@ -356,7 +348,6 @@ func ExampleJSON() {
 }

 func TestInputVariableInputLength(t *testing.T) {
-	t.Parallel()
 	const definition = `[
 	{ "type" : "function", "name" : "strOne", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" } ] },
 	{ "type" : "function", "name" : "bytesOne", "constant" : true, "inputs" : [ { "name" : "str", "type" : "bytes" } ] },
@@ -485,7 +476,6 @@ func TestInputVariableInputLength(t *testing.T) {
 }

 func TestInputFixedArrayAndVariableInputLength(t *testing.T) {
-	t.Parallel()
 	abi, err := JSON(strings.NewReader(jsondata))
 	if err != nil {
 		t.Error(err)
@@ -660,7 +650,6 @@ func TestInputFixedArrayAndVariableInputLength(t *testing.T) {
 }

 func TestDefaultFunctionParsing(t *testing.T) {
-	t.Parallel()
 	const definition = `[{ "name" : "balance", "type" : "function" }]`

 	abi, err := JSON(strings.NewReader(definition))
@@ -674,7 +663,6 @@ func TestDefaultFunctionParsing(t *testing.T) {
 }

 func TestBareEvents(t *testing.T) {
-	t.Parallel()
 	const definition = `[
 	{ "type" : "event", "name" : "balance" },
 	{ "type" : "event", "name" : "anon", "anonymous" : true},
@@ -751,7 +739,6 @@ func TestBareEvents(t *testing.T) {
 //
 //	receipt{status=1 cgas=23949 bloom=00000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000040200000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 logs=[log: b6818c8064f645cd82d99b59a1a267d6d61117ef [75fd880d39c1daf53b6547ab6cb59451fc6452d27caa90e5b6649dd8293b9eed] 000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158 9ae378b6d4409eada347a5dc0c180f186cb62dc68fcc0f043425eb917335aa28 0 95d429d309bb9d753954195fe2d69bd140b4ae731b9b5b605c34323de162cf00 0]}
 func TestUnpackEvent(t *testing.T) {
-	t.Parallel()
 	const abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"receive","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"}],"name":"receivedAddr","type":"event"}]`
 	abi, err := JSON(strings.NewReader(abiJSON))
 	if err != nil {
@@ -790,7 +777,6 @@ func TestUnpackEvent(t *testing.T) {
 }

 func TestUnpackEventIntoMap(t *testing.T) {
-	t.Parallel()
 	const abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"receive","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"}],"name":"receivedAddr","type":"event"}]`
 	abi, err := JSON(strings.NewReader(abiJSON))
 	if err != nil {
@@ -841,7 +827,6 @@ func TestUnpackEventIntoMap(t *testing.T) {
 }

 func TestUnpackMethodIntoMap(t *testing.T) {
-	t.Parallel()
 	const abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"receive","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[],"name":"send","outputs":[{"name":"amount","type":"uint256"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"name":"addr","type":"address"}],"name":"get","outputs":[{"name":"hash","type":"bytes"}],"payable":true,"stateMutability":"payable","type":"function"}]`
 	abi, err := JSON(strings.NewReader(abiJSON))
 	if err != nil {
@@ -892,7 +877,6 @@ func TestUnpackMethodIntoMap(t *testing.T) {
 }

 func TestUnpackIntoMapNamingConflict(t *testing.T) {
-	t.Parallel()
 	// Two methods have the same name
 	var abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"get","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[],"name":"send","outputs":[{"name":"amount","type":"uint256"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"name":"addr","type":"address"}],"name":"get","outputs":[{"name":"hash","type":"bytes"}],"payable":true,"stateMutability":"payable","type":"function"}]`
 	abi, err := JSON(strings.NewReader(abiJSON))
@@ -976,7 +960,6 @@ func TestUnpackIntoMapNamingConflict(t *testing.T) {
 }

 func TestABI_MethodById(t *testing.T) {
-	t.Parallel()
 	abi, err := JSON(strings.NewReader(jsondata))
 	if err != nil {
 		t.Fatal(err)
@@ -1009,7 +992,6 @@ func TestABI_MethodById(t *testing.T) {
 }

 func TestABI_EventById(t *testing.T) {
-	t.Parallel()
 	tests := []struct {
 		name  string
 		json  string
@@ -1076,7 +1058,6 @@ func TestABI_EventById(t *testing.T) {
 }

 func TestABI_ErrorByID(t *testing.T) {
-	t.Parallel()
 	abi, err := JSON(strings.NewReader(`[
 		{"inputs":[{"internalType":"uint256","name":"x","type":"uint256"}],"name":"MyError1","type":"error"},
 		{"inputs":[{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"string","name":"b","type":"string"},{"internalType":"address","name":"c","type":"address"}],"internalType":"struct MyError.MyStruct","name":"x","type":"tuple"},{"internalType":"address","name":"y","type":"address"},{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"string","name":"b","type":"string"},{"internalType":"address","name":"c","type":"address"}],"internalType":"struct MyError.MyStruct","name":"z","type":"tuple"}],"name":"MyError2","type":"error"},
@@ -1107,7 +1088,6 @@ func TestABI_ErrorByID(t *testing.T) {
 // TestDoubleDuplicateMethodNames checks that if transfer0 already exists, there won't be a name
 // conflict and that the second transfer method will be renamed transfer1.
 func TestDoubleDuplicateMethodNames(t *testing.T) {
-	t.Parallel()
 	abiJSON := `[{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"value","type":"uint256"}],"name":"transfer","outputs":[{"name":"ok","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"value","type":"uint256"},{"name":"data","type":"bytes"}],"name":"transfer0","outputs":[{"name":"ok","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"value","type":"uint256"},{"name":"data","type":"bytes"},{"name":"customFallback","type":"string"}],"name":"transfer","outputs":[{"name":"ok","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]`
 	contractAbi, err := JSON(strings.NewReader(abiJSON))
 	if err != nil {
@@ -1137,7 +1117,6 @@ func TestDoubleDuplicateMethodNames(t *testing.T) {
 //		event send();
 //	}
 func TestDoubleDuplicateEventNames(t *testing.T) {
-	t.Parallel()
 	abiJSON := `[{"anonymous": false,"inputs": [{"indexed": false,"internalType": "uint256","name": "a","type": "uint256"}],"name": "send","type": "event"},{"anonymous": false,"inputs": [],"name": "send0","type": "event"},{	"anonymous": false,	"inputs": [],"name": "send","type": "event"}]`
 	contractAbi, err := JSON(strings.NewReader(abiJSON))
 	if err != nil {
@@ -1165,7 +1144,6 @@ func TestDoubleDuplicateEventNames(t *testing.T) {
 //		event send(uint256, uint256);
 //	}
 func TestUnnamedEventParam(t *testing.T) {
-	t.Parallel()
 	abiJSON := `[{ "anonymous": false, "inputs": [{	"indexed": false,"internalType": "uint256",	"name": "","type": "uint256"},{"indexed": false,"internalType": "uint256","name": "","type": "uint256"}],"name": "send","type": "event"}]`
 	contractAbi, err := JSON(strings.NewReader(abiJSON))
 	if err != nil {
@@ -1195,13 +1173,9 @@ func TestUnpackRevert(t *testing.T) {
 		{"", "", errors.New("invalid data for unpacking")},
 		{"08c379a1", "", errors.New("invalid data for unpacking")},
 		{"08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000d72657665727420726561736f6e00000000000000000000000000000000000000", "revert reason", nil},
-		{"4e487b710000000000000000000000000000000000000000000000000000000000000000", "generic panic", nil},
-		{"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))
 			if c.expectErr != nil {
 				if err == nil {
--- a/accounts/abi/argument.go
+++ b/accounts/abi/argument.go
@@ -80,7 +80,7 @@ func (arguments Arguments) isTuple() bool {
 func (arguments Arguments) Unpack(data []byte) ([]interface{}, error) {
 	if len(data) == 0 {
 		if len(arguments.NonIndexed()) != 0 {
-			return nil, errors.New("abi: attempting to unmarshal an empty string while arguments are expected")
+			return nil, errors.New("abi: attempting to unmarshall an empty string while arguments are expected")
 		}
 		return make([]interface{}, 0), nil
 	}
@@ -95,7 +95,7 @@ func (arguments Arguments) UnpackIntoMap(v map[string]interface{}, data []byte)
 	}
 	if len(data) == 0 {
 		if len(arguments.NonIndexed()) != 0 {
-			return errors.New("abi: attempting to unmarshal an empty string while arguments are expected")
+			return errors.New("abi: attempting to unmarshall an empty string while arguments are expected")
 		}
 		return nil // Nothing to unmarshal, return
 	}
--- a/accounts/abi/bind/auth.go
+++ b/accounts/abi/bind/auth.go
@@ -56,7 +56,7 @@ func NewTransactor(keyin io.Reader, passphrase string) (*TransactOpts, error) {
 }

 // NewKeyStoreTransactor is a utility method to easily create a transaction signer from
-// a decrypted key from a keystore.
+// an decrypted key from a keystore.
 //
 // Deprecated: Use NewKeyStoreTransactorWithChainID instead.
 func NewKeyStoreTransactor(keystore *keystore.KeyStore, account accounts.Account) (*TransactOpts, error) {
@@ -117,7 +117,7 @@ func NewTransactorWithChainID(keyin io.Reader, passphrase string, chainID *big.I
 }

 // NewKeyStoreTransactorWithChainID is a utility method to easily create a transaction signer from
-// a decrypted key from a keystore.
+// an decrypted key from a keystore.
 func NewKeyStoreTransactorWithChainID(keystore *keystore.KeyStore, account accounts.Account, chainID *big.Int) (*TransactOpts, error) {
 	if chainID == nil {
 		return nil, ErrNoChainID
--- a/accounts/abi/bind/backend.go
+++ b/accounts/abi/bind/backend.go
@@ -37,10 +37,6 @@ var (
 	// on a backend that doesn't implement PendingContractCaller.
 	ErrNoPendingState = errors.New("backend does not support pending state")

-	// ErrNoBlockHashState is raised when attempting to perform a block hash action
-	// on a backend that doesn't implement BlockHashContractCaller.
-	ErrNoBlockHashState = errors.New("backend does not support block hash state")
-
 	// ErrNoCodeAfterDeploy is returned by WaitDeployed if contract creation leaves
 	// an empty contract behind.
 	ErrNoCodeAfterDeploy = errors.New("no contract code after deployment")
@@ -69,27 +65,11 @@ type PendingContractCaller interface {
 	PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error)
 }

-// BlockHashContractCaller defines methods to perform contract calls on a specific block hash.
-// Call will try to discover this interface when access to a block by hash is requested.
-// If the backend does not support the block hash state, Call returns ErrNoBlockHashState.
-type BlockHashContractCaller interface {
-	// CodeAtHash returns the code of the given account in the state at the specified block hash.
-	CodeAtHash(ctx context.Context, contract common.Address, blockHash common.Hash) ([]byte, error)
-
-	// CallContractAtHash executes an Ethereum contract call against the state at the specified block hash.
-	CallContractAtHash(ctx context.Context, call ethereum.CallMsg, blockHash common.Hash) ([]byte, error)
-}
-
 // ContractTransactor defines the methods needed to allow operating with a contract
 // on a write only basis. Besides the transacting method, the remainder are helpers
 // used when the user does not provide some needed values, but rather leaves it up
 // to the transactor to decide.
 type ContractTransactor interface {
-	ethereum.GasEstimator
-	ethereum.GasPricer
-	ethereum.GasPricer1559
-	ethereum.TransactionSender
-
 	// HeaderByNumber returns a block header from the current canonical chain. If
 	// number is nil, the latest known header is returned.
 	HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
@@ -100,22 +80,48 @@ type ContractTransactor interface {
 	// PendingNonceAt retrieves the current pending nonce associated with an account.
 	PendingNonceAt(ctx context.Context, account common.Address) (uint64, error)

+	// SuggestGasPrice retrieves the currently suggested gas price to allow a timely
+	// execution of a transaction.
+	SuggestGasPrice(ctx context.Context) (*big.Int, error)
+
+	// SuggestGasTipCap retrieves the currently suggested 1559 priority fee to allow
+	// a timely execution of a transaction.
+	SuggestGasTipCap(ctx context.Context) (*big.Int, error)
+
+	// EstimateGas tries to estimate the gas needed to execute a specific
+	// transaction based on the current pending state of the backend blockchain.
+	// There is no guarantee that this is the true gas limit requirement as other
+	// transactions may be added or removed by miners, but it should provide a basis
+	// for setting a reasonable default.
+	EstimateGas(ctx context.Context, call ethereum.CallMsg) (gas uint64, err error)
+
+	// SendTransaction injects the transaction into the pending pool for execution.
+	SendTransaction(ctx context.Context, tx *types.Transaction) error
+
 	// SendTransactionConditional injects the conditional transaction into the pending pool for execution after verification.
 	SendTransactionConditional(ctx context.Context, tx *types.Transaction, opts ethapi.TransactionOpts) error
 }

+// ContractFilterer defines the methods needed to access log events using one-off
+// queries or continuous event subscriptions.
+type ContractFilterer interface {
+	// FilterLogs executes a log filter operation, blocking during execution and
+	// returning all the results in one batch.
+	//
+	// TODO(karalabe): Deprecate when the subscription one can return past data too.
+	FilterLogs(ctx context.Context, query ethereum.FilterQuery) ([]types.Log, error)
+
+	// SubscribeFilterLogs creates a background log filtering operation, returning
+	// a subscription immediately, which can be used to stream the found events.
+	SubscribeFilterLogs(ctx context.Context, query ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error)
+}
+
 // DeployBackend wraps the operations needed by WaitMined and WaitDeployed.
 type DeployBackend interface {
 	TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error)
 	CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error)
 }

-// ContractFilterer defines the methods needed to access log events using one-off
-// queries or continuous event subscriptions.
-type ContractFilterer interface {
-	ethereum.LogFilterer
-}
-
 // ContractBackend defines the methods needed to work with contracts on a read-write basis.
 type ContractBackend interface {
 	ContractCaller
--- a/accounts/abi/bind/backends/simulated.go
+++ b/accounts/abi/bind/backends/simulated.go
@@ -18,35 +18,942 @@ package backends

 import (
 	"context"
+	"errors"
+	"fmt"
+	"math/big"
+	"sync"
+	"time"

+	"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/common/hexutil"
+	"github.com/ethereum/go-ethereum/common/math"
+	"github.com/ethereum/go-ethereum/consensus/ethash"
 	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/ethclient/simulated"
+	"github.com/ethereum/go-ethereum/core/bloombits"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/eth/filters"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/event"
+	"github.com/ethereum/go-ethereum/internal/ethapi"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/rpc"
 )

-// SimulatedBackend is a simulated blockchain.
-// Deprecated: use package github.com/ethereum/go-ethereum/ethclient/simulated instead.
+// This nil assignment ensures at compile time that SimulatedBackend implements bind.ContractBackend.
+var _ bind.ContractBackend = (*SimulatedBackend)(nil)
+
+var (
+	errBlockNumberUnsupported  = errors.New("simulatedBackend cannot access blocks other than the latest block")
+	errBlockDoesNotExist       = errors.New("block does not exist in blockchain")
+	errTransactionDoesNotExist = errors.New("transaction does not exist")
+)
+
+// SimulatedBackend implements bind.ContractBackend, simulating a blockchain in
+// the background. Its main purpose is to allow for easy testing of contract bindings.
+// Simulated backend implements the following interfaces:
+// ChainReader, ChainStateReader, ContractBackend, ContractCaller, ContractFilterer, ContractTransactor,
+// DeployBackend, GasEstimator, GasPricer, LogFilterer, PendingContractCaller, TransactionReader, and TransactionSender
 type SimulatedBackend struct {
-	*simulated.Backend
-	simulated.Client
+	database   ethdb.Database   // In memory database to store our testing data
+	blockchain *core.BlockChain // Ethereum blockchain to handle the consensus
+
+	mu              sync.Mutex
+	pendingBlock    *types.Block   // Currently pending block that will be imported on request
+	pendingState    *state.StateDB // Currently pending state that will be the active on request
+	pendingReceipts types.Receipts // Currently receipts for the pending block
+
+	events       *filters.EventSystem  // for filtering log events live
+	filterSystem *filters.FilterSystem // for filtering database logs
+
+	config *params.ChainConfig
 }

-// Fork sets the head to a new block, which is based on the provided parentHash.
-func (b *SimulatedBackend) Fork(ctx context.Context, parentHash common.Hash) error {
-	return b.Backend.Fork(parentHash)
+// NewSimulatedBackendWithDatabase creates a new binding backend based on the given database
+// and uses a simulated blockchain for testing purposes.
+// A simulated backend always uses chainID 1337.
+func NewSimulatedBackendWithDatabase(database ethdb.Database, alloc core.GenesisAlloc, gasLimit uint64) *SimulatedBackend {
+	genesis := core.Genesis{
+		Config:   params.AllEthashProtocolChanges,
+		GasLimit: gasLimit,
+		Alloc:    alloc,
+	}
+	blockchain, _ := core.NewBlockChain(database, nil, &genesis, nil, ethash.NewFaker(), vm.Config{}, nil, nil)
+
+	backend := &SimulatedBackend{
+		database:   database,
+		blockchain: blockchain,
+		config:     genesis.Config,
+	}
+
+	filterBackend := &filterBackend{database, blockchain, backend}
+	backend.filterSystem = filters.NewFilterSystem(filterBackend, filters.Config{})
+	backend.events = filters.NewEventSystem(backend.filterSystem)
+
+	header := backend.blockchain.CurrentBlock()
+	block := backend.blockchain.GetBlock(header.Hash(), header.Number.Uint64())
+
+	backend.rollback(block)
+	return backend
 }

 // NewSimulatedBackend creates a new binding backend using a simulated blockchain
 // for testing purposes.
-//
 // A simulated backend always uses chainID 1337.
-//
-// Deprecated: please use simulated.Backend from package
-// github.com/ethereum/go-ethereum/ethclient/simulated instead.
 func NewSimulatedBackend(alloc core.GenesisAlloc, gasLimit uint64) *SimulatedBackend {
-	b := simulated.NewBackend(alloc, simulated.WithBlockGasLimit(gasLimit))
-	return &SimulatedBackend{
-		Backend: b,
-		Client:  b.Client(),
+	return NewSimulatedBackendWithDatabase(rawdb.NewMemoryDatabase(), alloc, gasLimit)
+}
+
+// Close terminates the underlying blockchain's update loop.
+func (b *SimulatedBackend) Close() error {
+	b.blockchain.Stop()
+	return nil
+}
+
+// Commit imports all the pending transactions as a single block and starts a
+// fresh new state.
+func (b *SimulatedBackend) Commit() common.Hash {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if _, err := b.blockchain.InsertChain([]*types.Block{b.pendingBlock}); err != nil {
+		panic(err) // This cannot happen unless the simulator is wrong, fail in that case
+	}
+	blockHash := b.pendingBlock.Hash()
+
+	// Using the last inserted block here makes it possible to build on a side
+	// chain after a fork.
+	b.rollback(b.pendingBlock)
+
+	return blockHash
+}
+
+// Rollback aborts all pending transactions, reverting to the last committed state.
+func (b *SimulatedBackend) Rollback() {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	header := b.blockchain.CurrentBlock()
+	block := b.blockchain.GetBlock(header.Hash(), header.Number.Uint64())
+
+	b.rollback(block)
+}
+
+func (b *SimulatedBackend) rollback(parent *types.Block) {
+	blocks, _ := core.GenerateChain(b.config, parent, ethash.NewFaker(), b.database, 1, func(int, *core.BlockGen) {})
+
+	b.pendingBlock = blocks[0]
+	b.pendingState, _ = state.New(b.pendingBlock.Root(), b.blockchain.StateCache(), nil)
+}
+
+// Fork creates a side-chain that can be used to simulate reorgs.
+//
+// This function should be called with the ancestor block where the new side
+// chain should be started. Transactions (old and new) can then be applied on
+// top and Commit-ed.
+//
+// Note, the side-chain will only become canonical (and trigger the events) when
+// it becomes longer. Until then CallContract will still operate on the current
+// canonical chain.
+//
+// There is a % chance that the side chain becomes canonical at the same length
+// to simulate live network behavior.
+func (b *SimulatedBackend) Fork(ctx context.Context, parent common.Hash) error {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if len(b.pendingBlock.Transactions()) != 0 {
+		return errors.New("pending block dirty")
+	}
+	block, err := b.blockByHash(ctx, parent)
+	if err != nil {
+		return err
+	}
+	b.rollback(block)
+	return nil
+}
+
+// stateByBlockNumber retrieves a state by a given blocknumber.
+func (b *SimulatedBackend) stateByBlockNumber(ctx context.Context, blockNumber *big.Int) (*state.StateDB, error) {
+	if blockNumber == nil || blockNumber.Cmp(b.blockchain.CurrentBlock().Number) == 0 {
+		return b.blockchain.State()
+	}
+	block, err := b.blockByNumber(ctx, blockNumber)
+	if err != nil {
+		return nil, err
+	}
+	return b.blockchain.StateAt(block.Root())
+}
+
+// CodeAt returns the code associated with a certain account in the blockchain.
+func (b *SimulatedBackend) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	stateDB, err := b.stateByBlockNumber(ctx, blockNumber)
+	if err != nil {
+		return nil, err
+	}
+
+	return stateDB.GetCode(contract), nil
+}
+
+// BalanceAt returns the wei balance of a certain account in the blockchain.
+func (b *SimulatedBackend) BalanceAt(ctx context.Context, contract common.Address, blockNumber *big.Int) (*big.Int, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	stateDB, err := b.stateByBlockNumber(ctx, blockNumber)
+	if err != nil {
+		return nil, err
+	}
+
+	return stateDB.GetBalance(contract), nil
+}
+
+// NonceAt returns the nonce of a certain account in the blockchain.
+func (b *SimulatedBackend) NonceAt(ctx context.Context, contract common.Address, blockNumber *big.Int) (uint64, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	stateDB, err := b.stateByBlockNumber(ctx, blockNumber)
+	if err != nil {
+		return 0, err
+	}
+
+	return stateDB.GetNonce(contract), nil
+}
+
+// StorageAt returns the value of key in the storage of an account in the blockchain.
+func (b *SimulatedBackend) StorageAt(ctx context.Context, contract common.Address, key common.Hash, blockNumber *big.Int) ([]byte, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	stateDB, err := b.stateByBlockNumber(ctx, blockNumber)
+	if err != nil {
+		return nil, err
+	}
+
+	val := stateDB.GetState(contract, key)
+	return val[:], nil
+}
+
+// TransactionReceipt returns the receipt of a transaction.
+func (b *SimulatedBackend) TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	receipt, _, _, _ := rawdb.ReadReceipt(b.database, txHash, b.config)
+	if receipt == nil {
+		return nil, ethereum.NotFound
+	}
+	return receipt, nil
+}
+
+// TransactionByHash checks the pool of pending transactions in addition to the
+// blockchain. The isPending return value indicates whether the transaction has been
+// mined yet. Note that the transaction may not be part of the canonical chain even if
+// it's not pending.
+func (b *SimulatedBackend) TransactionByHash(ctx context.Context, txHash common.Hash) (*types.Transaction, bool, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	tx := b.pendingBlock.Transaction(txHash)
+	if tx != nil {
+		return tx, true, nil
+	}
+	tx, _, _, _ = rawdb.ReadTransaction(b.database, txHash)
+	if tx != nil {
+		return tx, false, nil
+	}
+	return nil, false, ethereum.NotFound
+}
+
+// BlockByHash retrieves a block based on the block hash.
+func (b *SimulatedBackend) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	return b.blockByHash(ctx, hash)
+}
+
+// blockByHash retrieves a block based on the block hash without Locking.
+func (b *SimulatedBackend) blockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {
+	if hash == b.pendingBlock.Hash() {
+		return b.pendingBlock, nil
+	}
+
+	block := b.blockchain.GetBlockByHash(hash)
+	if block != nil {
+		return block, nil
+	}
+
+	return nil, errBlockDoesNotExist
+}
+
+// BlockByNumber retrieves a block from the database by number, caching it
+// (associated with its hash) if found.
+func (b *SimulatedBackend) BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	return b.blockByNumber(ctx, number)
+}
+
+// blockByNumber retrieves a block from the database by number, caching it
+// (associated with its hash) if found without Lock.
+func (b *SimulatedBackend) blockByNumber(ctx context.Context, number *big.Int) (*types.Block, error) {
+	if number == nil || number.Cmp(b.pendingBlock.Number()) == 0 {
+		return b.blockByHash(ctx, b.blockchain.CurrentBlock().Hash())
+	}
+
+	block := b.blockchain.GetBlockByNumber(uint64(number.Int64()))
+	if block == nil {
+		return nil, errBlockDoesNotExist
+	}
+
+	return block, nil
+}
+
+// HeaderByHash returns a block header from the current canonical chain.
+func (b *SimulatedBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if hash == b.pendingBlock.Hash() {
+		return b.pendingBlock.Header(), nil
+	}
+
+	header := b.blockchain.GetHeaderByHash(hash)
+	if header == nil {
+		return nil, errBlockDoesNotExist
+	}
+
+	return header, nil
+}
+
+// HeaderByNumber returns a block header from the current canonical chain. If number is
+// nil, the latest known header is returned.
+func (b *SimulatedBackend) HeaderByNumber(ctx context.Context, block *big.Int) (*types.Header, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if block == nil || block.Cmp(b.pendingBlock.Number()) == 0 {
+		return b.blockchain.CurrentHeader(), nil
+	}
+
+	return b.blockchain.GetHeaderByNumber(uint64(block.Int64())), nil
+}
+
+// TransactionCount returns the number of transactions in a given block.
+func (b *SimulatedBackend) TransactionCount(ctx context.Context, blockHash common.Hash) (uint, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if blockHash == b.pendingBlock.Hash() {
+		return uint(b.pendingBlock.Transactions().Len()), nil
+	}
+
+	block := b.blockchain.GetBlockByHash(blockHash)
+	if block == nil {
+		return uint(0), errBlockDoesNotExist
+	}
+
+	return uint(block.Transactions().Len()), nil
+}
+
+// TransactionInBlock returns the transaction for a specific block at a specific index.
+func (b *SimulatedBackend) TransactionInBlock(ctx context.Context, blockHash common.Hash, index uint) (*types.Transaction, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if blockHash == b.pendingBlock.Hash() {
+		transactions := b.pendingBlock.Transactions()
+		if uint(len(transactions)) < index+1 {
+			return nil, errTransactionDoesNotExist
+		}
+
+		return transactions[index], nil
+	}
+
+	block := b.blockchain.GetBlockByHash(blockHash)
+	if block == nil {
+		return nil, errBlockDoesNotExist
+	}
+
+	transactions := block.Transactions()
+	if uint(len(transactions)) < index+1 {
+		return nil, errTransactionDoesNotExist
+	}
+
+	return transactions[index], nil
+}
+
+// PendingCodeAt returns the code associated with an account in the pending state.
+func (b *SimulatedBackend) PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	return b.pendingState.GetCode(contract), nil
+}
+
+func newRevertError(result *core.ExecutionResult) *revertError {
+	reason, errUnpack := abi.UnpackRevert(result.Revert())
+	err := errors.New("execution reverted")
+	if errUnpack == nil {
+		err = fmt.Errorf("execution reverted: %v", reason)
+	}
+	return &revertError{
+		error:  err,
+		reason: hexutil.Encode(result.Revert()),
 	}
 }
+
+// revertError is an API error that encompasses an EVM revert with JSON error
+// code and a binary data blob.
+type revertError struct {
+	error
+	reason string // revert reason hex encoded
+}
+
+// ErrorCode returns the JSON error code for a revert.
+// See: https://github.com/ethereum/wiki/wiki/JSON-RPC-Error-Codes-Improvement-Proposal
+func (e *revertError) ErrorCode() int {
+	return 3
+}
+
+// ErrorData returns the hex encoded revert reason.
+func (e *revertError) ErrorData() interface{} {
+	return e.reason
+}
+
+// CallContract executes a contract call.
+func (b *SimulatedBackend) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if blockNumber != nil && blockNumber.Cmp(b.blockchain.CurrentBlock().Number) != 0 {
+		return nil, errBlockNumberUnsupported
+	}
+	stateDB, err := b.blockchain.State()
+	if err != nil {
+		return nil, err
+	}
+	res, err := b.callContract(ctx, call, b.blockchain.CurrentBlock(), stateDB)
+	if err != nil {
+		return nil, err
+	}
+	// If the result contains a revert reason, try to unpack and return it.
+	if len(res.Revert()) > 0 {
+		return nil, newRevertError(res)
+	}
+	return res.Return(), res.Err
+}
+
+// PendingCallContract executes a contract call on the pending state.
+func (b *SimulatedBackend) PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	defer b.pendingState.RevertToSnapshot(b.pendingState.Snapshot())
+
+	res, err := b.callContract(ctx, call, b.pendingBlock.Header(), b.pendingState)
+	if err != nil {
+		return nil, err
+	}
+	// If the result contains a revert reason, try to unpack and return it.
+	if len(res.Revert()) > 0 {
+		return nil, newRevertError(res)
+	}
+	return res.Return(), res.Err
+}
+
+// PendingNonceAt implements PendingStateReader.PendingNonceAt, retrieving
+// the nonce currently pending for the account.
+func (b *SimulatedBackend) PendingNonceAt(ctx context.Context, account common.Address) (uint64, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	return b.pendingState.GetOrNewStateObject(account).Nonce(), nil
+}
+
+// SuggestGasPrice implements ContractTransactor.SuggestGasPrice. Since the simulated
+// chain doesn't have miners, we just return a gas price of 1 for any call.
+func (b *SimulatedBackend) SuggestGasPrice(ctx context.Context) (*big.Int, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if b.pendingBlock.Header().BaseFee != nil {
+		return b.pendingBlock.Header().BaseFee, nil
+	}
+	return big.NewInt(1), nil
+}
+
+// SuggestGasTipCap implements ContractTransactor.SuggestGasTipCap. Since the simulated
+// chain doesn't have miners, we just return a gas tip of 1 for any call.
+func (b *SimulatedBackend) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
+	return big.NewInt(1), nil
+}
+
+// EstimateGas executes the requested code against the currently pending block/state and
+// returns the used amount of gas.
+func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMsg) (uint64, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	// Determine the lowest and highest possible gas limits to binary search in between
+	var (
+		lo  uint64 = params.TxGas - 1
+		hi  uint64
+		cap uint64
+	)
+	if call.Gas >= params.TxGas {
+		hi = call.Gas
+	} else {
+		hi = b.pendingBlock.GasLimit()
+	}
+	// Normalize the max fee per gas the call is willing to spend.
+	var feeCap *big.Int
+	if call.GasPrice != nil && (call.GasFeeCap != nil || call.GasTipCap != nil) {
+		return 0, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified")
+	} else if call.GasPrice != nil {
+		feeCap = call.GasPrice
+	} else if call.GasFeeCap != nil {
+		feeCap = call.GasFeeCap
+	} else {
+		feeCap = common.Big0
+	}
+	// Recap the highest gas allowance with account's balance.
+	if feeCap.BitLen() != 0 {
+		balance := b.pendingState.GetBalance(call.From) // from can't be nil
+		available := new(big.Int).Set(balance)
+		if call.Value != nil {
+			if call.Value.Cmp(available) >= 0 {
+				return 0, core.ErrInsufficientFundsForTransfer
+			}
+			available.Sub(available, call.Value)
+		}
+		allowance := new(big.Int).Div(available, feeCap)
+		if allowance.IsUint64() && hi > allowance.Uint64() {
+			transfer := call.Value
+			if transfer == nil {
+				transfer = new(big.Int)
+			}
+			log.Warn("Gas estimation capped by limited funds", "original", hi, "balance", balance,
+				"sent", transfer, "feecap", feeCap, "fundable", allowance)
+			hi = allowance.Uint64()
+		}
+	}
+	cap = hi
+
+	// Create a helper to check if a gas allowance results in an executable transaction
+	executable := func(gas uint64) (bool, *core.ExecutionResult, error) {
+		call.Gas = gas
+
+		snapshot := b.pendingState.Snapshot()
+		res, err := b.callContract(ctx, call, b.pendingBlock.Header(), b.pendingState)
+		b.pendingState.RevertToSnapshot(snapshot)
+
+		if err != nil {
+			if errors.Is(err, core.ErrIntrinsicGas) {
+				return true, nil, nil // Special case, raise gas limit
+			}
+			return true, nil, err // Bail out
+		}
+		return res.Failed(), res, nil
+	}
+	// Execute the binary search and hone in on an executable gas limit
+	for lo+1 < hi {
+		mid := (hi + lo) / 2
+		failed, _, err := executable(mid)
+
+		// If the error is not nil(consensus error), it means the provided message
+		// call or transaction will never be accepted no matter how much gas it is
+		// assigned. Return the error directly, don't struggle any more
+		if err != nil {
+			return 0, err
+		}
+		if failed {
+			lo = mid
+		} else {
+			hi = mid
+		}
+	}
+	// Reject the transaction as invalid if it still fails at the highest allowance
+	if hi == cap {
+		failed, result, err := executable(hi)
+		if err != nil {
+			return 0, err
+		}
+		if failed {
+			if result != nil && result.Err != vm.ErrOutOfGas {
+				if len(result.Revert()) > 0 {
+					return 0, newRevertError(result)
+				}
+				return 0, result.Err
+			}
+			// Otherwise, the specified gas cap is too low
+			return 0, fmt.Errorf("gas required exceeds allowance (%d)", cap)
+		}
+	}
+	return hi, nil
+}
+
+// callContract implements common code between normal and pending contract calls.
+// state is modified during execution, make sure to copy it if necessary.
+func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallMsg, header *types.Header, stateDB *state.StateDB) (*core.ExecutionResult, error) {
+	// Gas prices post 1559 need to be initialized
+	if call.GasPrice != nil && (call.GasFeeCap != nil || call.GasTipCap != nil) {
+		return nil, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified")
+	}
+	head := b.blockchain.CurrentHeader()
+	if !b.blockchain.Config().IsLondon(head.Number) {
+		// If there's no basefee, then it must be a non-1559 execution
+		if call.GasPrice == nil {
+			call.GasPrice = new(big.Int)
+		}
+		call.GasFeeCap, call.GasTipCap = call.GasPrice, call.GasPrice
+	} else {
+		// A basefee is provided, necessitating 1559-type execution
+		if call.GasPrice != nil {
+			// User specified the legacy gas field, convert to 1559 gas typing
+			call.GasFeeCap, call.GasTipCap = call.GasPrice, call.GasPrice
+		} else {
+			// User specified 1559 gas fields (or none), use those
+			if call.GasFeeCap == nil {
+				call.GasFeeCap = new(big.Int)
+			}
+			if call.GasTipCap == nil {
+				call.GasTipCap = new(big.Int)
+			}
+			// Backfill the legacy gasPrice for EVM execution, unless we're all zeroes
+			call.GasPrice = new(big.Int)
+			if call.GasFeeCap.BitLen() > 0 || call.GasTipCap.BitLen() > 0 {
+				call.GasPrice = math.BigMin(new(big.Int).Add(call.GasTipCap, head.BaseFee), call.GasFeeCap)
+			}
+		}
+	}
+	// Ensure message is initialized properly.
+	if call.Gas == 0 {
+		call.Gas = 50000000
+	}
+	if call.Value == nil {
+		call.Value = new(big.Int)
+	}
+
+	// Set infinite balance to the fake caller account.
+	from := stateDB.GetOrNewStateObject(call.From)
+	from.SetBalance(math.MaxBig256)
+
+	// Execute the call.
+	msg := &core.Message{
+		From:              call.From,
+		To:                call.To,
+		Value:             call.Value,
+		GasLimit:          call.Gas,
+		GasPrice:          call.GasPrice,
+		GasFeeCap:         call.GasFeeCap,
+		GasTipCap:         call.GasTipCap,
+		Data:              call.Data,
+		AccessList:        call.AccessList,
+		SkipAccountChecks: true,
+	}
+
+	// Create a new environment which holds all relevant information
+	// about the transaction and calling mechanisms.
+	txContext := core.NewEVMTxContext(msg)
+	evmContext := core.NewEVMBlockContext(header, b.blockchain, nil)
+	vmEnv := vm.NewEVM(evmContext, txContext, stateDB, b.config, vm.Config{NoBaseFee: true})
+	gasPool := new(core.GasPool).AddGas(math.MaxUint64)
+
+	return core.ApplyMessage(vmEnv, msg, gasPool)
+}
+
+// SendTransaction updates the pending block to include the given transaction.
+func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transaction) error {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	// Get the last block
+	block, err := b.blockByHash(ctx, b.pendingBlock.ParentHash())
+	if err != nil {
+		return errors.New("could not fetch parent")
+	}
+	// Check transaction validity
+	signer := types.MakeSigner(b.blockchain.Config(), block.Number(), block.Time())
+	sender, err := types.Sender(signer, tx)
+	if err != nil {
+		return fmt.Errorf("invalid transaction: %v", err)
+	}
+	nonce := b.pendingState.GetNonce(sender)
+	if tx.Nonce() != nonce {
+		return fmt.Errorf("invalid transaction nonce: got %d, want %d", tx.Nonce(), nonce)
+	}
+	// Include tx in chain
+	blocks, receipts := core.GenerateChain(b.config, block, ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) {
+		for _, tx := range b.pendingBlock.Transactions() {
+			block.AddTxWithChain(b.blockchain, tx)
+		}
+		block.AddTxWithChain(b.blockchain, tx)
+	})
+	stateDB, _ := b.blockchain.State()
+
+	b.pendingBlock = blocks[0]
+	b.pendingState, _ = state.New(b.pendingBlock.Root(), stateDB.Database(), nil)
+	b.pendingReceipts = receipts[0]
+	return nil
+}
+
+// SendTransaction updates the pending block to include the given transaction.
+func (b *SimulatedBackend) SendTransactionConditional(ctx context.Context, tx *types.Transaction, opts ethapi.TransactionOpts) error {
+	state, err := b.blockchain.State()
+	if err != nil {
+		return err
+	}
+	if err := opts.Check(b.pendingBlock.NumberU64(), b.pendingBlock.Time(), state); err != nil {
+		return err
+	}
+	return b.SendTransaction(ctx, tx)
+}
+
+// FilterLogs executes a log filter operation, blocking during execution and
+// returning all the results in one batch.
+//
+// TODO(karalabe): Deprecate when the subscription one can return past data too.
+func (b *SimulatedBackend) FilterLogs(ctx context.Context, query ethereum.FilterQuery) ([]types.Log, error) {
+	var filter *filters.Filter
+	if query.BlockHash != nil {
+		// Block filter requested, construct a single-shot filter
+		filter = b.filterSystem.NewBlockFilter(*query.BlockHash, query.Addresses, query.Topics)
+	} else {
+		// Initialize unset filter boundaries to run from genesis to chain head
+		from := int64(0)
+		if query.FromBlock != nil {
+			from = query.FromBlock.Int64()
+		}
+		to := int64(-1)
+		if query.ToBlock != nil {
+			to = query.ToBlock.Int64()
+		}
+		// Construct the range filter
+		filter = b.filterSystem.NewRangeFilter(from, to, query.Addresses, query.Topics, false)
+	}
+	// Run the filter and return all the logs
+	logs, err := filter.Logs(ctx)
+	if err != nil {
+		return nil, err
+	}
+	res := make([]types.Log, len(logs))
+	for i, nLog := range logs {
+		res[i] = *nLog
+	}
+	return res, nil
+}
+
+// SubscribeFilterLogs creates a background log filtering operation, returning a
+// subscription immediately, which can be used to stream the found events.
+func (b *SimulatedBackend) SubscribeFilterLogs(ctx context.Context, query ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error) {
+	// Subscribe to contract events
+	sink := make(chan []*types.Log)
+
+	sub, err := b.events.SubscribeLogs(query, sink)
+	if err != nil {
+		return nil, err
+	}
+	// Since we're getting logs in batches, we need to flatten them into a plain stream
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case logs := <-sink:
+				for _, nlog := range logs {
+					select {
+					case ch <- *nlog:
+					case err := <-sub.Err():
+						return err
+					case <-quit:
+						return nil
+					}
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
+}
+
+// SubscribeNewHead returns an event subscription for a new header.
+func (b *SimulatedBackend) SubscribeNewHead(ctx context.Context, ch chan<- *types.Header) (ethereum.Subscription, error) {
+	// subscribe to a new head
+	sink := make(chan *types.Header)
+	sub := b.events.SubscribeNewHeads(sink)
+
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case head := <-sink:
+				select {
+				case ch <- head:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
+}
+
+// AdjustTime adds a time shift to the simulated clock.
+// It can only be called on empty blocks.
+func (b *SimulatedBackend) AdjustTime(adjustment time.Duration) error {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if len(b.pendingBlock.Transactions()) != 0 {
+		return errors.New("Could not adjust time on non-empty block")
+	}
+	// Get the last block
+	block := b.blockchain.GetBlockByHash(b.pendingBlock.ParentHash())
+	if block == nil {
+		return errors.New("could not find parent")
+	}
+
+	blocks, _ := core.GenerateChain(b.config, block, ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) {
+		block.OffsetTime(int64(adjustment.Seconds()))
+	})
+	stateDB, _ := b.blockchain.State()
+
+	b.pendingBlock = blocks[0]
+	b.pendingState, _ = state.New(b.pendingBlock.Root(), stateDB.Database(), nil)
+
+	return nil
+}
+
+// Blockchain returns the underlying blockchain.
+func (b *SimulatedBackend) Blockchain() *core.BlockChain {
+	return b.blockchain
+}
+
+// filterBackend implements filters.Backend to support filtering for logs without
+// taking bloom-bits acceleration structures into account.
+type filterBackend struct {
+	db      ethdb.Database
+	bc      *core.BlockChain
+	backend *SimulatedBackend
+}
+
+func (fb *filterBackend) ChainDb() ethdb.Database { return fb.db }
+
+func (fb *filterBackend) EventMux() *event.TypeMux { panic("not supported") }
+
+func (fb *filterBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error) {
+	switch number {
+	case rpc.PendingBlockNumber:
+		if block := fb.backend.pendingBlock; block != nil {
+			return block.Header(), nil
+		}
+		return nil, nil
+	case rpc.LatestBlockNumber:
+		return fb.bc.CurrentHeader(), nil
+	case rpc.FinalizedBlockNumber:
+		return fb.bc.CurrentFinalBlock(), nil
+	case rpc.SafeBlockNumber:
+		return fb.bc.CurrentSafeBlock(), nil
+	default:
+		return fb.bc.GetHeaderByNumber(uint64(number.Int64())), nil
+	}
+}
+
+func (fb *filterBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
+	return fb.bc.GetHeaderByHash(hash), nil
+}
+
+func (fb *filterBackend) GetBody(ctx context.Context, hash common.Hash, number rpc.BlockNumber) (*types.Body, error) {
+	if body := fb.bc.GetBody(hash); body != nil {
+		return body, nil
+	}
+	return nil, errors.New("block body not found")
+}
+
+func (fb *filterBackend) PendingBlockAndReceipts() (*types.Block, types.Receipts) {
+	return fb.backend.pendingBlock, fb.backend.pendingReceipts
+}
+
+func (fb *filterBackend) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error) {
+	number := rawdb.ReadHeaderNumber(fb.db, hash)
+	if number == nil {
+		return nil, nil
+	}
+	header := rawdb.ReadHeader(fb.db, hash, *number)
+	if header == nil {
+		return nil, nil
+	}
+	return rawdb.ReadReceipts(fb.db, hash, *number, header.Time, fb.bc.Config()), nil
+}
+
+func (fb *filterBackend) GetLogs(ctx context.Context, hash common.Hash, number uint64) ([][]*types.Log, error) {
+	logs := rawdb.ReadLogs(fb.db, hash, number, fb.bc.Config())
+	return logs, nil
+}
+
+func (fb *filterBackend) SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) event.Subscription {
+	return nullSubscription()
+}
+
+func (fb *filterBackend) SubscribeNewVoteEvent(ch chan<- core.NewVoteEvent) event.Subscription {
+	return nullSubscription()
+}
+
+func (fb *filterBackend) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription {
+	return fb.bc.SubscribeChainEvent(ch)
+}
+
+func (fb *filterBackend) SubscribeFinalizedHeaderEvent(ch chan<- core.FinalizedHeaderEvent) event.Subscription {
+	return fb.bc.SubscribeFinalizedHeaderEvent(ch)
+}
+
+func (fb *filterBackend) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription {
+	return fb.bc.SubscribeRemovedLogsEvent(ch)
+}
+
+func (fb *filterBackend) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription {
+	return fb.bc.SubscribeLogsEvent(ch)
+}
+
+func (fb *filterBackend) SubscribePendingLogsEvent(ch chan<- []*types.Log) event.Subscription {
+	return nullSubscription()
+}
+
+func (fb *filterBackend) BloomStatus() (uint64, uint64) { return 4096, 0 }
+
+func (fb *filterBackend) ServiceFilter(ctx context.Context, ms *bloombits.MatcherSession) {
+	panic("not supported")
+}
+
+func (fb *filterBackend) ChainConfig() *params.ChainConfig {
+	panic("not supported")
+}
+
+func (fb *filterBackend) CurrentHeader() *types.Header {
+	panic("not supported")
+}
+
+func nullSubscription() event.Subscription {
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		<-quit
+		return nil
+	})
+}
--- a/accounts/abi/bind/backends/simulated_test.go
+++ b/accounts/abi/bind/backends/simulated_test.go
--- a/accounts/abi/bind/base.go
+++ b/accounts/abi/bind/base.go
@@ -48,7 +48,6 @@ type CallOpts struct {
 	Pending     bool            // Whether to operate on the pending state or the last known one
 	From        common.Address  // Optional the sender address, otherwise the first account is used
 	BlockNumber *big.Int        // Optional the block number on which the call should be performed
-	BlockHash   common.Hash     // Optional the block hash on which the call should be performed
 	Context     context.Context // Network context to support cancellation and timeouts (nil = no timeout)
 }

@@ -190,23 +189,6 @@ func (c *BoundContract) Call(opts *CallOpts, results *[]interface{}, method stri
 				return ErrNoCode
 			}
 		}
-	} else if opts.BlockHash != (common.Hash{}) {
-		bh, ok := c.caller.(BlockHashContractCaller)
-		if !ok {
-			return ErrNoBlockHashState
-		}
-		output, err = bh.CallContractAtHash(ctx, msg, opts.BlockHash)
-		if err != nil {
-			return err
-		}
-		if len(output) == 0 {
-			// Make sure we have a contract to operate on, and bail out otherwise.
-			if code, err = bh.CodeAtHash(ctx, c.address, opts.BlockHash); err != nil {
-				return err
-			} else if len(code) == 0 {
-				return ErrNoCode
-			}
-		}
 	} else {
 		output, err = c.caller.CallContract(ctx, msg, opts.BlockNumber)
 		if err != nil {
@@ -238,7 +220,7 @@ func (c *BoundContract) Transact(opts *TransactOpts, method string, params ...in
 	if err != nil {
 		return nil, err
 	}
-	// todo(rjl493456442) check whether the method is payable or not,
+	// todo(rjl493456442) check the method is payable or not,
 	// reject invalid transaction at the first place
 	return c.transact(opts, &c.address, input)
 }
@@ -246,7 +228,7 @@ func (c *BoundContract) Transact(opts *TransactOpts, method string, params ...in
 // RawTransact initiates a transaction with the given raw calldata as the input.
 // It's usually used to initiate transactions for invoking **Fallback** function.
 func (c *BoundContract) RawTransact(opts *TransactOpts, calldata []byte) (*types.Transaction, error) {
-	// todo(rjl493456442) check whether the method is payable or not,
+	// todo(rjl493456442) check the method is payable or not,
 	// reject invalid transaction at the first place
 	return c.transact(opts, &c.address, calldata)
 }
--- a/accounts/abi/bind/base_test.go
+++ b/accounts/abi/bind/base_test.go
@@ -119,28 +119,7 @@ func (mc *mockPendingCaller) PendingCallContract(ctx context.Context, call ether
 	return mc.pendingCallContractBytes, mc.pendingCallContractErr
 }

-type mockBlockHashCaller struct {
-	*mockCaller
-	codeAtHashBytes          []byte
-	codeAtHashErr            error
-	codeAtHashCalled         bool
-	callContractAtHashCalled bool
-	callContractAtHashBytes  []byte
-	callContractAtHashErr    error
-}
-
-func (mc *mockBlockHashCaller) CodeAtHash(ctx context.Context, contract common.Address, hash common.Hash) ([]byte, error) {
-	mc.codeAtHashCalled = true
-	return mc.codeAtHashBytes, mc.codeAtHashErr
-}
-
-func (mc *mockBlockHashCaller) CallContractAtHash(ctx context.Context, call ethereum.CallMsg, hash common.Hash) ([]byte, error) {
-	mc.callContractAtHashCalled = true
-	return mc.callContractAtHashBytes, mc.callContractAtHashErr
-}
-
 func TestPassingBlockNumber(t *testing.T) {
-	t.Parallel()
 	mc := &mockPendingCaller{
 		mockCaller: &mockCaller{
 			codeAtBytes: []byte{1, 2, 3},
@@ -192,7 +171,6 @@ func TestPassingBlockNumber(t *testing.T) {
 const hexData = "0x000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158"

 func TestUnpackIndexedStringTyLogIntoMap(t *testing.T) {
-	t.Parallel()
 	hash := crypto.Keccak256Hash([]byte("testName"))
 	topics := []common.Hash{
 		crypto.Keccak256Hash([]byte("received(string,address,uint256,bytes)")),
@@ -214,7 +192,6 @@ func TestUnpackIndexedStringTyLogIntoMap(t *testing.T) {
 }

 func TestUnpackAnonymousLogIntoMap(t *testing.T) {
-	t.Parallel()
 	mockLog := newMockLog(nil, common.HexToHash("0x0"))

 	abiString := `[{"anonymous":false,"inputs":[{"indexed":false,"name":"amount","type":"uint256"}],"name":"received","type":"event"}]`
@@ -232,7 +209,6 @@ func TestUnpackAnonymousLogIntoMap(t *testing.T) {
 }

 func TestUnpackIndexedSliceTyLogIntoMap(t *testing.T) {
-	t.Parallel()
 	sliceBytes, err := rlp.EncodeToBytes([]string{"name1", "name2", "name3", "name4"})
 	if err != nil {
 		t.Fatal(err)
@@ -258,7 +234,6 @@ func TestUnpackIndexedSliceTyLogIntoMap(t *testing.T) {
 }

 func TestUnpackIndexedArrayTyLogIntoMap(t *testing.T) {
-	t.Parallel()
 	arrBytes, err := rlp.EncodeToBytes([2]common.Address{common.HexToAddress("0x0"), common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2")})
 	if err != nil {
 		t.Fatal(err)
@@ -284,7 +259,6 @@ func TestUnpackIndexedArrayTyLogIntoMap(t *testing.T) {
 }

 func TestUnpackIndexedFuncTyLogIntoMap(t *testing.T) {
-	t.Parallel()
 	mockAddress := common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2")
 	addrBytes := mockAddress.Bytes()
 	hash := crypto.Keccak256Hash([]byte("mockFunction(address,uint)"))
@@ -311,7 +285,6 @@ func TestUnpackIndexedFuncTyLogIntoMap(t *testing.T) {
 }

 func TestUnpackIndexedBytesTyLogIntoMap(t *testing.T) {
-	t.Parallel()
 	bytes := []byte{1, 2, 3, 4, 5}
 	hash := crypto.Keccak256Hash(bytes)
 	topics := []common.Hash{
@@ -334,7 +307,6 @@ func TestUnpackIndexedBytesTyLogIntoMap(t *testing.T) {
 }

 func TestTransactGasFee(t *testing.T) {
-	t.Parallel()
 	assert := assert.New(t)

 	// GasTipCap and GasFeeCap
@@ -410,7 +382,6 @@ func newMockLog(topics []common.Hash, txHash common.Hash) types.Log {
 }

 func TestCall(t *testing.T) {
-	t.Parallel()
 	var method, methodWithArg = "something", "somethingArrrrg"
 	tests := []struct {
 		name, method string
@@ -434,15 +405,6 @@ func TestCall(t *testing.T) {
 			Pending: true,
 		},
 		method: method,
-	}, {
-		name: "ok hash",
-		mc: &mockBlockHashCaller{
-			codeAtHashBytes: []byte{0},
-		},
-		opts: &bind.CallOpts{
-			BlockHash: common.Hash{0xaa},
-		},
-		method: method,
 	}, {
 		name:    "pack error, no method",
 		mc:      new(mockCaller),
@@ -456,14 +418,6 @@ func TestCall(t *testing.T) {
 		},
 		method:       method,
 		wantErrExact: bind.ErrNoPendingState,
-	}, {
-		name: "interface error, blockHash but not a BlockHashContractCaller",
-		mc:   new(mockCaller),
-		opts: &bind.CallOpts{
-			BlockHash: common.Hash{0xaa},
-		},
-		method:       method,
-		wantErrExact: bind.ErrNoBlockHashState,
 	}, {
 		name: "pending call canceled",
 		mc: &mockPendingCaller{
@@ -511,34 +465,6 @@ func TestCall(t *testing.T) {
 		mc:           new(mockCaller),
 		method:       method,
 		wantErrExact: bind.ErrNoCode,
-	}, {
-		name: "call contract at hash error",
-		mc: &mockBlockHashCaller{
-			callContractAtHashErr: context.DeadlineExceeded,
-		},
-		opts: &bind.CallOpts{
-			BlockHash: common.Hash{0xaa},
-		},
-		method:       method,
-		wantErrExact: context.DeadlineExceeded,
-	}, {
-		name: "code at error",
-		mc: &mockBlockHashCaller{
-			codeAtHashErr: errors.New(""),
-		},
-		opts: &bind.CallOpts{
-			BlockHash: common.Hash{0xaa},
-		},
-		method:  method,
-		wantErr: true,
-	}, {
-		name: "no code at hash",
-		mc:   new(mockBlockHashCaller),
-		opts: &bind.CallOpts{
-			BlockHash: common.Hash{0xaa},
-		},
-		method:       method,
-		wantErrExact: bind.ErrNoCode,
 	}, {
 		name: "unpack error missing arg",
 		mc: &mockCaller{
@@ -586,7 +512,6 @@ func TestCall(t *testing.T) {

 // TestCrashers contains some strings which previously caused the abi codec to crash.
 func TestCrashers(t *testing.T) {
-	t.Parallel()
 	abi.JSON(strings.NewReader(`[{"inputs":[{"type":"tuple[]","components":[{"type":"bool","name":"_1"}]}]}]`))
 	abi.JSON(strings.NewReader(`[{"inputs":[{"type":"tuple[]","components":[{"type":"bool","name":"&"}]}]}]`))
 	abi.JSON(strings.NewReader(`[{"inputs":[{"type":"tuple[]","components":[{"type":"bool","name":"----"}]}]}]`))
--- a/accounts/abi/bind/bind.go
+++ b/accounts/abi/bind/bind.go
@@ -79,7 +79,7 @@ func isKeyWord(arg string) bool {

 // Bind generates a Go wrapper around a contract ABI. This wrapper isn't meant
 // to be used as is in client code, but rather as an intermediate struct which
-// enforces compile time type safety and naming convention as opposed to having to
+// enforces compile time type safety and naming convention opposed to having to
 // manually maintain hard coded strings that break on runtime.
 func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, lang Lang, libs map[string]string, aliases map[string]string) (string, error) {
 	var (
@@ -363,7 +363,7 @@ func bindTopicTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
 	// parameters that are not value types i.e. arrays and structs are not
 	// stored directly but instead a keccak256-hash of an encoding is stored.
 	//
-	// We only convert strings and bytes to hash, still need to deal with
+	// We only convert stringS and bytes to hash, still need to deal with
 	// array(both fixed-size and dynamic-size) and struct.
 	if bound == "string" || bound == "[]byte" {
 		bound = "common.Hash"
--- a/accounts/abi/bind/bind_test.go
+++ b/accounts/abi/bind/bind_test.go
@@ -305,7 +305,6 @@ var bindTests = []struct {
 			if err != nil {
 				t.Fatalf("Failed to deploy interactor contract: %v", err)
 			}
-			sim.Commit()
 			if _, err := interactor.Transact(auth, "Transact string"); err != nil {
 				t.Fatalf("Failed to transact with interactor contract: %v", err)
 			}
@@ -513,7 +512,6 @@ var bindTests = []struct {
 			if err != nil {
 				t.Fatalf("Failed to deploy defaulter contract: %v", err)
 			}
-			sim.Commit()
 			if _, err := (&DefaulterRaw{defaulter}).Transfer(auth); err != nil {
 				t.Fatalf("Failed to invoke default method: %v", err)
 			}
@@ -1679,7 +1677,7 @@ var bindTests = []struct {
 			}
 			sim.Commit()

-			// This test the existence of the free retriever call for view and pure functions
+			// This test the existence of the free retreiver call for view and pure functions
 			if num, err := pav.PureFunc(nil); err != nil {
 				t.Fatalf("Failed to call anonymous field retriever: %v", err)
 			} else if num.Cmp(big.NewInt(42)) != 0 {
@@ -1876,7 +1874,6 @@ var bindTests = []struct {
 		[]string{"0x6080604052348015600f57600080fd5b5060998061001e6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063726c638214602d575b600080fd5b60336035565b005b60405163024876cd60e61b815260016004820152600260248201526003604482015260640160405180910390fdfea264697066735822122093f786a1bc60216540cd999fbb4a6109e0fef20abcff6e9107fb2817ca968f3c64736f6c63430008070033"},
 		[]string{`[{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"MyError","type":"error"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"MyError1","type":"error"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"MyError2","type":"error"},{"inputs":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256","name":"b","type":"uint256"},{"internalType":"uint256","name":"c","type":"uint256"}],"name":"MyError3","type":"error"},{"inputs":[],"name":"Error","outputs":[],"stateMutability":"pure","type":"function"}]`},
 		`
-			"context"
 			"math/big"
 	
 			"github.com/ethereum/go-ethereum/accounts/abi/bind"
@@ -1898,7 +1895,7 @@ var bindTests = []struct {
 				t.Fatal(err)
 			}
 			sim.Commit()
-			_, err = bind.WaitDeployed(context.Background(), sim, tx)
+			_, err = bind.WaitDeployed(nil, sim, tx)
 			if err != nil {
 				t.Error(err)
 			}
@@ -1929,7 +1926,6 @@ var bindTests = []struct {
 		bytecode: []string{`0x608060405234801561001057600080fd5b506040516101c43803806101c48339818101604052810190610032919061014a565b50610177565b6000604051905090565b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6100958261004c565b810181811067ffffffffffffffff821117156100b4576100b361005d565b5b80604052505050565b60006100c7610038565b90506100d3828261008c565b919050565b6000819050919050565b6100eb816100d8565b81146100f657600080fd5b50565b600081519050610108816100e2565b92915050565b60006020828403121561012457610123610047565b5b61012e60206100bd565b9050600061013e848285016100f9565b60008301525092915050565b6000602082840312156101605761015f610042565b5b600061016e8482850161010e565b91505092915050565b603f806101856000396000f3fe6080604052600080fdfea2646970667358221220cdffa667affecefac5561f65f4a4ba914204a8d4eb859d8cd426fb306e5c12a364736f6c634300080a0033`},
 		abi:      []string{`[{"inputs":[{"components":[{"internalType":"uint256","name":"field","type":"uint256"}],"internalType":"struct ConstructorWithStructParam.StructType","name":"st","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"}]`},
 		imports: `
-			"context"
 			"math/big"

 			"github.com/ethereum/go-ethereum/accounts/abi/bind"
@@ -1952,7 +1948,7 @@ var bindTests = []struct {
 			}
 			sim.Commit()
 			
-			if _, err = bind.WaitDeployed(context.Background(), sim, tx); err != nil {
+			if _, err = bind.WaitDeployed(nil, sim, tx); err != nil {
 				t.Logf("Deployment tx: %+v", tx)
 				t.Errorf("bind.WaitDeployed(nil, %T, <deployment tx>) got err %v; want nil err", sim, err)
 			}
@@ -1978,7 +1974,6 @@ var bindTests = []struct {
 		bytecode: []string{"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"},
 		abi:      []string{`[ { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "int256", "name": "msg", "type": "int256" }, { "indexed": false, "internalType": "int256", "name": "_msg", "type": "int256" } ], "name": "log", "type": "event" }, { "inputs": [ { "components": [ { "internalType": "bytes", "name": "data", "type": "bytes" }, { "internalType": "bytes", "name": "_data", "type": "bytes" } ], "internalType": "struct oracle.request", "name": "req", "type": "tuple" } ], "name": "addRequest", "outputs": [], "stateMutability": "pure", "type": "function" }, { "inputs": [], "name": "getRequest", "outputs": [ { "components": [ { "internalType": "bytes", "name": "data", "type": "bytes" }, { "internalType": "bytes", "name": "_data", "type": "bytes" } ], "internalType": "struct oracle.request", "name": "", "type": "tuple" } ], "stateMutability": "pure", "type": "function" } ]`},
 		imports: `
-			"context"
 			"math/big"

 			"github.com/ethereum/go-ethereum/accounts/abi/bind"
@@ -2001,7 +1996,7 @@ var bindTests = []struct {
 			}
 			sim.Commit()
 			
-			if _, err = bind.WaitDeployed(context.Background(), sim, tx); err != nil {
+			if _, err = bind.WaitDeployed(nil, sim, tx); err != nil {
 				t.Logf("Deployment tx: %+v", tx)
 				t.Errorf("bind.WaitDeployed(nil, %T, <deployment tx>) got err %v; want nil err", sim, err)
 			}
@@ -2019,7 +2014,6 @@ var bindTests = []struct {
 		bytecode: []string{"0x608060405234801561001057600080fd5b5060dc8061001f6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063527a119f14602d575b600080fd5b60436004803603810190603f9190605b565b6045565b005b50565b6000813590506055816092565b92915050565b600060208284031215606e57606d608d565b5b6000607a848285016048565b91505092915050565b6000819050919050565b600080fd5b6099816083565b811460a357600080fd5b5056fea2646970667358221220d4f4525e2615516394055d369fb17df41c359e5e962734f27fd683ea81fd9db164736f6c63430008070033"},
 		abi:      []string{`[{"inputs":[{"internalType":"uint256","name":"range","type":"uint256"}],"name":"functionWithKeywordParameter","outputs":[],"stateMutability":"pure","type":"function"}]`},
 		imports: `
-			"context"
 			"math/big"

 			"github.com/ethereum/go-ethereum/accounts/abi/bind"
@@ -2040,7 +2034,7 @@ var bindTests = []struct {
 			}
 			sim.Commit()

-			if _, err = bind.WaitDeployed(context.Background(), sim, tx); err != nil {
+			if _, err = bind.WaitDeployed(nil, sim, tx); err != nil {
 				t.Errorf("error deploying the contract: %v", err)
 			}
 		`,
@@ -2073,7 +2067,6 @@ var bindTests = []struct {
 // Tests that packages generated by the binder can be successfully compiled and
 // the requested tester run against it.
 func TestGolangBindings(t *testing.T) {
-	t.Parallel()
 	// Skip the test if no Go command can be found
 	gocmd := runtime.GOROOT() + "/bin/go"
 	if !common.FileExist(gocmd) {
@@ -2152,7 +2145,7 @@ func TestGolangBindings(t *testing.T) {
 		t.Fatalf("failed to replace cometbft dependency to bnb-chain source: %v\n%s", err, out)
 	}

-	tidier := exec.Command(gocmd, "mod", "tidy", "-compat=1.21")
+	tidier := exec.Command(gocmd, "mod", "tidy", "-compat=1.20")
 	tidier.Dir = pkg
 	if out, err := tidier.CombinedOutput(); err != nil {
 		t.Fatalf("failed to tidy Go module file: %v\n%s", err, out)
--- a/accounts/abi/bind/util_test.go
+++ b/accounts/abi/bind/util_test.go
@@ -24,12 +24,11 @@ import (
 	"time"

 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethclient/simulated"
-	"github.com/ethereum/go-ethereum/params"
 )

 var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
@@ -54,21 +53,21 @@ var waitDeployedTests = map[string]struct {
 }

 func TestWaitDeployed(t *testing.T) {
-	t.Parallel()
 	for name, test := range waitDeployedTests {
-		backend := simulated.NewBackend(
+		backend := backends.NewSimulatedBackend(
 			core.GenesisAlloc{
 				crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)},
 			},
+			10000000,
 		)
 		defer backend.Close()

 		// Create the transaction
-		head, _ := backend.Client().HeaderByNumber(context.Background(), nil) // Should be child's, good enough
+		head, _ := backend.HeaderByNumber(context.Background(), nil) // Should be child's, good enough
 		gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1))

 		tx := types.NewContractCreation(0, big.NewInt(0), test.gas, gasPrice, common.FromHex(test.code))
-		tx, _ = types.SignTx(tx, types.LatestSignerForChainID(big.NewInt(1337)), testKey)
+		tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey)

 		// Wait for it to get mined in the background.
 		var (
@@ -78,12 +77,12 @@ func TestWaitDeployed(t *testing.T) {
 			ctx     = context.Background()
 		)
 		go func() {
-			address, err = bind.WaitDeployed(ctx, backend.Client(), tx)
+			address, err = bind.WaitDeployed(ctx, backend, tx)
 			close(mined)
 		}()

 		// Send and mine the transaction.
-		backend.Client().SendTransaction(ctx, tx)
+		backend.SendTransaction(ctx, tx)
 		backend.Commit()

 		select {
@@ -101,40 +100,41 @@ func TestWaitDeployed(t *testing.T) {
 }

 func TestWaitDeployedCornerCases(t *testing.T) {
-	backend := simulated.NewBackend(
+	backend := backends.NewSimulatedBackend(
 		core.GenesisAlloc{
 			crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)},
 		},
+		10000000,
 	)
 	defer backend.Close()

-	head, _ := backend.Client().HeaderByNumber(context.Background(), nil) // Should be child's, good enough
+	head, _ := backend.HeaderByNumber(context.Background(), nil) // Should be child's, good enough
 	gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1))

 	// Create a transaction to an account.
 	code := "6060604052600a8060106000396000f360606040526008565b00"
 	tx := types.NewTransaction(0, common.HexToAddress("0x01"), big.NewInt(0), 3000000, gasPrice, common.FromHex(code))
-	tx, _ = types.SignTx(tx, types.LatestSigner(params.AllDevChainProtocolChanges), testKey)
+	tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey)
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	backend.Client().SendTransaction(ctx, tx)
+	backend.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() {
-		t.Errorf("error mismatch: want %q, got %q, ", notContractCreation, err)
+	notContentCreation := errors.New("tx is not contract creation")
+	if _, err := bind.WaitDeployed(ctx, backend, tx); err.Error() != notContentCreation.Error() {
+		t.Errorf("error missmatch: want %q, got %q, ", notContentCreation, err)
 	}

 	// Create a transaction that is not mined.
 	tx = types.NewContractCreation(1, big.NewInt(0), 3000000, gasPrice, common.FromHex(code))
-	tx, _ = types.SignTx(tx, types.LatestSigner(params.AllDevChainProtocolChanges), testKey)
+	tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey)

 	go func() {
 		contextCanceled := errors.New("context canceled")
-		if _, err := bind.WaitDeployed(ctx, backend.Client(), tx); err.Error() != contextCanceled.Error() {
-			t.Errorf("error mismatch: want %q, got %q, ", contextCanceled, err)
+		if _, err := bind.WaitDeployed(ctx, backend, tx); err.Error() != contextCanceled.Error() {
+			t.Errorf("error missmatch: want %q, got %q, ", contextCanceled, err)
 		}
 	}()

-	backend.Client().SendTransaction(ctx, tx)
+	backend.SendTransaction(ctx, tx)
 	cancel()
 }
--- a/accounts/abi/error.go
+++ b/accounts/abi/error.go
@@ -18,6 +18,7 @@ package abi

 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"strings"

@@ -83,10 +84,10 @@ func (e Error) String() string {

 func (e *Error) Unpack(data []byte) (interface{}, error) {
 	if len(data) < 4 {
-		return "", fmt.Errorf("insufficient data for unpacking: have %d, want at least 4", len(data))
+		return "", errors.New("invalid data for unpacking")
 	}
 	if !bytes.Equal(data[:4], e.ID[:4]) {
-		return "", fmt.Errorf("invalid identifier, have %#x want %#x", data[:4], e.ID[:4])
+		return "", errors.New("invalid data for unpacking")
 	}
 	return e.Inputs.Unpack(data[4:])
 }
--- a/accounts/abi/event_test.go
+++ b/accounts/abi/event_test.go
@@ -81,7 +81,6 @@ var pledgeData1 = "00000000000000000000000000ce0d46d924cc8437c806721496599fc3ffa
 var mixedCaseData1 = "00000000000000000000000000000000000000000000000000000000000f42400000000000000000000000000000000000000000000000000000020489e8000000000000000000000000000000000000000000000000000000000000000f4241"

 func TestEventId(t *testing.T) {
-	t.Parallel()
 	var table = []struct {
 		definition   string
 		expectations map[string]common.Hash
@@ -113,7 +112,6 @@ func TestEventId(t *testing.T) {
 }

 func TestEventString(t *testing.T) {
-	t.Parallel()
 	var table = []struct {
 		definition   string
 		expectations map[string]string
@@ -148,7 +146,6 @@ func TestEventString(t *testing.T) {

 // TestEventMultiValueWithArrayUnpack verifies that array fields will be counted after parsing array.
 func TestEventMultiValueWithArrayUnpack(t *testing.T) {
-	t.Parallel()
 	definition := `[{"name": "test", "type": "event", "inputs": [{"indexed": false, "name":"value1", "type":"uint8[2]"},{"indexed": false, "name":"value2", "type":"uint8"}]}]`
 	abi, err := JSON(strings.NewReader(definition))
 	require.NoError(t, err)
@@ -164,7 +161,6 @@ func TestEventMultiValueWithArrayUnpack(t *testing.T) {
 }

 func TestEventTupleUnpack(t *testing.T) {
-	t.Parallel()
 	type EventTransfer struct {
 		Value *big.Int
 	}
@@ -355,7 +351,6 @@ func unpackTestEventData(dest interface{}, hexData string, jsonEvent []byte, ass

 // TestEventUnpackIndexed verifies that indexed field will be skipped by event decoder.
 func TestEventUnpackIndexed(t *testing.T) {
-	t.Parallel()
 	definition := `[{"name": "test", "type": "event", "inputs": [{"indexed": true, "name":"value1", "type":"uint8"},{"indexed": false, "name":"value2", "type":"uint8"}]}]`
 	type testStruct struct {
 		Value1 uint8 // indexed
@@ -373,7 +368,6 @@ func TestEventUnpackIndexed(t *testing.T) {

 // TestEventIndexedWithArrayUnpack verifies that decoder will not overflow when static array is indexed input.
 func TestEventIndexedWithArrayUnpack(t *testing.T) {
-	t.Parallel()
 	definition := `[{"name": "test", "type": "event", "inputs": [{"indexed": true, "name":"value1", "type":"uint8[2]"},{"indexed": false, "name":"value2", "type":"string"}]}]`
 	type testStruct struct {
 		Value1 [2]uint8 // indexed
--- a/accounts/abi/method.go
+++ b/accounts/abi/method.go
@@ -117,23 +117,24 @@ func NewMethod(name string, rawName string, funType FunctionType, mutability str
 		sig = fmt.Sprintf("%v(%v)", rawName, strings.Join(types, ","))
 		id = crypto.Keccak256([]byte(sig))[:4]
 	}
+	// Extract meaningful state mutability of solidity method.
+	// If it's default value, never print it.
+	state := mutability
+	if state == "nonpayable" {
+		state = ""
+	}
+	if state != "" {
+		state = state + " "
+	}
 	identity := fmt.Sprintf("function %v", rawName)
-	switch funType {
-	case Fallback:
+	if funType == Fallback {
 		identity = "fallback"
-	case Receive:
+	} else if funType == Receive {
 		identity = "receive"
-	case Constructor:
+	} else if funType == Constructor {
 		identity = "constructor"
 	}
-	var str string
-	// Extract meaningful state mutability of solidity method.
-	// If it's empty string or default value "nonpayable", never print it.
-	if mutability == "" || mutability == "nonpayable" {
-		str = fmt.Sprintf("%v(%v) returns(%v)", identity, strings.Join(inputNames, ", "), strings.Join(outputNames, ", "))
-	} else {
-		str = fmt.Sprintf("%v(%v) %s returns(%v)", identity, strings.Join(inputNames, ", "), mutability, strings.Join(outputNames, ", "))
-	}
+	str := fmt.Sprintf("%v(%v) %sreturns(%v)", identity, strings.Join(inputNames, ", "), state, strings.Join(outputNames, ", "))

 	return Method{
 		Name:            name,
--- a/accounts/abi/method_test.go
+++ b/accounts/abi/method_test.go
@@ -35,7 +35,6 @@ const methoddata = `
 ]`

 func TestMethodString(t *testing.T) {
-	t.Parallel()
 	var table = []struct {
 		method      string
 		expectation string
@@ -85,12 +84,11 @@ func TestMethodString(t *testing.T) {

 	for _, test := range table {
 		var got string
-		switch test.method {
-		case "fallback":
+		if test.method == "fallback" {
 			got = abi.Fallback.String()
-		case "receive":
+		} else if test.method == "receive" {
 			got = abi.Receive.String()
-		default:
+		} else {
 			got = abi.Methods[test.method].String()
 		}
 		if got != test.expectation {
@@ -100,7 +98,6 @@ func TestMethodString(t *testing.T) {
 }

 func TestMethodSig(t *testing.T) {
-	t.Parallel()
 	var cases = []struct {
 		method string
 		expect string
--- a/accounts/abi/pack.go
+++ b/accounts/abi/pack.go
@@ -57,7 +57,7 @@ func packElement(t Type, reflectValue reflect.Value) ([]byte, error) {
 			reflectValue = mustArrayToByteSlice(reflectValue)
 		}
 		if reflectValue.Type() != reflect.TypeOf([]byte{}) {
-			return []byte{}, errors.New("bytes type is neither slice nor array")
+			return []byte{}, errors.New("Bytes type is neither slice nor array")
 		}
 		return packBytesSlice(reflectValue.Bytes(), reflectValue.Len()), nil
 	case FixedBytesTy, FunctionTy:
@@ -66,7 +66,7 @@ func packElement(t Type, reflectValue reflect.Value) ([]byte, error) {
 		}
 		return common.RightPadBytes(reflectValue.Bytes(), 32), nil
 	default:
-		return []byte{}, fmt.Errorf("could not pack element, unknown type: %v", t.T)
+		return []byte{}, fmt.Errorf("Could not pack element, unknown type: %v", t.T)
 	}
 }

--- a/accounts/abi/pack_test.go
+++ b/accounts/abi/pack_test.go
@@ -32,11 +32,8 @@ import (

 // TestPack tests the general pack/unpack tests in packing_test.go
 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)
 			if err != nil {
 				t.Fatalf("invalid hex %s: %v", test.packed, err)
@@ -60,7 +57,6 @@ func TestPack(t *testing.T) {
 }

 func TestMethodPack(t *testing.T) {
-	t.Parallel()
 	abi, err := JSON(strings.NewReader(jsondata))
 	if err != nil {
 		t.Fatal(err)
@@ -181,7 +177,6 @@ func TestMethodPack(t *testing.T) {
 }

 func TestPackNumber(t *testing.T) {
-	t.Parallel()
 	tests := []struct {
 		value  reflect.Value
 		packed []byte
--- a/accounts/abi/reflect.go
+++ b/accounts/abi/reflect.go
@@ -134,7 +134,7 @@ func setSlice(dst, src reflect.Value) error {
 		dst.Set(slice)
 		return nil
 	}
-	return errors.New("cannot set slice, destination not settable")
+	return errors.New("Cannot set slice, destination not settable")
 }

 func setArray(dst, src reflect.Value) error {
@@ -155,7 +155,7 @@ func setArray(dst, src reflect.Value) error {
 		dst.Set(array)
 		return nil
 	}
-	return errors.New("cannot set array, destination not settable")
+	return errors.New("Cannot set array, destination not settable")
 }

 func setStruct(dst, src reflect.Value) error {
@@ -163,7 +163,7 @@ func setStruct(dst, src reflect.Value) error {
 		srcField := src.Field(i)
 		dstField := dst.Field(i)
 		if !dstField.IsValid() || !srcField.IsValid() {
-			return fmt.Errorf("could not find src field: %v value: %v in destination", srcField.Type().Name(), srcField)
+			return fmt.Errorf("Could not find src field: %v value: %v in destination", srcField.Type().Name(), srcField)
 		}
 		if err := set(dstField, srcField); err != nil {
 			return err
--- a/accounts/abi/reflect_test.go
+++ b/accounts/abi/reflect_test.go
@@ -170,11 +170,8 @@ 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))
 			if len(test.err) > 0 {
 				if err == nil || err.Error() != test.err {
@@ -195,7 +192,6 @@ func TestReflectNameToStruct(t *testing.T) {
 }

 func TestConvertType(t *testing.T) {
-	t.Parallel()
 	// Test Basic Struct
 	type T struct {
 		X *big.Int
--- a/accounts/abi/selector_parser_test.go
+++ b/accounts/abi/selector_parser_test.go
@@ -24,7 +24,6 @@ import (
 )

 func TestParseSelector(t *testing.T) {
-	t.Parallel()
 	mkType := func(types ...interface{}) []ArgumentMarshaling {
 		var result []ArgumentMarshaling
 		for i, typeOrComponents := range types {
--- a/accounts/abi/topics.go
+++ b/accounts/abi/topics.go
@@ -24,7 +24,6 @@ import (
 	"reflect"

 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/crypto"
 )

@@ -42,7 +41,8 @@ func MakeTopics(query ...[]interface{}) ([][]common.Hash, error) {
 			case common.Address:
 				copy(topic[common.HashLength-common.AddressLength:], rule[:])
 			case *big.Int:
-				copy(topic[:], math.U256Bytes(rule))
+				blob := rule.Bytes()
+				copy(topic[common.HashLength-len(blob):], blob)
 			case bool:
 				if rule {
 					topic[common.HashLength-1] = 1
@@ -75,7 +75,7 @@ func MakeTopics(query ...[]interface{}) ([][]common.Hash, error) {
 				copy(topic[:], hash[:])

 			default:
-				// todo(rjl493456442) according to solidity documentation, indexed event
+				// todo(rjl493456442) according solidity documentation, indexed event
 				// parameters that are not value types i.e. arrays and structs are not
 				// stored directly but instead a keccak256-hash of an encoding is stored.
 				//
--- a/accounts/abi/topics_test.go
+++ b/accounts/abi/topics_test.go
@@ -17,7 +17,6 @@
 package abi

 import (
-	"math"
 	"math/big"
 	"reflect"
 	"testing"
@@ -27,7 +26,6 @@ import (
 )

 func TestMakeTopics(t *testing.T) {
-	t.Parallel()
 	type args struct {
 		query [][]interface{}
 	}
@@ -56,27 +54,9 @@ func TestMakeTopics(t *testing.T) {
 			false,
 		},
 		{
-			"support positive *big.Int types in topics",
-			args{[][]interface{}{
-				{big.NewInt(1)},
-				{big.NewInt(1).Lsh(big.NewInt(2), 254)},
-			}},
-			[][]common.Hash{
-				{common.HexToHash("0000000000000000000000000000000000000000000000000000000000000001")},
-				{common.Hash{128}},
-			},
-			false,
-		},
-		{
-			"support negative *big.Int types in topics",
-			args{[][]interface{}{
-				{big.NewInt(-1)},
-				{big.NewInt(math.MinInt64)},
-			}},
-			[][]common.Hash{
-				{common.MaxHash},
-				{common.HexToHash("ffffffffffffffffffffffffffffffffffffffffffffffff8000000000000000")},
-			},
+			"support *big.Int types in topics",
+			args{[][]interface{}{{big.NewInt(1).Lsh(big.NewInt(2), 254)}}},
+			[][]common.Hash{{common.Hash{128}}},
 			false,
 		},
 		{
@@ -137,9 +117,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...)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("makeTopics() error = %v, wantErr %v", err, tt.wantErr)
@@ -369,13 +347,10 @@ func setupTopicsTests() []topicTest {
 }

 func TestParseTopics(t *testing.T) {
-	t.Parallel()
 	tests := setupTopicsTests()

 	for _, tt := range tests {
-		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
 			createObj := tt.args.createObj()
 			if err := ParseTopics(createObj, tt.args.fields, tt.args.topics); (err != nil) != tt.wantErr {
 				t.Errorf("parseTopics() error = %v, wantErr %v", err, tt.wantErr)
@@ -389,13 +364,10 @@ func TestParseTopics(t *testing.T) {
 }

 func TestParseTopicsIntoMap(t *testing.T) {
-	t.Parallel()
 	tests := setupTopicsTests()

 	for _, tt := range tests {
-		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
 			outMap := make(map[string]interface{})
 			if err := ParseTopicsIntoMap(outMap, tt.args.fields, tt.args.topics); (err != nil) != tt.wantErr {
 				t.Errorf("parseTopicsIntoMap() error = %v, wantErr %v", err, tt.wantErr)
--- a/accounts/abi/type_test.go
+++ b/accounts/abi/type_test.go
@@ -31,7 +31,6 @@ type typeWithoutStringer Type

 // Tests that all allowed types get recognized by the type parser.
 func TestTypeRegexp(t *testing.T) {
-	t.Parallel()
 	tests := []struct {
 		blob       string
 		components []ArgumentMarshaling
@@ -118,7 +117,6 @@ func TestTypeRegexp(t *testing.T) {
 }

 func TestTypeCheck(t *testing.T) {
-	t.Parallel()
 	for i, test := range []struct {
 		typ        string
 		components []ArgumentMarshaling
@@ -310,7 +308,6 @@ func TestTypeCheck(t *testing.T) {
 }

 func TestInternalType(t *testing.T) {
-	t.Parallel()
 	components := []ArgumentMarshaling{{Name: "a", Type: "int64"}}
 	internalType := "struct a.b[]"
 	kind := Type{
@@ -335,7 +332,6 @@ func TestInternalType(t *testing.T) {
 }

 func TestGetTypeSize(t *testing.T) {
-	t.Parallel()
 	var testCases = []struct {
 		typ        string
 		components []ArgumentMarshaling
@@ -372,7 +368,6 @@ func TestGetTypeSize(t *testing.T) {
 }

 func TestNewFixedBytesOver32(t *testing.T) {
-	t.Parallel()
 	_, err := NewType("bytes4096", "", nil)
 	if err == nil {
 		t.Errorf("fixed bytes with size over 32 is not spec'd")
--- a/accounts/abi/unpack.go
+++ b/accounts/abi/unpack.go
@@ -160,14 +160,13 @@ func forEachUnpack(t Type, output []byte, start, size int) (interface{}, error)
 	// this value will become our slice or our array, depending on the type
 	var refSlice reflect.Value

-	switch t.T {
-	case SliceTy:
+	if t.T == SliceTy {
 		// declare our slice
 		refSlice = reflect.MakeSlice(t.GetType(), size, size)
-	case ArrayTy:
+	} else if t.T == ArrayTy {
 		// declare our array
 		refSlice = reflect.New(t.GetType()).Elem()
-	default:
+	} else {
 		return nil, errors.New("abi: invalid type in array/slice unpacking stage")
 	}

--- a/accounts/abi/unpack_test.go
+++ b/accounts/abi/unpack_test.go
@@ -33,7 +33,6 @@ import (

 // TestUnpack tests the general pack/unpack tests in packing_test.go
 func TestUnpack(t *testing.T) {
-	t.Parallel()
 	for i, test := range packUnpackTests {
 		t.Run(strconv.Itoa(i)+" "+test.def, func(t *testing.T) {
 			//Unpack
@@ -207,13 +206,13 @@ var unpackTests = []unpackTest{
 		def:  `[{"type":"bool"}]`,
 		enc:  "",
 		want: false,
-		err:  "abi: attempting to unmarshal an empty string while arguments are expected",
+		err:  "abi: attempting to unmarshall an empty string while arguments are expected",
 	},
 	{
 		def:  `[{"type":"bytes32","indexed":true},{"type":"uint256","indexed":false}]`,
 		enc:  "",
 		want: false,
-		err:  "abi: attempting to unmarshal an empty string while arguments are expected",
+		err:  "abi: attempting to unmarshall an empty string while arguments are expected",
 	},
 	{
 		def:  `[{"type":"bool","indexed":true},{"type":"uint64","indexed":true}]`,
@@ -225,7 +224,6 @@ var unpackTests = []unpackTest{
 // TestLocalUnpackTests runs test specially designed only for unpacking.
 // All test cases that can be used to test packing and unpacking should move to packing_test.go
 func TestLocalUnpackTests(t *testing.T) {
-	t.Parallel()
 	for i, test := range unpackTests {
 		t.Run(strconv.Itoa(i), func(t *testing.T) {
 			//Unpack
@@ -253,7 +251,6 @@ func TestLocalUnpackTests(t *testing.T) {
 }

 func TestUnpackIntoInterfaceSetDynamicArrayOutput(t *testing.T) {
-	t.Parallel()
 	abi, err := JSON(strings.NewReader(`[{"constant":true,"inputs":[],"name":"testDynamicFixedBytes15","outputs":[{"name":"","type":"bytes15[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"testDynamicFixedBytes32","outputs":[{"name":"","type":"bytes32[]"}],"payable":false,"stateMutability":"view","type":"function"}]`))
 	if err != nil {
 		t.Fatal(err)
@@ -324,7 +321,6 @@ func methodMultiReturn(require *require.Assertions) (ABI, []byte, methodMultiOut
 }

 func TestMethodMultiReturn(t *testing.T) {
-	t.Parallel()
 	type reversed struct {
 		String string
 		Int    *big.Int
@@ -404,7 +400,6 @@ func TestMethodMultiReturn(t *testing.T) {
 }

 func TestMultiReturnWithArray(t *testing.T) {
-	t.Parallel()
 	const definition = `[{"name" : "multi", "type": "function", "outputs": [{"type": "uint64[3]"}, {"type": "uint64"}]}]`
 	abi, err := JSON(strings.NewReader(definition))
 	if err != nil {
@@ -428,7 +423,6 @@ func TestMultiReturnWithArray(t *testing.T) {
 }

 func TestMultiReturnWithStringArray(t *testing.T) {
-	t.Parallel()
 	const definition = `[{"name" : "multi", "type": "function", "outputs": [{"name": "","type": "uint256[3]"},{"name": "","type": "address"},{"name": "","type": "string[2]"},{"name": "","type": "bool"}]}]`
 	abi, err := JSON(strings.NewReader(definition))
 	if err != nil {
@@ -459,7 +453,6 @@ func TestMultiReturnWithStringArray(t *testing.T) {
 }

 func TestMultiReturnWithStringSlice(t *testing.T) {
-	t.Parallel()
 	const definition = `[{"name" : "multi", "type": "function", "outputs": [{"name": "","type": "string[]"},{"name": "","type": "uint256[]"}]}]`
 	abi, err := JSON(strings.NewReader(definition))
 	if err != nil {
@@ -492,7 +485,6 @@ func TestMultiReturnWithStringSlice(t *testing.T) {
 }

 func TestMultiReturnWithDeeplyNestedArray(t *testing.T) {
-	t.Parallel()
 	// Similar to TestMultiReturnWithArray, but with a special case in mind:
 	//  values of nested static arrays count towards the size as well, and any element following
 	//  after such nested array argument should be read with the correct offset,
@@ -533,7 +525,6 @@ func TestMultiReturnWithDeeplyNestedArray(t *testing.T) {
 }

 func TestUnmarshal(t *testing.T) {
-	t.Parallel()
 	const definition = `[
 	{ "name" : "int", "type": "function", "outputs": [ { "type": "uint256" } ] },
 	{ "name" : "bool", "type": "function", "outputs": [ { "type": "bool" } ] },
@@ -783,7 +774,6 @@ func TestUnmarshal(t *testing.T) {
 }

 func TestUnpackTuple(t *testing.T) {
-	t.Parallel()
 	const simpleTuple = `[{"name":"tuple","type":"function","outputs":[{"type":"tuple","name":"ret","components":[{"type":"int256","name":"a"},{"type":"int256","name":"b"}]}]}]`
 	abi, err := JSON(strings.NewReader(simpleTuple))
 	if err != nil {
@@ -886,7 +876,6 @@ func TestUnpackTuple(t *testing.T) {
 }

 func TestOOMMaliciousInput(t *testing.T) {
-	t.Parallel()
 	oomTests := []unpackTest{
 		{
 			def: `[{"type": "uint8[]"}]`,
@@ -957,7 +946,6 @@ func TestOOMMaliciousInput(t *testing.T) {
 }

 func TestPackAndUnpackIncompatibleNumber(t *testing.T) {
-	t.Parallel()
 	var encodeABI Arguments
 	uint256Ty, err := NewType("uint256", "", nil)
 	if err != nil {
--- a/accounts/accounts_test.go
+++ b/accounts/accounts_test.go
@@ -24,7 +24,6 @@ import (
 )

 func TestTextHash(t *testing.T) {
-	t.Parallel()
 	hash := TextHash([]byte("Hello Joe"))
 	want := hexutil.MustDecode("0xa080337ae51c4e064c189e113edd0ba391df9206e2f49db658bb32cf2911730b")
 	if !bytes.Equal(hash, want) {
--- a/accounts/hd_test.go
+++ b/accounts/hd_test.go
@@ -25,7 +25,6 @@ import (
 // Tests that HD derivation paths can be correctly parsed into our internal binary
 // representation.
 func TestHDPathParsing(t *testing.T) {
-	t.Parallel()
 	tests := []struct {
 		input  string
 		output DerivationPath
@@ -90,7 +89,6 @@ func testDerive(t *testing.T, next func() DerivationPath, expected []string) {
 }

 func TestHdPathIteration(t *testing.T) {
-	t.Parallel()
 	testDerive(t, DefaultIterator(DefaultBaseDerivationPath),
 		[]string{
 			"m/44'/60'/0'/0/0", "m/44'/60'/0'/0/1",
--- a/accounts/keystore/account_cache_test.go
+++ b/accounts/keystore/account_cache_test.go
@@ -68,7 +68,7 @@ func waitWatcherStart(ks *KeyStore) bool {

 func waitForAccounts(wantAccounts []accounts.Account, ks *KeyStore) error {
 	var list []accounts.Account
-	for t0 := time.Now(); time.Since(t0) < 5*time.Second; time.Sleep(100 * time.Millisecond) {
+	for t0 := time.Now(); time.Since(t0) < 5*time.Second; time.Sleep(200 * time.Millisecond) {
 		list = ks.Accounts()
 		if reflect.DeepEqual(list, wantAccounts) {
 			// ks should have also received change notifications
@@ -152,7 +152,6 @@ func TestWatchNoDir(t *testing.T) {
 }

 func TestCacheInitialReload(t *testing.T) {
-	t.Parallel()
 	cache, _ := newAccountCache(cachetestDir)
 	accounts := cache.accounts()
 	if !reflect.DeepEqual(accounts, cachetestAccounts) {
@@ -161,7 +160,6 @@ func TestCacheInitialReload(t *testing.T) {
 }

 func TestCacheAddDeleteOrder(t *testing.T) {
-	t.Parallel()
 	cache, _ := newAccountCache("testdata/no-such-dir")
 	cache.watcher.running = true // prevent unexpected reloads

@@ -246,7 +244,6 @@ func TestCacheAddDeleteOrder(t *testing.T) {
 }

 func TestCacheFind(t *testing.T) {
-	t.Parallel()
 	dir := filepath.Join("testdata", "dir")
 	cache, _ := newAccountCache(dir)
 	cache.watcher.running = true // prevent unexpected reloads
@@ -353,7 +350,7 @@ func TestUpdatedKeyfileContents(t *testing.T) {
 		return
 	}
 	// needed so that modTime of `file` is different to its current value after forceCopyFile
-	os.Chtimes(file, time.Now().Add(-time.Second), time.Now().Add(-time.Second))
+	time.Sleep(time.Second)

 	// Now replace file contents
 	if err := forceCopyFile(file, cachetestAccounts[1].URL.Path); err != nil {
@@ -369,7 +366,7 @@ func TestUpdatedKeyfileContents(t *testing.T) {
 	}

 	// needed so that modTime of `file` is different to its current value after forceCopyFile
-	os.Chtimes(file, time.Now().Add(-time.Second), time.Now().Add(-time.Second))
+	time.Sleep(time.Second)

 	// Now replace file contents again
 	if err := forceCopyFile(file, cachetestAccounts[2].URL.Path); err != nil {
@@ -385,7 +382,7 @@ func TestUpdatedKeyfileContents(t *testing.T) {
 	}

 	// needed so that modTime of `file` is different to its current value after os.WriteFile
-	os.Chtimes(file, time.Now().Add(-time.Second), time.Now().Add(-time.Second))
+	time.Sleep(time.Second)

 	// Now replace file contents with crap
 	if err := os.WriteFile(file, []byte("foo"), 0600); err != nil {
--- a/accounts/keystore/keystore_test.go
+++ b/accounts/keystore/keystore_test.go
@@ -36,7 +36,6 @@ import (
 var testSigData = make([]byte, 32)

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

 	a, err := ks.NewAccount("foo")
@@ -71,7 +70,6 @@ func TestKeyStore(t *testing.T) {
 }

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

 	pass := "" // not used but required by API
@@ -88,7 +86,6 @@ func TestSign(t *testing.T) {
 }

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

 	pass := "passwd"
@@ -283,7 +280,6 @@ type walletEvent struct {
 // Tests that wallet notifications and correctly fired when accounts are added
 // or deleted from the keystore.
 func TestWalletNotifications(t *testing.T) {
-	t.Parallel()
 	_, ks := tmpKeyStore(t, false)

 	// Subscribe to the wallet feed and collect events.
@@ -345,7 +341,6 @@ func TestWalletNotifications(t *testing.T) {

 // TestImportExport tests the import functionality of a keystore.
 func TestImportECDSA(t *testing.T) {
-	t.Parallel()
 	_, ks := tmpKeyStore(t, true)
 	key, err := crypto.GenerateKey()
 	if err != nil {
@@ -364,7 +359,6 @@ func TestImportECDSA(t *testing.T) {

 // TestImportECDSA tests the import and export functionality of a keystore.
 func TestImportExport(t *testing.T) {
-	t.Parallel()
 	_, ks := tmpKeyStore(t, true)
 	acc, err := ks.NewAccount("old")
 	if err != nil {
@@ -393,7 +387,6 @@ func TestImportExport(t *testing.T) {
 // TestImportRace tests the keystore on races.
 // This test should fail under -race if importing races.
 func TestImportRace(t *testing.T) {
-	t.Parallel()
 	_, ks := tmpKeyStore(t, true)
 	acc, err := ks.NewAccount("old")
 	if err != nil {
--- a/accounts/keystore/passphrase.go
+++ b/accounts/keystore/passphrase.go
@@ -136,7 +136,7 @@ func (ks keyStorePassphrase) JoinPath(filename string) string {
 	return filepath.Join(ks.keysDirPath, filename)
 }

-// EncryptDataV3 encrypts the data given as 'data' with the password 'auth'.
+// Encryptdata encrypts the data given as 'data' with the password 'auth'.
 func EncryptDataV3(data, auth []byte, scryptN, scryptP int) (CryptoJSON, error) {
 	salt := make([]byte, 32)
 	if _, err := io.ReadFull(rand.Reader, salt); err != nil {
--- a/accounts/keystore/passphrase_test.go
+++ b/accounts/keystore/passphrase_test.go
@@ -30,7 +30,6 @@ const (

 // Tests that a json key file can be decrypted and encrypted in multiple rounds.
 func TestKeyEncryptDecrypt(t *testing.T) {
-	t.Parallel()
 	keyjson, err := os.ReadFile("testdata/very-light-scrypt.json")
 	if err != nil {
 		t.Fatal(err)
@@ -55,7 +54,7 @@ func TestKeyEncryptDecrypt(t *testing.T) {
 		// Recrypt with a new password and start over
 		password += "new data appended" // nolint: gosec
 		if keyjson, err = EncryptKey(key, password, veryLightScryptN, veryLightScryptP); err != nil {
-			t.Errorf("test %d: failed to re-encrypt key %v", i, err)
+			t.Errorf("test %d: failed to recrypt key %v", i, err)
 		}
 	}
 }
--- a/accounts/keystore/plain_test.go
+++ b/accounts/keystore/plain_test.go
@@ -40,7 +40,6 @@ func tmpKeyStoreIface(t *testing.T, encrypted bool) (dir string, ks keyStore) {
 }

 func TestKeyStorePlain(t *testing.T) {
-	t.Parallel()
 	_, ks := tmpKeyStoreIface(t, false)

 	pass := "" // not used but required by API
@@ -61,7 +60,6 @@ func TestKeyStorePlain(t *testing.T) {
 }

 func TestKeyStorePassphrase(t *testing.T) {
-	t.Parallel()
 	_, ks := tmpKeyStoreIface(t, true)

 	pass := "foo"
@@ -82,7 +80,6 @@ func TestKeyStorePassphrase(t *testing.T) {
 }

 func TestKeyStorePassphraseDecryptionFail(t *testing.T) {
-	t.Parallel()
 	_, ks := tmpKeyStoreIface(t, true)

 	pass := "foo"
@@ -96,7 +93,6 @@ func TestKeyStorePassphraseDecryptionFail(t *testing.T) {
 }

 func TestImportPreSaleKey(t *testing.T) {
-	t.Parallel()
 	dir, ks := tmpKeyStoreIface(t, true)

 	// file content of a presale key file generated with:
--- a/accounts/keystore/watch.go
+++ b/accounts/keystore/watch.go
@@ -20,7 +20,6 @@
 package keystore

 import (
-	"os"
 	"time"

 	"github.com/ethereum/go-ethereum/log"
@@ -78,9 +77,7 @@ func (w *watcher) loop() {
 	}
 	defer watcher.Close()
 	if err := watcher.Add(w.ac.keydir); err != nil {
-		if !os.IsNotExist(err) {
 		logger.Warn("Failed to watch keystore folder", "err", err)
-		}
 		return
 	}

@@ -125,7 +122,7 @@ func (w *watcher) loop() {
 			if !ok {
 				return
 			}
-			log.Info("Filesystem watcher error", "err", err)
+			log.Info("Filsystem watcher error", "err", err)
 		case <-debounce.C:
 			w.ac.scanAccounts()
 			rescanTriggered = false
--- a/accounts/manager.go
+++ b/accounts/manager.go
@@ -98,9 +98,6 @@ func NewManager(config *Config, backends ...Backend) *Manager {

 // Close terminates the account manager's internal notification processes.
 func (am *Manager) Close() error {
-	for _, w := range am.wallets {
-		w.Close()
-	}
 	errc := make(chan error)
 	am.quit <- errc
 	return <-errc
--- a/accounts/scwallet/README.md
+++ b/accounts/scwallet/README.md
@@ -8,7 +8,7 @@

 ## Preparing the smartcard

-  **WARNING: FOLLOWING THESE INSTRUCTIONS WILL DESTROY THE MASTER KEY ON YOUR CARD. ONLY PROCEED IF NO FUNDS ARE ASSOCIATED WITH THESE ACCOUNTS**
+  **WARNING: FOILLOWING THESE INSTRUCTIONS WILL DESTROY THE MASTER KEY ON YOUR CARD. ONLY PROCEED IF NO FUNDS ARE ASSOCIATED WITH THESE ACCOUNTS**

  You can use status' [keycard-cli](https://github.com/status-im/keycard-cli) and you should get _at least_ version 2.1.1 of their [smartcard application](https://github.com/status-im/status-keycard/releases/download/2.2.1/keycard_v2.2.1.cap)

--- a/accounts/scwallet/securechannel.go
+++ b/accounts/scwallet/securechannel.go
@@ -72,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, _ := key.Curve.ScalarMult(cardPublic.X, cardPublic.Y, key.D.Bytes()) //nolint:all //TODO
+	secret, _ := key.Curve.ScalarMult(cardPublic.X, cardPublic.Y, key.D.Bytes())
 	return &SecureChannelSession{
 		card:      card,
 		secret:    secret.Bytes(),
-		publicKey: elliptic.Marshal(crypto.S256(), key.PublicKey.X, key.PublicKey.Y), //nolint:all //TODO
+		publicKey: elliptic.Marshal(crypto.S256(), key.PublicKey.X, key.PublicKey.Y),
 	}, nil
 }

--- a/accounts/scwallet/wallet.go
+++ b/accounts/scwallet/wallet.go
@@ -776,16 +776,16 @@ func (w *Wallet) findAccountPath(account accounts.Account) (accounts.DerivationP
 		return nil, fmt.Errorf("scheme %s does not match wallet scheme %s", account.URL.Scheme, w.Hub.scheme)
 	}

-	url, path, found := strings.Cut(account.URL.Path, "/")
-	if !found {
+	parts := strings.SplitN(account.URL.Path, "/", 2)
+	if len(parts) != 2 {
 		return nil, fmt.Errorf("invalid URL format: %s", account.URL)
 	}

-	if url != fmt.Sprintf("%x", w.PublicKey[1:3]) {
+	if parts[0] != fmt.Sprintf("%x", w.PublicKey[1:3]) {
 		return nil, fmt.Errorf("URL %s is not for this wallet", account.URL)
 	}

-	return accounts.ParseDerivationPath(path)
+	return accounts.ParseDerivationPath(parts[1])
 }

 // Session represents a secured communication session with the wallet.
--- a/accounts/url_test.go
+++ b/accounts/url_test.go
@@ -21,7 +21,6 @@ import (
 )

 func TestURLParsing(t *testing.T) {
-	t.Parallel()
 	url, err := parseURL("https://ethereum.org")
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
@@ -41,7 +40,6 @@ func TestURLParsing(t *testing.T) {
 }

 func TestURLString(t *testing.T) {
-	t.Parallel()
 	url := URL{Scheme: "https", Path: "ethereum.org"}
 	if url.String() != "https://ethereum.org" {
 		t.Errorf("expected: %v, got: %v", "https://ethereum.org", url.String())
@@ -54,11 +52,10 @@ func TestURLString(t *testing.T) {
 }

 func TestURLMarshalJSON(t *testing.T) {
-	t.Parallel()
 	url := URL{Scheme: "https", Path: "ethereum.org"}
 	json, err := url.MarshalJSON()
 	if err != nil {
-		t.Errorf("unexpected error: %v", err)
+		t.Errorf("unexpcted error: %v", err)
 	}
 	if string(json) != "\"https://ethereum.org\"" {
 		t.Errorf("expected: %v, got: %v", "\"https://ethereum.org\"", string(json))
@@ -66,11 +63,10 @@ func TestURLMarshalJSON(t *testing.T) {
 }

 func TestURLUnmarshalJSON(t *testing.T) {
-	t.Parallel()
 	url := &URL{}
 	err := url.UnmarshalJSON([]byte("\"https://ethereum.org\""))
 	if err != nil {
-		t.Errorf("unexpected error: %v", err)
+		t.Errorf("unexpcted error: %v", err)
 	}
 	if url.Scheme != "https" {
 		t.Errorf("expected: %v, got: %v", "https", url.Scheme)
@@ -81,7 +77,6 @@ func TestURLUnmarshalJSON(t *testing.T) {
 }

 func TestURLComparison(t *testing.T) {
-	t.Parallel()
 	tests := []struct {
 		urlA   URL
 		urlB   URL
--- a/accounts/usbwallet/ledger.go
+++ b/accounts/usbwallet/ledger.go
@@ -279,7 +279,7 @@ func (w *ledgerDriver) ledgerDerive(derivationPath []uint32) (common.Address, er
 	}
 	hexstr := reply[1 : 1+int(reply[0])]

-	// Decode the hex string into an Ethereum address and return
+	// Decode the hex sting into an Ethereum address and return
 	var address common.Address
 	if _, err = hex.Decode(address[:], hexstr); err != nil {
 		return common.Address{}, err
--- a/accounts/usbwallet/wallet.go
+++ b/accounts/usbwallet/wallet.go
@@ -483,10 +483,6 @@ func (w *wallet) Derive(path accounts.DerivationPath, pin bool) (accounts.Accoun
 	w.stateLock.Lock()
 	defer w.stateLock.Unlock()

-	if w.device == nil {
-		return accounts.Account{}, accounts.ErrWalletClosed
-	}
-
 	if _, ok := w.paths[address]; !ok {
 		w.accounts = append(w.accounts, account)
 		w.paths[address] = make(accounts.DerivationPath, len(path))
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -54,4 +54,4 @@ for:
      - go run build/ci.go archive -arch %GETH_ARCH% -type zip -signer WINDOWS_SIGNING_KEY -upload gethstore/builds
      - go run build/ci.go nsis -arch %GETH_ARCH% -signer WINDOWS_SIGNING_KEY -upload gethstore/builds
    test_script:
-      - go run build/ci.go test -dlgo -arch %GETH_ARCH% -cc %GETH_CC% -short
+      - go run build/ci.go test -dlgo -arch %GETH_ARCH% -cc %GETH_CC%
--- a/beacon/engine/errors.go
+++ b/beacon/engine/errors.go
@@ -80,7 +80,6 @@ var (
 	InvalidPayloadAttributes = &EngineAPIError{code: -38003, msg: "Invalid payload attributes"}
 	TooLargeRequest          = &EngineAPIError{code: -38004, msg: "Too large request"}
 	InvalidParams            = &EngineAPIError{code: -32602, msg: "Invalid parameters"}
-	UnsupportedFork          = &EngineAPIError{code: -38005, msg: "Unsupported fork"}

 	STATUS_INVALID         = ForkChoiceResponse{PayloadStatus: PayloadStatusV1{Status: INVALID}, PayloadID: nil}
 	STATUS_SYNCING         = ForkChoiceResponse{PayloadStatus: PayloadStatusV1{Status: SYNCING}, PayloadID: nil}
--- a/beacon/engine/gen_blockparams.go
+++ b/beacon/engine/gen_blockparams.go
@@ -20,14 +20,12 @@ func (p PayloadAttributes) MarshalJSON() ([]byte, error) {
 		Random                common.Hash         `json:"prevRandao"            gencodec:"required"`
 		SuggestedFeeRecipient common.Address      `json:"suggestedFeeRecipient" gencodec:"required"`
 		Withdrawals           []*types.Withdrawal `json:"withdrawals"`
-		BeaconRoot            *common.Hash        `json:"parentBeaconBlockRoot"`
 	}
 	var enc PayloadAttributes
 	enc.Timestamp = hexutil.Uint64(p.Timestamp)
 	enc.Random = p.Random
 	enc.SuggestedFeeRecipient = p.SuggestedFeeRecipient
 	enc.Withdrawals = p.Withdrawals
-	enc.BeaconRoot = p.BeaconRoot
 	return json.Marshal(&enc)
 }

@@ -38,7 +36,6 @@ func (p *PayloadAttributes) UnmarshalJSON(input []byte) error {
 		Random                *common.Hash        `json:"prevRandao"            gencodec:"required"`
 		SuggestedFeeRecipient *common.Address     `json:"suggestedFeeRecipient" gencodec:"required"`
 		Withdrawals           []*types.Withdrawal `json:"withdrawals"`
-		BeaconRoot            *common.Hash        `json:"parentBeaconBlockRoot"`
 	}
 	var dec PayloadAttributes
 	if err := json.Unmarshal(input, &dec); err != nil {
@@ -59,8 +56,5 @@ func (p *PayloadAttributes) UnmarshalJSON(input []byte) error {
 	if dec.Withdrawals != nil {
 		p.Withdrawals = dec.Withdrawals
 	}
-	if dec.BeaconRoot != nil {
-		p.BeaconRoot = dec.BeaconRoot
-	}
 	return nil
 }
--- a/beacon/engine/gen_epe.go
+++ b/beacon/engine/gen_epe.go
@@ -18,13 +18,11 @@ func (e ExecutionPayloadEnvelope) MarshalJSON() ([]byte, error) {
 		ExecutionPayload *ExecutableData `json:"executionPayload"  gencodec:"required"`
 		BlockValue       *hexutil.Big    `json:"blockValue"  gencodec:"required"`
 		BlobsBundle      *BlobsBundleV1  `json:"blobsBundle"`
-		Override         bool            `json:"shouldOverrideBuilder"`
 	}
 	var enc ExecutionPayloadEnvelope
 	enc.ExecutionPayload = e.ExecutionPayload
 	enc.BlockValue = (*hexutil.Big)(e.BlockValue)
 	enc.BlobsBundle = e.BlobsBundle
-	enc.Override = e.Override
 	return json.Marshal(&enc)
 }

@@ -34,7 +32,6 @@ func (e *ExecutionPayloadEnvelope) UnmarshalJSON(input []byte) error {
 		ExecutionPayload *ExecutableData `json:"executionPayload"  gencodec:"required"`
 		BlockValue       *hexutil.Big    `json:"blockValue"  gencodec:"required"`
 		BlobsBundle      *BlobsBundleV1  `json:"blobsBundle"`
-		Override         *bool           `json:"shouldOverrideBuilder"`
 	}
 	var dec ExecutionPayloadEnvelope
 	if err := json.Unmarshal(input, &dec); err != nil {
@@ -51,8 +48,5 @@ func (e *ExecutionPayloadEnvelope) UnmarshalJSON(input []byte) error {
 	if dec.BlobsBundle != nil {
 		e.BlobsBundle = dec.BlobsBundle
 	}
-	if dec.Override != nil {
-		e.Override = *dec.Override
-	}
 	return nil
 }
--- a/beacon/engine/types.go
+++ b/beacon/engine/types.go
@@ -23,19 +23,10 @@ import (
 	"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/crypto/kzg4844"
 	"github.com/ethereum/go-ethereum/trie"
 )

-// PayloadVersion denotes the version of PayloadAttributes used to request the
-// building of the payload to commence.
-type PayloadVersion byte
-
-var (
-	PayloadV1 PayloadVersion = 0x1
-	PayloadV2 PayloadVersion = 0x2
-	PayloadV3 PayloadVersion = 0x3
-)
-
 //go:generate go run github.com/fjl/gencodec -type PayloadAttributes -field-override payloadAttributesMarshaling -out gen_blockparams.go

 // PayloadAttributes describes the environment context in which a block should
@@ -45,7 +36,6 @@ type PayloadAttributes struct {
 	Random                common.Hash         `json:"prevRandao"            gencodec:"required"`
 	SuggestedFeeRecipient common.Address      `json:"suggestedFeeRecipient" gencodec:"required"`
 	Withdrawals           []*types.Withdrawal `json:"withdrawals"`
-	BeaconRoot            *common.Hash        `json:"parentBeaconBlockRoot"`
 }

 // JSON type overrides for PayloadAttributes.
@@ -96,7 +86,6 @@ type ExecutionPayloadEnvelope struct {
 	ExecutionPayload *ExecutableData `json:"executionPayload"  gencodec:"required"`
 	BlockValue       *big.Int        `json:"blockValue"  gencodec:"required"`
 	BlobsBundle      *BlobsBundleV1  `json:"blobsBundle"`
-	Override         bool            `json:"shouldOverrideBuilder"`
 }

 type BlobsBundleV1 struct {
@@ -125,21 +114,6 @@ type TransitionConfigurationV1 struct {
 // PayloadID is an identifier of the payload build process
 type PayloadID [8]byte

-// Version returns the payload version associated with the identifier.
-func (b PayloadID) Version() PayloadVersion {
-	return PayloadVersion(b[0])
-}
-
-// Is returns whether the identifier matches any of provided payload versions.
-func (b PayloadID) Is(versions ...PayloadVersion) bool {
-	for _, v := range versions {
-		if v == b.Version() {
-			return true
-		}
-	}
-	return false
-}
-
 func (b PayloadID) String() string {
 	return hexutil.Encode(b[:])
 }
@@ -198,7 +172,7 @@ 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 params.
-func ExecutableDataToBlock(params ExecutableData, versionedHashes []common.Hash, beaconRoot *common.Hash) (*types.Block, error) {
+func ExecutableDataToBlock(params ExecutableData, versionedHashes []common.Hash) (*types.Block, error) {
 	txs, err := decodeTransactions(params.Transactions)
 	if err != nil {
 		return nil, err
@@ -252,7 +226,6 @@ func ExecutableDataToBlock(params ExecutableData, versionedHashes []common.Hash,
 		WithdrawalsHash: withdrawalsRoot,
 		ExcessBlobGas:   params.ExcessBlobGas,
 		BlobGasUsed:     params.BlobGasUsed,
-		ParentBeaconRoot: beaconRoot,
 	}
 	block := types.NewBlockWithHeader(header).WithBody(txs, nil /* uncles */).WithWithdrawals(params.Withdrawals)
 	if block.Hash() != params.BlockHash {
@@ -263,7 +236,7 @@ func ExecutableDataToBlock(params ExecutableData, versionedHashes []common.Hash,

 // 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) *ExecutionPayloadEnvelope {
+func BlockToExecutableData(block *types.Block, fees *big.Int, blobs []kzg4844.Blob, commitments []kzg4844.Commitment, proofs []kzg4844.Proof) *ExecutionPayloadEnvelope {
 	data := &ExecutableData{
 		BlockHash:     block.Hash(),
 		ParentHash:    block.ParentHash(),
@@ -283,19 +256,17 @@ func BlockToExecutableData(block *types.Block, fees *big.Int, sidecars []*types.
 		BlobGasUsed:   block.BlobGasUsed(),
 		ExcessBlobGas: block.ExcessBlobGas(),
 	}
-	bundle := BlobsBundleV1{
+	blobsBundle := BlobsBundleV1{
 		Commitments: make([]hexutil.Bytes, 0),
 		Blobs:       make([]hexutil.Bytes, 0),
 		Proofs:      make([]hexutil.Bytes, 0),
 	}
-	for _, sidecar := range sidecars {
-		for j := range sidecar.Blobs {
-			bundle.Blobs = append(bundle.Blobs, hexutil.Bytes(sidecar.Blobs[j][:]))
-			bundle.Commitments = append(bundle.Commitments, hexutil.Bytes(sidecar.Commitments[j][:]))
-			bundle.Proofs = append(bundle.Proofs, hexutil.Bytes(sidecar.Proofs[j][:]))
+	for i := range blobs {
+		blobsBundle.Blobs = append(blobsBundle.Blobs, hexutil.Bytes(blobs[i][:]))
+		blobsBundle.Commitments = append(blobsBundle.Commitments, hexutil.Bytes(commitments[i][:]))
+		blobsBundle.Proofs = append(blobsBundle.Proofs, hexutil.Bytes(proofs[i][:]))
 	}
-	}
-	return &ExecutionPayloadEnvelope{ExecutionPayload: data, BlockValue: fees, BlobsBundle: &bundle, Override: false}
+	return &ExecutionPayloadEnvelope{ExecutionPayload: data, BlockValue: fees, BlobsBundle: &blobsBundle}
 }

 // ExecutionPayloadBodyV1 is used in the response to GetPayloadBodiesByHashV1 and GetPayloadBodiesByRangeV1
--- a/beacon/types/light_sync.go
+++ b/beacon/types/light_sync.go
@@ -25,24 +25,6 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 )

-// 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.
-type BootstrapData struct {
-	Header          Header
-	CommitteeRoot   common.Hash
-	Committee       *SerializedSyncCommittee `rlp:"-"`
-	CommitteeBranch merkle.Values
-}
-
-// Validate verifies the proof included in BootstrapData.
-func (c *BootstrapData) Validate() error {
-	if c.CommitteeRoot != c.Committee.Root() {
-		return errors.New("wrong committee root")
-	}
-	return merkle.VerifyProof(c.Header.StateRoot, params.StateIndexSyncCommittee, c.CommitteeBranch, merkle.Value(c.CommitteeRoot))
-}
-
 // LightClientUpdate is a proof of the next sync committee root based on a header
 // signed by the sync committee of the given period. Optionally, the update can
 // prove quasi-finality by the signed header referring to a previous, finalized
--- a/build/checksums.txt
+++ b/build/checksums.txt
@@ -1,65 +1,69 @@
 # This file contains sha256 checksums of optional build dependencies.

-# version:spec-tests 1.0.6
-# https://github.com/ethereum/execution-spec-tests/releases
-# https://github.com/ethereum/execution-spec-tests/releases/download/v1.0.6/
-485af7b66cf41eb3a8c1bd46632913b8eb95995df867cf665617bbc9b4beedd1  fixtures_develop.tar.gz
+2c5ee9c9ec1e733b0dbbc2bdfed3f62306e51d8172bf38f4f4e542b27520f597  go1.20.7.src.tar.gz
+785170eab380a8985d53896808b0a71336d0ea60e0a26099b4ccec77798b1cf4  go1.20.7.darwin-amd64.tar.gz
+eea1e7e4c2f75c72629050e6a6c7c46c446d64056732a7787fb3ba16ace1982e  go1.20.7.darwin-arm64.tar.gz
+d8cff0357ac24eb06f3f280535397eeaacf95611d29f9b2abc3060f3d6dce3b4  go1.20.7.freebsd-386.tar.gz
+26918dcebf474a9e81ccf9f648cdf36968dfb76b481518cf615d78455dda4416  go1.20.7.freebsd-amd64.tar.gz
+ddb48145f05bda2f4617a22c979d4e94b22802cdb1a1fde1b1974e733b26f091  go1.20.7.linux-386.tar.gz
+f0a87f1bcae91c4b69f8dc2bc6d7e6bfcd7524fceec130af525058c0c17b1b44  go1.20.7.linux-amd64.tar.gz
+44781ae3b153c3b07651d93b6bc554e835a36e2d72a696281c1e4dad9efffe43  go1.20.7.linux-arm64.tar.gz
+7cc231b415b94f2f7065870a73f67dd2b0ec12b5a98052b7ee0121c42bc04f8d  go1.20.7.linux-armv6l.tar.gz
+6318a1db307c12b8afe68808bd6fae4fba1e558a85b958216096869ed506dcb3  go1.20.7.linux-ppc64le.tar.gz
+26aea2ede8722ceecbd9db883328a8d963136fd96c11dacc356c44c4c19c6515  go1.20.7.linux-s390x.tar.gz
+5b0ef6f58d3e04d6cc003aa98e9172f41ba9e091b1c98e7339b41c4c87fb78a1  go1.20.7.windows-386.zip
+736dc6c7fcab1c96b682c8c93e38d7e371e62a17d34cb2c37d451a1147f66af9  go1.20.7.windows-amd64.zip
+fc6f79c1e1ed9e506c65f2112ac4e387479916f1accb0d046a6a19ff6938baa5  go1.20.7.windows-arm64.zip

-# version:golang 1.21.6
-# https://go.dev/dl/
-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.55.2
-# https://github.com/golangci/golangci-lint/releases/
-# 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
+000d4d58f1e25323aaf0da20b337d059d401c8c1fb31cef92ce50ef35c05e877  golangci-lint-1.52.2-linux-ppc64le.deb
+0970b2e3ecc20003a0fc78b078623ab27c61f0f809a44288e2cc438bfbbf5616  golangci-lint-1.52.2-linux-s390x.deb
+0bfe9b51f68a33cc4e43139151d8032b57b15e61a19f5a7554b687a3fa166ab8  golangci-lint-1.52.2-netbsd-armv7.tar.gz
+0e4e24085d364f4e03752c060d5f37b5ead52acd62f07392f4c9022515e0ecd8  golangci-lint-1.52.2-linux-armv7.rpm
+0f19ad6c037d45867f4978287a7a6d78bc761daf8e6cb3a5e6af86d5714b0258  golangci-lint-1.52.2-linux-armv6.tar.gz
+1506b19f3f0410f6d85d1e339a47fcc84646d552516c0f429dc8cd7f34b4069a  golangci-lint-1.52.2-windows-armv6.zip
+1cc68baa226e186c15c5514a6e93b1cc8d47ff06aaf1a395b8266434cb01df29  golangci-lint-1.52.2-linux-386.rpm
+1d23661087ae686563e40d3b1e33f309dd3b4ba7d1c7e571ca7723f77a52a9e4  golangci-lint-1.52.2-linux-s390x.rpm
+227673a18d21b428f1768bb8ee46e38c36a0f002960bc6211ef6137b85d03f52  golangci-lint-1.52.2-freebsd-armv7.tar.gz
+24f0272e5741c05c59e7162b7ff0258cfa6beb0d9265bd87c386fe80ac25135d  golangci-lint-1.52.2-linux-mips64.deb
+3abc8ad30b336ccbe3c5e3c65fa146f5b12d8e81e644345fa8d51cdbaa8cb570  golangci-lint-1.52.2-netbsd-amd64.tar.gz
+40a2645b4c7bd94c16618eb0f12b32cd54c17e5620f761cf477b256d3622f299  golangci-lint-1.52.2-windows-386.zip
+40b40002e07db81628d94108265525052c58fc9ce358bef26a36d27f0aea3d87  golangci-lint-1.52.2-windows-amd64.zip
+41e936b62ba4fc66c02daf6fa9cf74213bc2220745c7a796acbe197c05ed26bb  golangci-lint-1.52.2-netbsd-armv6.tar.gz
+4bcbb4cf34bf3c8ae1ca880d12516a999499189326621599f8362ededd6e4229  golangci-lint-1.52.2-linux-riscv64.tar.gz
+4edb83f1433f7c57f06f79a7fc30bf3f920c1f86c334e481661ac6627d80293f  golangci-lint-1.52.2-linux-arm64.deb
+50d662e86d094dbad6634d086eca4f670ffa8ea7142508d8da357a2d750ac21a  golangci-lint-1.52.2-linux-armv7.tar.gz
+6891597bedbcd7e530d08ed198bab7eeb9b23f3f8161dc6e87505b783cb11593  golangci-lint-1.52.2-windows-arm64.zip
+6d79f4f3448b70e83952e746fcb9e251c6ba94ec2790a912806cc1704ade4d64  golangci-lint-1.52.2-linux-mips64.rpm
+6de51ae05d39002421caf6049e0dd0014a2f10961471c5547c905d33d8e6adf1  golangci-lint-1.52.2-linux-armv6.deb
+715dc0f0cf3538c3b2c75f084dde8dcdc3485b3494f42a6d0d9c0dc61e62b5a8  golangci-lint-1.52.2-linux-s390x.tar.gz
+7c559332a97ee49b80427aba5a7122e17cac18c57e700f48e6db5ffcbbb61b2b  golangci-lint-1.52.2-linux-arm64.rpm
+81201bb5f19897fefb4380af2e187a0133dc5efda22254698c063cc36a601f43  golangci-lint-1.52.2-linux-386.deb
+89e523d45883903cfc472ab65621073f850abd4ffbb7720bbdd7ba66ee490bc8  golangci-lint-1.52.2-darwin-arm64.tar.gz
+8d60d63eee38f8de679e57b1a781de32987152f004f852f20cd47baa4c582209  golangci-lint-1.52.2-linux-mips64le.rpm
+9e22df0516cbd847910f353d92245e58eab2b6edacc669646bfa06eb032a65a3  golangci-lint-1.52.2-linux-riscv64.deb
+a1a74747a196d4ccd2394ea8a461508eb2edf1eb5a88010611debf572991961d  golangci-lint-1.52.2-linux-loong64.tar.gz
+a7f076d0fb50e0f5bc24d0f3b2567f2cfe864441e6ad20323189b7fde7cc065d  golangci-lint-1.52.2-freebsd-386.tar.gz
+abc100851a59cbcea2a7e9ff5ad2974a43270135520aeac9a302ca6c712a41e1  golangci-lint-1.52.2-linux-loong64.rpm
+adf11a1f7f43b5a431c19cccea260e6205e2e2b42a2d2d450e31c287fec199f2  golangci-lint-1.52.2-linux-amd64.rpm
+b2249e43e1624486398f41700dbe4094a4222bf50b2b1b3a740323adb9a1b66f  golangci-lint-1.52.2-linux-386.tar.gz
+b8e81bf979dc8bf226cb592eb78c1792f1018c3dea1bbeb11517efc4cc3301bb  golangci-lint-1.52.2-windows-armv7.zip
+bb9a6a0aabe39fb3d581cc200c639ce6598821a53b4d16ec59366c65f4cc2960  golangci-lint-1.52.2-source.tar.gz
+c152280b2e61c202614c1c476cf4458922cda0d2781e4492be2c22d45655cae0  golangci-lint-1.52.2-freebsd-armv6.tar.gz
+c8bf25c0bca142638ce4bfc921bf23d23038818d57658d69aa4a9947d514d48f  golangci-lint-1.52.2-linux-ppc64le.rpm
+c9cf72d12058a131746edd409ed94ccd578fbd178899d1ed41ceae3ce5f54501  golangci-lint-1.52.2-linux-amd64.tar.gz
+d03f2b331b5139eddea5db2b49066d10a90094747b08d72d7b2d61cf91c79a27  golangci-lint-1.52.2-linux-mips64le.tar.gz
+d609c1d49591d714148e1f8c8b5ae9f9565c601aeabc44a5a53ba44b0eb99f36  golangci-lint-1.52.2-linux-riscv64.rpm
+d679adad29603ed7549372b64077cccad784e404deffe5c1e9495a06659cff33  golangci-lint-1.52.2-linux-mips64.tar.gz
+d91e8cb60920cf0e46958ed917fcdd059738c00d162189c2e878424ffc8ada75  golangci-lint-1.52.2-linux-ppc64le.tar.gz
+d9b5820b491e317fb1360775441d68bd3dc2f303439da5b6d536df23977e28c9  golangci-lint-1.52.2-freebsd-amd64.tar.gz
+ddeae781cf07c016898efd80eaed6853a91bfaf1f22c08fbbf5cf08a573b98c4  golangci-lint-1.52.2-linux-loong64.deb
+dfc5e755cfa95381f61f736780ff736a5b6c9cbccc88140348986c166d484f85  golangci-lint-1.52.2-linux-amd64.deb
+e57f2599de73c4da1d36d5255b9baec63f448b3d7fb726ebd3cd64dabbd3ee4a  golangci-lint-1.52.2-darwin-amd64.tar.gz
+ebfb5b643ba73ef6007236b90f863ae49fc34fd366682c971b7d1308ab28f642  golangci-lint-1.52.2-netbsd-386.tar.gz
+f46b60a90fab5916a7de899ad9a3a4b3d77278c2e1737d070719d3ea27919557  golangci-lint-1.52.2-linux-armv7.deb
+f6e39d0ac4691c2b9f49d6d5819594f48bb03e18692fd6d100e7114077f710e6  golangci-lint-1.52.2-linux-armv6.rpm
+fa5da589075143628a49a0c123ccd76a8717bb6308fb3bdb6bf1df59435d921b  golangci-lint-1.52.2-linux-mips64le.deb
+fc09a97f8888809fab83a316f7da70c8ed74d4863b7eed7d872cec41911a55e8  golangci-lint-1.52.2-linux-arm64.tar.gz

 # 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. If it ever becomes insufficient,
-# we need to switch over to a recursive builder to jump across supported
-# versions.
-#
-# version:ppa-builder 1.19.6
-# https://go.dev/dl/
 d7f0013f82e6d7f862cc6cb5c8cdb48eef5f2e239b35baa97e2f1a7466043767  go1.19.6.src.tar.gz
--- a/build/ci.go
+++ b/build/ci.go
@@ -120,16 +120,15 @@ var (
 	// 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
+	//   wily, yakkety, zesty, artful, cosmic, disco, eoan, groovy, hirsuite, impish
 	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
-		"lunar":  "golang-go",   // 23.04, EOL: 01/2024
-		"mantic": "golang-go",   // 23.10, EOL: 07/2024
+		"trusty":  "golang-1.11", // EOL: 04/2024
+		"xenial":  "golang-go",   // EOL: 04/2026
+		"bionic":  "golang-go",   // EOL: 04/2028
+		"focal":   "golang-go",   // EOL: 04/2030
+		"jammy":   "golang-go",   // EOL: 04/2032
+		"kinetic": "golang-go",   // EOL: 07/2023
+		"lunar":   "golang-go",   // EOL: 01/2024
 	}

 	debGoBootPaths = map[string]string{
@@ -137,8 +136,18 @@ var (
 		"golang-go":   "/usr/lib/go",
 	}

-	// This is where the tests should be unpacked.
-	executionSpecTestsDir = "tests/spec-tests"
+	// This is the version of Go that will be downloaded by
+	//
+	//     go run ci.go install -dlgo
+	dlgoVersion = "1.20.7"
+
+	// This is the version of Go that will be used to bootstrap the PPA builder.
+	//
+	// 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. If it ever becomes insufficient,
+	// we need to switch over to a recursive builder to jumpt across supported
+	// versions.
+	gobootVersion = "1.19.6"
 )

 var GOBIN, _ = filepath.Abs(filepath.Join("build", "bin"))
@@ -176,8 +185,6 @@ func main() {
 		doWindowsInstaller(os.Args[2:])
 	case "purge":
 		doPurge(os.Args[2:])
-	case "sanitycheck":
-		doSanityCheck()
 	default:
 		log.Fatal("unknown command ", os.Args[1])
 	}
@@ -200,8 +207,9 @@ func doInstall(cmdline []string) {
 	tc := build.GoToolchain{GOARCH: *arch, CC: *cc}
 	if *dlgo {
 		csdb := build.MustLoadChecksums("build/checksums.txt")
-		tc.Root = build.DownloadGo(csdb)
+		tc.Root = build.DownloadGo(csdb, dlgoVersion)
 	}
+
 	// Disable CLI markdown doc generation in release builds.
 	buildTags := []string{"urfave_cli_no_docs"}

@@ -292,19 +300,14 @@ func doTest(cmdline []string) {
 		verbose  = flag.Bool("v", false, "Whether to log verbosely")
 		timeout  = flag.String("timeout", "10m", `Timeout of runing tests`)
 		race     = flag.Bool("race", false, "Execute the race detector")
-		short    = flag.Bool("short", false, "Pass the 'short'-flag to go test")
-		cachedir = flag.String("cachedir", "./build/cache", "directory for caching downloads")
 	)
 	flag.CommandLine.Parse(cmdline)

-	// Get test fixtures.
-	csdb := build.MustLoadChecksums("build/checksums.txt")
-	downloadSpecTestFixtures(csdb, *cachedir)
-
 	// Configure the toolchain.
 	tc := build.GoToolchain{GOARCH: *arch, CC: *cc}
 	if *dlgo {
-		tc.Root = build.DownloadGo(csdb)
+		csdb := build.MustLoadChecksums("build/checksums.txt")
+		tc.Root = build.DownloadGo(csdb, dlgoVersion)
 	}
 	gotest := tc.Go("test")

@@ -314,9 +317,6 @@ func doTest(cmdline []string) {
 	// Enable CKZG backend in CI.
 	gotest.Args = append(gotest.Args, "-tags=ckzg")

-	// Enable integration-tests
-	gotest.Args = append(gotest.Args, "-tags=integrationtests")
-
 	// Test a single package at a time. CI builders are slow
 	// and some tests run into timeouts under load.
 	gotest.Args = append(gotest.Args, "-p", "1")
@@ -332,9 +332,6 @@ func doTest(cmdline []string) {
 	if *race {
 		gotest.Args = append(gotest.Args, "-race")
 	}
-	if *short {
-		gotest.Args = append(gotest.Args, "-short")
-	}

 	packages := []string{"./..."}
 	if len(flag.CommandLine.Args()) > 0 {
@@ -344,25 +341,6 @@ func doTest(cmdline []string) {
 	build.MustRun(gotest)
 }

-// downloadSpecTestFixtures downloads and extracts the execution-spec-tests fixtures.
-func downloadSpecTestFixtures(csdb *build.ChecksumDB, cachedir string) string {
-	executionSpecTestsVersion, err := build.Version(csdb, "spec-tests")
-	if err != nil {
-		log.Fatal(err)
-	}
-	ext := ".tar.gz"
-	base := "fixtures_develop" // TODO(MariusVanDerWijden) rename once the version becomes part of the filename
-	url := fmt.Sprintf("https://github.com/ethereum/execution-spec-tests/releases/download/v%s/%s%s", executionSpecTestsVersion, base, ext)
-	archivePath := filepath.Join(cachedir, base+ext)
-	if err := csdb.DownloadFile(url, archivePath); err != nil {
-		log.Fatal(err)
-	}
-	if err := build.ExtractArchive(archivePath, executionSpecTestsDir); err != nil {
-		log.Fatal(err)
-	}
-	return filepath.Join(cachedir, base)
-}
-
 // doLint runs golangci-lint on requested packages.
 func doLint(cmdline []string) {
 	var (
@@ -376,17 +354,15 @@ func doLint(cmdline []string) {

 	linter := downloadLinter(*cachedir)
 	lflags := []string{"run", "--config", ".golangci.yml"}
-	build.MustRunCommandWithOutput(linter, append(lflags, packages...)...)
+	build.MustRunCommand(linter, append(lflags, packages...)...)
 	fmt.Println("You have achieved perfection.")
 }

 // downloadLinter downloads and unpacks golangci-lint.
 func downloadLinter(cachedir string) string {
+	const version = "1.52.2"
+
 	csdb := build.MustLoadChecksums("build/checksums.txt")
-	version, err := build.Version(csdb, "golangci")
-	if err != nil {
-		log.Fatal(err)
-	}
 	arch := runtime.GOARCH
 	ext := ".tar.gz"

@@ -768,10 +744,6 @@ func doDebianSource(cmdline []string) {
 // to bootstrap the builder Go.
 func downloadGoBootstrapSources(cachedir string) string {
 	csdb := build.MustLoadChecksums("build/checksums.txt")
-	gobootVersion, err := build.Version(csdb, "ppa-builder")
-	if err != nil {
-		log.Fatal(err)
-	}
 	file := fmt.Sprintf("go%s.src.tar.gz", gobootVersion)
 	url := "https://dl.google.com/go/" + file
 	dst := filepath.Join(cachedir, file)
@@ -784,10 +756,6 @@ func downloadGoBootstrapSources(cachedir string) string {
 // downloadGoSources downloads the Go source tarball.
 func downloadGoSources(cachedir string) string {
 	csdb := build.MustLoadChecksums("build/checksums.txt")
-	dlgoVersion, err := build.Version(csdb, "golang")
-	if err != nil {
-		log.Fatal(err)
-	}
 	file := fmt.Sprintf("go%s.src.tar.gz", dlgoVersion)
 	url := "https://dl.google.com/go/" + file
 	dst := filepath.Join(cachedir, file)
@@ -1114,7 +1082,3 @@ func doPurge(cmdline []string) {
 		log.Fatal(err)
 	}
 }
-
-func doSanityCheck() {
-	build.DownloadAndVerifyChecksums(build.MustLoadChecksums("build/checksums.txt"))
-}
--- a/build/nsis.geth.nsi
+++ b/build/nsis.geth.nsi
@@ -20,7 +20,7 @@
 # - NSIS Large Strings build, http://nsis.sourceforge.net/Special_Builds
 # - SFP, http://nsis.sourceforge.net/NSIS_Simple_Firewall_Plugin (put dll in NSIS\Plugins\x86-ansi)
 #
-# After installing NSIS extra the NSIS Large Strings build zip and replace the makensis.exe and the
+# After intalling NSIS extra the NSIS Large Strings build zip and replace the makensis.exe and the
 # files found in Stub.
 #
 # based on: http://nsis.sourceforge.net/A_simple_installer_with_start_menu_shortcut_and_uninstaller
--- a/build/update-license.go
+++ b/build/update-license.go
@@ -65,8 +65,10 @@ var (
 		"vendor/", "tests/testdata/", "build/",

 		// don't relicense vendored sources
+		"cmd/internal/browser",
 		"common/bitutil/bitutil",
 		"common/prque/",
+		"consensus/ethash/xor.go",
 		"crypto/blake2b/",
 		"crypto/bn256/",
 		"crypto/bls12381/",
@@ -76,7 +78,6 @@ var (
 		"log/",
 		"metrics/",
 		"signer/rules/deps",
-		"internal/reexec",

 		// skip special licenses
 		"crypto/secp256k1", // Relicensed to BSD-3 via https://github.com/ethereum/go-ethereum/pull/17225
--- a/cmd/abigen/main.go
+++ b/cmd/abigen/main.go
@@ -232,7 +232,7 @@ func abigen(c *cli.Context) error {
 }

 func main() {
-	log.SetDefault(log.NewLogger(log.NewTerminalHandlerWithLevel(os.Stderr, log.LevelInfo, true)))
+	log.Root().SetHandler(log.LvlFilterHandler(log.LvlInfo, log.StreamHandler(os.Stderr, log.TerminalFormat(true))))

 	if err := app.Run(os.Args); err != nil {
 		fmt.Fprintln(os.Stderr, err)
--- a/cmd/abigen/namefilter_test.go
+++ b/cmd/abigen/namefilter_test.go
@@ -8,7 +8,6 @@ import (
 )

 func TestNameFilter(t *testing.T) {
-	t.Parallel()
 	_, err := newNameFilter("Foo")
 	require.Error(t, err)
 	_, err = newNameFilter("too/many:colons:Foo")
--- a/cmd/bootnode/main.go
+++ b/cmd/bootnode/main.go
@@ -54,11 +54,10 @@ func main() {
 	)
 	flag.Parse()

-	glogger := log.NewGlogHandler(log.NewTerminalHandler(os.Stderr, false))
-	slogVerbosity := log.FromLegacyLevel(*verbosity)
-	glogger.Verbosity(slogVerbosity)
+	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.TerminalFormat(false)))
+	glogger.Verbosity(log.Lvl(*verbosity))
 	glogger.Vmodule(*vmodule)
-	log.SetDefault(log.NewLogger(glogger))
+	log.Root().SetHandler(glogger)

 	natm, err := nat.Parse(*natdesc)
 	if err != nil {
--- a/cmd/clef/README.md
+++ b/cmd/clef/README.md
@@ -2,7 +2,7 @@

 Clef can be used to sign transactions and data and is meant as a(n eventual) replacement for Geth's account management. This allows DApps to not depend on Geth's account management. When a DApp wants to sign data (or a transaction), it can send the content to Clef, which will then provide the user with context and asks for permission to sign the content. If the users grants the signing request, Clef will send the signature back to the DApp.

-This setup allows a DApp to connect to a remote Ethereum node and send transactions that are locally signed. This can help in situations when a DApp is connected to an untrusted remote Ethereum node, because a local one is not available, not synchronized with the chain, or is a node that has no built-in (or limited) account management.
+This setup allows a DApp to connect to a remote Ethereum node and send transactions that are locally signed. This can help in situations when a DApp is connected to an untrusted remote Ethereum node, because a local one is not available, not synchronised with the chain, or is a node that has no built-in (or limited) account management.

 Clef can run as a daemon on the same machine, off a usb-stick like [USB armory](https://inversepath.com/usbarmory), or even a separate VM in a [QubesOS](https://www.qubes-os.org/) type setup.

--- a/cmd/clef/consolecmd_test.go
+++ b/cmd/clef/consolecmd_test.go
@@ -26,13 +26,12 @@ import (

 // TestImportRaw tests clef --importraw
 func TestImportRaw(t *testing.T) {
-	t.Parallel()
 	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()
+	t.Run("happy-path", func(t *testing.T) {
 		// Run clef importraw
 		clef := runClef(t, "--suppress-bootwarn", "--lightkdf", "importraw", keyPath)
 		clef.input("myverylongpassword").input("myverylongpassword")
@@ -44,7 +43,6 @@ func TestImportRaw(t *testing.T) {
 	})
 	// tests clef --importraw with mismatched passwords.
 	t.Run("pw-mismatch", func(t *testing.T) {
-		t.Parallel()
 		// Run clef importraw
 		clef := runClef(t, "--suppress-bootwarn", "--lightkdf", "importraw", keyPath)
 		clef.input("myverylongpassword1").input("myverylongpassword2").WaitExit()
@@ -54,7 +52,6 @@ func TestImportRaw(t *testing.T) {
 	})
 	// tests clef --importraw with a too short password.
 	t.Run("short-pw", func(t *testing.T) {
-		t.Parallel()
 		// Run clef importraw
 		clef := runClef(t, "--suppress-bootwarn", "--lightkdf", "importraw", keyPath)
 		clef.input("shorty").input("shorty").WaitExit()
@@ -67,13 +64,12 @@ func TestImportRaw(t *testing.T) {

 // TestListAccounts tests clef --list-accounts
 func TestListAccounts(t *testing.T) {
-	t.Parallel()
 	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()
+	t.Run("no-accounts", func(t *testing.T) {
 		clef := runClef(t, "--suppress-bootwarn", "--lightkdf", "list-accounts")
 		if out := string(clef.Output()); !strings.Contains(out, "The keystore is empty.") {
 			t.Logf("Output\n%v", out)
@@ -81,7 +77,6 @@ func TestListAccounts(t *testing.T) {
 		}
 	})
 	t.Run("one-account", func(t *testing.T) {
-		t.Parallel()
 		// First, we need to import
 		clef := runClef(t, "--suppress-bootwarn", "--lightkdf", "importraw", keyPath)
 		clef.input("myverylongpassword").input("myverylongpassword").WaitExit()
@@ -96,13 +91,12 @@ func TestListAccounts(t *testing.T) {

 // TestListWallets tests clef --list-wallets
 func TestListWallets(t *testing.T) {
-	t.Parallel()
 	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()
+	t.Run("no-accounts", func(t *testing.T) {
 		clef := runClef(t, "--suppress-bootwarn", "--lightkdf", "list-wallets")
 		if out := string(clef.Output()); !strings.Contains(out, "There are no wallets.") {
 			t.Logf("Output\n%v", out)
@@ -110,7 +104,6 @@ func TestListWallets(t *testing.T) {
 		}
 	})
 	t.Run("one-account", func(t *testing.T) {
-		t.Parallel()
 		// First, we need to import
 		clef := runClef(t, "--suppress-bootwarn", "--lightkdf", "importraw", keyPath)
 		clef.input("myverylongpassword").input("myverylongpassword").WaitExit()
--- a/cmd/clef/main.go
+++ b/cmd/clef/main.go
@@ -492,8 +492,7 @@ func initialize(c *cli.Context) error {
 	if usecolor {
 		output = colorable.NewColorable(logOutput)
 	}
-	verbosity := log.FromLegacyLevel(c.Int(logLevelFlag.Name))
-	log.SetDefault(log.NewLogger(log.NewTerminalHandlerWithLevel(output, verbosity, usecolor)))
+	log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(c.Int(logLevelFlag.Name)), log.StreamHandler(output, log.TerminalFormat(usecolor))))

 	return nil
 }
@@ -582,7 +581,6 @@ func accountImport(c *cli.Context) error {
 		return err
 	}
 	if first != second {
-		//lint:ignore ST1005 This is a message for the user
 		return errors.New("Passwords do not match")
 	}
 	acc, err := internalApi.ImportRawKey(hex.EncodeToString(crypto.FromECDSA(pKey)), first)
@@ -704,7 +702,6 @@ func signer(c *cli.Context) error {
 	log.Info("Starting signer", "chainid", chainId, "keystore", ksLoc,
 		"light-kdf", lightKdf, "advanced", advanced)
 	am := core.StartClefAccountManager(ksLoc, nousb, lightKdf, scpath)
-	defer am.Close()
 	apiImpl := core.NewSignerAPI(am, chainId, nousb, ui, db, advanced, pwStorage)

 	// Establish the bidirectional communication, by creating a new UI backend and registering
--- a/cmd/clef/pythonsigner.py
+++ b/cmd/clef/pythonsigner.py
@@ -91,7 +91,7 @@ class StdIOHandler:
        {"jsonrpc":"2.0","id":20,"method":"ui_approveTx","params":[{"transaction":{"from":"0xDEADbEeF000000000000000000000000DeaDbeEf","to":"0xDEADbEeF000000000000000000000000DeaDbeEf","gas":"0x3e8","gasPrice":"0x5","maxFeePerGas":null,"maxPriorityFeePerGas":null,"value":"0x6","nonce":"0x1","data":"0x"},"call_info":null,"meta":{"remote":"clef binary","local":"main","scheme":"in-proc","User-Agent":"","Origin":""}}]}

        :param transaction: transaction info
-        :param call_info: info about the call, e.g. if ABI info could not be
+        :param call_info: info abou the call, e.g. if ABI info could not be
        :param meta: metadata about the request, e.g. where the call comes from
        :return:
        """  # noqa: E501
--- a/cmd/clef/run_test.go
+++ b/cmd/clef/run_test.go
@@ -21,8 +21,8 @@ import (
 	"os"
 	"testing"

+	"github.com/docker/docker/pkg/reexec"
 	"github.com/ethereum/go-ethereum/internal/cmdtest"
-	"github.com/ethereum/go-ethereum/internal/reexec"
 )

 const registeredName = "clef-test"
--- a/cmd/devp2p/README.md
+++ b/cmd/devp2p/README.md
@@ -108,32 +108,31 @@ Start the test by running `devp2p discv5 test -listen1 127.0.0.1 -listen2 127.0.

 The Eth Protocol test suite is a conformance test suite for the [eth protocol][eth].

-To run the eth protocol test suite against your implementation, the node needs to be initialized
-with our test chain. The chain files are located in `./cmd/devp2p/internal/ethtest/testdata`.
+To run the eth protocol test suite against your implementation, the node needs to be initialized as such:

-1. initialize the geth node with the `genesis.json` file
-2. import blocks from `chain.rlp`
-3. run the client using the resulting database. For geth, use a command like the one below:
+1. initialize the geth node with the `genesis.json` file contained in the `testdata` directory
+2. import the `halfchain.rlp` file in the `testdata` directory
+3. run geth with the following flags:
+```
+geth --datadir <datadir> --nodiscover --nat=none --networkid 19763 --verbosity 5
+```

-    geth \
-        --datadir <datadir>            \
-        --nodiscover                   \
-        --nat=none                     \
-        --networkid 3503995874084926   \
-        --verbosity 5                  \
-        --authrpc.jwtsecret 0x7365637265747365637265747365637265747365637265747365637265747365
-
-Note that the tests also require access to the engine API.
-The test suite can now be executed using the devp2p tool.
-
-    devp2p rlpx eth-test \
-        --chain internal/ethtest/testdata   \
-        --node enode://....                 \
-        --engineapi http://127.0.0.1:8551   \
-        --jwtsecret 0x7365637265747365637265747365637265747365637265747365637265747365
+Then, run the following command, replacing `<enode>` with the enode of the geth node:
+ ```
+ devp2p rlpx eth-test <enode> cmd/devp2p/internal/ethtest/testdata/chain.rlp cmd/devp2p/internal/ethtest/testdata/genesis.json
+```

 Repeat the above process (re-initialising the node) in order to run the Eth Protocol test suite again.

+#### Eth66 Test Suite
+
+The Eth66 test suite is also a conformance test suite for the eth 66 protocol version specifically.
+To run the eth66 protocol test suite, initialize a geth node as described above and run the following command,
+replacing `<enode>` with the enode of the geth node:
+
+ ```
+ devp2p rlpx eth66-test <enode> cmd/devp2p/internal/ethtest/testdata/chain.rlp cmd/devp2p/internal/ethtest/testdata/genesis.json
+```

 [eth]: https://github.com/ethereum/devp2p/blob/master/caps/eth.md
 [dns-tutorial]: https://geth.ethereum.org/docs/developers/geth-developer/dns-discovery-setup
--- a/cmd/devp2p/crawl.go
+++ b/cmd/devp2p/crawl.go
@@ -17,7 +17,6 @@
 package main

 import (
-	"errors"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -52,14 +51,7 @@ type resolver interface {
 	RequestENR(*enode.Node) (*enode.Node, error)
 }

-func newCrawler(input nodeSet, bootnodes []*enode.Node, disc resolver, iters ...enode.Iterator) (*crawler, error) {
-	if len(input) == 0 {
-		input.add(bootnodes...)
-	}
-	if len(input) == 0 {
-		return nil, errors.New("no input nodes to start crawling")
-	}
-
+func newCrawler(input nodeSet, disc resolver, iters ...enode.Iterator) *crawler {
 	c := &crawler{
 		input:     input,
 		output:    make(nodeSet, len(input)),
@@ -75,7 +67,7 @@ func newCrawler(input nodeSet, bootnodes []*enode.Node, disc resolver, iters ...
 	for id, n := range input {
 		c.output[id] = n
 	}
-	return c, nil
+	return c
 }

 func (c *crawler) run(timeout time.Duration, nthreads int) nodeSet {
--- a/cmd/devp2p/discv4cmd.go
+++ b/cmd/devp2p/discv4cmd.go
@@ -143,7 +143,7 @@ var discoveryNodeFlags = []cli.Flag{

 func discv4Ping(ctx *cli.Context) error {
 	n := getNodeArg(ctx)
-	disc, _ := startV4(ctx)
+	disc := startV4(ctx)
 	defer disc.Close()

 	start := time.Now()
@@ -156,7 +156,7 @@ func discv4Ping(ctx *cli.Context) error {

 func discv4RequestRecord(ctx *cli.Context) error {
 	n := getNodeArg(ctx)
-	disc, _ := startV4(ctx)
+	disc := startV4(ctx)
 	defer disc.Close()

 	respN, err := disc.RequestENR(n)
@@ -169,7 +169,7 @@ func discv4RequestRecord(ctx *cli.Context) error {

 func discv4Resolve(ctx *cli.Context) error {
 	n := getNodeArg(ctx)
-	disc, _ := startV4(ctx)
+	disc := startV4(ctx)
 	defer disc.Close()

 	fmt.Println(disc.Resolve(n).String())
@@ -196,13 +196,10 @@ func discv4ResolveJSON(ctx *cli.Context) error {
 		nodeargs = append(nodeargs, n)
 	}

-	disc, config := startV4(ctx)
+	// Run the crawler.
+	disc := startV4(ctx)
 	defer disc.Close()
-
-	c, err := newCrawler(inputSet, config.Bootnodes, disc, enode.IterNodes(nodeargs))
-	if err != nil {
-		return err
-	}
+	c := newCrawler(inputSet, disc, enode.IterNodes(nodeargs))
 	c.revalidateInterval = 0
 	output := c.run(0, 1)
 	writeNodesJSON(nodesFile, output)
@@ -214,18 +211,14 @@ func discv4Crawl(ctx *cli.Context) error {
 		return errors.New("need nodes file as argument")
 	}
 	nodesFile := ctx.Args().First()
-	inputSet := make(nodeSet)
+	var inputSet nodeSet
 	if common.FileExist(nodesFile) {
 		inputSet = loadNodesJSON(nodesFile)
 	}

-	disc, config := startV4(ctx)
+	disc := startV4(ctx)
 	defer disc.Close()
-
-	c, err := newCrawler(inputSet, config.Bootnodes, disc, disc.RandomNodes())
-	if err != nil {
-		return err
-	}
+	c := newCrawler(inputSet, disc, disc.RandomNodes())
 	c.revalidateInterval = 10 * time.Minute
 	output := c.run(ctx.Duration(crawlTimeoutFlag.Name), ctx.Int(crawlParallelismFlag.Name))
 	writeNodesJSON(nodesFile, output)
@@ -236,7 +229,7 @@ func discv4Crawl(ctx *cli.Context) error {
 func discv4Test(ctx *cli.Context) error {
 	// Configure test package globals.
 	if !ctx.IsSet(remoteEnodeFlag.Name) {
-		return fmt.Errorf("missing -%v", remoteEnodeFlag.Name)
+		return fmt.Errorf("Missing -%v", remoteEnodeFlag.Name)
 	}
 	v4test.Remote = ctx.String(remoteEnodeFlag.Name)
 	v4test.Listen1 = ctx.String(testListen1Flag.Name)
@@ -245,14 +238,14 @@ func discv4Test(ctx *cli.Context) error {
 }

 // startV4 starts an ephemeral discovery V4 node.
-func startV4(ctx *cli.Context) (*discover.UDPv4, discover.Config) {
+func startV4(ctx *cli.Context) *discover.UDPv4 {
 	ln, config := makeDiscoveryConfig(ctx)
 	socket := listen(ctx, ln)
 	disc, err := discover.ListenV4(socket, ln, config)
 	if err != nil {
 		exit(err)
 	}
-	return disc, config
+	return disc
 }

 func makeDiscoveryConfig(ctx *cli.Context) (*enode.LocalNode, discover.Config) {
--- a/cmd/devp2p/discv5cmd.go
+++ b/cmd/devp2p/discv5cmd.go
@@ -81,7 +81,7 @@ var (

 func discv5Ping(ctx *cli.Context) error {
 	n := getNodeArg(ctx)
-	disc, _ := startV5(ctx)
+	disc := startV5(ctx)
 	defer disc.Close()

 	fmt.Println(disc.Ping(n))
@@ -90,7 +90,7 @@ func discv5Ping(ctx *cli.Context) error {

 func discv5Resolve(ctx *cli.Context) error {
 	n := getNodeArg(ctx)
-	disc, _ := startV5(ctx)
+	disc := startV5(ctx)
 	defer disc.Close()

 	fmt.Println(disc.Resolve(n))
@@ -102,18 +102,14 @@ func discv5Crawl(ctx *cli.Context) error {
 		return errors.New("need nodes file as argument")
 	}
 	nodesFile := ctx.Args().First()
-	inputSet := make(nodeSet)
+	var inputSet nodeSet
 	if common.FileExist(nodesFile) {
 		inputSet = loadNodesJSON(nodesFile)
 	}

-	disc, config := startV5(ctx)
+	disc := startV5(ctx)
 	defer disc.Close()
-
-	c, err := newCrawler(inputSet, config.Bootnodes, disc, disc.RandomNodes())
-	if err != nil {
-		return err
-	}
+	c := newCrawler(inputSet, disc, disc.RandomNodes())
 	c.revalidateInterval = 10 * time.Minute
 	output := c.run(ctx.Duration(crawlTimeoutFlag.Name), ctx.Int(crawlParallelismFlag.Name))
 	writeNodesJSON(nodesFile, output)
@@ -131,7 +127,7 @@ func discv5Test(ctx *cli.Context) error {
 }

 func discv5Listen(ctx *cli.Context) error {
-	disc, _ := startV5(ctx)
+	disc := startV5(ctx)
 	defer disc.Close()

 	fmt.Println(disc.Self())
@@ -139,12 +135,12 @@ func discv5Listen(ctx *cli.Context) error {
 }

 // startV5 starts an ephemeral discovery v5 node.
-func startV5(ctx *cli.Context) (*discover.UDPv5, discover.Config) {
+func startV5(ctx *cli.Context) *discover.UDPv5 {
 	ln, config := makeDiscoveryConfig(ctx)
 	socket := listen(ctx, ln)
 	disc, err := discover.ListenV5(socket, ln, config)
 	if err != nil {
 		exit(err)
 	}
-	return disc, config
+	return disc
 }
--- a/cmd/devp2p/dns_cloudflare.go
+++ b/cmd/devp2p/dns_cloudflare.go
@@ -114,7 +114,7 @@ func (c *cloudflareClient) uploadRecords(name string, records map[string]string)
 	records = lrecords

 	log.Info(fmt.Sprintf("Retrieving existing TXT records on %s", name))
-	entries, _, err := c.ListDNSRecords(context.Background(), cloudflare.ZoneIdentifier(c.zoneID), cloudflare.ListDNSRecordsParams{Type: "TXT"})
+	entries, err := c.DNSRecords(context.Background(), c.zoneID, cloudflare.DNSRecord{Type: "TXT"})
 	if err != nil {
 		return err
 	}
@@ -141,25 +141,14 @@ func (c *cloudflareClient) uploadRecords(name string, records map[string]string)
 			if path != name {
 				ttl = treeNodeTTLCloudflare // Max TTL permitted by Cloudflare
 			}
-			record := cloudflare.CreateDNSRecordParams{Type: "TXT", Name: path, Content: val, TTL: ttl}
-			_, err = c.CreateDNSRecord(context.Background(), cloudflare.ZoneIdentifier(c.zoneID), record)
+			record := cloudflare.DNSRecord{Type: "TXT", Name: path, Content: val, TTL: ttl}
+			_, err = c.CreateDNSRecord(context.Background(), c.zoneID, record)
 		} else if old.Content != val {
 			// Entry already exists, only change its content.
 			log.Info(fmt.Sprintf("Updating %s from %q to %q", path, old.Content, val))
 			updated++
-
-			record := cloudflare.UpdateDNSRecordParams{
-				Type:     old.Type,
-				Name:     old.Name,
-				Content:  val,
-				Data:     old.Data,
-				ID:       old.ID,
-				Priority: old.Priority,
-				TTL:      old.TTL,
-				Proxied:  old.Proxied,
-				Tags:     old.Tags,
-			}
-			_, err = c.UpdateDNSRecord(context.Background(), cloudflare.ZoneIdentifier(c.zoneID), record)
+			old.Content = val
+			err = c.UpdateDNSRecord(context.Background(), c.zoneID, old.ID, old)
 		} else {
 			skipped++
 			log.Debug(fmt.Sprintf("Skipping %s = %q", path, val))
@@ -179,7 +168,7 @@ func (c *cloudflareClient) uploadRecords(name string, records map[string]string)
 		// Stale entry, nuke it.
 		log.Debug(fmt.Sprintf("Deleting %s = %q", path, entry.Content))
 		deleted++
-		if err := c.DeleteDNSRecord(context.Background(), cloudflare.ZoneIdentifier(c.zoneID), entry.ID); err != nil {
+		if err := c.DeleteDNSRecord(context.Background(), c.zoneID, entry.ID); err != nil {
 			return fmt.Errorf("failed to delete %s: %v", path, err)
 		}
 	}
--- a/cmd/devp2p/dns_route53_test.go
+++ b/cmd/devp2p/dns_route53_test.go
@@ -26,7 +26,6 @@ import (
 // This test checks that computeChanges/splitChanges create DNS changes in
 // leaf-added -> root-changed -> leaf-deleted order.
 func TestRoute53ChangeSort(t *testing.T) {
-	t.Parallel()
 	testTree0 := map[string]recordSet{
 		"2kfjogvxdqtxxugbh7gs7naaai.n": {ttl: 3333, values: []string{
 			`"enr:-HW4QO1ml1DdXLeZLsUxewnthhUy8eROqkDyoMTyavfks9JlYQIlMFEUoM78PovJDPQrAkrb3LRJ-""vtrymDguKCOIAWAgmlkgnY0iXNlY3AyNTZrMaEDffaGfJzgGhUif1JqFruZlYmA31HzathLSWxfbq_QoQ4"`,
@@ -165,7 +164,6 @@ func TestRoute53ChangeSort(t *testing.T) {

 // This test checks that computeChanges compares the quoted value of the records correctly.
 func TestRoute53NoChange(t *testing.T) {
-	t.Parallel()
 	// Existing record set.
 	testTree0 := map[string]recordSet{
 		"n": {ttl: rootTTL, values: []string{
--- a/cmd/devp2p/internal/ethtest/chain.go
+++ b/cmd/devp2p/internal/ethtest/chain.go
@@ -17,118 +17,27 @@
 package ethtest

 import (
-	"bytes"
 	"compress/gzip"
-	"crypto/ecdsa"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"math/big"
 	"os"
-	"path"
-	"sort"
 	"strings"

 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/forkid"
-	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/eth/protocols/eth"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rlp"
-	"golang.org/x/exp/slices"
 )

-// Chain is a lightweight blockchain-like store which can read a hivechain
-// created chain.
 type Chain struct {
 	genesis     core.Genesis
 	blocks      []*types.Block
-	state   map[common.Address]state.DumpAccount // state of head block
-	senders map[common.Address]*senderInfo
-	config  *params.ChainConfig
-}
-
-// NewChain takes the given chain.rlp file, and decodes and returns
-// the blocks from the file.
-func NewChain(dir string) (*Chain, error) {
-	gen, err := loadGenesis(path.Join(dir, "genesis.json"))
-	if err != nil {
-		return nil, err
-	}
-	gblock := gen.ToBlock()
-
-	blocks, err := blocksFromFile(path.Join(dir, "chain.rlp"), gblock)
-	if err != nil {
-		return nil, err
-	}
-	state, err := readState(path.Join(dir, "headstate.json"))
-	if err != nil {
-		return nil, err
-	}
-	accounts, err := readAccounts(path.Join(dir, "accounts.json"))
-	if err != nil {
-		return nil, err
-	}
-	return &Chain{
-		genesis: gen,
-		blocks:  blocks,
-		state:   state,
-		senders: accounts,
-		config:  gen.Config,
-	}, nil
-}
-
-// senderInfo is an account record as output in the "accounts.json" file from
-// hivechain.
-type senderInfo struct {
-	Key   *ecdsa.PrivateKey `json:"key"`
-	Nonce uint64            `json:"nonce"`
-}
-
-// Head returns the chain head.
-func (c *Chain) Head() *types.Block {
-	return c.blocks[c.Len()-1]
-}
-
-// AccountsInHashOrder returns all accounts of the head state, ordered by hash of address.
-func (c *Chain) AccountsInHashOrder() []state.DumpAccount {
-	list := make([]state.DumpAccount, len(c.state))
-	i := 0
-	for addr, acc := range c.state {
-		addr := addr
-		list[i] = acc
-		list[i].Address = &addr
-		if len(acc.AddressHash) != 32 {
-			panic(fmt.Errorf("missing/invalid SecureKey in dump account %v", addr))
-		}
-		i++
-	}
-	slices.SortFunc(list, func(x, y state.DumpAccount) int {
-		return bytes.Compare(x.AddressHash, y.AddressHash)
-	})
-	return list
-}
-
-// CodeHashes returns all bytecode hashes contained in the head state.
-func (c *Chain) CodeHashes() []common.Hash {
-	var hashes []common.Hash
-	seen := make(map[common.Hash]struct{})
-	seen[types.EmptyCodeHash] = struct{}{}
-	for _, acc := range c.state {
-		h := common.BytesToHash(acc.CodeHash)
-		if _, ok := seen[h]; ok {
-			continue
-		}
-		hashes = append(hashes, h)
-		seen[h] = struct{}{}
-	}
-	slices.SortFunc(hashes, (common.Hash).Cmp)
-	return hashes
+	chainConfig *params.ChainConfig
 }

 // Len returns the length of the chain.
@@ -136,11 +45,6 @@ func (c *Chain) Len() int {
 	return len(c.blocks)
 }

-// ForkID gets the fork id of the chain.
-func (c *Chain) ForkID() forkid.ID {
-	return forkid.NewID(c.config, c.blocks[0], uint64(c.Len()), c.blocks[c.Len()-1].Time())
-}
-
 // TD calculates the total difficulty of the chain at the
 // chain head.
 func (c *Chain) TD() *big.Int {
@@ -151,12 +55,19 @@ func (c *Chain) TD() *big.Int {
 	return sum
 }

-// GetBlock returns the block at the specified number.
-func (c *Chain) GetBlock(number int) *types.Block {
-	return c.blocks[number]
+// TotalDifficultyAt calculates the total difficulty of the chain
+// at the given block height.
+func (c *Chain) TotalDifficultyAt(height int) *big.Int {
+	sum := new(big.Int)
+	if height >= c.Len() {
+		return sum
+	}
+	for _, block := range c.blocks[:height+1] {
+		sum.Add(sum, block.Difficulty())
+	}
+	return sum
 }

-// RootAt returns the state root for the block at the given height.
 func (c *Chain) RootAt(height int) common.Hash {
 	if height < c.Len() {
 		return c.blocks[height].Root()
@@ -164,56 +75,37 @@ func (c *Chain) RootAt(height int) common.Hash {
 	return common.Hash{}
 }

-// GetSender returns the address associated with account at the index in the
-// pre-funded accounts list.
-func (c *Chain) GetSender(idx int) (common.Address, uint64) {
-	var accounts Addresses
-	for addr := range c.senders {
-		accounts = append(accounts, addr)
-	}
-	sort.Sort(accounts)
-	addr := accounts[idx]
-	return addr, c.senders[addr].Nonce
+// ForkID gets the fork id of the chain.
+func (c *Chain) ForkID() forkid.ID {
+	return forkid.NewID(c.chainConfig, c.blocks[0].Hash(), uint64(c.Len()), c.blocks[0].Time())
 }

-// IncNonce increases the specified signing account's pending nonce.
-func (c *Chain) IncNonce(addr common.Address, amt uint64) {
-	if _, ok := c.senders[addr]; !ok {
-		panic("nonce increment for non-signer")
+// Shorten returns a copy chain of a desired height from the imported
+func (c *Chain) Shorten(height int) *Chain {
+	blocks := make([]*types.Block, height)
+	copy(blocks, c.blocks[:height])
+
+	config := *c.chainConfig
+	return &Chain{
+		blocks:      blocks,
+		chainConfig: &config,
 	}
-	c.senders[addr].Nonce += amt
 }

-// Balance returns the balance of an account at the head of the chain.
-func (c *Chain) Balance(addr common.Address) *big.Int {
-	bal := new(big.Int)
-	if acc, ok := c.state[addr]; ok {
-		bal, _ = bal.SetString(acc.Balance, 10)
-	}
-	return bal
+// Head returns the chain head.
+func (c *Chain) Head() *types.Block {
+	return c.blocks[c.Len()-1]
 }

-// SignTx signs a transaction for the specified from account, so long as that
-// account was in the hivechain accounts dump.
-func (c *Chain) SignTx(from common.Address, tx *types.Transaction) (*types.Transaction, error) {
-	signer := types.LatestSigner(c.config)
-	acc, ok := c.senders[from]
-	if !ok {
-		return nil, fmt.Errorf("account not available for signing: %s", from)
-	}
-	return types.SignTx(tx, signer, acc.Key)
-}
-
-// GetHeaders returns the headers base on an ethGetPacketHeadersPacket.
-func (c *Chain) GetHeaders(req *eth.GetBlockHeadersPacket) ([]*types.Header, error) {
+func (c *Chain) GetHeaders(req *GetBlockHeaders) ([]*types.Header, error) {
 	if req.Amount < 1 {
 		return nil, errors.New("no block headers requested")
 	}
-	var (
-		headers     = make([]*types.Header, req.Amount)
-		blockNumber uint64
-	)
-	// Range over blocks to check if our chain has the requested header.
+
+	headers := make([]*types.Header, req.Amount)
+	var blockNumber uint64
+
+	// range over blocks to check if our chain has the requested header
 	for _, block := range c.blocks {
 		if block.Hash() == req.Origin.Hash || block.Number().Uint64() == req.Origin.Number {
 			headers[0] = block.Header()
@@ -223,30 +115,40 @@ func (c *Chain) GetHeaders(req *eth.GetBlockHeadersPacket) ([]*types.Header, err
 	if headers[0] == nil {
 		return nil, fmt.Errorf("no headers found for given origin number %v, hash %v", req.Origin.Number, req.Origin.Hash)
 	}
+
 	if req.Reverse {
 		for i := 1; i < int(req.Amount); i++ {
 			blockNumber -= (1 - req.Skip)
 			headers[i] = c.blocks[blockNumber].Header()
 		}
+
 		return headers, nil
 	}
+
 	for i := 1; i < int(req.Amount); i++ {
 		blockNumber += (1 + req.Skip)
 		headers[i] = c.blocks[blockNumber].Header()
 	}
+
 	return headers, nil
 }

-// Shorten returns a copy chain of a desired height from the imported
-func (c *Chain) Shorten(height int) *Chain {
-	blocks := make([]*types.Block, height)
-	copy(blocks, c.blocks[:height])
-
-	config := *c.config
-	return &Chain{
-		blocks: blocks,
-		config: &config,
+// loadChain takes the given chain.rlp file, and decodes and returns
+// the blocks from the file.
+func loadChain(chainfile string, genesis string) (*Chain, error) {
+	gen, err := loadGenesis(genesis)
+	if err != nil {
+		return nil, err
 	}
+	gblock := gen.ToBlock()
+
+	blocks, err := blocksFromFile(chainfile, gblock)
+	if err != nil {
+		return nil, err
+	}
+
+	c := &Chain{genesis: gen, blocks: blocks, chainConfig: gen.Config}
+	return c, nil
 }

 func loadGenesis(genesisFile string) (core.Genesis, error) {
@@ -261,22 +163,6 @@ func loadGenesis(genesisFile string) (core.Genesis, error) {
 	return gen, nil
 }

-type Addresses []common.Address
-
-func (a Addresses) Len() int {
-	return len(a)
-}
-
-func (a Addresses) Less(i, j int) bool {
-	return bytes.Compare(a[i][:], a[j][:]) < 0
-}
-
-func (a Addresses) Swap(i, j int) {
-	tmp := a[i]
-	a[i] = a[j]
-	a[j] = tmp
-}
-
 func blocksFromFile(chainfile string, gblock *types.Block) ([]*types.Block, error) {
 	// Load chain.rlp.
 	fh, err := os.Open(chainfile)
@@ -307,47 +193,3 @@ func blocksFromFile(chainfile string, gblock *types.Block) ([]*types.Block, erro
 	}
 	return blocks, nil
 }
-
-func readState(file string) (map[common.Address]state.DumpAccount, error) {
-	f, err := os.ReadFile(file)
-	if err != nil {
-		return nil, fmt.Errorf("unable to read state: %v", err)
-	}
-	var dump state.Dump
-	if err := json.Unmarshal(f, &dump); err != nil {
-		return nil, fmt.Errorf("unable to unmarshal state: %v", err)
-	}
-
-	state := make(map[common.Address]state.DumpAccount)
-	for key, acct := range dump.Accounts {
-		var addr common.Address
-		if err := addr.UnmarshalText([]byte(key)); err != nil {
-			return nil, fmt.Errorf("invalid address %q", key)
-		}
-		state[addr] = acct
-	}
-	return state, nil
-}
-
-func readAccounts(file string) (map[common.Address]*senderInfo, error) {
-	f, err := os.ReadFile(file)
-	if err != nil {
-		return nil, fmt.Errorf("unable to read state: %v", err)
-	}
-	type account struct {
-		Key hexutil.Bytes `json:"key"`
-	}
-	keys := make(map[common.Address]account)
-	if err := json.Unmarshal(f, &keys); err != nil {
-		return nil, fmt.Errorf("unable to unmarshal accounts: %v", err)
-	}
-	accounts := make(map[common.Address]*senderInfo)
-	for addr, acc := range keys {
-		pk, err := crypto.HexToECDSA(common.Bytes2Hex(acc.Key))
-		if err != nil {
-			return nil, fmt.Errorf("unable to read private key for %s: %v", err, addr)
-		}
-		accounts[addr] = &senderInfo{Key: pk, Nonce: 0}
-	}
-	return accounts, nil
-}
--- a/cmd/devp2p/internal/ethtest/chain_test.go
+++ b/cmd/devp2p/internal/ethtest/chain_test.go
@@ -30,7 +30,6 @@ import (
 // TestEthProtocolNegotiation tests whether the test suite
 // can negotiate the highest eth protocol in a status message exchange
 func TestEthProtocolNegotiation(t *testing.T) {
-	t.Parallel()
 	var tests = []struct {
 		conn     *Conn
 		caps     []p2p.Cap
@@ -123,27 +122,30 @@ func TestEthProtocolNegotiation(t *testing.T) {
 	}
 }

-// TestChainGetHeaders tests whether the test suite can correctly
+// TestChain_GetHeaders tests whether the test suite can correctly
 // respond to a GetBlockHeaders request from a node.
-func TestChainGetHeaders(t *testing.T) {
-	t.Parallel()
-
-	dir, err := filepath.Abs("./testdata")
+func TestChain_GetHeaders(t *testing.T) {
+	chainFile, err := filepath.Abs("./testdata/chain.rlp")
 	if err != nil {
 		t.Fatal(err)
 	}
-	chain, err := NewChain(dir)
+	genesisFile, err := filepath.Abs("./testdata/genesis.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	chain, err := loadChain(chainFile, genesisFile)
 	if err != nil {
 		t.Fatal(err)
 	}

 	var tests = []struct {
-		req      eth.GetBlockHeadersPacket
+		req      GetBlockHeaders
 		expected []*types.Header
 	}{
 		{
-			req: eth.GetBlockHeadersPacket{
-				GetBlockHeadersRequest: &eth.GetBlockHeadersRequest{
+			req: GetBlockHeaders{
+				GetBlockHeadersPacket: &eth.GetBlockHeadersPacket{
 					Origin:  eth.HashOrNumber{Number: uint64(2)},
 					Amount:  uint64(5),
 					Skip:    1,
@@ -159,8 +161,8 @@ func TestChainGetHeaders(t *testing.T) {
 			},
 		},
 		{
-			req: eth.GetBlockHeadersPacket{
-				GetBlockHeadersRequest: &eth.GetBlockHeadersRequest{
+			req: GetBlockHeaders{
+				GetBlockHeadersPacket: &eth.GetBlockHeadersPacket{
 					Origin:  eth.HashOrNumber{Number: uint64(chain.Len() - 1)},
 					Amount:  uint64(3),
 					Skip:    0,
@@ -174,8 +176,8 @@ func TestChainGetHeaders(t *testing.T) {
 			},
 		},
 		{
-			req: eth.GetBlockHeadersPacket{
-				GetBlockHeadersRequest: &eth.GetBlockHeadersRequest{
+			req: GetBlockHeaders{
+				GetBlockHeadersPacket: &eth.GetBlockHeadersPacket{
 					Origin:  eth.HashOrNumber{Hash: chain.Head().Hash()},
 					Amount:  uint64(1),
 					Skip:    0,
--- a/cmd/devp2p/internal/ethtest/conn.go
+++ b/cmd/devp2p/internal/ethtest/conn.go
@@ -1,370 +0,0 @@
-// Copyright 2023 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum 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 General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package ethtest
-
-import (
-	"crypto/ecdsa"
-	"errors"
-	"fmt"
-	"net"
-	"reflect"
-	"time"
-
-	"github.com/davecgh/go-spew/spew"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/eth/protocols/eth"
-	"github.com/ethereum/go-ethereum/eth/protocols/snap"
-	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/p2p/rlpx"
-	"github.com/ethereum/go-ethereum/rlp"
-)
-
-var (
-	pretty = spew.ConfigState{
-		Indent:                  "  ",
-		DisableCapacities:       true,
-		DisablePointerAddresses: true,
-		SortKeys:                true,
-	}
-	timeout = 2 * time.Second
-)
-
-// dial attempts to dial the given node and perform a handshake, returning the
-// created Conn if successful.
-func (s *Suite) dial() (*Conn, error) {
-	key, _ := crypto.GenerateKey()
-	return s.dialAs(key)
-}
-
-// dialAs attempts to dial a given node and perform a handshake using the given
-// private key.
-func (s *Suite) dialAs(key *ecdsa.PrivateKey) (*Conn, error) {
-	fd, err := net.Dial("tcp", fmt.Sprintf("%v:%d", s.Dest.IP(), s.Dest.TCP()))
-	if err != nil {
-		return nil, err
-	}
-	conn := Conn{Conn: rlpx.NewConn(fd, s.Dest.Pubkey())}
-	conn.ourKey = key
-	_, err = conn.Handshake(conn.ourKey)
-	if err != nil {
-		conn.Close()
-		return nil, err
-	}
-	conn.caps = []p2p.Cap{
-		{Name: "eth", Version: 67},
-		{Name: "eth", Version: 68},
-	}
-	conn.ourHighestProtoVersion = 68
-	return &conn, nil
-}
-
-// dialSnap creates a connection with snap/1 capability.
-func (s *Suite) dialSnap() (*Conn, error) {
-	conn, err := s.dial()
-	if err != nil {
-		return nil, fmt.Errorf("dial failed: %v", err)
-	}
-	conn.caps = append(conn.caps, p2p.Cap{Name: "snap", Version: 1})
-	conn.ourHighestSnapProtoVersion = 1
-	return conn, nil
-}
-
-// Conn represents an individual connection with a peer
-type Conn struct {
-	*rlpx.Conn
-	ourKey                     *ecdsa.PrivateKey
-	negotiatedProtoVersion     uint
-	negotiatedSnapProtoVersion uint
-	ourHighestProtoVersion     uint
-	ourHighestSnapProtoVersion uint
-	caps                       []p2p.Cap
-}
-
-// Read reads a packet from the connection.
-func (c *Conn) Read() (uint64, []byte, error) {
-	c.SetReadDeadline(time.Now().Add(timeout))
-	code, data, _, err := c.Conn.Read()
-	if err != nil {
-		return 0, nil, err
-	}
-	return code, data, nil
-}
-
-// ReadMsg attempts to read a devp2p message with a specific code.
-func (c *Conn) ReadMsg(proto Proto, code uint64, msg any) error {
-	c.SetReadDeadline(time.Now().Add(timeout))
-	for {
-		got, data, err := c.Read()
-		if err != nil {
-			return err
-		}
-		if protoOffset(proto)+code == got {
-			return rlp.DecodeBytes(data, msg)
-		}
-	}
-}
-
-// Write writes a eth packet to the connection.
-func (c *Conn) Write(proto Proto, code uint64, msg any) error {
-	c.SetWriteDeadline(time.Now().Add(timeout))
-	payload, err := rlp.EncodeToBytes(msg)
-	if err != nil {
-		return err
-	}
-	_, err = c.Conn.Write(protoOffset(proto)+code, payload)
-	return err
-}
-
-// ReadEth reads an Eth sub-protocol wire message.
-func (c *Conn) ReadEth() (any, error) {
-	c.SetReadDeadline(time.Now().Add(timeout))
-	for {
-		code, data, _, err := c.Conn.Read()
-		if err != nil {
-			return nil, err
-		}
-		if code == pingMsg {
-			c.Write(baseProto, pongMsg, []byte{})
-			continue
-		}
-		if getProto(code) != ethProto {
-			// Read until eth message.
-			continue
-		}
-		code -= baseProtoLen
-
-		var msg any
-		switch int(code) {
-		case eth.StatusMsg:
-			msg = new(eth.StatusPacket)
-		case eth.GetBlockHeadersMsg:
-			msg = new(eth.GetBlockHeadersPacket)
-		case eth.BlockHeadersMsg:
-			msg = new(eth.BlockHeadersPacket)
-		case eth.GetBlockBodiesMsg:
-			msg = new(eth.GetBlockBodiesPacket)
-		case eth.BlockBodiesMsg:
-			msg = new(eth.BlockBodiesPacket)
-		case eth.NewBlockMsg:
-			msg = new(eth.NewBlockPacket)
-		case eth.NewBlockHashesMsg:
-			msg = new(eth.NewBlockHashesPacket)
-		case eth.TransactionsMsg:
-			msg = new(eth.TransactionsPacket)
-		case eth.NewPooledTransactionHashesMsg:
-			msg = new(eth.NewPooledTransactionHashesPacket68)
-		case eth.GetPooledTransactionsMsg:
-			msg = new(eth.GetPooledTransactionsPacket)
-		case eth.PooledTransactionsMsg:
-			msg = new(eth.PooledTransactionsPacket)
-		default:
-			panic(fmt.Sprintf("unhandled eth msg code %d", code))
-		}
-		if err := rlp.DecodeBytes(data, msg); err != nil {
-			return nil, fmt.Errorf("unable to decode eth msg: %v", err)
-		}
-		return msg, nil
-	}
-}
-
-// ReadSnap reads a snap/1 response with the given id from the connection.
-func (c *Conn) ReadSnap() (any, error) {
-	c.SetReadDeadline(time.Now().Add(timeout))
-	for {
-		code, data, _, err := c.Conn.Read()
-		if err != nil {
-			return nil, err
-		}
-		if getProto(code) != snapProto {
-			// Read until snap message.
-			continue
-		}
-		code -= baseProtoLen + ethProtoLen
-
-		var msg any
-		switch int(code) {
-		case snap.GetAccountRangeMsg:
-			msg = new(snap.GetAccountRangePacket)
-		case snap.AccountRangeMsg:
-			msg = new(snap.AccountRangePacket)
-		case snap.GetStorageRangesMsg:
-			msg = new(snap.GetStorageRangesPacket)
-		case snap.StorageRangesMsg:
-			msg = new(snap.StorageRangesPacket)
-		case snap.GetByteCodesMsg:
-			msg = new(snap.GetByteCodesPacket)
-		case snap.ByteCodesMsg:
-			msg = new(snap.ByteCodesPacket)
-		case snap.GetTrieNodesMsg:
-			msg = new(snap.GetTrieNodesPacket)
-		case snap.TrieNodesMsg:
-			msg = new(snap.TrieNodesPacket)
-		default:
-			panic(fmt.Errorf("unhandled snap code: %d", code))
-		}
-		if err := rlp.DecodeBytes(data, msg); err != nil {
-			return nil, fmt.Errorf("could not rlp decode message: %v", err)
-		}
-		return msg, nil
-	}
-}
-
-// peer performs both the protocol handshake and the status message
-// exchange with the node in order to peer with it.
-func (c *Conn) peer(chain *Chain, status *eth.StatusPacket) error {
-	if err := c.handshake(); err != nil {
-		return fmt.Errorf("handshake failed: %v", err)
-	}
-	if err := c.statusExchange(chain, status); err != nil {
-		return fmt.Errorf("status exchange failed: %v", err)
-	}
-	return nil
-}
-
-// handshake performs a protocol handshake with the node.
-func (c *Conn) handshake() error {
-	// Write hello to client.
-	pub0 := crypto.FromECDSAPub(&c.ourKey.PublicKey)[1:]
-	ourHandshake := &protoHandshake{
-		Version: 5,
-		Caps:    c.caps,
-		ID:      pub0,
-	}
-	if err := c.Write(baseProto, handshakeMsg, ourHandshake); err != nil {
-		return fmt.Errorf("write to connection failed: %v", err)
-	}
-	// Read hello from client.
-	code, data, err := c.Read()
-	if err != nil {
-		return fmt.Errorf("erroring reading handshake: %v", err)
-	}
-	switch code {
-	case handshakeMsg:
-		msg := new(protoHandshake)
-		if err := rlp.DecodeBytes(data, &msg); err != nil {
-			return fmt.Errorf("error decoding handshake msg: %v", err)
-		}
-		// Set snappy if version is at least 5.
-		if msg.Version >= 5 {
-			c.SetSnappy(true)
-		}
-		c.negotiateEthProtocol(msg.Caps)
-		if c.negotiatedProtoVersion == 0 {
-			return fmt.Errorf("could not negotiate eth protocol (remote caps: %v, local eth version: %v)", msg.Caps, c.ourHighestProtoVersion)
-		}
-		// If we require snap, verify that it was negotiated.
-		if c.ourHighestSnapProtoVersion != c.negotiatedSnapProtoVersion {
-			return fmt.Errorf("could not negotiate snap protocol (remote caps: %v, local snap version: %v)", msg.Caps, c.ourHighestSnapProtoVersion)
-		}
-		return nil
-	default:
-		return fmt.Errorf("bad handshake: got msg code %d", code)
-	}
-}
-
-// negotiateEthProtocol sets the Conn's eth protocol version to highest
-// advertised capability from peer.
-func (c *Conn) negotiateEthProtocol(caps []p2p.Cap) {
-	var highestEthVersion uint
-	var highestSnapVersion uint
-	for _, capability := range caps {
-		switch capability.Name {
-		case "eth":
-			if capability.Version > highestEthVersion && capability.Version <= c.ourHighestProtoVersion {
-				highestEthVersion = capability.Version
-			}
-		case "snap":
-			if capability.Version > highestSnapVersion && capability.Version <= c.ourHighestSnapProtoVersion {
-				highestSnapVersion = capability.Version
-			}
-		}
-	}
-	c.negotiatedProtoVersion = highestEthVersion
-	c.negotiatedSnapProtoVersion = highestSnapVersion
-}
-
-// statusExchange performs a `Status` message exchange with the given node.
-func (c *Conn) statusExchange(chain *Chain, status *eth.StatusPacket) error {
-loop:
-	for {
-		code, data, err := c.Read()
-		if err != nil {
-			return fmt.Errorf("failed to read from connection: %w", err)
-		}
-		switch code {
-		case eth.StatusMsg + protoOffset(ethProto):
-			msg := new(eth.StatusPacket)
-			if err := rlp.DecodeBytes(data, &msg); err != nil {
-				return fmt.Errorf("error decoding status packet: %w", err)
-			}
-			if have, want := msg.Head, chain.blocks[chain.Len()-1].Hash(); have != want {
-				return fmt.Errorf("wrong head block in status, want:  %#x (block %d) have %#x",
-					want, chain.blocks[chain.Len()-1].NumberU64(), have)
-			}
-			if have, want := msg.TD.Cmp(chain.TD()), 0; have != want {
-				return fmt.Errorf("wrong TD in status: have %v want %v", have, want)
-			}
-			if have, want := msg.ForkID, chain.ForkID(); !reflect.DeepEqual(have, want) {
-				return fmt.Errorf("wrong fork ID in status: have %v, want %v", have, want)
-			}
-			if have, want := msg.ProtocolVersion, c.ourHighestProtoVersion; have != uint32(want) {
-				return fmt.Errorf("wrong protocol version: have %v, want %v", have, want)
-			}
-			// make sure eth protocol version is set for negotiation
-			if c.negotiatedProtoVersion == 0 {
-				return errors.New("eth protocol version must be set in Conn")
-			}
-			if status == nil {
-				// default status message
-				status = &eth.StatusPacket{
-					ProtocolVersion: uint32(c.negotiatedProtoVersion),
-					NetworkID:       chain.config.ChainID.Uint64(),
-					TD:              chain.TD(),
-					Head:            chain.blocks[chain.Len()-1].Hash(),
-					Genesis:         chain.blocks[0].Hash(),
-					ForkID:          chain.ForkID(),
-				}
-			}
-			if err := c.Write(ethProto, eth.StatusMsg, status); err != nil {
-				return fmt.Errorf("write to connection failed: %v", err)
-			}
-		case eth.UpgradeStatusMsg + protoOffset(ethProto):
-			msg := new(eth.UpgradeStatusPacket)
-			if err := rlp.DecodeBytes(data, &msg); err != nil {
-				return fmt.Errorf("error decoding status packet: %w", err)
-			}
-			if err := c.Write(ethProto, eth.UpgradeStatusMsg, msg); err != nil {
-				return fmt.Errorf("write to connection failed: %v", err)
-			}
-			break loop
-		case discMsg:
-			var msg []p2p.DiscReason
-			if rlp.DecodeBytes(data, &msg); len(msg) == 0 {
-				return errors.New("invalid disconnect message")
-			}
-			return fmt.Errorf("disconnect received: %v", pretty.Sdump(msg))
-		case pingMsg:
-			// TODO (renaynay): in the future, this should be an error
-			// (PINGs should not be a response upon fresh connection)
-			c.Write(baseProto, pongMsg, nil)
-		default:
-			return fmt.Errorf("bad status message: code %d", code)
-		}
-	}
-
-	return nil
-}
--- a/cmd/devp2p/internal/ethtest/engine.go
+++ b/cmd/devp2p/internal/ethtest/engine.go
@@ -1,69 +0,0 @@
-// Copyright 2023 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum 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 General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package ethtest
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"path"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/golang-jwt/jwt/v4"
-)
-
-// EngineClient is a wrapper around engine-related data.
-type EngineClient struct {
-	url     string
-	jwt     [32]byte
-	headfcu []byte
-}
-
-// NewEngineClient creates a new engine client.
-func NewEngineClient(dir, url, jwt string) (*EngineClient, error) {
-	headfcu, err := os.ReadFile(path.Join(dir, "headfcu.json"))
-	if err != nil {
-		return nil, fmt.Errorf("failed to read headfcu: %w", err)
-	}
-	return &EngineClient{url, common.HexToHash(jwt), headfcu}, nil
-}
-
-// token returns the jwt claim token for authorization.
-func (ec *EngineClient) token() string {
-	claims := jwt.RegisteredClaims{IssuedAt: jwt.NewNumericDate(time.Now())}
-	token, _ := jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString(ec.jwt[:])
-	return token
-}
-
-// sendForkchoiceUpdated sends an fcu for the head of the generated chain.
-func (ec *EngineClient) sendForkchoiceUpdated() error {
-	var (
-		req, _ = http.NewRequest(http.MethodPost, ec.url, io.NopCloser(bytes.NewReader(ec.headfcu)))
-		header = make(http.Header)
-	)
-	// Set header
-	header.Set("accept", "application/json")
-	header.Set("content-type", "application/json")
-	header.Set("Authorization", fmt.Sprintf("Bearer %v", ec.token()))
-	req.Header = header
-
-	_, err := new(http.Client).Do(req)
-	return err
-}
--- a/cmd/devp2p/internal/ethtest/helpers.go
+++ b/cmd/devp2p/internal/ethtest/helpers.go
@@ -0,0 +1,675 @@
+// Copyright 2021 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package ethtest
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"reflect"
+	"strings"
+	"time"
+
+	"github.com/davecgh/go-spew/spew"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/eth/protocols/eth"
+	"github.com/ethereum/go-ethereum/internal/utesting"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/p2p"
+	"github.com/ethereum/go-ethereum/p2p/rlpx"
+)
+
+var (
+	pretty = spew.ConfigState{
+		Indent:                  "  ",
+		DisableCapacities:       true,
+		DisablePointerAddresses: true,
+		SortKeys:                true,
+	}
+	timeout = 20 * time.Second
+)
+
+// dial attempts to dial the given node and perform a handshake,
+// returning the created Conn if successful.
+func (s *Suite) dial() (*Conn, error) {
+	// dial
+	fd, err := net.Dial("tcp", fmt.Sprintf("%v:%d", s.Dest.IP(), s.Dest.TCP()))
+	if err != nil {
+		return nil, err
+	}
+	conn := Conn{Conn: rlpx.NewConn(fd, s.Dest.Pubkey())}
+	// do encHandshake
+	conn.ourKey, _ = crypto.GenerateKey()
+	_, err = conn.Handshake(conn.ourKey)
+	if err != nil {
+		conn.Close()
+		return nil, err
+	}
+	// set default p2p capabilities
+	conn.caps = []p2p.Cap{
+		{Name: "eth", Version: 66},
+		{Name: "eth", Version: 67},
+		{Name: "eth", Version: 68},
+	}
+	conn.ourHighestProtoVersion = 68
+	return &conn, nil
+}
+
+// dialSnap creates a connection with snap/1 capability.
+func (s *Suite) dialSnap() (*Conn, error) {
+	conn, err := s.dial()
+	if err != nil {
+		return nil, fmt.Errorf("dial failed: %v", err)
+	}
+	conn.caps = append(conn.caps, p2p.Cap{Name: "snap", Version: 1})
+	conn.ourHighestSnapProtoVersion = 1
+	return conn, nil
+}
+
+// peer performs both the protocol handshake and the status message
+// exchange with the node in order to peer with it.
+func (c *Conn) peer(chain *Chain, status *Status) error {
+	if err := c.handshake(); err != nil {
+		return fmt.Errorf("handshake failed: %v", err)
+	}
+	if _, err := c.statusExchange(chain, status); err != nil {
+		return fmt.Errorf("status exchange failed: %v", err)
+	}
+	return nil
+}
+
+// handshake performs a protocol handshake with the node.
+func (c *Conn) handshake() error {
+	defer c.SetDeadline(time.Time{})
+	c.SetDeadline(time.Now().Add(10 * time.Second))
+	// write hello to client
+	pub0 := crypto.FromECDSAPub(&c.ourKey.PublicKey)[1:]
+	ourHandshake := &Hello{
+		Version: 5,
+		Caps:    c.caps,
+		ID:      pub0,
+	}
+	if err := c.Write(ourHandshake); err != nil {
+		return fmt.Errorf("write to connection failed: %v", err)
+	}
+	// read hello from client
+	switch msg := c.Read().(type) {
+	case *Hello:
+		// set snappy if version is at least 5
+		if msg.Version >= 5 {
+			c.SetSnappy(true)
+		}
+		c.negotiateEthProtocol(msg.Caps)
+		if c.negotiatedProtoVersion == 0 {
+			return fmt.Errorf("could not negotiate eth protocol (remote caps: %v, local eth version: %v)", msg.Caps, c.ourHighestProtoVersion)
+		}
+		// If we require snap, verify that it was negotiated
+		if c.ourHighestSnapProtoVersion != c.negotiatedSnapProtoVersion {
+			return fmt.Errorf("could not negotiate snap protocol (remote caps: %v, local snap version: %v)", msg.Caps, c.ourHighestSnapProtoVersion)
+		}
+		return nil
+	default:
+		return fmt.Errorf("bad handshake: %#v", msg)
+	}
+}
+
+// negotiateEthProtocol sets the Conn's eth protocol version to highest
+// advertised capability from peer.
+func (c *Conn) negotiateEthProtocol(caps []p2p.Cap) {
+	var highestEthVersion uint
+	var highestSnapVersion uint
+	for _, capability := range caps {
+		switch capability.Name {
+		case "eth":
+			if capability.Version > highestEthVersion && capability.Version <= c.ourHighestProtoVersion {
+				highestEthVersion = capability.Version
+			}
+		case "snap":
+			if capability.Version > highestSnapVersion && capability.Version <= c.ourHighestSnapProtoVersion {
+				highestSnapVersion = capability.Version
+			}
+		}
+	}
+	c.negotiatedProtoVersion = highestEthVersion
+	c.negotiatedSnapProtoVersion = highestSnapVersion
+}
+
+// statusExchange performs a `Status` message exchange with the given node.
+func (c *Conn) statusExchange(chain *Chain, status *Status) (Message, error) {
+	defer c.SetDeadline(time.Time{})
+	c.SetDeadline(time.Now().Add(20 * time.Second))
+
+	// read status message from client
+	var message Message
+loop:
+	for {
+		switch msg := c.Read().(type) {
+		case *Status:
+			if have, want := msg.Head, chain.blocks[chain.Len()-1].Hash(); have != want {
+				return nil, fmt.Errorf("wrong head block in status, want:  %#x (block %d) have %#x",
+					want, chain.blocks[chain.Len()-1].NumberU64(), have)
+			}
+			if have, want := msg.TD.Cmp(chain.TD()), 0; have != want {
+				return nil, fmt.Errorf("wrong TD in status: have %v want %v", have, want)
+			}
+			if have, want := msg.ForkID, chain.ForkID(); !reflect.DeepEqual(have, want) {
+				return nil, fmt.Errorf("wrong fork ID in status: have %v, want %v", have, want)
+			}
+			if have, want := msg.ProtocolVersion, c.ourHighestProtoVersion; have != uint32(want) {
+				return nil, fmt.Errorf("wrong protocol version: have %v, want %v", have, want)
+			}
+			message = msg
+			break loop
+		case *Disconnect:
+			return nil, fmt.Errorf("disconnect received: %v", msg.Reason)
+		case *Ping:
+			c.Write(&Pong{}) // TODO (renaynay): in the future, this should be an error
+			// (PINGs should not be a response upon fresh connection)
+		default:
+			return nil, fmt.Errorf("bad status message: %s", pretty.Sdump(msg))
+		}
+	}
+	// make sure eth protocol version is set for negotiation
+	if c.negotiatedProtoVersion == 0 {
+		return nil, errors.New("eth protocol version must be set in Conn")
+	}
+	if status == nil {
+		// default status message
+		status = &Status{
+			ProtocolVersion: uint32(c.negotiatedProtoVersion),
+			NetworkID:       chain.chainConfig.ChainID.Uint64(),
+			TD:              chain.TD(),
+			Head:            chain.blocks[chain.Len()-1].Hash(),
+			Genesis:         chain.blocks[0].Hash(),
+			ForkID:          chain.ForkID(),
+		}
+	}
+	if err := c.Write(status); err != nil {
+		return nil, fmt.Errorf("write to connection failed: %v", err)
+	}
+
+	// exchange UpgradeStatus
+	if c.negotiatedProtoVersion >= eth.ETH67 {
+		extensionRaw, _ := (&eth.UpgradeStatusExtension{}).Encode()
+		upgradeStatus := UpgradeStatus{
+			Extension: extensionRaw,
+		}
+		if err := c.Write(upgradeStatus); err != nil {
+			return nil, fmt.Errorf("write to connection failed: %v", err)
+		}
+		switch msg := c.Read().(type) {
+		case *UpgradeStatus:
+			log.Debug("receive UpgradeStatus")
+		case *Disconnect:
+			return nil, fmt.Errorf("disconnect received: %v", msg.Reason)
+		case *Ping:
+			c.Write(&Pong{}) // TODO (renaynay): in the future, this should be an error
+			// (PINGs should not be a response upon fresh connection)
+		default:
+			return nil, fmt.Errorf("bad status message: %s", pretty.Sdump(msg))
+		}
+	}
+
+	return message, nil
+}
+
+// createSendAndRecvConns creates two connections, one for sending messages to the
+// node, and one for receiving messages from the node.
+func (s *Suite) createSendAndRecvConns() (*Conn, *Conn, error) {
+	sendConn, err := s.dial()
+	if err != nil {
+		return nil, nil, fmt.Errorf("dial failed: %v", err)
+	}
+	recvConn, err := s.dial()
+	if err != nil {
+		sendConn.Close()
+		return nil, nil, fmt.Errorf("dial failed: %v", err)
+	}
+	return sendConn, recvConn, nil
+}
+
+// readAndServe serves GetBlockHeaders requests while waiting
+// on another message from the node.
+func (c *Conn) readAndServe(chain *Chain, timeout time.Duration) Message {
+	start := time.Now()
+	for time.Since(start) < timeout {
+		c.SetReadDeadline(time.Now().Add(10 * time.Second))
+
+		msg := c.Read()
+		switch msg := msg.(type) {
+		case *Ping:
+			c.Write(&Pong{})
+		case *GetBlockHeaders:
+			headers, err := chain.GetHeaders(msg)
+			if err != nil {
+				return errorf("could not get headers for inbound header request: %v", err)
+			}
+			resp := &BlockHeaders{
+				RequestId:          msg.ReqID(),
+				BlockHeadersPacket: eth.BlockHeadersPacket(headers),
+			}
+			if err := c.Write(resp); err != nil {
+				return errorf("could not write to connection: %v", err)
+			}
+		default:
+			return msg
+		}
+	}
+	return errorf("no message received within %v", timeout)
+}
+
+// headersRequest executes the given `GetBlockHeaders` request.
+func (c *Conn) headersRequest(request *GetBlockHeaders, chain *Chain, reqID uint64) ([]*types.Header, error) {
+	defer c.SetReadDeadline(time.Time{})
+	c.SetReadDeadline(time.Now().Add(20 * time.Second))
+
+	// write request
+	request.RequestId = reqID
+	if err := c.Write(request); err != nil {
+		return nil, fmt.Errorf("could not write to connection: %v", err)
+	}
+
+	// wait for response
+	msg := c.waitForResponse(chain, timeout, request.RequestId)
+	resp, ok := msg.(*BlockHeaders)
+	if !ok {
+		return nil, fmt.Errorf("unexpected message received: %s", pretty.Sdump(msg))
+	}
+	headers := []*types.Header(resp.BlockHeadersPacket)
+	return headers, nil
+}
+
+func (c *Conn) snapRequest(msg Message, id uint64, chain *Chain) (Message, error) {
+	defer c.SetReadDeadline(time.Time{})
+	c.SetReadDeadline(time.Now().Add(5 * time.Second))
+	if err := c.Write(msg); err != nil {
+		return nil, fmt.Errorf("could not write to connection: %v", err)
+	}
+	return c.ReadSnap(id)
+}
+
+// headersMatch returns whether the received headers match the given request
+func headersMatch(expected []*types.Header, headers []*types.Header) bool {
+	return reflect.DeepEqual(expected, headers)
+}
+
+// waitForResponse reads from the connection until a response with the expected
+// request ID is received.
+func (c *Conn) waitForResponse(chain *Chain, timeout time.Duration, requestID uint64) Message {
+	for {
+		msg := c.readAndServe(chain, timeout)
+		if msg.ReqID() == requestID {
+			return msg
+		}
+	}
+}
+
+// sendNextBlock broadcasts the next block in the chain and waits
+// for the node to propagate the block and import it into its chain.
+func (s *Suite) sendNextBlock() error {
+	// set up sending and receiving connections
+	sendConn, recvConn, err := s.createSendAndRecvConns()
+	if err != nil {
+		return err
+	}
+	defer sendConn.Close()
+	defer recvConn.Close()
+	if err = sendConn.peer(s.chain, nil); err != nil {
+		return fmt.Errorf("peering failed: %v", err)
+	}
+	if err = recvConn.peer(s.chain, nil); err != nil {
+		return fmt.Errorf("peering failed: %v", err)
+	}
+	// create new block announcement
+	nextBlock := s.fullChain.blocks[s.chain.Len()]
+	blockAnnouncement := &NewBlock{
+		Block: nextBlock,
+		TD:    s.fullChain.TotalDifficultyAt(s.chain.Len()),
+	}
+	// send announcement and wait for node to request the header
+	if err = s.testAnnounce(sendConn, recvConn, blockAnnouncement); err != nil {
+		return fmt.Errorf("failed to announce block: %v", err)
+	}
+	// wait for client to update its chain
+	if err = s.waitForBlockImport(recvConn, nextBlock); err != nil {
+		return fmt.Errorf("failed to receive confirmation of block import: %v", err)
+	}
+	// update test suite chain
+	s.chain.blocks = append(s.chain.blocks, nextBlock)
+	return nil
+}
+
+// testAnnounce writes a block announcement to the node and waits for the node
+// to propagate it.
+func (s *Suite) testAnnounce(sendConn, receiveConn *Conn, blockAnnouncement *NewBlock) error {
+	if err := sendConn.Write(blockAnnouncement); err != nil {
+		return fmt.Errorf("could not write to connection: %v", err)
+	}
+	return s.waitAnnounce(receiveConn, blockAnnouncement)
+}
+
+// waitAnnounce waits for a NewBlock or NewBlockHashes announcement from the node.
+func (s *Suite) waitAnnounce(conn *Conn, blockAnnouncement *NewBlock) error {
+	for {
+		switch msg := conn.readAndServe(s.chain, timeout).(type) {
+		case *NewBlock:
+			if !reflect.DeepEqual(blockAnnouncement.Block.Header(), msg.Block.Header()) {
+				return fmt.Errorf("wrong header in block announcement: \nexpected %v "+
+					"\ngot %v", blockAnnouncement.Block.Header(), msg.Block.Header())
+			}
+			if !reflect.DeepEqual(blockAnnouncement.TD, msg.TD) {
+				return fmt.Errorf("wrong TD in announcement: expected %v, got %v", blockAnnouncement.TD, msg.TD)
+			}
+			return nil
+		case *NewBlockHashes:
+			hashes := *msg
+			if blockAnnouncement.Block.Hash() != hashes[0].Hash {
+				return fmt.Errorf("wrong block hash in announcement: expected %v, got %v", blockAnnouncement.Block.Hash(), hashes[0].Hash)
+			}
+			return nil
+
+		// ignore tx announcements from previous tests
+		case *NewPooledTransactionHashes66:
+			continue
+		case *NewPooledTransactionHashes:
+			continue
+		case *Transactions:
+			continue
+
+		default:
+			return fmt.Errorf("unexpected: %s", pretty.Sdump(msg))
+		}
+	}
+}
+
+func (s *Suite) waitForBlockImport(conn *Conn, block *types.Block) error {
+	defer conn.SetReadDeadline(time.Time{})
+	conn.SetReadDeadline(time.Now().Add(20 * time.Second))
+	// create request
+	req := &GetBlockHeaders{
+		GetBlockHeadersPacket: &eth.GetBlockHeadersPacket{
+			Origin: eth.HashOrNumber{Hash: block.Hash()},
+			Amount: 1,
+		},
+	}
+
+	// loop until BlockHeaders response contains desired block, confirming the
+	// node imported the block
+	for {
+		requestID := uint64(54)
+		headers, err := conn.headersRequest(req, s.chain, requestID)
+		if err != nil {
+			return fmt.Errorf("GetBlockHeader request failed: %v", err)
+		}
+		// if headers response is empty, node hasn't imported block yet, try again
+		if len(headers) == 0 {
+			time.Sleep(100 * time.Millisecond)
+			continue
+		}
+		if !reflect.DeepEqual(block.Header(), headers[0]) {
+			return fmt.Errorf("wrong header returned: wanted %v, got %v", block.Header(), headers[0])
+		}
+		return nil
+	}
+}
+
+func (s *Suite) oldAnnounce() error {
+	sendConn, receiveConn, err := s.createSendAndRecvConns()
+	if err != nil {
+		return err
+	}
+	defer sendConn.Close()
+	defer receiveConn.Close()
+	if err := sendConn.peer(s.chain, nil); err != nil {
+		return fmt.Errorf("peering failed: %v", err)
+	}
+	if err := receiveConn.peer(s.chain, nil); err != nil {
+		return fmt.Errorf("peering failed: %v", err)
+	}
+	// create old block announcement
+	oldBlockAnnounce := &NewBlock{
+		Block: s.chain.blocks[len(s.chain.blocks)/2],
+		TD:    s.chain.blocks[len(s.chain.blocks)/2].Difficulty(),
+	}
+	if err := sendConn.Write(oldBlockAnnounce); err != nil {
+		return fmt.Errorf("could not write to connection: %v", err)
+	}
+	// wait to see if the announcement is propagated
+	switch msg := receiveConn.readAndServe(s.chain, time.Second*8).(type) {
+	case *NewBlock:
+		block := *msg
+		if block.Block.Hash() == oldBlockAnnounce.Block.Hash() {
+			return fmt.Errorf("unexpected: block propagated: %s", pretty.Sdump(msg))
+		}
+	case *NewBlockHashes:
+		hashes := *msg
+		for _, hash := range hashes {
+			if hash.Hash == oldBlockAnnounce.Block.Hash() {
+				return fmt.Errorf("unexpected: block announced: %s", pretty.Sdump(msg))
+			}
+		}
+	case *Error:
+		errMsg := *msg
+		// check to make sure error is timeout (propagation didn't come through == test successful)
+		if !strings.Contains(errMsg.String(), "timeout") {
+			return fmt.Errorf("unexpected error: %v", pretty.Sdump(msg))
+		}
+	default:
+		return fmt.Errorf("unexpected: %s", pretty.Sdump(msg))
+	}
+	return nil
+}
+
+func (s *Suite) maliciousHandshakes(t *utesting.T) error {
+	conn, err := s.dial()
+	if err != nil {
+		return fmt.Errorf("dial failed: %v", err)
+	}
+	defer conn.Close()
+
+	// write hello to client
+	pub0 := crypto.FromECDSAPub(&conn.ourKey.PublicKey)[1:]
+	handshakes := []*Hello{
+		{
+			Version: 5,
+			Caps: []p2p.Cap{
+				{Name: largeString(2), Version: 64},
+			},
+			ID: pub0,
+		},
+		{
+			Version: 5,
+			Caps: []p2p.Cap{
+				{Name: "eth", Version: 64},
+				{Name: "eth", Version: 65},
+			},
+			ID: append(pub0, byte(0)),
+		},
+		{
+			Version: 5,
+			Caps: []p2p.Cap{
+				{Name: "eth", Version: 64},
+				{Name: "eth", Version: 65},
+			},
+			ID: append(pub0, pub0...),
+		},
+		{
+			Version: 5,
+			Caps: []p2p.Cap{
+				{Name: "eth", Version: 64},
+				{Name: "eth", Version: 65},
+			},
+			ID: largeBuffer(2),
+		},
+		{
+			Version: 5,
+			Caps: []p2p.Cap{
+				{Name: largeString(2), Version: 64},
+			},
+			ID: largeBuffer(2),
+		},
+	}
+	for i, handshake := range handshakes {
+		t.Logf("Testing malicious handshake %v\n", i)
+		if err := conn.Write(handshake); err != nil {
+			return fmt.Errorf("could not write to connection: %v", err)
+		}
+		// check that the peer disconnected
+		for i := 0; i < 2; i++ {
+			switch msg := conn.readAndServe(s.chain, 20*time.Second).(type) {
+			case *Disconnect:
+			case *Error:
+			case *Hello:
+				// Discard one hello as Hello's are sent concurrently
+				continue
+			default:
+				return fmt.Errorf("unexpected: %s", pretty.Sdump(msg))
+			}
+		}
+		// dial for the next round
+		conn, err = s.dial()
+		if err != nil {
+			return fmt.Errorf("dial failed: %v", err)
+		}
+	}
+	return nil
+}
+
+func (s *Suite) maliciousStatus(conn *Conn) error {
+	if err := conn.handshake(); err != nil {
+		return fmt.Errorf("handshake failed: %v", err)
+	}
+	status := &Status{
+		ProtocolVersion: uint32(conn.negotiatedProtoVersion),
+		NetworkID:       s.chain.chainConfig.ChainID.Uint64(),
+		TD:              largeNumber(2),
+		Head:            s.chain.blocks[s.chain.Len()-1].Hash(),
+		Genesis:         s.chain.blocks[0].Hash(),
+		ForkID:          s.chain.ForkID(),
+	}
+
+	// get status
+	msg, err := conn.statusExchange(s.chain, status)
+	if err != nil {
+		return fmt.Errorf("status exchange failed: %v", err)
+	}
+	switch msg := msg.(type) {
+	case *Status:
+	default:
+		return fmt.Errorf("expected status, got: %#v ", msg)
+	}
+
+	// wait for disconnect
+	switch msg := conn.readAndServe(s.chain, timeout).(type) {
+	case *Disconnect:
+		return nil
+	case *Error:
+		return nil
+	default:
+		return fmt.Errorf("expected disconnect, got: %s", pretty.Sdump(msg))
+	}
+}
+
+func (s *Suite) hashAnnounce() error {
+	// create connections
+	sendConn, recvConn, err := s.createSendAndRecvConns()
+	if err != nil {
+		return fmt.Errorf("failed to create connections: %v", err)
+	}
+	defer sendConn.Close()
+	defer recvConn.Close()
+	if err := sendConn.peer(s.chain, nil); err != nil {
+		return fmt.Errorf("peering failed: %v", err)
+	}
+	if err := recvConn.peer(s.chain, nil); err != nil {
+		return fmt.Errorf("peering failed: %v", err)
+	}
+
+	// create NewBlockHashes announcement
+	type anno struct {
+		Hash   common.Hash // Hash of one particular block being announced
+		Number uint64      // Number of one particular block being announced
+	}
+	nextBlock := s.fullChain.blocks[s.chain.Len()]
+	announcement := anno{Hash: nextBlock.Hash(), Number: nextBlock.Number().Uint64()}
+	newBlockHash := &NewBlockHashes{announcement}
+	if err := sendConn.Write(newBlockHash); err != nil {
+		return fmt.Errorf("failed to write to connection: %v", err)
+	}
+
+	// Announcement sent, now wait for a header request
+	msg := sendConn.Read()
+	blockHeaderReq, ok := msg.(*GetBlockHeaders)
+	if !ok {
+		return fmt.Errorf("unexpected %s", pretty.Sdump(msg))
+	}
+	if blockHeaderReq.Amount != 1 {
+		return fmt.Errorf("unexpected number of block headers requested: %v", blockHeaderReq.Amount)
+	}
+	if blockHeaderReq.Origin.Hash != announcement.Hash {
+		return fmt.Errorf("unexpected block header requested. Announced:\n %v\n Remote request:\n%v",
+			pretty.Sdump(announcement),
+			pretty.Sdump(blockHeaderReq))
+	}
+	err = sendConn.Write(&BlockHeaders{
+		RequestId:          blockHeaderReq.ReqID(),
+		BlockHeadersPacket: eth.BlockHeadersPacket{nextBlock.Header()},
+	})
+	if err != nil {
+		return fmt.Errorf("failed to write to connection: %v", err)
+	}
+
+	// wait for block announcement
+	msg = recvConn.readAndServe(s.chain, timeout)
+	switch msg := msg.(type) {
+	case *NewBlockHashes:
+		hashes := *msg
+		if len(hashes) != 1 {
+			return fmt.Errorf("unexpected new block hash announcement: wanted 1 announcement, got %d", len(hashes))
+		}
+		if nextBlock.Hash() != hashes[0].Hash {
+			return fmt.Errorf("unexpected block hash announcement, wanted %v, got %v", nextBlock.Hash(),
+				hashes[0].Hash)
+		}
+
+	case *NewBlock:
+		// node should only propagate NewBlock without having requested the body if the body is empty
+		nextBlockBody := nextBlock.Body()
+		if len(nextBlockBody.Transactions) != 0 || len(nextBlockBody.Uncles) != 0 {
+			return fmt.Errorf("unexpected non-empty new block propagated: %s", pretty.Sdump(msg))
+		}
+		if msg.Block.Hash() != nextBlock.Hash() {
+			return fmt.Errorf("mismatched hash of propagated new block: wanted %v, got %v",
+				nextBlock.Hash(), msg.Block.Hash())
+		}
+		// check to make sure header matches header that was sent to the node
+		if !reflect.DeepEqual(nextBlock.Header(), msg.Block.Header()) {
+			return fmt.Errorf("incorrect header received: wanted %v, got %v", nextBlock.Header(), msg.Block.Header())
+		}
+	default:
+		return fmt.Errorf("unexpected: %s", pretty.Sdump(msg))
+	}
+	// confirm node imported block
+	if err := s.waitForBlockImport(recvConn, nextBlock); err != nil {
+		return fmt.Errorf("error waiting for node to import new block: %v", err)
+	}
+	// update the chain
+	s.chain.blocks = append(s.chain.blocks, nextBlock)
+	return nil
+}
--- a/cmd/devp2p/internal/ethtest/large.go
+++ b/cmd/devp2p/internal/ethtest/large.go
@@ -0,0 +1,80 @@
+// Copyright 2020 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package ethtest
+
+import (
+	"crypto/rand"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+// largeNumber returns a very large big.Int.
+func largeNumber(megabytes int) *big.Int {
+	buf := make([]byte, megabytes*1024*1024)
+	rand.Read(buf)
+	bigint := new(big.Int)
+	bigint.SetBytes(buf)
+	return bigint
+}
+
+// largeBuffer returns a very large buffer.
+func largeBuffer(megabytes int) []byte {
+	buf := make([]byte, megabytes*1024*1024)
+	rand.Read(buf)
+	return buf
+}
+
+// largeString returns a very large string.
+func largeString(megabytes int) string {
+	buf := make([]byte, megabytes*1024*1024)
+	rand.Read(buf)
+	return hexutil.Encode(buf)
+}
+
+func largeBlock() *types.Block {
+	return types.NewBlockWithHeader(largeHeader())
+}
+
+// Returns a random hash
+func randHash() common.Hash {
+	var h common.Hash
+	rand.Read(h[:])
+	return h
+}
+
+func largeHeader() *types.Header {
+	return &types.Header{
+		MixDigest:   randHash(),
+		ReceiptHash: randHash(),
+		TxHash:      randHash(),
+		Nonce:       types.BlockNonce{},
+		Extra:       []byte{},
+		Bloom:       types.Bloom{},
+		GasUsed:     0,
+		Coinbase:    common.Address{},
+		GasLimit:    0,
+		UncleHash:   types.EmptyUncleHash,
+		Time:        1337,
+		ParentHash:  randHash(),
+		Root:        randHash(),
+		Number:      largeNumber(2),
+		Difficulty:  largeNumber(2),
+	}
+}
--- a/cmd/devp2p/internal/ethtest/mkchain.sh
+++ b/cmd/devp2p/internal/ethtest/mkchain.sh
@@ -1,9 +0,0 @@
-#!/bin/sh
-
-hivechain generate \
-  --fork-interval 6 \
-  --tx-interval 1 \
-  --length 500 \
-  --outdir testdata \
-  --lastfork cancun \
-  --outputs accounts,genesis,chain,headstate,txinfo,headblock,headfcu,newpayload,forkenv
--- a/cmd/devp2p/internal/ethtest/protocol.go
+++ b/cmd/devp2p/internal/ethtest/protocol.go
@@ -1,87 +0,0 @@
-// Copyright 2023 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum 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 General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-package ethtest
-
-import (
-	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/rlp"
-)
-
-// Unexported devp2p message codes from p2p/peer.go.
-const (
-	handshakeMsg = 0x00
-	discMsg      = 0x01
-	pingMsg      = 0x02
-	pongMsg      = 0x03
-)
-
-// Unexported devp2p protocol lengths from p2p package.
-const (
-	baseProtoLen = 16
-	ethProtoLen  = 17
-	snapProtoLen = 8
-)
-
-// Unexported handshake structure from p2p/peer.go.
-type protoHandshake struct {
-	Version    uint64
-	Name       string
-	Caps       []p2p.Cap
-	ListenPort uint64
-	ID         []byte
-	Rest       []rlp.RawValue `rlp:"tail"`
-}
-
-type Hello = protoHandshake
-
-// Proto is an enum representing devp2p protocol types.
-type Proto int
-
-const (
-	baseProto Proto = iota
-	ethProto
-	snapProto
-)
-
-// getProto returns the protocol a certain message code is associated with
-// (assuming the negotiated capabilities are exactly {eth,snap})
-func getProto(code uint64) Proto {
-	switch {
-	case code < baseProtoLen:
-		return baseProto
-	case code < baseProtoLen+ethProtoLen:
-		return ethProto
-	case code < baseProtoLen+ethProtoLen+snapProtoLen:
-		return snapProto
-	default:
-		panic("unhandled msg code beyond last protocol")
-	}
-}
-
-// protoOffset will return the offset at which the specified protocol's messages
-// begin.
-func protoOffset(proto Proto) uint64 {
-	switch proto {
-	case baseProto:
-		return 0
-	case ethProto:
-		return baseProtoLen
-	case snapProto:
-		return baseProtoLen + ethProtoLen
-	default:
-		panic("unhandled protocol")
-	}
-}
--- a/cmd/devp2p/internal/ethtest/snap.go
+++ b/cmd/devp2p/internal/ethtest/snap.go
--- a/cmd/devp2p/internal/ethtest/snapTypes.go
+++ b/cmd/devp2p/internal/ethtest/snapTypes.go
@@ -0,0 +1,60 @@
+// Copyright 2022 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package ethtest
+
+import "github.com/ethereum/go-ethereum/eth/protocols/snap"
+
+// GetAccountRange represents an account range query.
+type GetAccountRange snap.GetAccountRangePacket
+
+func (msg GetAccountRange) Code() int     { return 33 }
+func (msg GetAccountRange) ReqID() uint64 { return msg.ID }
+
+type AccountRange snap.AccountRangePacket
+
+func (msg AccountRange) Code() int     { return 34 }
+func (msg AccountRange) ReqID() uint64 { return msg.ID }
+
+type GetStorageRanges snap.GetStorageRangesPacket
+
+func (msg GetStorageRanges) Code() int     { return 35 }
+func (msg GetStorageRanges) ReqID() uint64 { return msg.ID }
+
+type StorageRanges snap.StorageRangesPacket
+
+func (msg StorageRanges) Code() int     { return 36 }
+func (msg StorageRanges) ReqID() uint64 { return msg.ID }
+
+type GetByteCodes snap.GetByteCodesPacket
+
+func (msg GetByteCodes) Code() int     { return 37 }
+func (msg GetByteCodes) ReqID() uint64 { return msg.ID }
+
+type ByteCodes snap.ByteCodesPacket
+
+func (msg ByteCodes) Code() int     { return 38 }
+func (msg ByteCodes) ReqID() uint64 { return msg.ID }
+
+type GetTrieNodes snap.GetTrieNodesPacket
+
+func (msg GetTrieNodes) Code() int     { return 39 }
+func (msg GetTrieNodes) ReqID() uint64 { return msg.ID }
+
+type TrieNodes snap.TrieNodesPacket
+
+func (msg TrieNodes) Code() int     { return 40 }
+func (msg TrieNodes) ReqID() uint64 { return msg.ID }
--- a/cmd/devp2p/internal/ethtest/suite.go
+++ b/cmd/devp2p/internal/ethtest/suite.go
--- a/cmd/devp2p/internal/ethtest/suite_test.go
+++ b/cmd/devp2p/internal/ethtest/suite_test.go
@@ -17,56 +17,37 @@
 package ethtest // TOFIX

 import (
-	crand "crypto/rand"
-	"fmt"
 	"os"
-	"path"
 	"testing"
 	"time"

-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/eth"
-	"github.com/ethereum/go-ethereum/eth/catalyst"
 	"github.com/ethereum/go-ethereum/eth/ethconfig"
 	"github.com/ethereum/go-ethereum/internal/utesting"
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/p2p"
 )

-func makeJWTSecret() (string, [32]byte, error) {
-	var secret [32]byte
-	if _, err := crand.Read(secret[:]); err != nil {
-		return "", secret, fmt.Errorf("failed to create jwt secret: %v", err)
-	}
-	jwtPath := path.Join(os.TempDir(), "jwt_secret")
-	if err := os.WriteFile(jwtPath, []byte(hexutil.Encode(secret[:])), 0600); err != nil {
-		return "", secret, fmt.Errorf("failed to prepare jwt secret file: %v", err)
-	}
-	return jwtPath, secret, nil
-}
+var (
+	genesisFile   = "./testdata/genesis.json"
+	halfchainFile = "./testdata/halfchain.rlp"
+	fullchainFile = "./testdata/chain.rlp"
+)

 func TestEthSuite(t *testing.T) {
-	jwtPath, secret, err := makeJWTSecret()
-	if err != nil {
-		t.Fatalf("could not make jwt secret: %v", err)
-	}
-	geth, err := runGeth("./testdata", jwtPath)
+	geth, err := runGeth()
 	if err != nil {
 		t.Fatalf("could not run geth: %v", err)
 	}
 	defer geth.Close()

-	suite, err := NewSuite(geth.Server().Self(), "./testdata", geth.HTTPAuthEndpoint(), common.Bytes2Hex(secret[:]))
+	suite, err := NewSuite(geth.Server().Self(), fullchainFile, genesisFile)
 	if err != nil {
 		t.Fatalf("could not create new test suite: %v", err)
 	}
 	for _, test := range suite.EthTests() {
 		t.Run(test.Name, func(t *testing.T) {
-			if test.Slow && testing.Short() {
-				t.Skipf("%s: skipping in -short mode", test.Name)
-			}
-			result := utesting.RunTests([]utesting.Test{{Name: test.Name, Fn: test.Fn}}, os.Stdout)
+			result := utesting.RunTAP([]utesting.Test{{Name: test.Name, Fn: test.Fn}}, os.Stdout)
 			if result[0].Failed {
 				t.Fatal()
 			}
@@ -75,23 +56,19 @@ func TestEthSuite(t *testing.T) {
 }

 func TestSnapSuite(t *testing.T) {
-	jwtPath, secret, err := makeJWTSecret()
-	if err != nil {
-		t.Fatalf("could not make jwt secret: %v", err)
-	}
-	geth, err := runGeth("./testdata", jwtPath)
+	geth, err := runGeth()
 	if err != nil {
 		t.Fatalf("could not run geth: %v", err)
 	}
 	defer geth.Close()

-	suite, err := NewSuite(geth.Server().Self(), "./testdata", geth.HTTPAuthEndpoint(), common.Bytes2Hex(secret[:]))
+	suite, err := NewSuite(geth.Server().Self(), fullchainFile, genesisFile)
 	if err != nil {
 		t.Fatalf("could not create new test suite: %v", err)
 	}
 	for _, test := range suite.SnapTests() {
 		t.Run(test.Name, func(t *testing.T) {
-			result := utesting.RunTests([]utesting.Test{{Name: test.Name, Fn: test.Fn}}, os.Stdout)
+			result := utesting.RunTAP([]utesting.Test{{Name: test.Name, Fn: test.Fn}}, os.Stdout)
 			if result[0].Failed {
 				t.Fatal()
 			}
@@ -100,10 +77,8 @@ func TestSnapSuite(t *testing.T) {
 }

 // runGeth creates and starts a geth node
-func runGeth(dir string, jwtPath string) (*node.Node, error) {
+func runGeth() (*node.Node, error) {
 	stack, err := node.New(&node.Config{
-		AuthAddr: "127.0.0.1",
-		AuthPort: 0,
 		P2P: p2p.Config{
 			ListenAddr:    "127.0.0.1:0",
 			NoDiscovery:   true,
@@ -111,13 +86,12 @@ func runGeth(dir string, jwtPath string) (*node.Node, error) {
 			MaxPeersPerIP: 10,
 			NoDial:        true,
 		},
-		JWTSecret: jwtPath,
 	})
 	if err != nil {
 		return nil, err
 	}

-	err = setupGeth(stack, dir)
+	err = setupGeth(stack)
 	if err != nil {
 		stack.Close()
 		return nil, err
@@ -129,11 +103,12 @@ func runGeth(dir string, jwtPath string) (*node.Node, error) {
 	return stack, nil
 }

-func setupGeth(stack *node.Node, dir string) error {
-	chain, err := NewChain(dir)
+func setupGeth(stack *node.Node) error {
+	chain, err := loadChain(halfchainFile, genesisFile)
 	if err != nil {
 		return err
 	}
+
 	backend, err := eth.New(stack, &ethconfig.Config{
 		Genesis:        &chain.genesis,
 		NetworkId:      chain.genesis.Config.ChainID.Uint64(), // 19763
@@ -147,9 +122,7 @@ func setupGeth(stack *node.Node, dir string) error {
 	if err != nil {
 		return err
 	}
-	if err := catalyst.Register(stack, backend); err != nil {
-		return fmt.Errorf("failed to register catalyst service: %v", err)
-	}
+
 	_, err = backend.BlockChain().InsertChain(chain.blocks[1:])
 	return err
 }
--- a/cmd/devp2p/internal/ethtest/testdata/accounts.json
+++ b/cmd/devp2p/internal/ethtest/testdata/accounts.json
@@ -1,62 +0,0 @@
-{
-  "0x0c2c51a0990aee1d73c1228de158688341557508": {
-    "key": "0xbfcd0e032489319f4e5ca03e643b2025db624be6cf99cbfed90c4502e3754850"
-  },
-  "0x14e46043e63d0e3cdcf2530519f4cfaf35058cb2": {
-    "key": "0x457075f6822ac29481154792f65c5f1ec335b4fea9ca20f3fea8fa1d78a12c68"
-  },
-  "0x16c57edf7fa9d9525378b0b81bf8a3ced0620c1c": {
-    "key": "0x865898edcf43206d138c93f1bbd86311f4657b057658558888aa5ac4309626a6"
-  },
-  "0x1f4924b14f34e24159387c0a4cdbaa32f3ddb0cf": {
-    "key": "0xee7f7875d826d7443ccc5c174e38b2c436095018774248a8074ee92d8914dcdb"
-  },
-  "0x1f5bde34b4afc686f136c7a3cb6ec376f7357759": {
-    "key": "0x25e6ce8611cefb5cd338aeaa9292ed2139714668d123a4fb156cabb42051b5b7"
-  },
-  "0x2d389075be5be9f2246ad654ce152cf05990b209": {
-    "key": "0x19168cd7767604b3d19b99dc3da1302b9ccb6ee9ad61660859e07acd4a2625dd"
-  },
-  "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c": {
-    "key": "0x71aa7d299c7607dabfc3d0e5213d612b5e4a97455b596c2f642daac43fa5eeaa"
-  },
-  "0x4340ee1b812acb40a1eb561c019c327b243b92df": {
-    "key": "0x47f666f20e2175606355acec0ea1b37870c15e5797e962340da7ad7972a537e8"
-  },
-  "0x4a0f1452281bcec5bd90c3dce6162a5995bfe9df": {
-    "key": "0xa88293fefc623644969e2ce6919fb0dbd0fd64f640293b4bf7e1a81c97e7fc7f"
-  },
-  "0x4dde844b71bcdf95512fb4dc94e84fb67b512ed8": {
-    "key": "0x6e1e16a9c15641c73bf6e237f9293ab1d4e7c12b9adf83cfc94bcf969670f72d"
-  },
-  "0x5f552da00dfb4d3749d9e62dcee3c918855a86a0": {
-    "key": "0x41be4e00aac79f7ffbb3455053ec05e971645440d594c047cdcc56a3c7458bd6"
-  },
-  "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e": {
-    "key": "0xc825f31cd8792851e33a290b3d749e553983111fc1f36dfbbdb45f101973f6a9"
-  },
-  "0x717f8aa2b982bee0e29f573d31df288663e1ce16": {
-    "key": "0x8d0faa04ae0f9bc3cd4c890aa025d5f40916f4729538b19471c0beefe11d9e19"
-  },
-  "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f": {
-    "key": "0x4552dbe6ca4699322b5d923d0c9bcdd24644f5db8bf89a085b67c6c49b8a1b91"
-  },
-  "0x83c7e323d189f18725ac510004fdc2941f8c4a78": {
-    "key": "0x34391cbbf06956bb506f45ec179cdd84df526aa364e27bbde65db9c15d866d00"
-  },
-  "0x84e75c28348fb86acea1a93a39426d7d60f4cc46": {
-    "key": "0xf6a8f1603b8368f3ca373292b7310c53bec7b508aecacd442554ebc1c5d0c856"
-  },
-  "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0": {
-    "key": "0x8d56bcbcf2c1b7109e1396a28d7a0234e33544ade74ea32c460ce4a443b239b1"
-  },
-  "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d": {
-    "key": "0xfc39d1c9ddbba176d806ebb42d7460189fe56ca163ad3eb6143bfc6beb6f6f72"
-  },
-  "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc": {
-    "key": "0x9ee3fd550664b246ad7cdba07162dd25530a3b1d51476dd1d85bbc29f0592684"
-  },
-  "0xeda8645ba6948855e3b3cd596bbb07596d59c603": {
-    "key": "0x14cdde09d1640eb8c3cda063891b0453073f57719583381ff78811efa6d4199f"
-  }
-}
--- a/cmd/devp2p/internal/ethtest/testdata/chain.rlp
+++ b/cmd/devp2p/internal/ethtest/testdata/chain.rlp
--- a/cmd/devp2p/internal/ethtest/testdata/forkenv.json
+++ b/cmd/devp2p/internal/ethtest/testdata/forkenv.json
@@ -1,20 +0,0 @@
-{
-  "HIVE_CANCUN_TIMESTAMP": "840",
-  "HIVE_CHAIN_ID": "3503995874084926",
-  "HIVE_FORK_ARROW_GLACIER": "60",
-  "HIVE_FORK_BERLIN": "48",
-  "HIVE_FORK_BYZANTIUM": "18",
-  "HIVE_FORK_CONSTANTINOPLE": "24",
-  "HIVE_FORK_GRAY_GLACIER": "66",
-  "HIVE_FORK_HOMESTEAD": "0",
-  "HIVE_FORK_ISTANBUL": "36",
-  "HIVE_FORK_LONDON": "54",
-  "HIVE_FORK_MUIR_GLACIER": "42",
-  "HIVE_FORK_PETERSBURG": "30",
-  "HIVE_FORK_SPURIOUS": "12",
-  "HIVE_FORK_TANGERINE": "6",
-  "HIVE_MERGE_BLOCK_ID": "72",
-  "HIVE_NETWORK_ID": "3503995874084926",
-  "HIVE_SHANGHAI_TIMESTAMP": "780",
-  "HIVE_TERMINAL_TOTAL_DIFFICULTY": "9454784"
-}
--- a/cmd/devp2p/internal/ethtest/testdata/genesis.json
+++ b/cmd/devp2p/internal/ethtest/testdata/genesis.json
@@ -1,112 +1,27 @@
 {
    "config": {
-    "chainId": 3503995874084926,
+        "chainId": 19763,
        "homesteadBlock": 0,
-    "eip150Block": 6,
-    "eip155Block": 12,
-    "eip158Block": 12,
-    "byzantiumBlock": 18,
-    "constantinopleBlock": 24,
-    "petersburgBlock": 30,
-    "istanbulBlock": 36,
-    "muirGlacierBlock": 42,
-    "berlinBlock": 48,
-    "londonBlock": 54,
-    "arrowGlacierBlock": 60,
-    "grayGlacierBlock": 66,
-    "mergeNetsplitBlock": 72,
-    "shanghaiTime": 780,
-    "cancunTime": 840,
-    "terminalTotalDifficulty": 9454784,
+        "eip150Block": 0,
+        "eip155Block": 0,
+        "eip158Block": 0,
+        "byzantiumBlock": 0,
        "terminalTotalDifficultyPassed": true,
        "ethash": {}
    },
-  "nonce": "0x0",
+    "nonce": "0xdeadbeefdeadbeef",
    "timestamp": "0x0",
-  "extraData": "0x68697665636861696e",
-  "gasLimit": "0x23f3e20",
+    "extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "gasLimit": "0x80000000",
    "difficulty": "0x20000",
    "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "coinbase": "0x0000000000000000000000000000000000000000",
    "alloc": {
-    "000f3df6d732807ef1319fb7b8bb8522d0beac02": {
-      "code": "0x3373fffffffffffffffffffffffffffffffffffffffe14604d57602036146024575f5ffd5b5f35801560495762001fff810690815414603c575f5ffd5b62001fff01545f5260205ff35b5f5ffd5b62001fff42064281555f359062001fff015500",
-      "balance": "0x2a"
-    },
-    "0c2c51a0990aee1d73c1228de158688341557508": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "14e46043e63d0e3cdcf2530519f4cfaf35058cb2": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "16c57edf7fa9d9525378b0b81bf8a3ced0620c1c": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "1f4924b14f34e24159387c0a4cdbaa32f3ddb0cf": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "1f5bde34b4afc686f136c7a3cb6ec376f7357759": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "2d389075be5be9f2246ad654ce152cf05990b209": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "3ae75c08b4c907eb63a8960c45b86e1e9ab6123c": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "4340ee1b812acb40a1eb561c019c327b243b92df": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "4a0f1452281bcec5bd90c3dce6162a5995bfe9df": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "4dde844b71bcdf95512fb4dc94e84fb67b512ed8": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "5f552da00dfb4d3749d9e62dcee3c918855a86a0": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "654aa64f5fbefb84c270ec74211b81ca8c44a72e": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "717f8aa2b982bee0e29f573d31df288663e1ce16": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "7435ed30a8b4aeb0877cef0c6e8cffe834eb865f": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "83c7e323d189f18725ac510004fdc2941f8c4a78": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "84e75c28348fb86acea1a93a39426d7d60f4cc46": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "8bebc8ba651aee624937e7d897853ac30c95a067": {
-      "storage": {
-        "0x0000000000000000000000000000000000000000000000000000000000000001": "0x0000000000000000000000000000000000000000000000000000000000000001",
-        "0x0000000000000000000000000000000000000000000000000000000000000002": "0x0000000000000000000000000000000000000000000000000000000000000002",
-        "0x0000000000000000000000000000000000000000000000000000000000000003": "0x0000000000000000000000000000000000000000000000000000000000000003"
-      },
-      "balance": "0x1",
-      "nonce": "0x1"
-    },
-    "c7b99a164efd027a93f147376cc7da7c67c6bbe0": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "d803681e487e6ac18053afc5a6cd813c86ec3e4d": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "e7d13f7aa2a838d24c59b40186a0aca1e21cffcc": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
-    },
-    "eda8645ba6948855e3b3cd596bbb07596d59c603": {
-      "balance": "0xc097ce7bc90715b34b9f1000000000"
+        "71562b71999873db5b286df957af199ec94617f7": {
+            "balance": "0xffffffffffffffffffffffffff"
        }
    },
    "number": "0x0",
    "gasUsed": "0x0",
-  "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "baseFeePerGas": null,
-  "excessBlobGas": null,
-  "blobGasUsed": null
+    "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
 }
--- a/cmd/devp2p/internal/ethtest/testdata/halfchain.rlp
+++ b/cmd/devp2p/internal/ethtest/testdata/halfchain.rlp
--- a/cmd/devp2p/internal/ethtest/testdata/headblock.json
+++ b/cmd/devp2p/internal/ethtest/testdata/headblock.json
@@ -1,23 +0,0 @@
-{
-  "parentHash": "0x96a73007443980c5e0985dfbb45279aa496dadea16918ad42c65c0bf8122ec39",
-  "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
-  "miner": "0x0000000000000000000000000000000000000000",
-  "stateRoot": "0xea4c1f4d9fa8664c22574c5b2f948a78c4b1a753cebc1861e7fb5b1aa21c5a94",
-  "transactionsRoot": "0xecda39025fc4c609ce778d75eed0aa53b65ce1e3d1373b34bad8578cc31e5b48",
-  "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2",
-  "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-  "difficulty": "0x0",
-  "number": "0x1f4",
-  "gasLimit": "0x47e7c40",
-  "gasUsed": "0x5208",
-  "timestamp": "0x1388",
-  "extraData": "0x",
-  "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "nonce": "0x0000000000000000",
-  "baseFeePerGas": "0x7",
-  "withdrawalsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
-  "blobGasUsed": "0x0",
-  "excessBlobGas": "0x0",
-  "parentBeaconBlockRoot": "0xf653da50cdff4733f13f7a5e338290e883bdf04adf3f112709728063ea965d6c",
-  "hash": "0x36a166f0dcd160fc5e5c61c9a7c2d7f236d9175bf27f43aaa2150e291f092ef7"
-}
--- a/cmd/devp2p/internal/ethtest/testdata/headfcu.json
+++ b/cmd/devp2p/internal/ethtest/testdata/headfcu.json
@@ -1,13 +0,0 @@
-{
-  "jsonrpc": "2.0",
-  "id": "fcu500",
-  "method": "engine_forkchoiceUpdatedV3",
-  "params": [
-    {
-      "headBlockHash": "0x36a166f0dcd160fc5e5c61c9a7c2d7f236d9175bf27f43aaa2150e291f092ef7",
-      "safeBlockHash": "0x36a166f0dcd160fc5e5c61c9a7c2d7f236d9175bf27f43aaa2150e291f092ef7",
-      "finalizedBlockHash": "0x36a166f0dcd160fc5e5c61c9a7c2d7f236d9175bf27f43aaa2150e291f092ef7"
-    },
-    null
-  ]
-}
--- a/cmd/devp2p/internal/ethtest/testdata/headstate.json
+++ b/cmd/devp2p/internal/ethtest/testdata/headstate.json
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
j75689	5bba0e11e9	chore: rialto network for testing	2024-01-16 11:31:17 +08:00
Roshan	7ade1d2a5d	fix: compare headers' number in Big.Int rather than Uint64 (#2158 )	2024-01-15 10:54:54 +08:00
Roshan	e2e2ac750c	chore: fix lint issue (#2139 )	2024-01-08 12:06:27 +08:00
zjubfd	85c6750592	Merge pull request #2138 from Pythonberg1997/bc-fusion chore: merge with develop branch	2024-01-08 11:49:07 +08:00
Roshan	7466f0a075	Merge branch 'develop' into bc-fusion # Conflicts: # core/systemcontracts/upgrade.go # params/config.go	2024-01-08 11:37:58 +08:00
Roshan	64a57a3e2a	chore: update abi and bytecode (#2137 )	2024-01-08 11:15:14 +08:00
Roshan	e5822640c6	chore: add `SystemTxsGas` for Feynman upgrade (#2133 )	2024-01-04 20:18:45 +08:00
Roshan	432085ea62	fix: avoid update validators on Feynman block (#2102 )	2023-12-25 11:20:50 +08:00
zjubfd	aab5ad94b8	Merge pull request #2096 from Pythonberg1997/bc-fusion chore: merge with develop branch	2023-12-21 16:30:35 +08:00
Roshan	c0df5e7000	chore: add new byte code of `TokenHub` and `GovHub` to Feynman upgrade	2023-12-21 16:15:10 +08:00
Roshan	167da21801	Merge branch 'develop' into merge # Conflicts: # params/config.go	2023-12-21 16:14:09 +08:00
Roshan	08f75ca23f	chore: update system contracts' byte code (#2093 )	2023-12-20 17:17:43 +08:00
Roshan	6685f68995	chore: fix CI issues (#2085 )	2023-12-19 09:46:15 +08:00
Roshan	d4f7313760	chore: remove unused code (#2061 )	2023-12-13 15:53:36 +08:00
Roshan	94b68156c8	chore: update logic of determining breathe block and returned data of `verifyDoubleSignEvidence` (#2056 )	2023-12-12 17:24:43 +08:00
Roshan	ab8793ae9f	fix: bug in determining breathe block (#2055 )	2023-12-12 14:21:30 +08:00
Roshan	6744d7c15f	chore: modify breath block interval for test (#2054 )	2023-12-11 17:12:42 +08:00
zjubfd	3414e5672a	Merge pull request #2048 from Pythonberg1997/bc-fusion chore: merge with develop branch	2023-12-08 16:26:32 +08:00
Roshan	8f3c525adc	chore: resolve merge conflicts and fix review comments	2023-12-08 16:20:30 +08:00
Roshan	3e9e6423c0	Merge remote-tracking branch 'BNBChain/develop' into bc-fusion # Conflicts: # cmd/geth/blsaccountcmd.go # params/config.go	2023-12-07 18:25:45 +08:00
Roshan	5743b067ba	feat: add `generate-proof` to geth cmd (#2028 ) * feat: add `generate-proof` to geth cmd * chore: rename variable	2023-12-05 11:46:54 +08:00
Roshan	d3f882d799	chore: update contracts code (#2024 )	2023-12-04 10:43:23 +08:00
Roshan	030e41607e	feat: add new fork block and precompile contract for BEP294 and BEP299 (#1874 )	2023-11-30 19:36:54 +08:00