Pectra upgrade

2026-07-25 06:06:44 +00:00 · 2025-06-24 20:57:55 +08:00 · 2025-06-24 20:57:55 +08:00 · c70d33f478
commit c70d33f478
parent 23651e4329
1459 changed files with 187668 additions and 73485 deletions
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@ -1,22 +1,36 @@
 # Lines starting with '#' are comments.
 # Each line is a file pattern followed by one or more owners.
-accounts/usbwallet              @karalabe
+accounts/usbwallet/             @gballet
-accounts/scwallet               @gballet
+accounts/scwallet/              @gballet
-accounts/abi                    @gballet @MariusVanDerWijden
+accounts/abi/                   @gballet @MariusVanDerWijden
-cmd/clef                        @holiman
+beacon/engine/                  @MariusVanDerWijden @lightclient @fjl
-consensus                       @karalabe
+beacon/light/                   @zsfelfoldi
-core/                           @karalabe @holiman @rjl493456442
+beacon/merkle/                  @zsfelfoldi 
-eth/                            @karalabe @holiman @rjl493456442
+beacon/types/                   @zsfelfoldi @fjl
-eth/catalyst/                   @gballet
+beacon/params/                  @zsfelfoldi @fjl
 cmd/clef/                       @holiman
 cmd/evm/                        @holiman @MariusVanDerWijden @lightclient
 core/state/                     @rjl493456442 @holiman
 crypto/                         @gballet @jwasinger @holiman @fjl
 core/                           @holiman @rjl493456442
 eth/                            @holiman @rjl493456442
 eth/catalyst/                   @MariusVanDerWijden @lightclient @fjl @jwasinger
 eth/tracers/                    @s1na
 ethclient/                      @fjl
 ethdb/                          @rjl493456442
 event/                          @fjl
 trie/                           @rjl493456442
 triedb/                         @rjl493456442
 core/tracing/                   @s1na
 graphql/                        @s1na
-les/                            @zsfelfoldi @rjl493456442
+internal/ethapi/                @fjl @s1na @lightclient
-light/                          @zsfelfoldi @rjl493456442
+internal/era/                   @lightclient
 metrics/                        @holiman
 miner/                          @MariusVanDerWijden @holiman @fjl @rjl493456442
 node/                           @fjl
 p2p/                            @fjl @zsfelfoldi
 rlp/                            @fjl
 params/                         @fjl @holiman @karalabe @gballet @rjl493456442 @zsfelfoldi
 rpc/                            @fjl @holiman
 p2p/simulations                 @fjl
 p2p/protocols                   @fjl
 p2p/testing                     @fjl
 signer/                         @holiman
--- a/.github/workflows/unit_tests.yml
+++ b/.github/workflows/unit_tests.yml
@ -1,3 +1,4 @@
 name: Unit Tests
 on:
@ -52,19 +53,12 @@ jobs:
        run: go get github.com/wadey/gocovmerge && go install github.com/wadey/gocovmerge
      - name: Merge coverage reports
-        run: gocovmerge $(find . -type f -name '*coverage.out') > coverage.txt
+        run: gocovmerge $(find . -type f -name '*profile.out') > coverage.txt
      - name: Check coverage report lines
        run: wc -l coverage.txt
        continue-on-error: true
      - name: Check coverage report files
-        run: ls **/*coverage.out
+        run: ls **/*profile.out
        continue-on-error: true
      - name: Upload coverage to Codecov
        uses: codecov/codecov-action@v4
        with:
          file: ./coverage.txt
          token: ${{ secrets.CODECOV_TOKEN }}
          fail_ci_if_error: true
--- a/.gitignore
+++ b/.gitignore
@ -4,16 +4,11 @@
 # or operating system, you probably want to add a global ignore instead:
 #   git config --global core.excludesfile ~/.gitignore_global
 /tmp
 */**/*un~
 */**/*.test
 *un~
 .DS_Store
 */**/.DS_Store
 .ethtest
 */**/*tx_database*
 */**/*dapps*
 build/_vendor/pkg
 #*
 .#*
@ -28,25 +23,36 @@ build/_vendor/pkg
 /build/bin/
 /geth*.zip
 # used by the build/ci.go archive + upload tool
 /geth*.tar.gz
 /geth*.tar.gz.sig
 /geth*.tar.gz.asc
 /geth*.zip.sig
 /geth*.zip.asc
 # travis
 profile.tmp
 profile.cov
 # IdeaIDE
 .idea
 *.iml
 # VS Code
 .vscode
 # dashboard
 /dashboard/assets/flow-typed
 /dashboard/assets/node_modules
 /dashboard/assets/stats.json
 /dashboard/assets/bundle.js
 /dashboard/assets/bundle.js.map
 /dashboard/assets/package-lock.json
 **/yarn-error.log
 logs/
 tests/spec-tests/
 # binaries
 cmd/abidump/abidump
 cmd/abigen/abigen
 cmd/blsync/blsync
 cmd/clef/clef
 cmd/devp2p/devp2p
 cmd/era/era
 cmd/ethkey/ethkey
 cmd/evm/evm
 cmd/geth/geth
 cmd/rlpdump/rlpdump
 cmd/workload/workload
--- a/.golangci.yml
+++ b/.golangci.yml
@ -3,16 +3,10 @@
 run:
  timeout: 20m
  tests: true
  # default is true. Enables skipping of directories:
  #   vendor$, third_party$, testdata$, examples$, Godeps$, builtin$
  skip-dirs-use-default: true
  skip-files:
    - core/genesis_alloc.go
 linters:
  disable-all: true
  enable:
    - goconst
    - goimports
    - gosimple
    - govet
@ -24,9 +18,16 @@ linters:
    - staticcheck
    - bidichk
    - durationcheck
-    - exportloopref
+    - copyloopvar
    - whitespace
-
+    - revive # only certain checks enabled
    - durationcheck
    - gocheckcompilerdirectives
    - reassign
    - mirror
    - usetesting
    ### linters we tried and will not be using:
    ###
    # - structcheck # lots of false positives
    # - errcheck #lot of false positives
    # - contextcheck
@ -39,24 +40,38 @@ linters:
 linters-settings:
  gofmt:
    simplify: true
-  goconst:
+  revive:
-    min-len: 3 # minimum length of string constant
+    enable-all-rules: false
-    min-occurrences: 6 # minimum number of occurrences
+    # here we enable specific useful rules
    # see https://golangci-lint.run/usage/linters/#revive for supported rules
    rules:
      - name: receiver-naming
        severity: warning
        disabled: false
        exclude: [""]
 issues:
  # default is true. Enables skipping of directories:
  #   vendor$, third_party$, testdata$, examples$, Godeps$, builtin$
  exclude-dirs-use-default: true
  exclude-files:
    - core/genesis_alloc.go
  exclude-rules:
    - path: crypto/bn256/cloudflare/optate.go
      linters:
        - deadcode
        - staticcheck
    - path: crypto/bn256/
      linters:
        - revive
    - path: cmd/utils/flags.go
      text: "SA1019: cfg.TxLookupLimit is deprecated: use 'TransactionHistory' instead."
    - path: cmd/utils/flags.go
      text: "SA1019: ethconfig.Defaults.TxLookupLimit is deprecated: use 'TransactionHistory' instead."
    - path: internal/build/pgp.go
      text: 'SA1019: "golang.org/x/crypto/openpgp" is deprecated: this package is unmaintained except for security fixes.'
    - path: core/vm/contracts.go
      text: 'SA1019: "golang.org/x/crypto/ripemd160" is deprecated: RIPEMD-160 is a legacy hash and should not be used for new applications.'
    - path: accounts/usbwallet/trezor.go
      text: 'SA1019: "github.com/golang/protobuf/proto" is deprecated: Use the "google.golang.org/protobuf/proto" package instead.'
    - path: accounts/usbwallet/trezor/
      text: 'SA1019: "github.com/golang/protobuf/proto" is deprecated: Use the "google.golang.org/protobuf/proto" package instead.'
  exclude:
    - 'SA1019: event.TypeMux is deprecated: use Feed'
    - 'SA1019: strings.Title is deprecated'
--- a/.mailmap
+++ b/.mailmap
@ -5,6 +5,9 @@ Aaron Kumavis <kumavis@users.noreply.github.com>
 Abel Nieto <abel.nieto90@gmail.com>
 Abel Nieto <abel.nieto90@gmail.com> <anietoro@uwaterloo.ca>
 Adrian Sutton <adrian@oplabs.co>
 Adrian Sutton <adrian@oplabs.co> <adrian@symphonious.net>
 Afri Schoedon <58883403+q9f@users.noreply.github.com>
 Afri Schoedon <5chdn@users.noreply.github.com> <58883403+q9f@users.noreply.github.com>
@ -22,6 +25,9 @@ Alexey Akhunov <akhounov@gmail.com>
 Alon Muroch <alonmuroch@gmail.com>
 Andrei Silviu Dragnea <andreidragnea.dev@gmail.com>
 Andrei Silviu Dragnea <andreidragnea.dev@gmail.com> <andreisilviudragnea@gmail.com>
 Andrey Petrov <shazow@gmail.com>
 Andrey Petrov <shazow@gmail.com> <andrey.petrov@shazow.net>
@ -51,10 +57,15 @@ Chris Ziogas <ziogaschr@gmail.com> <ziogas_chr@hotmail.com>
 Christoph Jentzsch <jentzsch.software@gmail.com>
 Daniel Liu <liudaniel@qq.com>
 Daniel Liu <liudaniel@qq.com> <139250065@qq.com>
 Diederik Loerakker <proto@protolambda.com>
 Dimitry Khokhlov <winsvega@mail.ru>
 Ha ĐANG <dvietha@gmail.com>
 Domino Valdano <dominoplural@gmail.com>
 Domino Valdano <dominoplural@gmail.com> <jeff@okcupid.com>
@ -83,6 +94,9 @@ Gavin Wood <i@gavwood.com>
 Gregg Dourgarian <greggd@tempworks.com>
 guangwu <guoguangwu@magic-shield.com>
 guangwu <guoguangwu@magic-shield.com> <guoguangwug@gmail.com>
 Guillaume Ballet <gballet@gmail.com>
 Guillaume Ballet <gballet@gmail.com> <3272758+gballet@users.noreply.github.com>
@ -96,13 +110,21 @@ Heiko Hees <heiko@heiko.org>
 Henning Diedrich <hd@eonblast.com>
 Henning Diedrich <hd@eonblast.com> Drake Burroughs <wildfyre@hotmail.com>
 henridf <henri@dubfer.com>
 henridf <henri@dubfer.com> <henridf@gmail.com>
 Hwanjo Heo <34005989+hwanjo@users.noreply.github.com>
 Ikko Eltociear Ashimine <eltociear@gmail.com>
 Iskander (Alex) Sharipov <quasilyte@gmail.com>
 Iskander (Alex) Sharipov <quasilyte@gmail.com> <i.sharipov@corp.vk.com>
 Jae Kwon <jkwon.work@gmail.com>
 James Prestwich <james@prestwi.ch>
 James Prestwich <james@prestwi.ch> <10149425+prestwich@users.noreply.github.com>
 Janoš Guljaš <janos@resenje.org> <janos@users.noreply.github.com>
 Janoš Guljaš <janos@resenje.org> Janos Guljas <janos@resenje.org>
@ -121,23 +143,38 @@ Jeffrey Wilcke <jeffrey@ethereum.org> <obscuren@users.noreply.github.com>
 Jens Agerberg <github@agerberg.me>
 Jeremy Schlatter <jeremy.schlatter@gmail.com>
 Jeremy Schlatter <jeremy.schlatter@gmail.com> <jeremy@jeremyschlatter.com>
 John Chase <68833933+joohhnnn@users.noreply.github.com>
 Joseph Chow <ethereum@outlook.com>
 Joseph Chow <ethereum@outlook.com> ethers <TODO>
 Joseph Goulden <joegoulden@gmail.com>
 Justin Drake <drakefjustin@gmail.com>
 Karl Bartel <karl.bartel@clabs.co>
 Karl Bartel <karl.bartel@clabs.co> <karl@karl.berlin>
 Kenso Trabing <ktrabing@acm.org>
 Kenso Trabing <ktrabing@acm.org> <kenso.trabing@bloomwebsite.com>
 Liyi Guo <102356659+colinlyguo@users.noreply.github.com>
 lmittmann <3458786+lmittmann@users.noreply.github.com>
 lmittmann <3458786+lmittmann@users.noreply.github.com> <lmittmann@users.noreply.github.com>
 Liang Ma <liangma@liangbit.com>
 Liang Ma <liangma@liangbit.com> <liangma.ul@gmail.com>
 Louis Holbrook <dev@holbrook.no>
 Louis Holbrook <dev@holbrook.no> <nolash@users.noreply.github.com>
 makcandrov <makcandrov@proton.me>
 makcandrov <makcandrov@proton.me> <108467407+makcandrov@users.noreply.github.com>
 Maran Hidskes <maran.hidskes@gmail.com>
 Marian Oancea <contact@siteshop.ro>
@ -145,17 +182,33 @@ Marian Oancea <contact@siteshop.ro>
 Martin Becze <mjbecze@gmail.com>
 Martin Becze <mjbecze@gmail.com> <wanderer@users.noreply.github.com>
 Martin Holst Swende <martin@swende.se>
 Martin Lundfall <martin.lundfall@protonmail.com>
-Matt Garnett <14004106+lightclient@users.noreply.github.com>
+Marius van der Wijden <m.vanderwijden@live.de>
 Marius van der Wijden <m.vanderwijden@live.de> <115323661+vdwijden@users.noreply.github.com>
 Matt Garnett <lightclient@protonmail.com>
 Matt Garnett <lightclient@protonmail.com> <14004106+lightclient@users.noreply.github.com>
 Matthew Halpern <matthalp@gmail.com>
 Matthew Halpern <matthalp@gmail.com> <matthalp@google.com>
 meowsbits <b5c6@protonmail.com>
 meowsbits <b5c6@protonmail.com> <45600330+meowsbits@users.noreply.github.com>
 Michael Riabzev <michael@starkware.co>
 Michael de Hoog <michael.dehoog@gmail.com>
 Michael de Hoog <michael.dehoog@gmail.com> <michael.dehoog@coinbase.com>
 Nchinda Nchinda <nchinda2@gmail.com>
 Nebojsa Urosevic <nebojsa94@users.noreply.github.com>
 nedifi <103940716+nedifi@users.noreply.github.com>
 Nick Dodson <silentcicero@outlook.com>
 Nick Johnson <arachnid@notdot.net>
@ -170,6 +223,9 @@ Olivier Hervieu <olivier.hervieu@gmail.com>
 Pascal Dierich <pascal@merkleplant.xyz>
 Pascal Dierich <pascal@merkleplant.xyz> <pascal@pascaldierich.com>
 Paweł Bylica <chfast@gmail.com>
 Paweł Bylica <chfast@gmail.com> <pawel@ethereum.org>
 RJ Catalano <catalanor0220@gmail.com>
 RJ Catalano <catalanor0220@gmail.com> <rj@erisindustries.com>
@ -180,8 +236,22 @@ Rene Lubov <41963722+renaynay@users.noreply.github.com>
 Robert Zaremba <robert@zaremba.ch>
 Robert Zaremba <robert@zaremba.ch> <robert.zaremba@scale-it.pl>
 Roberto Bayardo <bayardo@alum.mit.edu>
 Roberto Bayardo <bayardo@alum.mit.edu> <roberto.bayardo@coinbase.com>
 Roman Mandeleil <roman.mandeleil@gmail.com>
 Sebastian Stammler <seb@oplabs.co>
 Sebastian Stammler <seb@oplabs.co> <stammler.s@gmail.com>
 Seungbae Yu <dbadoy4874@gmail.com>
 Seungbae Yu <dbadoy4874@gmail.com> <72970043+dbadoy@users.noreply.github.com>
 Sina Mahmoodi <1591639+s1na@users.noreply.github.com>
 Steve Milk <wangpeculiar@gmail.com>
 Steve Milk <wangpeculiar@gmail.com> <915337710@qq.com>
 Sorin Neacsu <sorin.neacsu@gmail.com>
 Sorin Neacsu <sorin.neacsu@gmail.com> <sorin@users.noreply.github.com>
@ -192,8 +262,14 @@ Taylor Gerring <taylor.gerring@gmail.com> <taylor.gerring@ethereum.org>
 Thomas Bocek <tom@tomp2p.net>
 tianyeyouyou <tianyeyouyou@gmail.com>
 tianyeyouyou <tianyeyouyou@gmail.com> <150894831+tianyeyouyou@users.noreply.github.com>
 Tim Cooijmans <timcooijmans@gmail.com>
 ucwong <ethereum2k@gmail.com>
 ucwong <ethereum2k@gmail.com> <ucwong@126.com>
 Valentin Wüstholz <wuestholz@gmail.com>
 Valentin Wüstholz <wuestholz@gmail.com> <wuestholz@users.noreply.github.com>
@ -222,6 +298,9 @@ Xudong Liu <33193253+r1cs@users.noreply.github.com>
 Yohann Léon <sybiload@gmail.com>
 yzb <335357057@qq.com>
 yzb <335357057@qq.com> <flyingyzb@gmail.com>
 Zachinquarantine <Zachinquarantine@protonmail.com>
 Zachinquarantine <Zachinquarantine@protonmail.com> <zachinquarantine@yahoo.com>
@ -229,9 +308,4 @@ Ziyuan Zhong <zzy.albert@163.com>
 Zsolt Felföldi <zsfelfoldi@gmail.com>
 meowsbits <b5c6@protonmail.com>
 meowsbits <b5c6@protonmail.com> <45600330+meowsbits@users.noreply.github.com>
 nedifi <103940716+nedifi@users.noreply.github.com>
 Максим Чусовлянов <mchusovlianov@gmail.com>
--- a/.travis.yml
+++ b/.travis.yml
@ -2,33 +2,14 @@ language: go
 go_import_path: github.com/ethereum/go-ethereum
 sudo: false
 jobs:
  allow_failures:
    - stage: build
      os: osx
      env:
        - azure-osx
  include:
-    # This builder only tests code linters on latest version of Go
+    # This builder create and push the Docker images for all architectures
    - stage: lint
      os: linux
      dist: bionic
      go: 1.21.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
      if: type = push
      os: linux
      arch: amd64
-      dist: bionic
+      dist: focal
-      go: 1.21.x
+      go: 1.24.x
      env:
        - docker
      services:
@ -38,44 +19,27 @@ jobs:
      before_install:
        - export DOCKER_CLI_EXPERIMENTAL=enabled
      script:
-        - go run build/ci.go docker -image -manifest amd64,arm64 -upload ethereum/client-go
+        - go run build/ci.go dockerx -platform "linux/amd64,linux/arm64,linux/riscv64" -hub ethereum/client-go -upload
    - stage: build
      if: type = push
      os: linux
      arch: arm64
      dist: bionic
      go: 1.21.x
      env:
        - docker
      services:
        - docker
      git:
        submodules: false # avoid cloning ethereum/tests
      before_install:
        - export DOCKER_CLI_EXPERIMENTAL=enabled
      script:
        - go run build/ci.go docker -image -manifest amd64,arm64 -upload ethereum/client-go
    # This builder does the Linux Azure uploads
    - stage: build
      if: type = push
      os: linux
-      dist: bionic
+      dist: focal
      sudo: required
-      go: 1.21.x
+      go: 1.24.x
      env:
        - azure-linux
      git:
        submodules: false # avoid cloning ethereum/tests
      addons:
        apt:
          packages:
            - gcc-multilib
      script:
-        # Build for the primary platforms that Trusty can manage
+        # build amd64
        - go run build/ci.go install -dlgo
        - go run build/ci.go archive -type tar -signer LINUX_SIGNING_KEY -signify SIGNIFY_KEY -upload gethstore/builds
        # build 386
        - sudo -E apt-get -yq --no-install-suggests --no-install-recommends install gcc-multilib
        - git status --porcelain
        - go run build/ci.go install -dlgo -arch 386
        - go run build/ci.go archive -arch 386 -type tar -signer LINUX_SIGNING_KEY -signify SIGNIFY_KEY -upload gethstore/builds
@ -92,66 +56,36 @@ jobs:
        - go run build/ci.go install -dlgo -arch arm64 -cc aarch64-linux-gnu-gcc
        - go run build/ci.go archive -arch arm64 -type tar -signer LINUX_SIGNING_KEY -signify SIGNIFY_KEY -upload gethstore/builds
    # This builder does the OSX Azure uploads
    - stage: build
      if: type = push
      os: osx
      osx_image: xcode14.2
      go: 1.21.x
      env:
        - azure-osx
      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
      if: type = push
      os: linux
      arch: amd64
-      dist: bionic
+      dist: focal
-      go: 1.21.x
+      go: 1.24.x
      script:
-        - travis_wait 30 go run build/ci.go test $TEST_PACKAGES
+        - travis_wait 45 go run build/ci.go test $TEST_PACKAGES
    - stage: build
-      if: type = pull_request
+      if: type = push
      os: linux
-      arch: arm64
+      dist: focal
-      dist: bionic
+      go: 1.23.x
      go: 1.20.x
      script:
-        - travis_wait 30 go run build/ci.go test $TEST_PACKAGES
+        - travis_wait 45 go run build/ci.go test $TEST_PACKAGES
    - stage: build
      os: linux
      dist: bionic
      go: 1.20.x
      script:
        - travis_wait 30 go run build/ci.go test $TEST_PACKAGES
    # This builder does the Ubuntu PPA nightly uploads
    - stage: build
      if: type = cron || (type = push && tag ~= /^v[0-9]/)
      os: linux
-      dist: bionic
+      dist: focal
-      go: 1.21.x
+      go: 1.24.x
      env:
        - ubuntu-ppa
      git:
        submodules: false # avoid cloning ethereum/tests
-      addons:
+      before_install:
-        apt:
+        - sudo -E apt-get -yq --no-install-suggests --no-install-recommends install devscripts debhelper dput fakeroot
          packages:
            - devscripts
            - debhelper
            - dput
            - fakeroot
            - python-bzrlib
            - python-paramiko
      script:
        - echo '|1|7SiYPr9xl3uctzovOTj4gMwAC1M=|t6ReES75Bo/PxlOPJ6/GsGbTrM0= ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA0aKz5UTUndYgIGG7dQBV+HaeuEZJ2xPHo2DS2iSKvUL4xNMSAY4UguNW+pX56nAQmZKIZZ8MaEvSj6zMEDiq6HFfn5JcTlM80UwlnyKe8B8p7Nk06PPQLrnmQt5fh0HmEcZx+JU9TZsfCHPnX7MNz4ELfZE6cFsclClrKim3BHUIGq//t93DllB+h4O9LHjEUsQ1Sr63irDLSutkLJD6RXchjROXkNirlcNVHH/jwLWR5RcYilNX7S5bIkK8NlWPjsn/8Ua5O7I9/YoE97PpO6i73DTGLh5H9JN/SITwCKBkgSDWUt61uPK3Y11Gty7o2lWsBjhBUm2Y38CBsoGmBw==' >> ~/.ssh/known_hosts
        - go run build/ci.go debsrc -upload ethereum/ethereum -sftp-user geth-ci -signer "Go Ethereum Linux Builder <geth-ci@ethereum.org>"
@ -160,8 +94,8 @@ jobs:
    - stage: build
      if: type = cron
      os: linux
-      dist: bionic
+      dist: focal
-      go: 1.21.x
+      go: 1.24.x
      env:
        - azure-purge
      git:
@ -173,8 +107,9 @@ jobs:
    - stage: build
      if: type = cron
      os: linux
-      dist: bionic
+      dist: focal
-      go: 1.21.x
+      go: 1.24.x
      env:
        - racetests
      script:
-        - travis_wait 30 go run build/ci.go test  -race $TEST_PACKAGES
+        - travis_wait 60 go run build/ci.go test -race $TEST_PACKAGES
--- a/300
+++ b/300
@ -1,52 +1,81 @@
 # This is the official list of go-ethereum authors for copyright purposes.
 0xbeny <55846654+0xbeny@users.noreply.github.com>
 0xbstn <bastien-bouge@hotmail.fr>
 0xe3b0c4 <110295932+0xe3b0c4@users.noreply.github.com>
 6543 <6543@obermui.de>
 6xiaowu9 <736518585@qq.com>
 a e r t h <aerth@users.noreply.github.com>
 Aaron Buchwald <aaron.buchwald56@gmail.com>
 Aaron Chen <aaronchen.lisp@gmail.com>
 Aaron Kumavis <kumavis@users.noreply.github.com>
 Aayush Rajasekaran <arajasek94@gmail.com>
 Abel Nieto <abel.nieto90@gmail.com>
 Abirdcfly <fp544037857@gmail.com>
 Adam Babik <a.babik@designfortress.com>
 Adam Schmideg <adamschmideg@users.noreply.github.com>
 Aditya <adityasripal@gmail.com>
 Aditya Arora <arora.aditya520@gmail.com>
 Adrian Sutton <adrian@oplabs.co>
 Adrià Cidre <adria.cidre@gmail.com>
 Afanasii Kurakin <afanasy@users.noreply.github.com>
 Afri Schoedon <5chdn@users.noreply.github.com>
 Agustin Armellini Fischer <armellini13@gmail.com>
 Ahmet Avci <ahmetabdullahavci07@gmail.com>
 Ahyun <urbanart2251@gmail.com>
 Airead <fgh1987168@gmail.com>
 Alan Chen <alanchchen@users.noreply.github.com>
 Alejandro Isaza <alejandro.isaza@gmail.com>
 Aleksey Smyrnov <i@soar.name>
 Ales Katona <ales@coinbase.com>
 alex <152680487+bodhi-crypo@users.noreply.github.com>
 Alex Beregszaszi <alex@rtfs.hu>
 Alex Gartner <github@agartner.com>
 Alex Leverington <alex@ethdev.com>
 Alex Mazalov <mazalov@gmail.com>
 Alex Mylonas <alex.a.mylonas@gmail.com>
 Alex Pozhilenkov <alex_pozhilenkov@adoriasoft.com>
 Alex Prut <1648497+alexprut@users.noreply.github.com>
 Alex Stokes <r.alex.stokes@gmail.com>
 Alex Wu <wuyiding@gmail.com>
 Alexander Mint <webinfo.alexander@gmail.com>
 Alexander van der Meij <alexandervdm@users.noreply.github.com>
 Alexander Yastrebov <yastrebov.alex@gmail.com>
 Alexandre Van de Sande <alex.vandesande@ethdev.com>
 Alexey Akhunov <akhounov@gmail.com>
 Alexey Shekhirin <a.shekhirin@gmail.com>
 alexwang <39109351+dipingxian2@users.noreply.github.com>
 Alfie John <alfiedotwtf@users.noreply.github.com>
 Ali Atiia <42751398+aliatiia@users.noreply.github.com>
 Ali Hajimirza <Ali92hm@users.noreply.github.com>
 Alvaro Sevilla <alvarosevilla95@gmail.com>
 am2rican5 <am2rican5@gmail.com>
 Amin Talebi <talebi242@gmail.com>
 AMIR <31338382+amiremohamadi@users.noreply.github.com>
 AmitBRD <60668103+AmitBRD@users.noreply.github.com>
 Anatole <62328077+a2br@users.noreply.github.com>
 Andre Patta <andre_luis@outlook.com>
 Andrea Franz <andrea@gravityblast.com>
 Andrei Kostakov <bps@dzen.ws>
 Andrei Maiboroda <andrei@ethereum.org>
 Andrei Silviu Dragnea <andreidragnea.dev@gmail.com>
 Andrew Ashikhmin <34320705+yperbasis@users.noreply.github.com>
 Andrey Petrov <shazow@gmail.com>
 Andryanau Kanstantsin <andrianov.dev@yandex.by>
 ANOTHEL <anothel1@naver.com>
 Antoine Rondelet <rondelet.antoine@gmail.com>
 Antoine Toulme <atoulme@users.noreply.github.com>
 Anton Evangelatov <anton.evangelatov@gmail.com>
 Antonio Salazar Cardozo <savedfastcool@gmail.com>
 Antony Denyer <email@antonydenyer.co.uk>
 Anusha <63559942+anusha-ctrl@users.noreply.github.com>
 Arba Sasmoyo <arba.sasmoyo@gmail.com>
 Armani Ferrante <armaniferrante@berkeley.edu>
 Armin Braun <me@obrown.io>
 Aron Fischer <github@aron.guru>
 Arran Schlosberg <519948+ARR4N@users.noreply.github.com>
 ArtificialPB <matej.berger@hotmail.com>
 Artyom Aminov <artjoma@users.noreply.github.com>
 atsushi-ishibashi <atsushi.ishibashi@finatext.com>
 Austin Roberts <code@ausiv.com>
 ayeowch <ayeowch@gmail.com>
@ -54,83 +83,135 @@ b00ris <b00ris@mail.ru>
 b1ackd0t <blackd0t@protonmail.com>
 bailantaotao <Edwin@maicoin.com>
 baizhenxuan <nkbai@163.com>
 Bala Murali Krishna Komatireddy <krishna192reddy@gmail.com>
 Balaji Shetty Pachai <32358081+balajipachai@users.noreply.github.com>
 Balint Gabor <balint.g@gmail.com>
 baptiste-b-pegasys <85155432+baptiste-b-pegasys@users.noreply.github.com>
 Bas van Kervel <bas@ethdev.com>
 Benjamin Brent <benjamin@benjaminbrent.com>
 Benjamin Prosnitz <bprosnitz@gmail.com>
 benma <mbencun@gmail.com>
 Benoit Verkindt <benoit.verkindt@gmail.com>
 Bin <49082129+songzhibin97@users.noreply.github.com>
 Binacs <bin646891055@gmail.com>
 bitcoin-lightning <153181187+AtomicInnovation321@users.noreply.github.com>
 bk <5810624+bkellerman@users.noreply.github.com>
 bloonfield <bloonfield@163.com>
 bnovil <lzqcn2000@126.com>
 Bo <bohende@gmail.com>
 Bo Ye <boy.e.computer.1982@outlook.com>
 Bob Glickstein <bobg@users.noreply.github.com>
 Boqin Qin <bobbqqin@bupt.edu.cn>
 BorkBorked <107079055+BorkBorked@users.noreply.github.com>
 Brandon Harden <b.harden92@gmail.com>
 Brandon Liu <lzqcn2000@126.com>
 Brent <bmperrea@gmail.com>
 Brian Schroeder <bts@gmail.com>
 Brion <4777457+cifer76@users.noreply.github.com>
 Bruno Škvorc <bruno@skvorc.me>
 buddho <galaxystroller@gmail.com>
 bugmaker9371 <167614621+bugmaker9371@users.noreply.github.com>
 C. Brown <hackdom@majoolr.io>
 Caesar Chad <BLUE.WEB.GEEK@gmail.com>
 cam-schultz <78878559+cam-schultz@users.noreply.github.com>
 Casey Detrio <cdetrio@gmail.com>
 caseylove <casey4love@foxmail.com>
 CDsigma <cdsigma271@gmail.com>
 Cedrick <Cedrickentrep@gmail.com>
 Ceelog <chenwei@ceelog.org>
 Ceyhun Onur <ceyhun.onur@avalabs.org>
 chabashilah <doumodoumo@gmail.com>
 changhong <changhong.yu@shanbay.com>
 Charles Cooper <cooper.charles.m@gmail.com>
 Chase Wright <mysticryuujin@gmail.com>
 Chawin Aiemvaravutigul <nick41746@hotmail.com>
 Chen Quan <terasum@163.com>
 chen4903 <108803001+chen4903@users.noreply.github.com>
 Cheng Li <lob4tt@gmail.com>
 chenglin <910372762@qq.com>
 chenyufeng <yufengcode@gmail.com>
 Chirag Garg <38765776+DeVil2O@users.noreply.github.com>
 chirag-bgh <76247491+chirag-bgh@users.noreply.github.com>
 Chris Pacia <ctpacia@gmail.com>
 Chris Ziogas <ziogaschr@gmail.com>
 Christian Muehlhaeuser <muesli@gmail.com>
 Christina <156356273+cratiu222@users.noreply.github.com>
 Christoph Jentzsch <jentzsch.software@gmail.com>
 Christopher Harrison <31964100+chrischarlesharrison@users.noreply.github.com>
 chuwt <weitaochu@gmail.com>
 cocoyeal <150209682+cocoyeal@users.noreply.github.com>
 cong <ackratos@users.noreply.github.com>
 Connor Stein <connor.stein@mail.mcgill.ca>
 Corey Lin <514971757@qq.com>
 courtier <derinilter@gmail.com>
 cpusoft <cpusoft@live.com>
 crazeteam <164632007+crazeteam@users.noreply.github.com>
 Crispin Flowerday <crispin@bitso.com>
 croath <croathliu@gmail.com>
 cui <523516579@qq.com>
 cui fliter <imcusg@gmail.com>
 cuinix <65650185+cuinix@users.noreply.github.com>
 Curith <oiooj@qq.com>
 cygaar <97691933+cygaar@users.noreply.github.com>
 Dan Cline <6798349+Rjected@users.noreply.github.com>
 Dan DeGreef <dan.degreef@gmail.com>
 Dan Kinsley <dan@joincivil.com>
 Dan Laine <daniel.laine@avalabs.org>
 Dan Sosedoff <dan.sosedoff@gmail.com>
 danceratopz <danceratopz@gmail.com>
 Daniel A. Nagy <nagy.da@gmail.com>
 Daniel Fernandes <711733+daferna@users.noreply.github.com>
 Daniel Katzan <108216499+dkatzan@users.noreply.github.com>
 Daniel Knopik <107140945+dknopik@users.noreply.github.com>
 Daniel Liu <liudaniel@qq.com>
 Daniel Perez <daniel@perez.sh>
 Daniel Sloof <goapsychadelic@gmail.com>
 Danno Ferrin <danno@numisight.com>
 Danyal Prout <me@dany.al>
 Darioush Jalali <darioush.jalali@avalabs.org>
 Darrel Herbst <dherbst@gmail.com>
 Darren Kelly <107671032+darrenvechain@users.noreply.github.com>
 dashangcun <907225865@qq.com>
 Dave Appleton <calistralabs@gmail.com>
 Dave McGregor <dave.s.mcgregor@gmail.com>
 David Cai <davidcai1993@yahoo.com>
 David Dzhalaev <72649244+DavidRomanovizc@users.noreply.github.com>
 David Huie <dahuie@gmail.com>
 David Murdoch <187813+davidmurdoch@users.noreply.github.com>
 David Theodore <29786815+infosecual@users.noreply.github.com>
 ddl <ddl196526@163.com>
 Dean Eigenmann <7621705+decanus@users.noreply.github.com>
 Delweng <delweng@gmail.com>
 Denver <aeharvlee@gmail.com>
 Derek Chiang <me@derekchiang.com>
 Derek Gottfrid <derek@codecubed.com>
 deterclosed <164524498+deterclosed@users.noreply.github.com>
 Devon Bear <itsdevbear@berachain.com>
 Di Peng <pendyaaa@gmail.com>
 Diederik Loerakker <proto@protolambda.com>
 Diego Siqueira <DiSiqueira@users.noreply.github.com>
 Diep Pham <mrfavadi@gmail.com>
 Dimitris Apostolou <dimitris.apostolou@icloud.com>
 dipingxian2 <39109351+dipingxian2@users.noreply.github.com>
 divergencetech <94644849+divergencetech@users.noreply.github.com>
 dknopik <107140945+dknopik@users.noreply.github.com>
 dm4 <sunrisedm4@gmail.com>
 Dmitrij Koniajev <dimchansky@gmail.com>
 Dmitry Shulyak <yashulyak@gmail.com>
 Dmitry Zenovich <dzenovich@gmail.com>
 Domino Valdano <dominoplural@gmail.com>
 DongXi Huang <418498589@qq.com>
 Dragan Milic <dragan@netice9.com>
 dragonvslinux <35779158+dragononcrypto@users.noreply.github.com>
 Dylan Vassallo <dylan.vassallo@hotmail.com>
 easyfold <137396765+easyfold@users.noreply.github.com>
 Edgar Aroutiounian <edgar.factorial@gmail.com>
 Eduard S <eduardsanou@posteo.net>
 Egon Elbre <egonelbre@gmail.com>
 Elad <theman@elad.im>
 Eli <elihanover@yahoo.com>
 Elias Naur <elias.naur@gmail.com>
 Elias Rad <146735585+nnsW3@users.noreply.github.com>
 Elliot Shepherd <elliot@identitii.com>
 Emil <mursalimovemeel@gmail.com>
 emile <emile@users.noreply.github.com>
@ -151,11 +232,13 @@ Evgeny <awesome.observer@yandex.com>
 Evgeny Danilenko <6655321@bk.ru>
 evgk <evgeniy.kamyshev@gmail.com>
 Evolution404 <35091674+Evolution404@users.noreply.github.com>
 Exca-DK <85954505+Exca-DK@users.noreply.github.com>
 EXEC <execvy@gmail.com>
 Fabian Vogelsteller <fabian@frozeman.de>
 Fabio Barone <fabio.barone.co@gmail.com>
 Fabio Berger <fabioberger1991@gmail.com>
 FaceHo <facehoshi@gmail.com>
 felipe <fselmo2@gmail.com>
 Felipe Strozberg <48066928+FelStroz@users.noreply.github.com>
 Felix Lange <fjl@twurst.com>
 Ferenc Szabo <frncmx@gmail.com>
@ -163,68 +246,102 @@ ferhat elmas <elmas.ferhat@gmail.com>
 Ferran Borreguero <ferranbt@protonmail.com>
 Fiisio <liangcszzu@163.com>
 Fire Man <55934298+basdevelop@users.noreply.github.com>
 FletcherMan <fanciture@163.com>
 flowerofdream <775654398@qq.com>
 fomotrader <82184770+fomotrader@users.noreply.github.com>
 Ford <153042616+guerrierindien@users.noreply.github.com>
 ForLina <471133417@qq.com>
 Frank Szendzielarz <33515470+FrankSzendzielarz@users.noreply.github.com>
 Frank Wang <eternnoir@gmail.com>
 Franklin <mr_franklin@126.com>
 Freeman Jiang <freeman.jiang.ca@gmail.com>
 Furkan KAMACI <furkankamaci@gmail.com>
 Fuyang Deng <dengfuyang@outlook.com>
 GagziW <leon.stanko@rwth-aachen.de>
 Gary Rong <garyrong0905@gmail.com>
 Gautam Botrel <gautam.botrel@gmail.com>
 Gealber Morales <48373523+Gealber@users.noreply.github.com>
 George Ma <164313692+availhang@users.noreply.github.com>
 George Ornbo <george@shapeshed.com>
 georgehao <haohongfan@gmail.com>
 gitglorythegreat <t4juu3@proton.me>
 Giuseppe Bertone <bertone.giuseppe@gmail.com>
 Greg Colvin <greg@colvin.org>
 Gregg Dourgarian <greggd@tempworks.com>
 Gregory Markou <16929357+GregTheGreek@users.noreply.github.com>
 guangwu <guoguangwu@magic-shield.com>
 Guido Vranken <guidovranken@users.noreply.github.com>
 Guifel <toowik@gmail.com>
 Guilherme Salgado <gsalgado@gmail.com>
 Guillaume Ballet <gballet@gmail.com>
 Guillaume Michel <guillaumemichel@users.noreply.github.com>
 Guillaume Nicolas <guin56@gmail.com>
 GuiltyMorishita <morilliantblue@gmail.com>
 Guruprasad Kamath <48196632+gurukamath@users.noreply.github.com>
 Gus <yo@soygus.com>
 Gustav Simonsson <gustav.simonsson@gmail.com>
 Gustavo Silva <GustavoRSSilva@users.noreply.github.com>
 Gísli Kristjánsson <gislik@hamstur.is>
 Ha ĐANG <dvietha@gmail.com>
 HackyMiner <hackyminer@gmail.com>
-hadv <dvietha@gmail.com>
+Halimao <1065621723@qq.com>
 Hanjiang Yu <delacroix.yu@gmail.com>
 Hao Bryan Cheng <haobcheng@gmail.com>
 Hao Duan <duanhao0814@gmail.com>
 haoran <159284258+hr98w@users.noreply.github.com>
 Haotian <51777534+tmelhao@users.noreply.github.com>
 HAOYUatHZ <37070449+HAOYUatHZ@users.noreply.github.com>
 Harry Dutton <me@bytejedi.com>
 Harry Kalodner <harry.kalodner@gmail.com>
 haryu703 <34744512+haryu703@users.noreply.github.com>
 hattizai <hattizai@gmail.com>
 Hendrik Hofstadt <hendrik@nexantic.com>
 Henning Diedrich <hd@eonblast.com>
 henopied <13500516+henopied@users.noreply.github.com>
 henridf <henri@dubfer.com>
 Henry <101552941+henry-0@users.noreply.github.com>
 hero5512 <lvshuaino@gmail.com>
 holisticode <holistic.computing@gmail.com>
 Hongbin Mao <hello2mao@gmail.com>
 Hsien-Tang Kao <htkao@pm.me>
 hsyodyssey <47173566+hsyodyssey@users.noreply.github.com>
 Hteev Oli <gethorz@proton.me>
 Husam Ibrahim <39692071+HusamIbrahim@users.noreply.github.com>
 Hwanjo Heo <34005989+hwanjo@users.noreply.github.com>
 hydai <z54981220@gmail.com>
 hyhnet <cyrusyun@qq.com>
 hyunchel <3271191+hyunchel@users.noreply.github.com>
 Hyung-Kyu Hqueue Choi <hyungkyu.choi@gmail.com>
 Hyunsoo Shin (Lake) <hyunsooda@kaist.ac.kr>
 hzysvilla <ecjgvmhc@gmail.com>
 Håvard Anda Estensen <haavard.ae@gmail.com>
 Ian Macalinao <me@ian.pw>
 Ian Norden <iannordenn@gmail.com>
 Icarus Wu <icaruswu66@qq.com>
 icodezjb <icodezjb@163.com>
-Ikko Ashimine <eltociear@gmail.com>
+ids <tonyhaha163@163.com>
 Ignacio Hagopian <jsign.uy@gmail.com>
 Ikko Eltociear Ashimine <eltociear@gmail.com>
 Ilan Gitter <8359193+gitteri@users.noreply.github.com>
 imalasong <55082705+imalasong@users.noreply.github.com>
 ImanSharaf <78227895+ImanSharaf@users.noreply.github.com>
 imulmat4 <117636097+imulmat4@users.noreply.github.com>
 Inphi <mlaw2501@gmail.com>
 int88 <106391185+int88@users.noreply.github.com>
 Isidoro Ghezzi <isidoro.ghezzi@icloud.com>
 Iskander (Alex) Sharipov <quasilyte@gmail.com>
 Ivan Aracki <aracki.ivan@gmail.com>
 Ivan Bogatyy <bogatyi@gmail.com>
 Ivan Daniluk <ivan.daniluk@gmail.com>
 Ivo Georgiev <ivo@strem.io>
 j2gg0s <j2gg0s@gmail.com>
 jacksoom <lifengliu1994@gmail.com>
 jackyin <648588267@qq.com>
 Jae Kwon <jkwon.work@gmail.com>
-James Prestwich <10149425+prestwich@users.noreply.github.com>
+Jakub Freebit <49676311+jakub-freebit@users.noreply.github.com>
 James Prestwich <james@prestwi.ch>
 Jamie Pitts <james.pitts@gmail.com>
 Janko Simonovic <simonovic86@gmail.com>
 Janoš Guljaš <janos@resenje.org>
 Jared Wasinger <j-wasinger@hotmail.com>
 Jason Carver <jacarver@linkedin.com>
@ -239,42 +356,63 @@ Jeff Wentworth <jeff@curvegrid.com>
 Jeffery Robert Walsh <rlxrlps@gmail.com>
 Jeffrey Wilcke <jeffrey@ethereum.org>
 Jens Agerberg <github@agerberg.me>
 Jens W <8270201+DragonDev1906@users.noreply.github.com>
 Jeremy McNevin <jeremy.mcnevin@optum.com>
 Jeremy Schlatter <jeremy.schlatter@gmail.com>
 Jerzy Lasyk <jerzylasyk@gmail.com>
 Jesse Tane <jesse.tane@gmail.com>
 Jia Chenhui <jiachenhui1989@gmail.com>
 Jim McDonald <Jim@mcdee.net>
 jin <35813306+lochjin@users.noreply.github.com>
 jk-jeongkyun <45347815+jeongkyun-oh@users.noreply.github.com>
 jkcomment <jkcomment@gmail.com>
 Joe Netti <joe@netti.dev>
 JoeGruffins <34998433+JoeGruffins@users.noreply.github.com>
 Joel Burget <joelburget@gmail.com>
 John C. Vernaleo <john@netpurgatory.com>
 John Chase <68833933+joohhnnn@users.noreply.github.com>
 John Difool <johndifoolpi@gmail.com>
 John Hilliard <jhilliard@polygon.technology>
 John Xu <dyxushuai@gmail.com>
 Johns Beharry <johns@peakshift.com>
 Jolly Zhao <zhaolei@pm.me>
 Jonas <felberj@users.noreply.github.com>
 Jonathan Brown <jbrown@bluedroplet.com>
 Jonathan Chappelow <chappjc@users.noreply.github.com>
 Jonathan Gimeno <jgimeno@gmail.com>
 Jonathan Otto <jonathan.otto@gmail.com>
 JoranHonig <JoranHonig@users.noreply.github.com>
 Jordan Krage <jmank88@gmail.com>
 Jorge <jorgeacortes@users.noreply.github.com>
 Jorropo <jorropo.pgm@gmail.com>
 Joseph Chow <ethereum@outlook.com>
 Joseph Cook <33655003+jmcook1186@users.noreply.github.com>
 Joshua Colvin <jcolvin@offchainlabs.com>
 Joshua Gutow <jbgutow@gmail.com>
 jovijovi <mageyul@hotmail.com>
 jp-imx <109574657+jp-imx@users.noreply.github.com>
 jtakalai <juuso.takalainen@streamr.com>
 JU HYEONG PARK <dkdkajej@gmail.com>
 Julian Y <jyap808@users.noreply.github.com>
 Justin Clark-Casey <justincc@justincc.org>
 Justin Dhillon <justin.singh.dhillon@gmail.com>
 Justin Drake <drakefjustin@gmail.com>
 Justin Traglia <95511699+jtraglia@users.noreply.github.com>
 Justus <jus@gtsbr.org>
 KAI <35927054+ThreeAndTwo@users.noreply.github.com>
 kaliubuntu0206 <139627505+kaliubuntu0206@users.noreply.github.com>
 Karl Bartel <karl.bartel@clabs.co>
 Karol Chojnowski <karolchojnowski95@gmail.com>
 Kawashima <91420903+sscodereth@users.noreply.github.com>
 kazak <alright-epsilon8h@icloud.com>
 ken10100147 <sunhongping@kanjian.com>
 Kenji Siu <kenji@isuntv.com>
 Kenso Trabing <ktrabing@acm.org>
 Kero <keroroxx520@gmail.com>
 kevaundray <kevtheappdev@gmail.com>
 Kevin <denk.kevin@web.de>
 kevin.xu <cming.xu@gmail.com>
 Kiarash Hajian <133909368+kiarash8112@users.noreply.github.com>
 KibGzr <kibgzr@gmail.com>
 kiel barry <kiel.j.barry@gmail.com>
 kilic <onurkilic1004@gmail.com>
@ -282,8 +420,10 @@ kimmylin <30611210+kimmylin@users.noreply.github.com>
 Kitten King <53072918+kittenking@users.noreply.github.com>
 knarfeh <hejun1874@gmail.com>
 Kobi Gurkan <kobigurk@gmail.com>
 Koichi Shiraishi <zchee.io@gmail.com>
 komika <komika@komika.org>
 Konrad Feldmeier <konrad@brainbot.com>
 Kosuke Taniguchi <73885532+TaniguchiKosuke@users.noreply.github.com>
 Kris Shinn <raggamuffin.music@gmail.com>
 Kristofer Peterson <svenski123@users.noreply.github.com>
 Kumar Anirudha <mail@anirudha.dev>
@ -296,6 +436,8 @@ Lefteris Karapetsas <lefteris@refu.co>
 Leif Jurvetson <leijurv@gmail.com>
 Leo Shklovskii <leo@thermopylae.net>
 LeoLiao <leofantast@gmail.com>
 Leon <316032931@qq.com>
 levisyin <150114626+levisyin@users.noreply.github.com>
 Lewis Marshall <lewis@lmars.net>
 lhendre <lhendre2@gmail.com>
 Li Dongwei <lidw1988@126.com>
@ -305,36 +447,58 @@ libby kent <viskovitzzz@gmail.com>
 libotony <liboliqi@gmail.com>
 LieutenantRoger <dijsky_2015@hotmail.com>
 ligi <ligi@ligi.de>
 lilasxie <thanklilas@163.com>
 Lindlof <mikael@lindlof.io>
 Lio李欧 <lionello@users.noreply.github.com>
-lmittmann <lmittmann@users.noreply.github.com>
+Liyi Guo <102356659+colinlyguo@users.noreply.github.com>
 llkhacquan <3724362+llkhacquan@users.noreply.github.com>
 lmittmann <3458786+lmittmann@users.noreply.github.com>
 lorenzo <31852651+lorenzo-dev1@users.noreply.github.com>
 Lorenzo Manacorda <lorenzo@kinvolk.io>
 Louis Holbrook <dev@holbrook.no>
 Luca Zeug <luclu@users.noreply.github.com>
 Lucas <lucaslg360@gmail.com>
 Lucas Hendren <lhendre2@gmail.com>
 Luozhu <70309026+LuozhuZhang@users.noreply.github.com>
 lwh <lwhile521@gmail.com>
 lzhfromustc <43191155+lzhfromustc@users.noreply.github.com>
 Maciej Kulawik <10907694+magicxyyz@users.noreply.github.com>
 Madhur Shrimal <madhur.shrimal@gmail.com>
 Magicking <s@6120.eu>
 makcandrov <makcandrov@proton.me>
 manlio <manlio.poltronieri@gmail.com>
 Manoj Kumar <mnjkmr398@gmail.com>
 Maran Hidskes <maran.hidskes@gmail.com>
 Marcin Sobczak <77129288+marcindsobczak@users.noreply.github.com>
 Marcus Baldassarre <baldassarremarcus@gmail.com>
 Marek Kotewicz <marek.kotewicz@gmail.com>
 Mariano Cortesi <mcortesi@gmail.com>
 Mario Vega <marioevz@gmail.com>
 Marius G <90795310+bearpebble@users.noreply.github.com>
 Marius Kjærstad <sandakersmann@users.noreply.github.com>
 Marius van der Wijden <m.vanderwijden@live.de>
 Mark <markya0616@gmail.com>
 Mark Rushakoff <mark.rushakoff@gmail.com>
 Mark Tyneway <mark.tyneway@gmail.com>
 mark.lin <mark@maicoin.com>
 markus <55011443+mdymalla@users.noreply.github.com>
 Marquis Shanahan <29431502+9547@users.noreply.github.com>
 Martin Alex Philip Dawson <u1356770@gmail.com>
 Martin Holst Swende <martin@swende.se>
 Martin Klepsch <martinklepsch@googlemail.com>
 Martin Lundfall <martin.lundfall@protonmail.com>
 Martin Michlmayr <tbm@cyrius.com>
 Martin Redmond <21436+reds@users.noreply.github.com>
 maskpp <maskpp266@gmail.com>
 Mason Fischer <mason@kissr.co>
 Mateusz Morusiewicz <11313015+Ruteri@users.noreply.github.com>
 Mats Julian Olsen <mats@plysjbyen.net>
-Matt Garnett <14004106+lightclient@users.noreply.github.com>
+Matt Garnett <lightclient@protonmail.com>
 Matt K <1036969+mkrump@users.noreply.github.com>
 Matthew Di Ferrante <mattdf@users.noreply.github.com>
 Matthew Halpern <matthalp@gmail.com>
 Matthew Wampler-Doty <matthew.wampler.doty@gmail.com>
 Matthieu Vachon <matt@streamingfast.io>
 Max Sistemich <mafrasi2@googlemail.com>
 Maxim Zhiburt <zhiburt@gmail.com>
 Maximilian Meister <mmeister@suse.de>
@ -342,34 +506,55 @@ me020523 <me020523@gmail.com>
 Melvin Junhee Woo <melvin.woo@groundx.xyz>
 meowsbits <b5c6@protonmail.com>
 Micah Zoltu <micah@zoltu.net>
 Michael de Hoog <michael.dehoog@gmail.com>
 Michael Forney <mforney@mforney.org>
 Michael Riabzev <michael@starkware.co>
 Michael Ruminer <michael.ruminer+github@gmail.com>
 michael1011 <me@michael1011.at>
 Miguel Mota <miguelmota2@gmail.com>
 Mike Burr <mburr@nightmare.com>
 Mikel Cortes <45786396+cortze@users.noreply.github.com>
 Mikhail Mikheev <mmvsha73@gmail.com>
 Mikhail Vazhnov <michael.vazhnov@gmail.com>
 miles <66052478+miles-six@users.noreply.github.com>
 Miles Chen <fearlesschenc@gmail.com>
 milesvant <milesvant@gmail.com>
 minh-bq <97180373+minh-bq@users.noreply.github.com>
 Mio <mshimmeris@gmail.com>
 Miro <mirokuratczyk@users.noreply.github.com>
 Miya Chen <miyatlchen@gmail.com>
 mmsqe <mavis@crypto.com>
 Mobin Mohanan <47410557+tr1sm0s1n@users.noreply.github.com>
 Mohanson <mohanson@outlook.com>
 moomin <67548026+nothingmin@users.noreply.github.com>
 mr_franklin <mr_franklin@126.com>
 Mskxn <118117161+Mskxn@users.noreply.github.com>
 Mudit Gupta <guptamudit@ymail.com>
 Mymskmkt <1847234666@qq.com>
 Nalin Bhardwaj <nalinbhardwaj@nibnalin.me>
 nand2 <nicolas@deschildre.fr>
 Nathan <Nathan.l@nodereal.io>
 Nathan Jo <162083209+qqqeck@users.noreply.github.com>
 Natsu Kagami <natsukagami@gmail.com>
 Naveen <116692862+naveen-imtb@users.noreply.github.com>
 Nchinda Nchinda <nchinda2@gmail.com>
-nebojsa94 <nebojsa94@users.noreply.github.com>
+Nebojsa Urosevic <nebojsa94@users.noreply.github.com>
 necaremus <necaremus@gmail.com>
 nedifi <103940716+nedifi@users.noreply.github.com>
 needkane <604476380@qq.com>
 Newt6611 <45097780+Newt6611@users.noreply.github.com>
 Ng Wei Han <47109095+weiihann@users.noreply.github.com>
 Nguyen Kien Trung <trung.n.k@gmail.com>
 Nguyen Sy Thanh Son <thanhson1085@gmail.com>
 Nic Jansma <nic@nicj.net>
 Nicholas <nicholas.zhaoyu@gmail.com>
 Nick Dodson <silentcicero@outlook.com>
 Nick Johnson <arachnid@notdot.net>
 Nicola Cocchiaro <3538109+ncocchiaro@users.noreply.github.com>
 Nicolas Feignon <nfeignon@gmail.com>
 Nicolas Gotchac <ngotchac@gmail.com>
 Nicolas Guillaume <gunicolas@sqli.com>
 Nikhil Suri <nikhilsuri@comcast.net>
 Nikita Kozhemyakin <enginegl.ec@gmail.com>
 Nikola Madjarevic <nikola.madjarevic@gmail.com>
 Nilesh Trivedi <nilesh@hypertrack.io>
@ -379,32 +564,47 @@ njupt-moon <1015041018@njupt.edu.cn>
 nkbai <nkbai@163.com>
 noam-alchemy <76969113+noam-alchemy@users.noreply.github.com>
 nobody <ddean2009@163.com>
 noel <72006780+0x00Duke@users.noreply.github.com>
 Noman <noman@noman.land>
 norwnd <112318969+norwnd@users.noreply.github.com>
 nujabes403 <nujabes403@gmail.com>
 Nye Liu <nyet@nyet.org>
 Obtuse7772 <117080049+Obtuse7772@users.noreply.github.com>
 Oleg Kovalov <iamolegkovalov@gmail.com>
 Oli Bye <olibye@users.noreply.github.com>
 Oliver Tale-Yazdi <oliver@perun.network>
 Olivier Hervieu <olivier.hervieu@gmail.com>
 openex <openexkevin@gmail.com>
 Or Neeman <oneeman@gmail.com>
 oseau <harbin.kyang@gmail.com>
 Osoro Bironga <fanosoro@gmail.com>
 Osuke <arget-fee.free.dgm@hotmail.co.jp>
 panicalways <113693386+panicalways@users.noreply.github.com>
 Pantelis Peslis <pespantelis@gmail.com>
 Parithosh Jayanthi <parithosh@indenwolken.xyz>
 Park Changwan <pcw109550@gmail.com>
 Pascal Dierich <pascal@merkleplant.xyz>
 Patrick O'Grady <prohb125@gmail.com>
 Pau <pau@dabax.net>
 Paul <41552663+molecula451@users.noreply.github.com>
 Paul Berg <hello@paulrberg.com>
 Paul Lange <palango@users.noreply.github.com>
 Paul Litvak <litvakpol@012.net.il>
 Paul-Armand Verhaegen <paularmand.verhaegen@gmail.com>
 Paulo L F Casaretto <pcasaretto@gmail.com>
 Pawan Dhananjay <pawandhananjay@gmail.com>
 Paweł Bylica <chfast@gmail.com>
 Pedro Gomes <otherview@gmail.com>
 Pedro Pombeiro <PombeirP@users.noreply.github.com>
 persmor <166146971+persmor@users.noreply.github.com>
 Peter (bitfly) <1674920+peterbitfly@users.noreply.github.com>
 Peter Broadhurst <peter@themumbles.net>
 peter cresswell <pcresswell@gmail.com>
 Peter Pratscher <pratscher@gmail.com>
 Peter Simard <petesimard56@gmail.com>
 Peter Straus <153843855+krauspt@users.noreply.github.com>
 Petr Mikusek <petr@mikusek.info>
 phenix3443 <phenix3443@gmail.com>
 Philip Schlump <pschlump@gmail.com>
 Pierre Neter <pierreneter@gmail.com>
 Pierre R <p.rousset@gmail.com>
@ -412,15 +612,24 @@ piersy <pierspowlesland@gmail.com>
 PilkyuJung <anothel1@naver.com>
 Piotr Dyraga <piotr.dyraga@keep.network>
 ploui <64719999+ploui@users.noreply.github.com>
 PolyMa <151764357+polymaer@users.noreply.github.com>
 Preston Van Loon <preston@prysmaticlabs.com>
 Prince Sinha <sinhaprince013@gmail.com>
 psogv0308 <psogv0308@gmail.com>
 puhtaytow <18026645+puhtaytow@users.noreply.github.com>
 Péter Szilágyi <peterke@gmail.com>
 qcrao <qcrao91@gmail.com>
 qd-ethan <31876119+qdgogogo@users.noreply.github.com>
 Qian Bin <cola.tin.com@gmail.com>
 qiuhaohao <trouserrr@gmail.com>
 Qt <golang.chen@gmail.com>
 Quentin McGaw <quentin.mcgaw@gmail.com>
 Quest Henkart <qhenkart@gmail.com>
 Rachel Bousfield <nfranks@protonmail.com>
 Rachel Franks <nfranks@protonmail.com>
 Rafael Matias <rafael@skyle.net>
 Raghav Sood <raghavsood@gmail.com>
 Rajaram Gaunker <zimbabao@gmail.com>
 Ralph Caraveo <deckarep@gmail.com>
 Ramesh Nair <ram@hiddentao.com>
 rangzen <public@l-homme.com>
@ -430,45 +639,65 @@ rhaps107 <dod-source@yandex.ru>
 Ricardo Catalinas Jiménez <r@untroubled.be>
 Ricardo Domingos <ricardohsd@gmail.com>
 Richard Hart <richardhart92@gmail.com>
 RichΛrd <info@richardramos.me>
 Rick <rick.no@groundx.xyz>
 RJ Catalano <catalanor0220@gmail.com>
 Rob <robert@rojotek.com>
 Rob Mulholand <rmulholand@8thlight.com>
 Robert Zaremba <robert@zaremba.ch>
 Roberto Bayardo <bayardo@alum.mit.edu>
 Roc Yu <rociiu0112@gmail.com>
 Roman Krasiuk <rokrassyuk@gmail.com>
 Roman Mazalov <83914728+gopherxyz@users.noreply.github.com>
 Ross <9055337+Chadsr@users.noreply.github.com>
 Rossen Krastev <rosen4obg@gmail.com>
 Roy Crihfield <roy@manteia.ltd>
 Runchao Han <elvisage941102@gmail.com>
 Ruohui Wang <nomaru@outlook.com>
 Russ Cox <rsc@golang.org>
 Ryan Schneider <ryanleeschneider@gmail.com>
 Ryan Tinianov <tinianov@live.com>
 ryanc414 <ryan@tokencard.io>
 Rémy Roy <remyroy@remyroy.com>
 S. Matthew English <s-matthew-english@users.noreply.github.com>
 salanfe <salanfe@users.noreply.github.com>
 Sam <39165351+Xia-Sam@users.noreply.github.com>
 Saman H. Pasha <51169592+saman-pasha@users.noreply.github.com>
 Sammy Libre <7374093+sammy007@users.noreply.github.com>
 Samuel Marks <samuelmarks@gmail.com>
 Sanghee Choi <32831939+pengin7384@users.noreply.github.com>
 SangIlMo <156392700+SangIlMo@users.noreply.github.com>
 sanskarkhare <sanskarkhare47@gmail.com>
 SanYe <kumakichi@users.noreply.github.com>
 Sarlor <kinsleer@outlook.com>
 Sasuke1964 <neilperry1964@gmail.com>
 Satpal <28562234+SatpalSandhu61@users.noreply.github.com>
 Saulius Grigaitis <saulius@necolt.com>
 Sean <darcys22@gmail.com>
 seayyyy <163325936+seay404@users.noreply.github.com>
 Sebastian Stammler <seb@oplabs.co>
 Serhat Şevki Dinçer <jfcgauss@gmail.com>
 Seungbae Yu <dbadoy4874@gmail.com>
 Seungmin Kim <a7965344@gmail.com>
 Shane Bammel <sjb933@gmail.com>
 shawn <36943337+lxex@users.noreply.github.com>
 shigeyuki azuchi <azuchi@chaintope.com>
 Shihao Xia <charlesxsh@hotmail.com>
 Shiming <codingmylife@gmail.com>
 Shiming Zhang <wzshiming@hotmail.com>
 Shintaro Kaneko <kaneshin0120@gmail.com>
 shiqinfeng1 <150627601@qq.com>
 Shivam Sandbhor <shivam.sandbhor@gmail.com>
 shivhg <shivhg@gmail.com>
 Shuai Qi <qishuai231@gmail.com>
 Shude Li <islishude@gmail.com>
 Shunsuke Watanabe <ww.shunsuke@gmail.com>
 shuo <shuoli84@gmail.com>
 silence <wangsai.silence@qq.com>
 Simon Jentzsch <simon@slock.it>
 Sina Mahmoodi <1591639+s1na@users.noreply.github.com>
 sixdays <lj491685571@126.com>
 sjlee1125 <47561537+sjlee1125@users.noreply.github.com>
 SjonHortensius <SjonHortensius@users.noreply.github.com>
 Slava Karpenko <slavikus@gmail.com>
 slumber1122 <slumber1122@gmail.com>
@ -477,17 +706,29 @@ soc1c <soc1c@users.noreply.github.com>
 Sorin Neacsu <sorin.neacsu@gmail.com>
 Sparty <vignesh.crysis@gmail.com>
 Stein Dekker <dekker.stein@gmail.com>
 Stephen Flynn <ssflynn@gmail.com>
 Stephen Guo <stephen.fire@gmail.com>
 Steve Gattuso <steve@stevegattuso.me>
 Steve Milk <wangpeculiar@gmail.com>
 Steve Ruckdashel <steve.ruckdashel@gmail.com>
 Steve Waldman <swaldman@mchange.com>
 Steven E. Harris <seh@panix.com>
 Steven Roose <stevenroose@gmail.com>
 stompesi <stompesi@gmail.com>
 stormpang <jialinpeng@vip.qq.com>
 storyicon <storyicon@foxmail.com>
 strykerin <dacosta.pereirafabio@gmail.com>
 sudeep <sudeepdino008@gmail.com>
 SuiYuan <165623542+suiyuan1314@users.noreply.github.com>
 Sungwoo Kim <git@sung-woo.kim>
 sunxiaojun2014 <sunxiaojun-xy@360.cn>
 Suriyaa Sundararuban <isc.suriyaa@gmail.com>
 Sylvain Laurent <s@6120.eu>
 Szupingwang <cara4bear@gmail.com>
 tactical_retreat <tactical0retreat@gmail.com>
 Taeguk Kwon <xornrbboy@gmail.com>
 Taeik Lim <sibera21@gmail.com>
 taiking <c.tsujiyan727@gmail.com>
 tamirms <tamir@trello.com>
 Tangui Clairet <tangui.clairet@gmail.com>
 Tatsuya Shimoda <tacoo@users.noreply.github.com>
@ -495,21 +736,35 @@ Taylor Gerring <taylor.gerring@gmail.com>
 TColl <38299499+TColl@users.noreply.github.com>
 terasum <terasum@163.com>
 tgyKomgo <52910426+tgyKomgo@users.noreply.github.com>
 Thabokani <149070269+Thabokani@users.noreply.github.com>
 Thad Guidry <thadguidry@gmail.com>
 therainisme <therainisme@qq.com>
 Thomas Bocek <tom@tomp2p.net>
 thomasmodeneis <thomas.modeneis@gmail.com>
 thumb8432 <thumb8432@gmail.com>
 Ti Zhou <tizhou1986@gmail.com>
 tia-99 <67107070+tia-99@users.noreply.github.com>
 tianyeyouyou <tianyeyouyou@gmail.com>
 Tien Nguyen <116023870+htiennv@users.noreply.github.com>
 Tim Cooijmans <timcooijmans@gmail.com>
 TinyFoxy <tiny.fox@foxmail.com>
 Tobias Hildebrandt <79341166+tobias-hildebrandt@users.noreply.github.com>
 tokikuch <msmania@users.noreply.github.com>
 Tom <45168162+tomdever@users.noreply.github.com>
 Tosh Camille <tochecamille@gmail.com>
 trillo <trillo8652@gmail.com>
 Tristan-Wilson <87238672+Tristan-Wilson@users.noreply.github.com>
 trocher <trooocher@proton.me>
 tsarpaul <Litvakpol@012.net.il>
 TY <45994721+tylerK1294@users.noreply.github.com>
 Tyler Chambers <2775339+tylerchambers@users.noreply.github.com>
 tylerni7 <tylerni7@gmail.com>
 tzapu <alex@tzapu.com>
-ucwong <ucwong@126.com>
+ucwong <ethereum2k@gmail.com>
 uji <49834542+uji@users.noreply.github.com>
 ult-bobonovski <alex@ultiledger.io>
 Undefinedor <wanghao@imwh.net>
 Ursulafe <152976968+Ursulafe@users.noreply.github.com>
 Valentin Trinqué <ValentinTrinque@users.noreply.github.com>
 Valentin Wüstholz <wuestholz@gmail.com>
 Vedhavyas Singareddi <vedhavyas.singareddi@gmail.com>
@ -528,39 +783,60 @@ Vitaly V <vvelikodny@gmail.com>
 Vivek Anand <vivekanand1101@users.noreply.github.com>
 Vlad Bokov <razum2um@mail.ru>
 Vlad Gluhovsky <gluk256@gmail.com>
 VM <112189277+sysvm@users.noreply.github.com>
 vuittont60 <81072379+vuittont60@users.noreply.github.com>
 wangjingcun <wangjingcun@aliyun.com>
 wangyifan <wangyifan@uchicago.edu>
 Ward Bradt <wardbradt5@gmail.com>
 Water <44689567+codeoneline@users.noreply.github.com>
 wbt <wbt@users.noreply.github.com>
 Wei Tang <acc@pacna.org>
 weimumu <934657014@qq.com>
 Wenbiao Zheng <delweng@gmail.com>
 Wenshao Zhong <wzhong20@uic.edu>
 Wihan de Beer <debeerwihan@gmail.com>
 Will Villanueva <hello@willvillanueva.com>
 William Morriss <wjmelements@gmail.com>
 William Setzer <bootstrapsetzer@gmail.com>
 williambannas <wrschwartz@wpi.edu>
 willian.eth <willian@ufpa.br>
 winniehere <winnie050812@qq.com>
 winterjihwan <113398351+winterjihwan@users.noreply.github.com>
 wuff1996 <33193253+wuff1996@users.noreply.github.com>
 Wuxiang <wuxiangzhou2010@gmail.com>
 Xiaobing Jiang <s7v7nislands@gmail.com>
 xiaodong <81516175+javaandfly@users.noreply.github.com>
 xiekeyang <xiekeyang@users.noreply.github.com>
 xinbenlv <zzn@zzn.im>
 xincaosu <xincaosu@126.com>
 xinluyin <31590468+xinluyin@users.noreply.github.com>
 xiyang <90125263+JBossBC@users.noreply.github.com>
 Xudong Liu <33193253+r1cs@users.noreply.github.com>
 xwjack <XWJACK@users.noreply.github.com>
 yahtoo <yahtoo.ma@gmail.com>
 Yang Hau <vulxj0j8j8@gmail.com>
 YaoZengzeng <yaozengzeng@zju.edu.cn>
 ycyraum <ycyraum@fastmail.com>
 YH-Zhou <yanhong.zhou05@gmail.com>
 Yier <90763233+yierx@users.noreply.github.com>
 Yihau Chen <a122092487@gmail.com>
 yihuang <huang@crypto.com>
 Yohann Léon <sybiload@gmail.com>
 Yoichi Hirai <i@yoichihirai.com>
 Yole <007yuyue@gmail.com>
 Yondon Fu <yondon.fu@gmail.com>
 yong <33920876+yzhaoyu@users.noreply.github.com>
 YOSHIDA Masanori <masanori.yoshida@gmail.com>
 yoza <yoza.is12s@gmail.com>
 ysh0566 <ysh0566@qq.com>
 yudrywet <166895665+yudrywet@users.noreply.github.com>
 yujinpark <petere123123@gmail.com>
 yukionfire <yukionfire@qq.com>
 yumiel yoomee1313 <yumiel.ko@groundx.xyz>
 Yusup <awklsgrep@gmail.com>
 yutianwu <wzxingbupt@gmail.com>
 ywzqwwt <39263032+ywzqwwt@users.noreply.github.com>
 yzb <335357057@qq.com>
 zaccoding <zaccoding725@gmail.com>
 Zach <zach.ramsay@gmail.com>
 Zachinquarantine <Zachinquarantine@protonmail.com>
@ -568,24 +844,34 @@ zah <zahary@gmail.com>
 Zahoor Mohamed <zahoor@zahoor.in>
 Zak Cole <zak@beattiecole.com>
 zcheng9 <zcheng9@hawk.iit.edu>
 zeim839 <50573884+zeim839@users.noreply.github.com>
 zer0to0ne <36526113+zer0to0ne@users.noreply.github.com>
 zgfzgf <48779939+zgfzgf@users.noreply.github.com>
 Zhang Zhuo <mycinbrin@gmail.com>
 zhangsoledad <787953403@qq.com>
 zhaochonghe <41711151+zhaochonghe@users.noreply.github.com>
 zhen peng <505380967@qq.com>
 Zhenguo Niu <Niu.ZGlinux@gmail.com>
 Zheyuan He <ecjgvmhc@gmail.com>
 Zhihao Lin <3955922+kkqy@users.noreply.github.com>
 zhiqiangxu <652732310@qq.com>
 Zhou Zhiyao <ZHOU0250@e.ntu.edu.sg>
 Ziyuan Zhong <zzy.albert@163.com>
 Zoe Nolan <github@zoenolan.org>
 zoereco <158379334+zoereco@users.noreply.github.com>
 Zoo <zoosilence@gmail.com>
 Zoro <40222601+BabyHalimao@users.noreply.github.com>
 Zou Guangxian <zouguangxian@gmail.com>
 Zsolt Felföldi <zsfelfoldi@gmail.com>
 Łukasz Kurowski <crackcomm@users.noreply.github.com>
 Łukasz Zimnoch <lukaszzimnoch1994@gmail.com>
 ΞTHΞЯSPHΞЯΞ <{viktor.tron,nagydani,zsfelfoldi}@gmail.com>
 Максим Чусовлянов <mchusovlianov@gmail.com>
 かげ <47621124+ronething-bot@users.noreply.github.com>
 スパイク <1311798+spkjp@users.noreply.github.com>
 大彬 <hz_stb@163.com>
 沉风 <myself659@users.noreply.github.com>
 牛晓婕 <30611384+niuxiaojie81@users.noreply.github.com>
 贺鹏飞 <hpf@hackerful.cn>
 陈佳 <chenjiablog@gmail.com>
 유용환 <33824408+eric-yoo@users.noreply.github.com>
--- a/4
+++ b/4
@ -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.24-alpine AS builder
 RUN apk add --no-cache gcc musl-dev linux-headers git
@ -25,7 +25,7 @@ COPY --from=builder /go-ethereum/build/bin/geth /usr/local/bin/
 EXPOSE 8545 8546 30303 30303/udp
 ENTRYPOINT ["geth"]
-# Add some metadata labels to help programatic image consumption
+# Add some metadata labels to help programmatic image consumption
 ARG COMMIT=""
 ARG VERSION=""
 ARG BUILDNUM=""
--- a/Dockerfile.alltools
+++ b/Dockerfile.alltools
@ -4,7 +4,7 @@ ARG VERSION=""
 ARG BUILDNUM=""
 # Build Geth in a stock Go builder container
-FROM golang:1.21-alpine as builder
+FROM golang:1.24-alpine AS builder
 RUN apk add --no-cache gcc musl-dev linux-headers git
@ -14,6 +14,13 @@ COPY go.sum /go-ethereum/
 RUN cd /go-ethereum && go mod download
 ADD . /go-ethereum
 # This is not strictly necessary, but it matches the "Dockerfile" steps, thus
 # makes it so that under certain circumstances, the docker layer can be cached,
 # and the builder can jump to the next (build all) command, with the go cache fully loaded.
 #
 RUN cd /go-ethereum && go run build/ci.go install -static ./cmd/geth
 RUN cd /go-ethereum && go run build/ci.go install -static
 # Pull all binaries into a second stage deploy alpine container
@ -24,7 +31,7 @@ COPY --from=builder /go-ethereum/build/bin/* /usr/local/bin/
 EXPOSE 8545 8546 30303 30303/udp
-# Add some metadata labels to help programatic image consumption
+# Add some metadata labels to help programmatic image consumption
 ARG COMMIT=""
 ARG VERSION=""
 ARG BUILDNUM=""
--- a/23
+++ b/23
@ -2,26 +2,35 @@
 # with Go source code. If you know what GOPATH is then you probably
 # don't need to bother with make.
-.PHONY: geth android ios evm all test clean
+.PHONY: geth all test lint fmt clean devtools help
 GOBIN = ./build/bin
 GO ?= latest
 GORUN = go run
 #? geth: Build geth.
 geth:
 	$(GORUN) build/ci.go install ./cmd/geth
 	@echo "Done building."
 	@echo "Run \"$(GOBIN)/geth\" to launch geth."
 #? all: Build all packages and executables.
 all:
 	$(GORUN) build/ci.go install
 #? test: Run the tests.
 test: all
 	$(GORUN) build/ci.go test
 #? lint: Run certain pre-selected linters.
 lint: ## Run linters.
 	$(GORUN) build/ci.go lint
 #? fmt: Ensure consistent code formatting.
 fmt:
 	gofmt -s -w $(shell find . -name "*.go")
 #? clean: Clean go cache, built executables, and the auto generated folder.
 clean:
 	go clean -cache
 	rm -fr build/_workspace/pkg/ $(GOBIN)/*
@ -29,10 +38,20 @@ clean:
 # The devtools target installs tools required for 'go generate'.
 # You need to put $GOBIN (or $GOPATH/bin) in your PATH to use 'go generate'.
 #? devtools: Install recommended developer tools.
 devtools:
 	env GOBIN= go install golang.org/x/tools/cmd/stringer@latest
 	env GOBIN= go install github.com/fjl/gencodec@latest
-	env GOBIN= go install github.com/golang/protobuf/protoc-gen-go@latest
+	env GOBIN= go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
 	env GOBIN= go install ./cmd/abigen
 	@type "solc" 2> /dev/null || echo 'Please install solc'
 	@type "protoc" 2> /dev/null || echo 'Please install protoc'
 #? help: Get more info on make commands.
 help: Makefile
 	@echo ''
 	@echo 'Usage:'
 	@echo '  make [target]'
 	@echo ''
 	@echo 'Targets:'
 	@sed -n 's/^#?//p' $< | column -t -s ':' |  sort | sed -e 's/^/ /'
--- a/README.md
+++ b/README.md
@ -1,12 +1,12 @@
 ## Go Ethereum
-Official Golang execution layer implementation of the Ethereum protocol.
+Golang execution layer implementation of the Ethereum protocol.
 [![API Reference](
-https://camo.githubusercontent.com/915b7be44ada53c290eb157634330494ebe3e30a/68747470733a2f2f676f646f632e6f72672f6769746875622e636f6d2f676f6c616e672f6764646f3f7374617475732e737667
+https://pkg.go.dev/badge/github.com/ethereum/go-ethereum
 )](https://pkg.go.dev/github.com/ethereum/go-ethereum?tab=doc)
 [![Go Report Card](https://goreportcard.com/badge/github.com/ethereum/go-ethereum)](https://goreportcard.com/report/github.com/ethereum/go-ethereum)
-[![Travis](https://travis-ci.com/ethereum/go-ethereum.svg?branch=master)](https://travis-ci.com/ethereum/go-ethereum)
+[![Travis](https://app.travis-ci.com/ethereum/go-ethereum.svg?branch=master)](https://app.travis-ci.com/github/ethereum/go-ethereum)
 [![Discord](https://img.shields.io/badge/discord-join%20chat-blue.svg)](https://discord.gg/nthXNEv)
 Automated builds are available for stable releases and the unstable master branch. Binary
@ -16,7 +16,7 @@ archives are published at https://geth.ethereum.org/downloads/.
 For prerequisites and detailed build instructions please read the [Installation Instructions](https://geth.ethereum.org/docs/getting-started/installing-geth).
-Building `geth` requires both a Go (version 1.19 or later) and a C compiler. You can install
+Building `geth` requires both a Go (version 1.23 or later) and a C compiler. You can install
 them using your favourite package manager. Once the dependencies are installed, run
 ```shell
@ -40,7 +40,6 @@ directory.
 |   `clef`   | Stand-alone signing tool, which can be used as a backend signer for `geth`.                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 |  `devp2p`  | Utilities to interact with nodes on the networking layer, without running a full blockchain.                                                                                                                                                                                                                                                                                                                                                                                                                                       |
 |  `abigen`  | Source code generator to convert Ethereum contract definitions into easy-to-use, compile-time type-safe Go packages. It operates on plain [Ethereum contract ABIs](https://docs.soliditylang.org/en/develop/abi-spec.html) with expanded functionality if the contract bytecode is also available. However, it also accepts Solidity source files, making development much more streamlined. Please see our [Native DApps](https://geth.ethereum.org/docs/developers/dapp-developer/native-bindings) page for details.                                  |
 | `bootnode` | Stripped down version of our Ethereum client implementation that only takes part in the network node discovery protocol, but does not run any of the higher level application protocols. It can be used as a lightweight bootstrap node to aid in finding peers in private networks.                                                                                                                                                                                                                                               |
 |   `evm`    | Developer utility version of the EVM (Ethereum Virtual Machine) that is capable of running bytecode snippets within a configurable environment and execution mode. Its purpose is to allow isolated, fine-grained debugging of EVM opcodes (e.g. `evm --code 60ff60ff --debug run`).                                                                                                                                                                                                                                               |
 | `rlpdump`  | Developer utility tool to convert binary RLP ([Recursive Length Prefix](https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp)) dumps (data encoding used by the Ethereum protocol both network as well as consensus wise) to user-friendlier hierarchical representation (e.g. `rlpdump --hex CE0183FFFFFFC4C304050583616263`).                                                                                                                                                                                |
@ -55,14 +54,14 @@ on how you can run your own `geth` instance.
 Minimum:
-* CPU with 2+ cores
+* CPU with 4+ cores
-* 4GB RAM
+* 8GB RAM
 * 1TB free storage space to sync the Mainnet
 * 8 MBit/sec download Internet service
 Recommended:
-* Fast CPU with 4+ cores
+* Fast CPU with 8+ cores
 * 16GB+ RAM
 * High-performance SSD with at least 1TB of free space
 * 25+ MBit/sec download Internet service
@ -89,7 +88,7 @@ This command will:
   This tool is optional and if you leave it out you can always attach it to an already running
   `geth` instance with `geth attach`.
-### A Full node on the Görli test network
+### A Full node on the Holesky test network
 Transitioning towards developers, if you'd like to play around with creating Ethereum
 contracts, you almost certainly would like to do that without any real money involved until
@ -98,23 +97,23 @@ network, you want to join the **test** network with your node, which is fully eq
 the main network, but with play-Ether only.
 ```shell
-$ geth --goerli console
+$ geth --holesky console
 ```
 The `console` subcommand has the same meaning as above and is equally
 useful on the testnet too.
-Specifying the `--goerli` flag, however, will reconfigure your `geth` instance a bit:
+Specifying the `--holesky` flag, however, will reconfigure your `geth` instance a bit:
- * Instead of connecting to the main Ethereum network, the client will connect to the Görli
+ * Instead of connecting to the main Ethereum network, the client will connect to the Holesky 
   test network, which uses different P2P bootnodes, different network IDs and genesis
   states.
 * Instead of using the default data directory (`~/.ethereum` on Linux for example), `geth`
-   will nest itself one level deeper into a `goerli` subfolder (`~/.ethereum/goerli` on
+   will nest itself one level deeper into a `holesky` subfolder (`~/.ethereum/holesky` on
   Linux). Note, on OSX and Linux this also means that attaching to a running testnet node
   requires the use of a custom endpoint since `geth attach` will try to attach to a
   production node endpoint by default, e.g.,
-   `geth attach <datadir>/goerli/geth.ipc`. Windows users are not affected by
+   `geth attach <datadir>/holesky/geth.ipc`. Windows users are not affected by
   this.
 *Note: Although some internal protective measures prevent transactions from
@ -139,8 +138,6 @@ export your existing configuration:
 $ geth --your-favourite-flags dumpconfig
 ```
 *Note: This works only with `geth` v1.6.0 and above.*
 #### Docker quick start
 One of the quickest ways to get Ethereum up and running on your machine is by using
@ -181,14 +178,13 @@ HTTP based JSON-RPC API options:
  * `--http.addr` HTTP-RPC server listening interface (default: `localhost`)
  * `--http.port` HTTP-RPC server listening port (default: `8545`)
  * `--http.api` API's offered over the HTTP-RPC interface (default: `eth,net,web3`)
-  * `--http.corsdomain` Comma separated list of domains from which to accept cross origin requests (browser enforced)
+  * `--http.corsdomain` Comma separated list of domains from which to accept cross-origin requests (browser enforced)
  * `--ws` Enable the WS-RPC server
  * `--ws.addr` WS-RPC server listening interface (default: `localhost`)
  * `--ws.port` WS-RPC server listening port (default: `8546`)
  * `--ws.api` API's offered over the WS-RPC interface (default: `eth,net,web3`)
  * `--ws.origins` Origins from which to accept WebSocket requests
  * `--ipcdisable` Disable the IPC-RPC server
  * `--ipcapi` API's offered over the IPC-RPC interface (default: `admin,debug,eth,miner,net,personal,txpool,web3`)
  * `--ipcpath` Filename for IPC socket/pipe within the datadir (explicit paths escape it)
 You'll need to use your own programming environments' capabilities (libraries, tools, etc) to
@ -207,113 +203,14 @@ APIs!**
 Maintaining your own private network is more involved as a lot of configurations taken for
 granted in the official networks need to be manually set up.
-#### Defining the private genesis state
+Unfortunately since [the Merge](https://ethereum.org/en/roadmap/merge/) it is no longer possible
 to easily set up a network of geth nodes without also setting up a corresponding beacon chain.
-First, you'll need to create the genesis state of your networks, which all nodes need to be
+There are three different solutions depending on your use case:
 aware of and agree upon. This consists of a small JSON file (e.g. call it `genesis.json`):
-```json
+  * If you are looking for a simple way to test smart contracts from go in your CI, you can use the [Simulated Backend](https://geth.ethereum.org/docs/developers/dapp-developer/native-bindings#blockchain-simulator).
-{
+  * If you want a convenient single node environment for testing, you can use our [Dev Mode](https://geth.ethereum.org/docs/developers/dapp-developer/dev-mode).
-  "config": {
+  * If you are looking for a multiple node test network, you can set one up quite easily with [Kurtosis](https://geth.ethereum.org/docs/fundamentals/kurtosis).
    "chainId": <arbitrary positive integer>,
    "homesteadBlock": 0,
    "eip150Block": 0,
    "eip155Block": 0,
    "eip158Block": 0,
    "byzantiumBlock": 0,
    "constantinopleBlock": 0,
    "petersburgBlock": 0,
    "istanbulBlock": 0,
    "berlinBlock": 0,
    "londonBlock": 0
  },
  "alloc": {},
  "coinbase": "0x0000000000000000000000000000000000000000",
  "difficulty": "0x20000",
  "extraData": "",
  "gasLimit": "0x2fefd8",
  "nonce": "0x0000000000000042",
  "mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "timestamp": "0x00"
 }
 ```
 The above fields should be fine for most purposes, although we'd recommend changing
 the `nonce` to some random value so you prevent unknown remote nodes from being able
 to connect to you. If you'd like to pre-fund some accounts for easier testing, create
 the accounts and populate the `alloc` field with their addresses.
 ```json
 "alloc": {
  "0x0000000000000000000000000000000000000001": {
    "balance": "111111111"
  },
  "0x0000000000000000000000000000000000000002": {
    "balance": "222222222"
  }
 }
 ```
 With the genesis state defined in the above JSON file, you'll need to initialize **every**
 `geth` node with it prior to starting it up to ensure all blockchain parameters are correctly
 set:
 ```shell
 $ geth init path/to/genesis.json
 ```
 #### Creating the rendezvous point
 With all nodes that you want to run initialized to the desired genesis state, you'll need to
 start a bootstrap node that others can use to find each other in your network and/or over
 the internet. The clean way is to configure and run a dedicated bootnode:
 ```shell
 $ bootnode --genkey=boot.key
 $ bootnode --nodekey=boot.key
 ```
 With the bootnode online, it will display an [`enode` URL](https://ethereum.org/en/developers/docs/networking-layer/network-addresses/#enode)
 that other nodes can use to connect to it and exchange peer information. Make sure to
 replace the displayed IP address information (most probably `[::]`) with your externally
 accessible IP to get the actual `enode` URL.
 *Note: You could also use a full-fledged `geth` node as a bootnode, but it's the less
 recommended way.*
 #### Starting up your member nodes
 With the bootnode operational and externally reachable (you can try
 `telnet <ip> <port>` to ensure it's indeed reachable), start every subsequent `geth`
 node pointed to the bootnode for peer discovery via the `--bootnodes` flag. It will
 probably also be desirable to keep the data directory of your private network separated, so
 do also specify a custom `--datadir` flag.
 ```shell
 $ geth --datadir=path/to/custom/data/folder --bootnodes=<bootnode-enode-url-from-above>
 ```
 *Note: Since your network will be completely cut off from the main and test networks, you'll
 also need to configure a miner to process transactions and create new blocks for you.*
 #### Running a private miner
 In a private network setting a single CPU miner instance is more than enough for
 practical purposes as it can produce a stable stream of blocks at the correct intervals
 without needing heavy resources (consider running on a single thread, no need for multiple
 ones either). To start a `geth` instance for mining, run it with all your usual flags, extended
 by:
 ```shell
 $ geth <usual-flags> --mine --miner.threads=1 --miner.etherbase=0x0000000000000000000000000000000000000000
 ```
 Which will start mining blocks and transactions on a single CPU thread, crediting all
 proceedings to the account specified by `--miner.etherbase`. You can further tune the mining
 by changing the default gas limit blocks converge to (`--miner.targetgaslimit`) and the price
 transactions are accepted at (`--miner.gasprice`).
 ## Contribution
--- a/SECURITY.md
+++ b/SECURITY.md
@ -29,147 +29,69 @@ Fingerprint: `AE96 ED96 9E47 9B00 84F3 E17F E88D 3334 FA5F 6A0A`
 ```
 -----BEGIN PGP PUBLIC KEY BLOCK-----
 Version: SKS 1.1.6
 Comment: Hostname: pgp.mit.edu
-mQINBFgl3tgBEAC8A1tUBkD9YV+eLrOmtgy+/JS/H9RoZvkg3K1WZ8IYfj6iIRaYneAk3Bp1
+mQINBFgl3tgBEAC8A1tUBkD9YV+eLrOmtgy+/JS/H9RoZvkg3K1WZ8IYfj6iIRaY
-82GUPVz/zhKr2g0tMXIScDR3EnaDsY+Qg+JqQl8NOG+Cikr1nnkG2on9L8c8yiqry1ZTCmYM
+neAk3Bp182GUPVz/zhKr2g0tMXIScDR3EnaDsY+Qg+JqQl8NOG+Cikr1nnkG2on9
-qCa2acTFqnyuXJ482aZNtB4QG2BpzfhW4k8YThpegk/EoRUim+y7buJDtoNf7YILlhDQXN8q
+L8c8yiqry1ZTCmYMqCa2acTFqnyuXJ482aZNtB4QG2BpzfhW4k8YThpegk/EoRUi
-lHB02DWOVUihph9tUIFsPK6BvTr9SIr/eG6j6k0bfUo9pexOn7LS4SojoJmsm/5dp6AoKlac
+m+y7buJDtoNf7YILlhDQXN8qlHB02DWOVUihph9tUIFsPK6BvTr9SIr/eG6j6k0b
-48cZU5zwR9AYcq/nvkrfmf2WkObg/xRdEvKZzn05jRopmAIwmoC3CiLmqCHPmT5a29vEob/y
+fUo9pexOn7LS4SojoJmsm/5dp6AoKlac48cZU5zwR9AYcq/nvkrfmf2WkObg/xRd
-PFE335k+ujjZCPOu7OwjzDk7M0zMSfnNfDq8bXh16nn+ueBxJ0NzgD1oC6c2PhM+XRQCXCho
+EvKZzn05jRopmAIwmoC3CiLmqCHPmT5a29vEob/yPFE335k+ujjZCPOu7OwjzDk7
-yI8vbfp4dGvCvYqvQAE1bWjqnumZ/7vUPgZN6gDfiAzG2mUxC2SeFBhacgzDvtQls+uuvm+F
+M0zMSfnNfDq8bXh16nn+ueBxJ0NzgD1oC6c2PhM+XRQCXChoyI8vbfp4dGvCvYqv
-nQOUgg2Hh8x2zgoZ7kqV29wjaUPFREuew7e+Th5BxielnzOfVycVXeSuvvIn6cd3g/s8mX1c
+QAE1bWjqnumZ/7vUPgZN6gDfiAzG2mUxC2SeFBhacgzDvtQls+uuvm+FnQOUgg2H
-2kLSXJR7+KdWDrIrR5Az0kwAqFZt6B6QTlDrPswu3mxsm5TzMbny0PsbL/HBM+GZEZCjMXxB
+h8x2zgoZ7kqV29wjaUPFREuew7e+Th5BxielnzOfVycVXeSuvvIn6cd3g/s8mX1c
-8bqV2eSaktjnSlUNX1VXxyOxXA+ZG2jwpr51egi57riVRXokrQARAQABtDRFdGhlcmV1bSBG
+2kLSXJR7+KdWDrIrR5Az0kwAqFZt6B6QTlDrPswu3mxsm5TzMbny0PsbL/HBM+GZ
-b3VuZGF0aW9uIEJ1ZyBCb3VudHkgPGJvdW50eUBldGhlcmV1bS5vcmc+iQIcBBEBCAAGBQJa
+EZCjMXxB8bqV2eSaktjnSlUNX1VXxyOxXA+ZG2jwpr51egi57riVRXokrQARAQAB
-FCY6AAoJEHoMA3Q0/nfveH8P+gJBPo9BXZL8isUfbUWjwLi81Yi70hZqIJUnz64SWTqBzg5b
+tDRFdGhlcmV1bSBGb3VuZGF0aW9uIEJ1ZyBCb3VudHkgPGJvdW50eUBldGhlcmV1
-mCZ69Ji5637THsxQetS2ARabz0DybQ779FhD/IWnqV9T3KuBM/9RzJtuhLzKCyMrAINPMo28
+bS5vcmc+iQJVBBMBCAA/AhsDBgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgBYhBK6W
-rKWdunHHarpuR4m3tL2zWJkle5QVYb+vkZXJJE98PJw+N4IYeKKeCs2ubeqZu636GA0sMzzB
+7ZaeR5sAhPPhf+iNMzT6X2oKBQJl2LD9BQkRdTklAAoJEOiNMzT6X2oKYYYQALkV
-Jn3m/dRRA2va+/zzbr6F6b51ynzbMxWKTsJnstjC8gs8EeI+Zcd6otSyelLtCUkk3h5sTvpV
+wJjWYoVoMuw9D1ybQo4Sqyp6D/XYHXSpqZDO9RlADQisYBfuO7EW75evgZ+54Ajc
-Wv67BNSU0BYsMkxyFi9PUyy07Wixgeas89K5jG1oOtDva/FkpRHrTE/WA5OXDRcLrHJM+SwD
+8gZ2BUkFcSR9z2t0TEkUyjmPDZsaElTTP2Boa2GG5pyziEM6t1cMMY1sP1aotx9H
-CwqcLQqJd09NxwUW1iKeBmPptTiOGu1Gv2o7aEyoaWrHRBO7JuYrQrj6q2B3H1Je0zjAd2qt
+DYwCeMmDv0wTMi6v0C6+/in2hBxbGALRbQKWKd/5ss4OEPe37hG9zAJcBYZg2tes
-09ni2bLwLn4LA+VDpprNTO+eZDprv09s2oFSU6NwziHybovu0y7X4pADGkK2evOM7c86PohX
+O7ceg7LHZpNC1zvMUrBY6os74FJ437f8bankqvVE83/dvTcCDhMsei9LiWS2uo26
-QRQ1M1T16xLj6wP8/Ykwl6v/LUk7iDPXP3GPILnh4YOkwBR3DsCOPn8098xy7FxEELmupRzt
+qiyqeR9lZEj8W5F6UgkQH+UOhamJ9UB3N/h//ipKrwtiv0+jQm9oNG7aIAi3UJgD
-Cj9oC7YAoweeShgUjBPzb+nGY1m6OcFfbUPBgFyMMfwF6joHbiVIO+39+Ut2g2ysZa7KF+yp
+CvSod87H0l7/U8RWzyam/r8eh4KFM75hIVtqEy5jFV2z7x2SibXQi7WRfAysjFLp
-XqVDqyEkYXsOLb25OC7brt8IJEPgBPwcHK5GNag6RfLxnQV+iVZ9KNH1yQgSiQI+BBMBAgAo
+/li8ff6kLDR9IMATuMSF7Ol0O9JMRfSPjRZRtVOwYVIBla3BhfMrjvMMcZMAy/qS
-AhsDBgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgAUCWglh+gUJBaNgWAAKCRDojTM0+l9qCgQ2
+DWx2iFYDMGsswv7hp3lsFOaa1ju95ClZZk3q/z7u5gH7LFAxR0jPaW48ay3CFylW
-D/4udJpV4zGIZW1yNaVvtd3vfKsTLi7GIRJLUBqVb2Yx/uhnN8jTl/tAhCVosCQ1pzvi9kMl
+sDpQpO1DWb9uXBdhOU+MN18uSjqzocga3Wz2C8jhWRvxyFf3SNIybm3zk6W6IIoy
-s8qO1vu2kw5EWFFkwK96roI8pTql3VIjwhRVQrCkR7oAk/eUd1U/nt2q6J4UTYeVgqbq4dsI
+6KmwSRZ30oxizy6zMYw1qJE89zjjumzlZAm0R/Q4Ui+WJhlSyrYbqzqdxYuLgdEL
-ZZTRyPJMD667YpuAIcaah+w9j/E5xksYQdMeprnDrQkkBCb4FIMqfDzBPKvEa8DcQr949K85
+lgKfbv9/t8tNXGGSuCe5L7quOv9k7l2+QmLlg+SJtDlFdGhlcmV1bSBGb3VuZGF0
-kxhr6LDq9i5l4Egxt2JdH8DaR4GLca6+oHy0MyPs/bZOsfmZUObfM2oZgPpqYM96JanhzO1j
+aW9uIFNlY3VyaXR5IFRlYW0gPHNlY3VyaXR5QGV0aGVyZXVtLm9yZz6JAlUEEwEI
-dpnItyBii2pc+kNx5nMOf4eikE/MBv+WUJ0TttWzApGGmFUzDhtuEvRH9NBjtJ/pMrYspIGu
+AD8CGwMGCwkIBwMCBhUIAgkKCwQWAgMBAh4BAheAFiEErpbtlp5HmwCE8+F/6I0z
-O/QNY5KKOKQTvVIlwGcm8dTsSkqtBDSUwZyWbfKfKOI1/RhM9dC3gj5/BOY57DYYV4rdTK01
+NPpfagoFAmXYsP4FCRF1OSUACgkQ6I0zNPpfagoUGA/+LVzXUJrsfi8+ADMF1hru
-ZtYjuhdfs2bhuP1uF/cgnSSZlv8azvf7Egh7tHPnYxvLjfq1bJAhCIX0hNg0a81/ndPAEFky
+wFDcY1r+vM4Ovbk1NhCc/DnV5VG40j5FiQpE81BNiH59sYeZkQm9jFbwevK7Zpuq
-fSko+JPKvdSvsUcSi2QQ4U2HX//jNBjXRfG4F0utgbJnhXzEckz6gqt7wSDZH2oddVuO8Ssc
+RZaG2WGiwU/11xrt5/Qjq7T+vEtd94546kFcBnP8uexZqP4dTi4LHa2on8aRbwzN
-T7sK+CdXthSKnRyuI+sGUpG+6glpKWIfYkWFKNZWuQ+YUatY3QEDHXTIioycSmV8p4d/g/0S
+7RjCpCQhy1TUuk47dyOR1y3ZHrpTwkHpuhwgffaWtxgSyCMYz7fsd5Ukh3eE+Ani
-V6TegidLxY8bXMkbqz+3n6FArRffv5MH7qt3cYkCPgQTAQIAKAUCWCXhOwIbAwUJAeEzgAYL
+90CIUieve2U3o+WPxBD9PRaIPg6LmBhfGxGvC/6tqY9W3Z9xEOVDxC4wdYppQzsg
-CQgHAwIGFQgCCQoLBBYCAwECHgECF4AACgkQ6I0zNPpfagrN/w/+Igp3vtYdNunikw3yHnYf
+Pg7bNnVmlFWHsEk8FuMfY8nTqY3/ojhJxikWKz2V3Y2AbsLEXCvrEg6b4FvmsS97
-Jkm0MmaMDUM9mtsaXVN6xb9n25N3Xa3GWCpmdsbYZ8334tI/oQ4/NHq/bEI5WFH5F1aFkMkm
+8ifEBbFXU8hvMSpMLtO7vLamWyOHq41IXWH6HLNLhDfDzTfpAJ8iYDKGj72YsMzF
-5AJVLuUkipCtmCZ5NkbRPJA9l0uNUUE6uuFXBhf4ddu7jb0jMetRF/kifJHVCCo5fISUNhLp
+0fIjPa6mniMB2RmREAM0Jas3M/6DUw1EzwK1iQofIBoCRPIkR5mxmzjcRB6tVdQa
-7bwcWq9qgDQNZNYMOo4s9WX5Tl+5x4gTZdd2/cAYt49h/wnkw+huM+Jm0GojpLqIQ1jZiffm
+on20/9YTKKBUQAdK0OWW8j1euuULDgNdkN2LBXdQLy/JcQiggU8kOCKL/Lmj5HWP
-otf5rF4L+JhIIdW0W4IIh1v9BhHVllXw+z9oj0PALstT5h8/DuKoIiirFJ4DejU85GR1KKAS
+FNT9rYfnjmCuux3UfJGfhPryujEA0CdIfq1Qf4ldOVzpWYjsMn+yQxAQTorAzF3z
-DeO19G/lSpWj1rSgFv2N2gAOxq0X+BbQTua2jdcY6JpHR4H1JJ2wzfHsHPgDQcgY1rGlmjVF
+iYddP2cw/Nvookay8xywKJnDsaRaWqdQ8Ceox3qSB4LCjQRNR5c3HfvGm3EBdEyI
-aqU73WV4/hzXc/HshK/k4Zd8uD4zypv6rFsZ3UemK0aL2zXLVpV8SPWQ61nS03x675SmDlYr
+zEEpjZ6GHa05DCajqKjtjlm5Ag0EWCXe2AEQAJuCrodM3mAQGLSWQP8xp8ieY2L7
-A80ENfdqvsn00JQuBVIv4Tv0Ub7NfDraDGJCst8rObjBT/0vnBWTBCebb2EsnS2iStIFkWdz
+n1TmBEZiqTjpaV9GOEe51eMOmAPSWiUZviFiie2QxopGUKDZG+CO+Tdm97Q8paMr
-/WXs4L4Yzre1iJwqRjiuqahZR5jHsjAUf2a0O29HVHE7zlFtCFmLPClml2lGQfQOpm5klGZF
+DuCvxgFr18wVjwGEBcjfY53Ij2sWHERkV9YB/ApWZPX0F14BBEW9x937zDx/VdVz
-rmvus+qZ9rt35UgWHPZezykkwtWrFOwspwuCWaPDto6tgbRJZ4ftitpdYYM3dKW9IGJXBwrt
+7N11QswkUFOv7EoOUhFbBOR0s9B5ZuOjR4eX+Di24uIutPFVuePbpt/7b7UNsz/D
-BQrMsu+lp0vDF+yJAlUEEwEIAD8CGwMGCwkIBwMCBhUIAgkKCwQWAgMBAh4BAheAFiEErpbt
+lVq/M+uS+Ieq8p79A/+BrLhANWJa8WAtv3SJ18Ach2w+B+WnRUNLmtUcUvoPvetJ
-lp5HmwCE8+F/6I0zNPpfagoFAmEAEJwFCQycmLgACgkQ6I0zNPpfagpWoBAAhOcbMAUw6Zt0
+F0hGjcjxzyZig2NJHhcO6+A6QApb0tHem+i4UceOnoWvQZ6xFuttvYQbrqI+xH30
-GYzT3sR5/c0iatezPzXEXJf9ebzR8M5uPElXcxcnMx1dvXZmGPXPJKCPa99WCu1NZYy8F+Wj
+xDsWogv1Uwc+baa1H5e9ucqQfatjISpoxtJ2Tb2MZqmQBaV7iwiFIqTvj0Di0aQe
-GTOY9tfIkvSxhys1p/giPAmvid6uQmD+bz7ivktnyzCkDWfMA+l8lsCSEqVlaq6y5T+a6SWB
+XTwpnY32joat9R6E/9XZ4ktqmHYOKgUvUfFGvKsrLzRBAoswlF6TGKCryCt5bzEH
-6TzC2S0MPb/RrC/7DpwyrNYWumvyVJh09adm1Mw/UGgst/sZ8eMaRYEd3X0yyT1CBpX4zp2E
+jO5/0yS6i75Ec2ajw95seMWy0uKCIPr/M/Z77i1SatPT8lMY5KGgYyXxG3RVHF08
-qQj9IEOTizvzv1x2jkHe5ZUeU3+nTBNlhSA+WFHUi0pfBdo2qog3Mv2EC1P2qMKoSdD5tPbA
+iYq6f7gs5dt87ECs5KRjqLfn6CyCSRLLWBMkTQFjdL1q5Pr5iuCVj9NY9D0gnFZU
-zql1yKoHHnXOMsqdftGwbiv2sYXWvrYvmaCd3Ys/viOyt3HOy9uV2ZEtBd9Yqo9x/NZj8QMA
+4qVP7dYinnAm7ZsEpDjbRUuoNjOShbK16X9szUAJS2KkyIhV5Sza4WJGOnMDVbLR
-nY5k8jjrIXbUC89MqrJsQ6xxWQIg5ikMT7DvY0Ln89ev4oJyVvwIQAwCm4jUzFNm9bZLYDOP
+Aco9N1K4aUk9Gt9xABEBAAGJAjwEGAEIACYCGwwWIQSulu2WnkebAITz4X/ojTM0
-5lGJCV7tF5NYVU7NxNM8vescKc40mVNK/pygS5mxhK9QYOUjZsIv8gddrl1TkqrFMuxFnTyN
+l9qCgUCZdiwoAUJEXU4yAAKCRDojTM0+l9qCj2PD/9pbIPRMZtvKIIE+OhOAl/s
-WvzE29wFu/n4N1DkF+ZBqS70SlRvB+Hjz5LrDgEzF1Wf1eA/wq1dZbvMjjDVIc2VGlYp8Cp2
+qfZJXByAM40ELpUhDHqwbOplIEyvXtWfQ5c+kWlG/LPJ2CgLkHyFQDn6tuat82rH
-8ob23c1seTtYXTNYgSR5go4EpH+xi+bIWv01bQQ9xGwBbT5sm4WUeWOcmX4QewzLZ3T/wK9+
+/5VoZyxp16CBAwEgYdycOr9hMGSVKNIJDfV9Bu6VtZnn6fa/swBzGE7eVpXsIoNr
-N4Ye/hmU9O34FwWJOY58EIe0OUV0aGVyZXVtIEZvdW5kYXRpb24gU2VjdXJpdHkgVGVhbSA8
+jeqsogBtzLecG1oHMXRMq7oUqu9c6VNoCx2uxRUOeWW8YuP7h9j6mxIuKKbcpmQ5
-c2VjdXJpdHlAZXRoZXJldW0ub3JnPokCHAQRAQgABgUCWhQmOgAKCRB6DAN0NP5372LSEACT
+RSLNEhJZJsMMFLf8RAQPXmshG1ZixY2ZliNe/TTm6eEfFCw0KcQxoX9LmurLWE9w
-wZk1TASWZj5QF7rmkIM1GEyBxLE+PundNcMgM9Ktj1315ED8SmiukNI4knVS1MY99OIgXhQl
+dIKgn1/nQ04GFnmtcq3hVxY/m9BvzY1jmZXNd4TdpfrPXhi0W/GDn53ERFPJmw5L
-D1foF2GKdTomrwwC4012zTNyUYCY60LnPZ6Z511HG+rZgZtZrbkz0IiUpwAlhGQND77lBqem
+F8ogxzD/ekxzyd9nCCgtzkamtBKDJk35x/MoVWMLjD5k6P+yW7YY4xMQliSJHKss
-J3K+CFX2XpDA/ojui/kqrY4cwMT5P8xPJkwgpRgw/jgdcZyJTsXdHblV9IGU4H1Vd1SgcfAf
+leLnaPpgDBi4KPtLxPswgFqObcy4TNse07rFO4AyHf11FBwMTEfuODCOMnQTpi3z
-Db3YxDUlBtzlp0NkZqxen8irLIXUQvsfuIfRUbUSkWoK/n3U/gOCajAe8ZNF07iX4OWjH4Sw
+Zx6KxvS3BEY36abjvwrqsmt8dJ/+/QXT0e82fo2kJ65sXIszez3e0VUZ8KrMp+wd
-NDA841WhFWcGE+d8+pfMVfPASU3UPKH72uw86b2VgR46Av6voyMFd1pj+yCA+YAhJuOpV4yL
+X0GWYWAfqXws6HrQFYfIpEE0Vz9gXDxEOTFZ2FoVIvIHyRfyDrAIz3wZLmnLGk1h
-QaGg2Z0kVOjuNWK/kBzp1F58DWGh4YBatbhE/UyQOqAAtR7lNf0M3QF9AdrHTxX8oZeqVW3V
+l3CDjHF0Wigv0CacIQ1V1aYp3NhIVwAvShQ+qS5nFgik6UZnjjWibobOm3yQDzll
-Fmi2mk0NwCIUv8SSrZr1dTchp04OtyXe5gZBXSfzncCSRQIUDC8OgNWaOzAaUmK299v4bvye
+6F7hEeTW+gnXEI2gPjfb5w==
-uSCxOysxC7Q1hZtjzFPKdljS81mRlYeUL4fHlJU9R57bg8mriSXLmn7eKrSEDm/EG5T8nRx7
+=b5eA
-TgX2MqJs8sWFxD2+bboVEu75yuFmZ//nmCBApAit9Hr2/sCshGIEpa9MQ6xJCYUxyqeJH+Cc
+-----END PGP PUBLIC KEY BLOCK-----
 Aja0UfXhnK2uvPClpJLIl4RE3gm4OXeE1IkCPgQTAQIAKAIbAwYLCQgHAwIGFQgCCQoLBBYC
 AwECHgECF4AFAloJYfoFCQWjYFgACgkQ6I0zNPpfagr4MQ//cfp3GSbSG8dkqgctW67Fy7cQ
 diiTmx3cwxY+tlI3yrNmdjtrIQMzGdqtY6LNz7aN87F8mXNf+DyVHX9+wd1Y8U+E+hVCTzKC
 sefUfxTz6unD9TTcGqaoelgIPMn4IiKz1RZE6eKpfDWe6q78W1Y6x1bE0qGNSjqT/QSxpezF
 E/OAm/t8RRxVxDtqz8LfH2zLea5zaC+ADj8EqgY9vX9TQa4DyVV8MgOyECCCadJQCD5O5hIA
 B2gVDWwrAUw+KBwskXZ7Iq4reJTKLEmt5z9zgtJ/fABwaCFt66ojwg0/RjbO9cNA3ZwHLGwU
 C6hkb6bRzIoZoMfYxVS84opiqf/Teq+t/XkBYCxbSXTJDA5MKjcVuw3N6YKWbkGP/EfQThe7
 BfAKFwwIw5YmsWjHK8IQj6R6hBxzTz9rz8y1Lu8EAAFfA7OJKaboI2qbOlauH98OuOUmVtr1
 TczHO+pTcgWVN0ytq2/pX5KBf4vbmULNbg3HFRq+gHx8CW+jyXGkcqjbgU/5FwtDxeqRTdGJ
 SyBGNBEU6pBNolyynyaKaaJjJ/biY27pvjymL5rlz95BH3Dn16Z4RRmqwlT6eq/wFYginujg
 CCE1icqOSE+Vjl7V8tV8AcgANkXKdbBE+Q8wlKsGI/kS1w4XFAYcaNHFT8qNeS8TSFXFhvU8
 HylYxO79t56JAj4EEwECACgFAlgl3tgCGwMFCQHhM4AGCwkIBwMCBhUIAgkKCwQWAgMBAh4B
 AheAAAoJEOiNMzT6X2oKmUMP/0hnaL6bVyepAq2LIdvIUbHfagt/Oo/KVfZs4bkM+xJOitJR
 0kwZV9PTihXFdzhL/YNWc2+LtEBtKItqkJZKmWC0E6OPXGVuU6hfFPebuzVccYJfm0Q3Ej19
 VJI9Uomf59Bpak8HYyEED7WVQjoYn7XVPsonwus/9+LDX+c5vutbrUdbjga3KjHbewD93X4O
 wVVoXyHEmU2Plyg8qvzFbNDylCWO7N2McO6SN6+7DitGZGr2+jO+P2R4RT1cnl2V3IRVcWZ0
 OTspPSnRGVr2fFiHN/+v8G/wHPLQcJZFvYPfUGNdcYbTmhWdiY0bEYXFiNrgzCCsyad7eKUR
 WN9QmxqmyqLDjUEDJCAh19ES6Vg3tqGwXk+uNUCoF30ga0TxQt6UXZJDEQFAGeASQ/RqE/q1
 EAuLv8IGM8o7IqKO2pWfLuqsY6dTbKBwDzz9YOJt7EOGuPPQbHxaYStTushZmJnm7hi8lhVG
 jT7qsEJdE95Il+I/mHWnXsCevaXjZugBiyV9yvOq4Hwwe2s1zKfrnQ4u0cadvGAh2eIqum7M
 Y3o6nD47aJ3YmEPX/WnhI56bACa2GmWvUwjI4c0/er3esSPYnuHnM9L8Am4qQwMVSmyU80tC
 MI7A9e13Mvv+RRkYFLJ7PVPdNpbW5jqX1doklFpKf6/XM+B+ngYneU+zgCUBiQJVBBMBCAA/
 AhsDBgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgBYhBK6W7ZaeR5sAhPPhf+iNMzT6X2oKBQJh
 ABCQBQkMnJi4AAoJEOiNMzT6X2oKAv0P+gJ3twBp5efNWyVLcIg4h4cOo9uD0NPvz8/fm2gX
 FoOJL3MeigtPuSVfE9kuTaTuRbArzuFtdvH6G/kcRQvOlO4zyiIRHCk1gDHoIvvtn6RbRhVm
 /Xo4uGIsFHst7n4A7BjicwEK5Op6Ih5Hoq19xz83YSBgBVk2fYEJIRyJiKFbyPjH0eSYe8v+
 Ra5/F85ugLx1P6mMVkW+WPzULns89riW7BGTnZmXFHZp8nO2pkUlcI7F3KRG7l4kmlC50ox6
 DiG/6AJCVulbAClky9C68TmJ/R1RazQxU/9IqVywsydq66tbJQbm5Z7GEti0C5jjbSRJL2oT
 1xC7Rilr85PMREkPL3vegJdgj5PKlffZ/MocD/0EohiQ7wFpejFD4iTljeh0exRUwCRb6655
 9ib34JSQgU8Hl4JJu+mEgd9v0ZHD0/1mMD6fnAR84zca+O3cdASbnQmzTOKcGzLIrkE8TEnU
 +2UZ8Ol7SAAqmBgzY1gKOilUho6dkyCAwNL+QDpvrITDPLEFPsjyB/M2KudZSVEn+Rletju1
 qkMW31qFMNlsbwzMZw+0USeGcs31Cs0B2/WQsro99CExlhS9auUFkmoVjJmYVTIYOM0zuPa4
 OyGspqPhRu5hEsmMDPDWD7Aad5k4GTqogQNnuKyRliZjXXrDZqFD5nfsJSL8Ky/sJGEMuQIN
 BFgl3tgBEACbgq6HTN5gEBi0lkD/MafInmNi+59U5gRGYqk46WlfRjhHudXjDpgD0lolGb4h
 YontkMaKRlCg2Rvgjvk3Zve0PKWjKw7gr8YBa9fMFY8BhAXI32OdyI9rFhxEZFfWAfwKVmT1
 9BdeAQRFvcfd+8w8f1XVc+zddULMJFBTr+xKDlIRWwTkdLPQeWbjo0eHl/g4tuLiLrTxVbnj
 26bf+2+1DbM/w5VavzPrkviHqvKe/QP/gay4QDViWvFgLb90idfAHIdsPgflp0VDS5rVHFL6
 D73rSRdIRo3I8c8mYoNjSR4XDuvgOkAKW9LR3pvouFHHjp6Fr0GesRbrbb2EG66iPsR99MQ7
 FqIL9VMHPm2mtR+XvbnKkH2rYyEqaMbSdk29jGapkAWle4sIhSKk749A4tGkHl08KZ2N9o6G
 rfUehP/V2eJLaph2DioFL1HxRryrKy80QQKLMJRekxigq8greW8xB4zuf9Mkuou+RHNmo8Pe
 bHjFstLigiD6/zP2e+4tUmrT0/JTGOShoGMl8Rt0VRxdPImKun+4LOXbfOxArOSkY6i35+gs
 gkkSy1gTJE0BY3S9auT6+YrglY/TWPQ9IJxWVOKlT+3WIp5wJu2bBKQ420VLqDYzkoWytel/
 bM1ACUtipMiIVeUs2uFiRjpzA1Wy0QHKPTdSuGlJPRrfcQARAQABiQIlBBgBAgAPAhsMBQJa
 CWIIBQkFo2BYAAoJEOiNMzT6X2oKgSwQAKKs7BGF8TyZeIEO2EUK7R2bdQDCdSGZY06tqLFg
 3IHMGxDMb/7FVoa2AEsFgv6xpoebxBB5zkhUk7lslgxvKiSLYjxfNjTBltfiFJ+eQnf+OTs8
 KeR51lLa66rvIH2qUzkNDCCTF45H4wIDpV05AXhBjKYkrDCrtey1rQyFp5fxI+0IQ1UKKXvz
 ZK4GdxhxDbOUSd38MYy93nqcmclGSGK/gF8XiyuVjeifDCM6+T1NQTX0K9lneidcqtBDvlgg
 JTLJtQPO33o5EHzXSiud+dKth1uUhZOFEaYRZoye1YE3yB0TNOOE8fXlvu8iuIAMBSDL9ep6
 sEIaXYwoD60I2gHdWD0lkP0DOjGQpi4ouXM3Edsd5MTi0MDRNTij431kn8T/D0LCgmoUmYYM
 BgbwFhXr67axPZlKjrqR0z3F/Elv0ZPPcVg1tNznsALYQ9Ovl6b5M3cJ5GapbbvNWC7yEE1q
 Scl9HiMxjt/H6aPastH63/7wcN0TslW+zRBy05VNJvpWGStQXcngsSUeJtI1Gd992YNjUJq4
 /Lih6Z1TlwcFVap+cTcDptoUvXYGg/9mRNNPZwErSfIJ0Ibnx9wPVuRN6NiCLOt2mtKp2F1p
 M6AOQPpZ85vEh6I8i6OaO0w/Z0UHBwvpY6jDUliaROsWUQsqz78Z34CVj4cy6vPW2EF4iQIl
 BBgBAgAPBQJYJd7YAhsMBQkB4TOAAAoJEOiNMzT6X2oKTjgP/1ojCVyGyvHMLUgnX0zwrR5Q
 1M5RKFz6kHwKjODVLR3Isp8I935oTQt3DY7yFDI4t0GqbYRQMtxcNEb7maianhK2trCXfhPs
 6/L04igjDf5iTcmzamXN6xnh5xkz06hZJJCMuu4MvKxC9MQHCVKAwjswl/9H9JqIBXAY3E2l
 LpX5P+5jDZuPxS86p3+k4Rrdp9KTGXjiuEleM3zGlz5BLWydqovOck7C2aKh27ETFpDYY0z3
 yQ5AsPJyk1rAr0wrH6+ywmwWlzuQewavnrLnJ2M8iMFXpIhyHeEIU/f7o8f+dQk72rZ9CGzd
 cqig2za/BS3zawZWgbv2vB2elNsIllYLdir45jxBOxx2yvJvEuu4glz78y4oJTCTAYAbMlle
 5gVdPkVcGyvvVS9tinnSaiIzuvWrYHKWll1uYPm2Q1CDs06P5I7bUGAXpgQLUh/XQguy/0sX
 GWqW3FS5JzP+XgcR/7UASvwBdHylubKbeqEpB7G1s+m+8C67qOrc7EQv3Jmy1YDOkhEyNig1
 rmjplLuir3tC1X+D7dHpn7NJe7nMwFx2b2MpMkLA9jPPAGPp/ekcu5sxCe+E0J/4UF++K+CR
 XIxgtzU2UJfp8p9x+ygbx5qHinR0tVRdIzv3ZnGsXrfxnWfSOaB582cU3VRN9INzHHax8ETa
 QVDnGO5uQa+FiQI8BBgBCAAmAhsMFiEErpbtlp5HmwCE8+F/6I0zNPpfagoFAmEAELYFCQyc
 mN4ACgkQ6I0zNPpfagoqAQ/+MnDjBx8JWMd/XjeFoYKx/Oo0ntkInV+ME61JTBls4PdVk+TB
 8PWZdPQHw9SnTvRmykFeznXIRzuxkowjrZYXdPXBxY2b1WyD5V3Ati1TM9vqpaR4osyPs2xy
 I4dzDssh9YvUsIRL99O04/65lGiYeBNuACq+yK/7nD/ErzBkDYJHhMCdadbVWUACxvVIDvro
 yQeVLKMsHqMCd8BTGD7VDs79NXskPnN77pAFnkzS4Z2b8SNzrlgTc5pUiuZHIXPIpEYmsYzh
 ucTU6uI3dN1PbSFHK5tG2pHb4ZrPxY3L20Dgc2Tfu5/SDApZzwvvKTqjdO891MEJ++H+ssOz
 i4O1UeWKs9owWttan9+PI47ozBSKOTxmMqLSQ0f56Np9FJsV0ilGxRKfjhzJ4KniOMUBA7mP
 +m+TmXfVtthJred4sHlJMTJNpt+sCcT6wLMmyc3keIEAu33gsJj3LTpkEA2q+V+ZiP6Q8HRB
 402ITklABSArrPSE/fQU9L8hZ5qmy0Z96z0iyILgVMLuRCCfQOMWhwl8yQWIIaf1yPI07xur
 epy6lH7HmxjjOR7eo0DaSxQGQpThAtFGwkWkFh8yki8j3E42kkrxvEyyYZDXn2YcI3bpqhJx
 PtwCMZUJ3kc/skOrs6bOI19iBNaEoNX5Dllm7UHjOgWNDQkcCuOCxucKano=
 =arte
 -----END PGP PUBLIC KEY BLOCK------
 ```
--- a/accounts/abi/abi.go
+++ b/accounts/abi/abi.go
@ -29,7 +29,7 @@ import (
 )
 // The ABI holds information about a contract's context and available
-// invokable methods. It will allow you to type check function calls and
+// invocable methods. It will allow you to type check function calls and
 // packs data accordingly.
 type ABI struct {
 	Constructor Method
@ -84,7 +84,7 @@ func (abi ABI) Pack(name string, args ...interface{}) ([]byte, error) {
 func (abi ABI) getArguments(name string, data []byte) (Arguments, error) {
 	// since there can't be naming collisions with contracts and events,
-	// we need to decide whether we're calling a method or an event
+	// we need to decide whether we're calling a method, event or an error
 	var args Arguments
 	if method, ok := abi.Methods[name]; ok {
 		if len(data)%32 != 0 {
@ -95,8 +95,11 @@ func (abi ABI) getArguments(name string, data []byte) (Arguments, error) {
 	if event, ok := abi.Events[name]; ok {
 		args = event.Inputs
 	}
 	if err, ok := abi.Errors[name]; ok {
 		args = err.Inputs
 	}
 	if args == nil {
-		return nil, fmt.Errorf("abi: could not locate named method or event: %s", name)
+		return nil, fmt.Errorf("abi: could not locate named method, event or error: %s", name)
 	}
 	return args, nil
 }
@ -251,7 +254,7 @@ var revertSelector = crypto.Keccak256([]byte("Error(string)"))[:4]
 var panicSelector = crypto.Keccak256([]byte("Panic(uint256)"))[:4]
 // panicReasons map is for readable panic codes
-// see this linkage for the deails
+// 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
--- a/accounts/abi/abi_test.go
+++ b/accounts/abi/abi_test.go
@ -29,6 +29,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/internal/testrand"
 )
 const jsondata = `
@ -317,6 +318,38 @@ func TestCustomErrors(t *testing.T) {
 	check("MyError", "MyError(uint256)")
 }
 func TestCustomErrorUnpackIntoInterface(t *testing.T) {
 	t.Parallel()
 	errorName := "MyError"
 	json := fmt.Sprintf(`[{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"}],"name":"%s","type":"error"}]`, errorName)
 	abi, err := JSON(strings.NewReader(json))
 	if err != nil {
 		t.Fatal(err)
 	}
 	type MyError struct {
 		Sender  common.Address
 		Balance *big.Int
 	}
 	sender := testrand.Address()
 	balance := new(big.Int).SetBytes(testrand.Bytes(8))
 	encoded, err := abi.Errors[errorName].Inputs.Pack(sender, balance)
 	if err != nil {
 		t.Fatal(err)
 	}
 	result := MyError{}
 	err = abi.UnpackIntoInterface(&result, errorName, encoded)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if result.Sender != sender {
 		t.Errorf("expected %x got %x", sender, result.Sender)
 	}
 	if result.Balance.Cmp(balance) != 0 {
 		t.Errorf("expected %v got %v", balance, result.Balance)
 	}
 }
 func TestMultiPack(t *testing.T) {
 	t.Parallel()
 	abi, err := JSON(strings.NewReader(jsondata))
@ -1199,7 +1232,6 @@ func TestUnpackRevert(t *testing.T) {
 		{"4e487b7100000000000000000000000000000000000000000000000000000000000000ff", "unknown panic code: 0xff", nil},
 	}
 	for index, c := range cases {
 		index, c := index, c
 		t.Run(fmt.Sprintf("case %d", index), func(t *testing.T) {
 			t.Parallel()
 			got, err := UnpackRevert(common.Hex2Bytes(c.input))
@ -1218,3 +1250,10 @@ func TestUnpackRevert(t *testing.T) {
 		})
 	}
 }
 func TestInternalContractType(t *testing.T) {
 	jsonData := `[{"inputs":[{"components":[{"internalType":"uint256","name":"dailyLimit","type":"uint256"},{"internalType":"uint256","name":"txLimit","type":"uint256"},{"internalType":"uint256","name":"accountDailyLimit","type":"uint256"},{"internalType":"uint256","name":"minAmount","type":"uint256"},{"internalType":"bool","name":"onlyWhitelisted","type":"bool"}],"internalType":"struct IMessagePassingBridge.BridgeLimits","name":"bridgeLimits","type":"tuple"},{"components":[{"internalType":"uint256","name":"lastTransferReset","type":"uint256"},{"internalType":"uint256","name":"bridged24Hours","type":"uint256"}],"internalType":"struct IMessagePassingBridge.AccountLimit","name":"accountDailyLimit","type":"tuple"},{"components":[{"internalType":"uint256","name":"lastTransferReset","type":"uint256"},{"internalType":"uint256","name":"bridged24Hours","type":"uint256"}],"internalType":"struct IMessagePassingBridge.BridgeDailyLimit","name":"bridgeDailyLimit","type":"tuple"},{"internalType":"contract INameService","name":"nameService","type":"INameService"},{"internalType":"bool","name":"isClosed","type":"bool"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"canBridge","outputs":[{"internalType":"bool","name":"isWithinLimit","type":"bool"},{"internalType":"string","name":"error","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint8","name":"decimals","type":"uint8"}],"name":"normalizeFrom18ToTokenDecimals","outputs":[{"internalType":"uint256","name":"normalized","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint8","name":"decimals","type":"uint8"}],"name":"normalizeFromTokenTo18Decimals","outputs":[{"internalType":"uint256","name":"normalized","type":"uint256"}],"stateMutability":"pure","type":"function"}]`
 	if _, err := JSON(strings.NewReader(jsonData)); err != nil {
 		t.Fatal(err)
 	}
 }
--- a/accounts/abi/abigen/bind.go
+++ b/accounts/abi/abigen/bind.go
@ -14,11 +14,11 @@
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-// Package bind generates Ethereum contract Go bindings.
+// Package abigen generates Ethereum contract Go bindings.
 //
 // Detailed usage document and tutorial available on the go-ethereum Wiki page:
-// https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts
+// https://geth.ethereum.org/docs/developers/dapp-developer/native-bindings
-package bind
+package abigen
 import (
 	"bytes"
@ -33,13 +33,6 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 )
 // Lang is a target programming language selector to generate bindings for.
 type Lang int
 const (
 	LangGo Lang = iota
 )
 func isKeyWord(arg string) bool {
 	switch arg {
 	case "break":
@ -79,9 +72,9 @@ 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 opposed to having to
+// enforces compile time type safety and naming convention as 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) {
+func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, libs map[string]string, aliases map[string]string) (string, error) {
 	var (
 		// contracts is the map of each individual contract requested binding
 		contracts = make(map[string]*tmplContract)
@ -125,14 +118,14 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 		for _, input := range evmABI.Constructor.Inputs {
 			if hasStruct(input.Type) {
-				bindStructType[lang](input.Type, structs)
+				bindStructType(input.Type, structs)
 			}
 		}
 		for _, original := range evmABI.Methods {
 			// Normalize the method for capital cases and non-anonymous inputs/outputs
 			normalized := original
-			normalizedName := methodNormalizer[lang](alias(aliases, original.Name))
+			normalizedName := abi.ToCamelCase(alias(aliases, original.Name))
 			// Ensure there is no duplicated identifier
 			var identifiers = callIdentifiers
 			if !original.IsConstant() {
@ -159,17 +152,17 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 					normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j)
 				}
 				if hasStruct(input.Type) {
-					bindStructType[lang](input.Type, structs)
+					bindStructType(input.Type, structs)
 				}
 			}
 			normalized.Outputs = make([]abi.Argument, len(original.Outputs))
 			copy(normalized.Outputs, original.Outputs)
 			for j, output := range normalized.Outputs {
 				if output.Name != "" {
-					normalized.Outputs[j].Name = capitalise(output.Name)
+					normalized.Outputs[j].Name = abi.ToCamelCase(output.Name)
 				}
 				if hasStruct(output.Type) {
-					bindStructType[lang](output.Type, structs)
+					bindStructType(output.Type, structs)
 				}
 			}
 			// Append the methods to the call or transact lists
@ -188,7 +181,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 			normalized := original
 			// Ensure there is no duplicated identifier
-			normalizedName := methodNormalizer[lang](alias(aliases, original.Name))
+			normalizedName := abi.ToCamelCase(alias(aliases, original.Name))
 			// Name shouldn't start with a digit. It will make the generated code invalid.
 			if len(normalizedName) > 0 && unicode.IsDigit(rune(normalizedName[0])) {
 				normalizedName = fmt.Sprintf("E%s", normalizedName)
@ -213,14 +206,14 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 				// Event is a bit special, we need to define event struct in binding,
 				// ensure there is no camel-case-style name conflict.
 				for index := 0; ; index++ {
-					if !used[capitalise(normalized.Inputs[j].Name)] {
+					if !used[abi.ToCamelCase(normalized.Inputs[j].Name)] {
-						used[capitalise(normalized.Inputs[j].Name)] = true
+						used[abi.ToCamelCase(normalized.Inputs[j].Name)] = true
 						break
 					}
 					normalized.Inputs[j].Name = fmt.Sprintf("%s%d", normalized.Inputs[j].Name, index)
 				}
 				if hasStruct(input.Type) {
-					bindStructType[lang](input.Type, structs)
+					bindStructType(input.Type, structs)
 				}
 			}
 			// Append the event to the accumulator list
@ -233,8 +226,9 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 		if evmABI.HasReceive() {
 			receive = &tmplMethod{Original: evmABI.Receive}
 		}
 		contracts[types[i]] = &tmplContract{
-			Type:        capitalise(types[i]),
+			Type:        abi.ToCamelCase(types[i]),
 			InputABI:    strings.ReplaceAll(strippedABI, "\"", "\\\""),
 			InputBin:    strings.TrimPrefix(strings.TrimSpace(bytecodes[i]), "0x"),
 			Constructor: evmABI.Constructor,
@ -245,6 +239,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 			Events:      events,
 			Libraries:   make(map[string]string),
 		}
 		// Function 4-byte signatures are stored in the same sequence
 		// as types, if available.
 		if len(fsigs) > i {
@ -252,7 +247,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 		}
 		// Parse library references.
 		for pattern, name := range libs {
-			matched, err := regexp.Match("__\\$"+pattern+"\\$__", []byte(contracts[types[i]].InputBin))
+			matched, err := regexp.MatchString("__\\$"+pattern+"\\$__", contracts[types[i]].InputBin)
 			if err != nil {
 				log.Error("Could not search for pattern", "pattern", pattern, "contract", contracts[types[i]], "err", err)
 			}
@ -270,6 +265,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 		_, ok := isLib[types[i]]
 		contracts[types[i]].Library = ok
 	}
 	// Generate the contract template data content and render it
 	data := &tmplData{
 		Package:   pkg,
@ -280,36 +276,25 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 	buffer := new(bytes.Buffer)
 	funcs := map[string]interface{}{
-		"bindtype":      bindType[lang],
+		"bindtype":      bindType,
-		"bindtopictype": bindTopicType[lang],
+		"bindtopictype": bindTopicType,
-		"namedtype":     namedType[lang],
+		"capitalise":    abi.ToCamelCase,
 		"capitalise":    capitalise,
 		"decapitalise":  decapitalise,
 	}
-	tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSource[lang]))
+	tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSource))
 	if err := tmpl.Execute(buffer, data); err != nil {
 		return "", err
 	}
-	// For Go bindings pass the code through gofmt to clean it up
+	// Pass the code through gofmt to clean it up
 	if lang == LangGo {
 	code, err := format.Source(buffer.Bytes())
 	if err != nil {
 		return "", fmt.Errorf("%v\n%s", err, buffer)
 	}
 	return string(code), nil
 	}
 	// For all others just return as is for now
 	return buffer.String(), nil
 }
-// bindType is a set of type binders that convert Solidity types to some supported
+// bindBasicType converts basic solidity types(except array, slice and tuple) to Go ones.
-// programming language types.
+func bindBasicType(kind abi.Type) string {
 var bindType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{
 	LangGo: bindTypeGo,
 }
 // bindBasicTypeGo converts basic solidity types(except array, slice and tuple) to Go ones.
 func bindBasicTypeGo(kind abi.Type) string {
 	switch kind.T {
 	case abi.AddressTy:
 		return "common.Address"
@ -332,32 +317,26 @@ func bindBasicTypeGo(kind abi.Type) string {
 	}
 }
-// bindTypeGo converts solidity types to Go ones. Since there is no clear mapping
+// bindType converts solidity types to Go ones. Since there is no clear mapping
 // from all Solidity types to Go ones (e.g. uint17), those that cannot be exactly
 // mapped will use an upscaled type (e.g. BigDecimal).
-func bindTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
+func bindType(kind abi.Type, structs map[string]*tmplStruct) string {
 	switch kind.T {
 	case abi.TupleTy:
 		return structs[kind.TupleRawName+kind.String()].Name
 	case abi.ArrayTy:
-		return fmt.Sprintf("[%d]", kind.Size) + bindTypeGo(*kind.Elem, structs)
+		return fmt.Sprintf("[%d]", kind.Size) + bindType(*kind.Elem, structs)
 	case abi.SliceTy:
-		return "[]" + bindTypeGo(*kind.Elem, structs)
+		return "[]" + bindType(*kind.Elem, structs)
 	default:
-		return bindBasicTypeGo(kind)
+		return bindBasicType(kind)
 	}
 }
-// bindTopicType is a set of type binders that convert Solidity types to some
+// bindTopicType converts a Solidity topic type to a Go one. It is almost the same
 // supported programming language topic types.
 var bindTopicType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{
 	LangGo: bindTopicTypeGo,
 }
 // bindTopicTypeGo converts a Solidity topic type to a Go one. It is almost the same
 // functionality as for simple types, but dynamic types get converted to hashes.
-func bindTopicTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
+func bindTopicType(kind abi.Type, structs map[string]*tmplStruct) string {
-	bound := bindTypeGo(kind, structs)
+	bound := bindType(kind, structs)
 	// todo(rjl493456442) according solidity documentation, indexed event
 	// parameters that are not value types i.e. arrays and structs are not
@ -371,16 +350,10 @@ func bindTopicTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
 	return bound
 }
-// bindStructType is a set of type binders that convert Solidity tuple types to some supported
+// bindStructType converts a Solidity tuple type to a Go one and records the mapping
-// programming language struct definition.
+// in the given map. Notably, this function will resolve and record nested struct
-var bindStructType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{
+// recursively.
-	LangGo: bindStructTypeGo,
+func bindStructType(kind abi.Type, structs map[string]*tmplStruct) string {
 }
 // bindStructTypeGo converts a Solidity tuple type to a Go one and records the mapping
 // in the given map.
 // Notably, this function will resolve and record nested struct recursively.
 func bindStructTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
 	switch kind.T {
 	case abi.TupleTy:
 		// We compose a raw struct name and a canonical parameter expression
@ -398,16 +371,20 @@ func bindStructTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
 			fields []*tmplField
 		)
 		for i, elem := range kind.TupleElems {
-			name := capitalise(kind.TupleRawNames[i])
+			name := abi.ToCamelCase(kind.TupleRawNames[i])
 			name = abi.ResolveNameConflict(name, func(s string) bool { return names[s] })
 			names[name] = true
-			fields = append(fields, &tmplField{Type: bindStructTypeGo(*elem, structs), Name: name, SolKind: *elem})
+			fields = append(fields, &tmplField{
 				Type:    bindStructType(*elem, structs),
 				Name:    name,
 				SolKind: *elem,
 			})
 		}
 		name := kind.TupleRawName
 		if name == "" {
 			name = fmt.Sprintf("Struct%d", len(structs))
 		}
-		name = capitalise(name)
+		name = abi.ToCamelCase(name)
 		structs[id] = &tmplStruct{
 			Name:   name,
@ -415,20 +392,14 @@ func bindStructTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
 		}
 		return name
 	case abi.ArrayTy:
-		return fmt.Sprintf("[%d]", kind.Size) + bindStructTypeGo(*kind.Elem, structs)
+		return fmt.Sprintf("[%d]", kind.Size) + bindStructType(*kind.Elem, structs)
 	case abi.SliceTy:
-		return "[]" + bindStructTypeGo(*kind.Elem, structs)
+		return "[]" + bindStructType(*kind.Elem, structs)
 	default:
-		return bindBasicTypeGo(kind)
+		return bindBasicType(kind)
 	}
 }
 // namedType is a set of functions that transform language specific types to
 // named versions that may be used inside method names.
 var namedType = map[Lang]func(string, abi.Type) string{
 	LangGo: func(string, abi.Type) string { panic("this shouldn't be needed") },
 }
 // alias returns an alias of the given string based on the aliasing rules
 // or returns itself if no rule is matched.
 func alias(aliases map[string]string, n string) string {
@ -438,21 +409,11 @@ func alias(aliases map[string]string, n string) string {
 	return n
 }
 // methodNormalizer is a name transformer that modifies Solidity method names to
 // conform to target language naming conventions.
 var methodNormalizer = map[Lang]func(string) string{
 	LangGo: abi.ToCamelCase,
 }
 // capitalise makes a camel-case string which starts with an upper case character.
 var capitalise = abi.ToCamelCase
 // decapitalise makes a camel-case string which starts with a lower case character.
 func decapitalise(input string) string {
 	if len(input) == 0 {
 		return input
 	}
 	goForm := abi.ToCamelCase(input)
 	return strings.ToLower(goForm[:1]) + goForm[1:]
 }
@ -471,7 +432,7 @@ func structured(args abi.Arguments) bool {
 		}
 		// If the field name is empty when normalized or collides (var, Var, _var, _Var),
 		// we can't organize into a struct
-		field := capitalise(out.Name)
+		field := abi.ToCamelCase(out.Name)
 		if field == "" || exists[field] {
 			return false
 		}
--- a/accounts/abi/abigen/bind_test.go
+++ b/accounts/abi/abigen/bind_test.go
--- a/accounts/abi/abigen/bindv2.go
+++ b/accounts/abi/abigen/bindv2.go
@ -0,0 +1,373 @@
 // Copyright 2024 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Lesser General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 //
 // The go-ethereum library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 // GNU Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 package abigen
 import (
 	"bytes"
 	"fmt"
 	"go/format"
 	"reflect"
 	"regexp"
 	"slices"
 	"sort"
 	"strings"
 	"text/template"
 	"unicode"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 )
 // underlyingBindType returns a string representation of the Go type
 // that corresponds to the given ABI type, panicking if it is not a
 // pointer.
 func underlyingBindType(typ abi.Type) string {
 	goType := typ.GetType()
 	if goType.Kind() != reflect.Pointer {
 		panic("trying to retrieve underlying bind type of non-pointer type.")
 	}
 	return goType.Elem().String()
 }
 // isPointerType returns true if the underlying type is a pointer.
 func isPointerType(typ abi.Type) bool {
 	return typ.GetType().Kind() == reflect.Pointer
 }
 // OLD:
 // binder is used during the conversion of an ABI definition into Go bindings
 // (as part of the execution of BindV2). In contrast to contractBinder, binder
 // contains binding-generation-state that is shared between contracts:
 //
 // a global struct map of structs emitted by all contracts is tracked and expanded.
 // Structs generated in the bindings are not prefixed with the contract name
 // that uses them (to keep the generated bindings less verbose).
 //
 // This contrasts to other per-contract state (constructor/method/event/error,
 // pack/unpack methods) which are guaranteed to be unique because of their
 // association with the uniquely-named owning contract (whether prefixed in the
 // generated symbol name, or as a member method on a contract struct).
 //
 // In addition, binder contains the input alias map. In BindV2, a binder is
 // instantiated to produce a set of tmplContractV2 and tmplStruct objects from
 // the provided ABI definition. These are used as part of the input to rendering
 // the binding template.
 // NEW:
 // binder is used to translate an ABI definition into a set of data-structures
 // that will be used to render the template and produce Go bindings.  This can
 // be thought of as the "backend" that sanitizes the ABI definition to a format
 // that can be directly rendered with minimal complexity in the template.
 //
 // The input data to the template rendering consists of:
 //   - the set of all contracts requested for binding, each containing
 //     methods/events/errors to emit pack/unpack methods for.
 //   - the set of structures defined by the contracts, and created
 //     as part of the binding process.
 type binder struct {
 	// contracts is the map of each individual contract requested binding.
 	// It is keyed by the contract name provided in the ABI definition.
 	contracts map[string]*tmplContractV2
 	// structs is the map of all emitted structs from contracts being bound.
 	// it is keyed by a unique identifier generated from the name of the owning contract
 	// and the solidity type signature of the struct
 	structs map[string]*tmplStruct
 	// aliases is a map for renaming instances of named events/functions/errors
 	// to specified values. it is keyed by source symbol name, and values are
 	// what the replacement name should be.
 	aliases map[string]string
 }
 // BindStructType registers the type to be emitted as a struct in the
 // bindings.
 func (b *binder) BindStructType(typ abi.Type) {
 	bindStructType(typ, b.structs)
 }
 // contractBinder holds state for binding of a single contract. It is a type
 // registry for compiling maps of identifiers that will be emitted in generated
 // bindings.
 type contractBinder struct {
 	binder *binder
 	// all maps are keyed by the original (non-normalized) name of the symbol in question
 	// from the provided ABI definition.
 	calls            map[string]*tmplMethod
 	events           map[string]*tmplEvent
 	errors           map[string]*tmplError
 	callIdentifiers  map[string]bool
 	eventIdentifiers map[string]bool
 	errorIdentifiers map[string]bool
 }
 func newContractBinder(binder *binder) *contractBinder {
 	return &contractBinder{
 		binder,
 		make(map[string]*tmplMethod),
 		make(map[string]*tmplEvent),
 		make(map[string]*tmplError),
 		make(map[string]bool),
 		make(map[string]bool),
 		make(map[string]bool),
 	}
 }
 // registerIdentifier applies alias renaming, name normalization (conversion
 // from snake to camel-case), and registers the normalized name in the specified identifier map.
 // It returns an error if the normalized name already exists in the map.
 func (cb *contractBinder) registerIdentifier(identifiers map[string]bool, original string) (normalized string, err error) {
 	normalized = abi.ToCamelCase(alias(cb.binder.aliases, original))
 	// Name shouldn't start with a digit. It will make the generated code invalid.
 	if len(normalized) > 0 && unicode.IsDigit(rune(normalized[0])) {
 		normalized = fmt.Sprintf("E%s", normalized)
 		normalized = abi.ResolveNameConflict(normalized, func(name string) bool {
 			_, ok := identifiers[name]
 			return ok
 		})
 	}
 	if _, ok := identifiers[normalized]; ok {
 		return "", fmt.Errorf("duplicate symbol '%s'", normalized)
 	}
 	identifiers[normalized] = true
 	return normalized, nil
 }
 // bindMethod registers a method to be emitted in the bindings. The name, inputs
 // and outputs are normalized. If any inputs are struct-type their structs are
 // registered to be emitted in the bindings. Any methods that return more than
 // one output have their results gathered into a struct.
 func (cb *contractBinder) bindMethod(original abi.Method) error {
 	normalized := original
 	normalizedName, err := cb.registerIdentifier(cb.callIdentifiers, original.Name)
 	if err != nil {
 		return err
 	}
 	normalized.Name = normalizedName
 	normalized.Inputs = normalizeArgs(original.Inputs)
 	for _, input := range normalized.Inputs {
 		if hasStruct(input.Type) {
 			cb.binder.BindStructType(input.Type)
 		}
 	}
 	normalized.Outputs = normalizeArgs(original.Outputs)
 	for _, output := range normalized.Outputs {
 		if hasStruct(output.Type) {
 			cb.binder.BindStructType(output.Type)
 		}
 	}
 	var isStructured bool
 	// If the call returns multiple values, gather them into a struct
 	if len(normalized.Outputs) > 1 {
 		isStructured = true
 	}
 	cb.calls[original.Name] = &tmplMethod{
 		Original:   original,
 		Normalized: normalized,
 		Structured: isStructured,
 	}
 	return nil
 }
 // normalize a set of arguments by stripping underscores, giving a generic name
 // in the case where the arg name collides with a reserved Go keyword, and finally
 // converting to camel-case.
 func normalizeArgs(args abi.Arguments) abi.Arguments {
 	args = slices.Clone(args)
 	used := make(map[string]bool)
 	for i, input := range args {
 		if isKeyWord(input.Name) {
 			args[i].Name = fmt.Sprintf("arg%d", i)
 		}
 		args[i].Name = abi.ToCamelCase(args[i].Name)
 		if args[i].Name == "" {
 			args[i].Name = fmt.Sprintf("arg%d", i)
 		} else {
 			args[i].Name = strings.ToLower(args[i].Name[:1]) + args[i].Name[1:]
 		}
 		for index := 0; ; index++ {
 			if !used[args[i].Name] {
 				used[args[i].Name] = true
 				break
 			}
 			args[i].Name = fmt.Sprintf("%s%d", args[i].Name, index)
 		}
 	}
 	return args
 }
 // normalizeErrorOrEventFields normalizes errors/events for emitting through
 // bindings: Any anonymous fields are given generated names.
 func (cb *contractBinder) normalizeErrorOrEventFields(originalInputs abi.Arguments) abi.Arguments {
 	normalizedArguments := normalizeArgs(originalInputs)
 	for _, input := range normalizedArguments {
 		if hasStruct(input.Type) {
 			cb.binder.BindStructType(input.Type)
 		}
 	}
 	return normalizedArguments
 }
 // bindEvent normalizes an event and registers it to be emitted in the bindings.
 func (cb *contractBinder) bindEvent(original abi.Event) error {
 	// Skip anonymous events as they don't support explicit filtering
 	if original.Anonymous {
 		return nil
 	}
 	normalizedName, err := cb.registerIdentifier(cb.eventIdentifiers, original.Name)
 	if err != nil {
 		return err
 	}
 	normalized := original
 	normalized.Name = normalizedName
 	normalized.Inputs = cb.normalizeErrorOrEventFields(original.Inputs)
 	cb.events[original.Name] = &tmplEvent{Original: original, Normalized: normalized}
 	return nil
 }
 // bindError normalizes an error and registers it to be emitted in the bindings.
 func (cb *contractBinder) bindError(original abi.Error) error {
 	normalizedName, err := cb.registerIdentifier(cb.errorIdentifiers, original.Name)
 	if err != nil {
 		return err
 	}
 	normalized := original
 	normalized.Name = normalizedName
 	normalized.Inputs = cb.normalizeErrorOrEventFields(original.Inputs)
 	cb.errors[original.Name] = &tmplError{Original: original, Normalized: normalized}
 	return nil
 }
 // parseLibraryDeps extracts references to library dependencies from the unlinked
 // hex string deployment bytecode.
 func parseLibraryDeps(unlinkedCode string) (res []string) {
 	reMatchSpecificPattern, err := regexp.Compile(`__\$([a-f0-9]+)\$__`)
 	if err != nil {
 		panic(err)
 	}
 	for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(unlinkedCode, -1) {
 		res = append(res, match[1])
 	}
 	return res
 }
 // iterSorted iterates the map in the lexicographic order of the keys calling
 // onItem on each. If the callback returns an error, iteration is halted and
 // the error is returned from iterSorted.
 func iterSorted[V any](inp map[string]V, onItem func(string, V) error) error {
 	var sortedKeys []string
 	for key := range inp {
 		sortedKeys = append(sortedKeys, key)
 	}
 	sort.Strings(sortedKeys)
 	for _, key := range sortedKeys {
 		if err := onItem(key, inp[key]); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 // BindV2 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
 // manually maintain hard coded strings that break on runtime.
 func BindV2(types []string, abis []string, bytecodes []string, pkg string, libs map[string]string, aliases map[string]string) (string, error) {
 	b := binder{
 		contracts: make(map[string]*tmplContractV2),
 		structs:   make(map[string]*tmplStruct),
 		aliases:   aliases,
 	}
 	for i := 0; i < len(types); i++ {
 		// Parse the actual ABI to generate the binding for
 		evmABI, err := abi.JSON(strings.NewReader(abis[i]))
 		if err != nil {
 			return "", err
 		}
 		for _, input := range evmABI.Constructor.Inputs {
 			if hasStruct(input.Type) {
 				bindStructType(input.Type, b.structs)
 			}
 		}
 		cb := newContractBinder(&b)
 		err = iterSorted(evmABI.Methods, func(_ string, original abi.Method) error {
 			return cb.bindMethod(original)
 		})
 		if err != nil {
 			return "", err
 		}
 		err = iterSorted(evmABI.Events, func(_ string, original abi.Event) error {
 			return cb.bindEvent(original)
 		})
 		if err != nil {
 			return "", err
 		}
 		err = iterSorted(evmABI.Errors, func(_ string, original abi.Error) error {
 			return cb.bindError(original)
 		})
 		if err != nil {
 			return "", err
 		}
 		b.contracts[types[i]] = newTmplContractV2(types[i], abis[i], bytecodes[i], evmABI.Constructor, cb)
 	}
 	invertedLibs := make(map[string]string)
 	for pattern, name := range libs {
 		invertedLibs[name] = pattern
 	}
 	data := tmplDataV2{
 		Package:   pkg,
 		Contracts: b.contracts,
 		Libraries: invertedLibs,
 		Structs:   b.structs,
 	}
 	for typ, contract := range data.Contracts {
 		for _, depPattern := range parseLibraryDeps(contract.InputBin) {
 			data.Contracts[typ].Libraries[libs[depPattern]] = depPattern
 		}
 	}
 	buffer := new(bytes.Buffer)
 	funcs := map[string]interface{}{
 		"bindtype":           bindType,
 		"bindtopictype":      bindTopicType,
 		"capitalise":         abi.ToCamelCase,
 		"decapitalise":       decapitalise,
 		"ispointertype":      isPointerType,
 		"underlyingbindtype": underlyingBindType,
 	}
 	tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSourceV2))
 	if err := tmpl.Execute(buffer, data); err != nil {
 		return "", err
 	}
 	// Pass the code through gofmt to clean it up
 	code, err := format.Source(buffer.Bytes())
 	if err != nil {
 		return "", fmt.Errorf("%v\n%s", err, buffer)
 	}
 	return string(code), nil
 }
--- a/accounts/abi/abigen/bindv2_test.go
+++ b/accounts/abi/abigen/bindv2_test.go
--- a/accounts/abi/abigen/source.go.tpl
+++ b/accounts/abi/abigen/source.go.tpl
@ -1,86 +1,3 @@
 // Copyright 2016 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Lesser General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 //
 // The go-ethereum library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 // GNU Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 package bind
 import "github.com/ethereum/go-ethereum/accounts/abi"
 // tmplData is the data structure required to fill the binding template.
 type tmplData struct {
 	Package   string                   // Name of the package to place the generated file in
 	Contracts map[string]*tmplContract // List of contracts to generate into this file
 	Libraries map[string]string        // Map the bytecode's link pattern to the library name
 	Structs   map[string]*tmplStruct   // Contract struct type definitions
 }
 // tmplContract contains the data needed to generate an individual contract binding.
 type tmplContract struct {
 	Type        string                 // Type name of the main contract binding
 	InputABI    string                 // JSON ABI used as the input to generate the binding from
 	InputBin    string                 // Optional EVM bytecode used to generate deploy code from
 	FuncSigs    map[string]string      // Optional map: string signature -> 4-byte signature
 	Constructor abi.Method             // Contract constructor for deploy parametrization
 	Calls       map[string]*tmplMethod // Contract calls that only read state data
 	Transacts   map[string]*tmplMethod // Contract calls that write state data
 	Fallback    *tmplMethod            // Additional special fallback function
 	Receive     *tmplMethod            // Additional special receive function
 	Events      map[string]*tmplEvent  // Contract events accessors
 	Libraries   map[string]string      // Same as tmplData, but filtered to only keep what the contract needs
 	Library     bool                   // Indicator whether the contract is a library
 }
 // tmplMethod is a wrapper around an abi.Method that contains a few preprocessed
 // and cached data fields.
 type tmplMethod struct {
 	Original   abi.Method // Original method as parsed by the abi package
 	Normalized abi.Method // Normalized version of the parsed method (capitalized names, non-anonymous args/returns)
 	Structured bool       // Whether the returns should be accumulated into a struct
 }
 // tmplEvent is a wrapper around an abi.Event that contains a few preprocessed
 // and cached data fields.
 type tmplEvent struct {
 	Original   abi.Event // Original event as parsed by the abi package
 	Normalized abi.Event // Normalized version of the parsed fields
 }
 // tmplField is a wrapper around a struct field with binding language
 // struct type definition and relative filed name.
 type tmplField struct {
 	Type    string   // Field type representation depends on target binding language
 	Name    string   // Field name converted from the raw user-defined field name
 	SolKind abi.Type // Raw abi type information
 }
 // tmplStruct is a wrapper around an abi.tuple and contains an auto-generated
 // struct name.
 type tmplStruct struct {
 	Name   string       // Auto-generated struct name(before solidity v0.5.11) or raw name.
 	Fields []*tmplField // Struct fields definition depends on the binding language.
 }
 // tmplSource is language to template mapping containing all the supported
 // programming languages the package can generate to.
 var tmplSource = map[Lang]string{
 	LangGo: tmplSourceGo,
 }
 // tmplSourceGo is the Go source template that the generated Go contract binding
 // is based on.
 const tmplSourceGo = `
 // Code generated - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
@ -568,4 +485,3 @@ var (
 	{{end}}
 {{end}}
 `
--- a/accounts/abi/abigen/source2.go.tpl
+++ b/accounts/abi/abigen/source2.go.tpl
@ -0,0 +1,238 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package {{.Package}}
 import (
 	"bytes"
 	"math/big"
 	"errors"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 {{$structs := .Structs}}
 {{range $structs}}
 	// {{.Name}} is an auto generated low-level Go binding around an user-defined struct.
 	type {{.Name}} struct {
 	{{range $field := .Fields}}
 	{{capitalise $field.Name}} {{$field.Type}}{{end}}
 	}
 {{end}}
 {{range $contract := .Contracts}}
 	// {{.Type}}MetaData contains all meta data concerning the {{.Type}} contract.
 	var {{.Type}}MetaData = bind.MetaData{
 		ABI: "{{.InputABI}}",
 		{{if (index $.Libraries .Type) -}}
 		ID: "{{index $.Libraries .Type}}",
 		{{ else -}}
 		ID: "{{.Type}}",
 		{{end -}}
 		{{if .InputBin -}}
 		Bin: "0x{{.InputBin}}",
 		{{end -}}
 		{{if .Libraries -}}
 		Deps: []*bind.MetaData{
 		{{- range $name, $pattern := .Libraries}}
 			&{{$name}}MetaData,
 		{{- end}}
 		},
 		{{end}}
 	}
 	// {{.Type}} is an auto generated Go binding around an Ethereum contract.
 	type {{.Type}} struct {
 		abi abi.ABI
 	}
 	// New{{.Type}} creates a new instance of {{.Type}}.
 	func New{{.Type}}() *{{.Type}} {
 		parsed, err := {{.Type}}MetaData.ParseABI()
 		if err != nil {
 			panic(errors.New("invalid ABI: " + err.Error()))
 		}
 		return &{{.Type}}{abi: *parsed}
 	}
 	// Instance creates a wrapper for a deployed contract instance at the given address.
 	// Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 	func (c *{{.Type}}) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 		 return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 	}
 	{{ if .Constructor.Inputs }}
 	// PackConstructor is the Go binding used to pack the parameters required for
 	// contract deployment.
 	//
 	// Solidity: {{.Constructor.String}}
 	func ({{ decapitalise $contract.Type}} *{{$contract.Type}}) PackConstructor({{range .Constructor.Inputs}} {{.Name}} {{bindtype .Type $structs}}, {{end}}) []byte {
 		enc, err := {{ decapitalise $contract.Type}}.abi.Pack("" {{range .Constructor.Inputs}}, {{.Name}}{{end}})
 		if err != nil {
 		   panic(err)
 		}
 		return enc
 	}
 	{{ end }}
 	{{range .Calls}}
 		// Pack{{.Normalized.Name}} is the Go binding used to pack the parameters required for calling
 		// the contract method with ID 0x{{printf "%x" .Original.ID}}.
 		//
 		// Solidity: {{.Original.String}}
 		func ({{ decapitalise $contract.Type}} *{{$contract.Type}}) Pack{{.Normalized.Name}}({{range .Normalized.Inputs}} {{.Name}} {{bindtype .Type $structs}}, {{end}}) []byte {
 			enc, err := {{ decapitalise $contract.Type}}.abi.Pack("{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}})
 			if err != nil {
 				panic(err)
 			}
 			return enc
 		}
 		{{/* Unpack method is needed only when there are return args */}}
 		{{if .Normalized.Outputs }}
 			{{ if .Structured }}
 			// {{.Normalized.Name}}Output serves as a container for the return parameters of contract
 			// method {{ .Normalized.Name }}.
 			type {{.Normalized.Name}}Output struct {
 			  {{range .Normalized.Outputs}}
 			  {{capitalise .Name}} {{bindtype .Type $structs}}{{end}}
 			}
 			{{ end }}
 			// Unpack{{.Normalized.Name}} is the Go binding that unpacks the parameters returned
 			// from invoking the contract method with ID 0x{{printf "%x" .Original.ID}}.
 			//
 			// Solidity: {{.Original.String}}
 			func ({{ decapitalise $contract.Type}} *{{$contract.Type}}) Unpack{{.Normalized.Name}}(data []byte) (
 				{{- if .Structured}} {{.Normalized.Name}}Output,{{else}}
 				{{- range .Normalized.Outputs}} {{bindtype .Type $structs}},{{- end }}
 				{{- end }} error) {
 				out, err := {{ decapitalise $contract.Type}}.abi.Unpack("{{.Original.Name}}", data)
 				{{- if .Structured}}
 				outstruct := new({{.Normalized.Name}}Output)
 				if err != nil {
 					return *outstruct, err
 				}
 				{{- range $i, $t := .Normalized.Outputs}}
 				{{- if ispointertype .Type}}
 					outstruct.{{capitalise .Name}} = abi.ConvertType(out[{{$i}}], new({{underlyingbindtype .Type }})).({{bindtype .Type $structs}})
 				{{- else }}
 					outstruct.{{capitalise .Name}} = *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}})
 				{{- end }}
 				{{- end }}
 				return *outstruct, err
 				{{else}}
 				if err != nil {
 					return {{range $i, $_ := .Normalized.Outputs}}{{if ispointertype .Type}}new({{underlyingbindtype .Type }}), {{else}}*new({{bindtype .Type $structs}}), {{end}}{{end}} err
 				}
 				{{- range $i, $t := .Normalized.Outputs}}
 				{{- if ispointertype .Type }}
 				out{{$i}} := abi.ConvertType(out[{{$i}}], new({{underlyingbindtype .Type}})).({{bindtype .Type $structs}})
 				{{- else }}
 				out{{$i}} := *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}})
 				{{- end }}
 				{{- end}}
 				return {{range $i, $t := .Normalized.Outputs}}out{{$i}}, {{end}} err
                {{- end}}
 			}
 		{{end}}
 	{{end}}
 	{{range .Events}}
 		// {{$contract.Type}}{{.Normalized.Name}} represents a {{.Original.Name}} event raised by the {{$contract.Type}} contract.
 		type {{$contract.Type}}{{.Normalized.Name}} struct {
 			{{- range .Normalized.Inputs}}
 				{{ capitalise .Name}}
 				{{- if .Indexed}} {{ bindtopictype .Type $structs}}{{- else}} {{ bindtype .Type $structs}}{{ end }}
 			{{- end}}
 			Raw *types.Log // Blockchain specific contextual infos
 		}
 		const {{$contract.Type}}{{.Normalized.Name}}EventName = "{{.Original.Name}}"
 		// ContractEventName returns the user-defined event name.
 		func ({{$contract.Type}}{{.Normalized.Name}}) ContractEventName() string {
 			return {{$contract.Type}}{{.Normalized.Name}}EventName
 		}
 		// Unpack{{.Normalized.Name}}Event is the Go binding that unpacks the event data emitted
 		// by contract.
 		//
 		// Solidity: {{.Original.String}}
 		func ({{ decapitalise $contract.Type}} *{{$contract.Type}}) Unpack{{.Normalized.Name}}Event(log *types.Log) (*{{$contract.Type}}{{.Normalized.Name}}, error) {
 			event := "{{.Original.Name}}"
 			if log.Topics[0] != {{ decapitalise $contract.Type}}.abi.Events[event].ID {
 				return nil, errors.New("event signature mismatch")
 			}
 			out := new({{$contract.Type}}{{.Normalized.Name}})
 			if len(log.Data) > 0 {
 				if err := {{ decapitalise $contract.Type}}.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
 					return nil, err
 				}
 			}
 			var indexed abi.Arguments
 			for _, arg := range {{ decapitalise $contract.Type}}.abi.Events[event].Inputs {
 				if arg.Indexed {
 					indexed = append(indexed, arg)
 				}
 			}
 			if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil {
 				return nil, err
 			}
 			out.Raw = log
 			return out, nil
 		}
 	{{end}}
 	{{ if .Errors }}
 	// UnpackError attempts to decode the provided error data using user-defined
 	// error definitions.
 	func ({{ decapitalise $contract.Type}} *{{$contract.Type}}) UnpackError(raw []byte) (any, error) {
 		{{- range $k, $v := .Errors}}
 		if bytes.Equal(raw[:4], {{ decapitalise $contract.Type}}.abi.Errors["{{.Normalized.Name}}"].ID.Bytes()[:4]) {
 			return {{ decapitalise $contract.Type}}.Unpack{{.Normalized.Name}}Error(raw[4:])
 		}
 		{{- end }}
 		return nil, errors.New("Unknown error")
 	}
 	{{ end }}
 	{{range .Errors}}
 		// {{$contract.Type}}{{.Normalized.Name}} represents a {{.Original.Name}} error raised by the {{$contract.Type}} contract.
 		type {{$contract.Type}}{{.Normalized.Name}} struct { {{range .Normalized.Inputs}}
 			{{capitalise .Name}} {{if .Indexed}}{{bindtopictype .Type $structs}}{{else}}{{bindtype .Type $structs}}{{end}}; {{end}}
 		}
 		// ErrorID returns the hash of canonical representation of the error's signature.
 		//
 		// Solidity: {{.Original.String}}
 		func {{$contract.Type}}{{.Normalized.Name}}ErrorID() common.Hash {
 			return common.HexToHash("{{.Original.ID}}")
 		}
 		// Unpack{{.Normalized.Name}}Error is the Go binding used to decode the provided
 		// error data into the corresponding Go error struct.
 		//
 		// Solidity: {{.Original.String}}
 		func ({{ decapitalise $contract.Type}} *{{$contract.Type}}) Unpack{{.Normalized.Name}}Error(raw []byte) (*{{$contract.Type}}{{.Normalized.Name}}, error) {
 			out := new({{$contract.Type}}{{.Normalized.Name}})
 			if err := {{ decapitalise $contract.Type}}.abi.UnpackIntoInterface(out, "{{.Normalized.Name}}", raw); err != nil {
 				return nil, err
 			}
 			return out, nil
 		}
 	{{end}}
 {{end}}
--- a/accounts/abi/abigen/template.go
+++ b/accounts/abi/abigen/template.go
@ -0,0 +1,136 @@
 // Copyright 2016 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Lesser General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 //
 // The go-ethereum library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 // GNU Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 package abigen
 import (
 	_ "embed"
 	"strings"
 	"unicode"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 )
 // tmplData is the data structure required to fill the binding template.
 type tmplData struct {
 	Package   string                   // Name of the package to place the generated file in
 	Contracts map[string]*tmplContract // List of contracts to generate into this file
 	Libraries map[string]string        // Map the bytecode's link pattern to the library name
 	Structs   map[string]*tmplStruct   // Contract struct type definitions
 }
 // tmplContract contains the data needed to generate an individual contract binding.
 type tmplContract struct {
 	Type        string                 // Type name of the main contract binding
 	InputABI    string                 // JSON ABI used as the input to generate the binding from
 	InputBin    string                 // Optional EVM bytecode used to generate deploy code from
 	FuncSigs    map[string]string      // Optional map: string signature -> 4-byte signature
 	Constructor abi.Method             // Contract constructor for deploy parametrization
 	Calls       map[string]*tmplMethod // Contract calls that only read state data
 	Transacts   map[string]*tmplMethod // Contract calls that write state data
 	Fallback    *tmplMethod            // Additional special fallback function
 	Receive     *tmplMethod            // Additional special receive function
 	Events      map[string]*tmplEvent  // Contract events accessors
 	Libraries   map[string]string      // Same as tmplData, but filtered to only keep direct deps that the contract needs
 	Library     bool                   // Indicator whether the contract is a library
 }
 type tmplContractV2 struct {
 	Type        string                 // Type name of the main contract binding
 	InputABI    string                 // JSON ABI used as the input to generate the binding from
 	InputBin    string                 // Optional EVM bytecode used to generate deploy code from
 	Constructor abi.Method             // Contract constructor for deploy parametrization
 	Calls       map[string]*tmplMethod // All contract methods (excluding fallback, receive)
 	Events      map[string]*tmplEvent  // Contract events accessors
 	Libraries   map[string]string      // all direct library dependencies
 	Errors      map[string]*tmplError  // all errors defined
 }
 func newTmplContractV2(typ string, abiStr string, bytecode string, constructor abi.Method, cb *contractBinder) *tmplContractV2 {
 	// Strip any whitespace from the JSON ABI
 	strippedABI := strings.Map(func(r rune) rune {
 		if unicode.IsSpace(r) {
 			return -1
 		}
 		return r
 	}, abiStr)
 	return &tmplContractV2{
 		abi.ToCamelCase(typ),
 		strings.ReplaceAll(strippedABI, "\"", "\\\""),
 		strings.TrimPrefix(strings.TrimSpace(bytecode), "0x"),
 		constructor,
 		cb.calls,
 		cb.events,
 		make(map[string]string),
 		cb.errors,
 	}
 }
 type tmplDataV2 struct {
 	Package   string                     // Name of the package to use for the generated bindings
 	Contracts map[string]*tmplContractV2 // Contracts that will be emitted in the bindings (keyed by contract name)
 	Libraries map[string]string          // Map of the contract's name to link pattern
 	Structs   map[string]*tmplStruct     // Contract struct type definitions
 }
 // tmplMethod is a wrapper around an abi.Method that contains a few preprocessed
 // and cached data fields.
 type tmplMethod struct {
 	Original   abi.Method // Original method as parsed by the abi package
 	Normalized abi.Method // Normalized version of the parsed method (capitalized names, non-anonymous args/returns)
 	Structured bool       // Whether the returns should be accumulated into a struct
 }
 // tmplEvent is a wrapper around an abi.Event that contains a few preprocessed
 // and cached data fields.
 type tmplEvent struct {
 	Original   abi.Event // Original event as parsed by the abi package
 	Normalized abi.Event // Normalized version of the parsed fields
 }
 // tmplError is a wrapper around an abi.Error that contains a few preprocessed
 // and cached data fields.
 type tmplError struct {
 	Original   abi.Error
 	Normalized abi.Error
 }
 // tmplField is a wrapper around a struct field with binding language
 // struct type definition and relative filed name.
 type tmplField struct {
 	Type    string   // Field type representation depends on target binding language
 	Name    string   // Field name converted from the raw user-defined field name
 	SolKind abi.Type // Raw abi type information
 }
 // tmplStruct is a wrapper around an abi.tuple and contains an auto-generated
 // struct name.
 type tmplStruct struct {
 	Name   string       // Auto-generated struct name(before solidity v0.5.11) or raw name.
 	Fields []*tmplField // Struct fields definition depends on the binding language.
 }
 // tmplSource is the Go source template that the generated Go contract binding
 // is based on.
 //
 //go:embed source.go.tpl
 var tmplSource string
 // tmplSourceV2 is the Go source template that the generated Go contract binding
 // for abigen v2 is based on.
 //
 //go:embed source2.go.tpl
 var tmplSourceV2 string
--- a/accounts/abi/abigen/testdata/v2/callbackparam.go.txt
+++ b/accounts/abi/abigen/testdata/v2/callbackparam.go.txt
@ -0,0 +1,64 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // CallbackParamMetaData contains all meta data concerning the CallbackParam contract.
 var CallbackParamMetaData = bind.MetaData{
 	ABI: "[{\"constant\":false,\"inputs\":[{\"name\":\"callback\",\"type\":\"function\"}],\"name\":\"test\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
 	ID:  "949f96f86d3c2e1bcc15563ad898beaaca",
 	Bin: "0x608060405234801561001057600080fd5b5061015e806100206000396000f3fe60806040526004361061003b576000357c010000000000000000000000000000000000000000000000000000000090048063d7a5aba214610040575b600080fd5b34801561004c57600080fd5b506100be6004803603602081101561006357600080fd5b810190808035806c0100000000000000000000000090049068010000000000000000900463ffffffff1677ffffffffffffffffffffffffffffffffffffffffffffffff169091602001919093929190939291905050506100c0565b005b818160016040518263ffffffff167c010000000000000000000000000000000000000000000000000000000002815260040180828152602001915050600060405180830381600087803b15801561011657600080fd5b505af115801561012a573d6000803e3d6000fd5b50505050505056fea165627a7a7230582062f87455ff84be90896dbb0c4e4ddb505c600d23089f8e80a512548440d7e2580029",
 }
 // CallbackParam is an auto generated Go binding around an Ethereum contract.
 type CallbackParam struct {
 	abi abi.ABI
 }
 // NewCallbackParam creates a new instance of CallbackParam.
 func NewCallbackParam() *CallbackParam {
 	parsed, err := CallbackParamMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &CallbackParam{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *CallbackParam) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackTest is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xd7a5aba2.
 //
 // Solidity: function test(function callback) returns()
 func (callbackParam *CallbackParam) PackTest(callback [24]byte) []byte {
 	enc, err := callbackParam.abi.Pack("test", callback)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
--- a/accounts/abi/abigen/testdata/v2/crowdsale.go.txt
+++ b/accounts/abi/abigen/testdata/v2/crowdsale.go.txt
@ -0,0 +1,304 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // CrowdsaleMetaData contains all meta data concerning the Crowdsale contract.
 var CrowdsaleMetaData = bind.MetaData{
 	ABI: "[{\"constant\":false,\"inputs\":[],\"name\":\"checkGoalReached\",\"outputs\":[],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"deadline\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"beneficiary\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"tokenReward\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"fundingGoal\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"amountRaised\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"price\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"funders\",\"outputs\":[{\"name\":\"addr\",\"type\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"inputs\":[{\"name\":\"ifSuccessfulSendTo\",\"type\":\"address\"},{\"name\":\"fundingGoalInEthers\",\"type\":\"uint256\"},{\"name\":\"durationInMinutes\",\"type\":\"uint256\"},{\"name\":\"etherCostOfEachToken\",\"type\":\"uint256\"},{\"name\":\"addressOfTokenUsedAsReward\",\"type\":\"address\"}],\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"backer\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"isContribution\",\"type\":\"bool\"}],\"name\":\"FundTransfer\",\"type\":\"event\"}]",
 	ID:  "84d7e935785c5c648282d326307bb8fa0d",
 	Bin: "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",
 }
 // Crowdsale is an auto generated Go binding around an Ethereum contract.
 type Crowdsale struct {
 	abi abi.ABI
 }
 // NewCrowdsale creates a new instance of Crowdsale.
 func NewCrowdsale() *Crowdsale {
 	parsed, err := CrowdsaleMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &Crowdsale{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *Crowdsale) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackConstructor is the Go binding used to pack the parameters required for
 // contract deployment.
 //
 // Solidity: constructor(address ifSuccessfulSendTo, uint256 fundingGoalInEthers, uint256 durationInMinutes, uint256 etherCostOfEachToken, address addressOfTokenUsedAsReward) returns()
 func (crowdsale *Crowdsale) PackConstructor(ifSuccessfulSendTo common.Address, fundingGoalInEthers *big.Int, durationInMinutes *big.Int, etherCostOfEachToken *big.Int, addressOfTokenUsedAsReward common.Address) []byte {
 	enc, err := crowdsale.abi.Pack("", ifSuccessfulSendTo, fundingGoalInEthers, durationInMinutes, etherCostOfEachToken, addressOfTokenUsedAsReward)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackAmountRaised is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x7b3e5e7b.
 //
 // Solidity: function amountRaised() returns(uint256)
 func (crowdsale *Crowdsale) PackAmountRaised() []byte {
 	enc, err := crowdsale.abi.Pack("amountRaised")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackAmountRaised is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x7b3e5e7b.
 //
 // Solidity: function amountRaised() returns(uint256)
 func (crowdsale *Crowdsale) UnpackAmountRaised(data []byte) (*big.Int, error) {
 	out, err := crowdsale.abi.Unpack("amountRaised", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
 // PackBeneficiary is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x38af3eed.
 //
 // Solidity: function beneficiary() returns(address)
 func (crowdsale *Crowdsale) PackBeneficiary() []byte {
 	enc, err := crowdsale.abi.Pack("beneficiary")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackBeneficiary is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x38af3eed.
 //
 // Solidity: function beneficiary() returns(address)
 func (crowdsale *Crowdsale) UnpackBeneficiary(data []byte) (common.Address, error) {
 	out, err := crowdsale.abi.Unpack("beneficiary", data)
 	if err != nil {
 		return *new(common.Address), err
 	}
 	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
 	return out0, err
 }
 // PackCheckGoalReached is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x01cb3b20.
 //
 // Solidity: function checkGoalReached() returns()
 func (crowdsale *Crowdsale) PackCheckGoalReached() []byte {
 	enc, err := crowdsale.abi.Pack("checkGoalReached")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackDeadline is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x29dcb0cf.
 //
 // Solidity: function deadline() returns(uint256)
 func (crowdsale *Crowdsale) PackDeadline() []byte {
 	enc, err := crowdsale.abi.Pack("deadline")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackDeadline is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x29dcb0cf.
 //
 // Solidity: function deadline() returns(uint256)
 func (crowdsale *Crowdsale) UnpackDeadline(data []byte) (*big.Int, error) {
 	out, err := crowdsale.abi.Unpack("deadline", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
 // PackFunders is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xdc0d3dff.
 //
 // Solidity: function funders(uint256 ) returns(address addr, uint256 amount)
 func (crowdsale *Crowdsale) PackFunders(arg0 *big.Int) []byte {
 	enc, err := crowdsale.abi.Pack("funders", arg0)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // FundersOutput serves as a container for the return parameters of contract
 // method Funders.
 type FundersOutput struct {
 	Addr   common.Address
 	Amount *big.Int
 }
 // UnpackFunders is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0xdc0d3dff.
 //
 // Solidity: function funders(uint256 ) returns(address addr, uint256 amount)
 func (crowdsale *Crowdsale) UnpackFunders(data []byte) (FundersOutput, error) {
 	out, err := crowdsale.abi.Unpack("funders", data)
 	outstruct := new(FundersOutput)
 	if err != nil {
 		return *outstruct, err
 	}
 	outstruct.Addr = *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
 	outstruct.Amount = abi.ConvertType(out[1], new(big.Int)).(*big.Int)
 	return *outstruct, err
 }
 // PackFundingGoal is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x7a3a0e84.
 //
 // Solidity: function fundingGoal() returns(uint256)
 func (crowdsale *Crowdsale) PackFundingGoal() []byte {
 	enc, err := crowdsale.abi.Pack("fundingGoal")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackFundingGoal is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x7a3a0e84.
 //
 // Solidity: function fundingGoal() returns(uint256)
 func (crowdsale *Crowdsale) UnpackFundingGoal(data []byte) (*big.Int, error) {
 	out, err := crowdsale.abi.Unpack("fundingGoal", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
 // PackPrice is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xa035b1fe.
 //
 // Solidity: function price() returns(uint256)
 func (crowdsale *Crowdsale) PackPrice() []byte {
 	enc, err := crowdsale.abi.Pack("price")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackPrice is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0xa035b1fe.
 //
 // Solidity: function price() returns(uint256)
 func (crowdsale *Crowdsale) UnpackPrice(data []byte) (*big.Int, error) {
 	out, err := crowdsale.abi.Unpack("price", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
 // PackTokenReward is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x6e66f6e9.
 //
 // Solidity: function tokenReward() returns(address)
 func (crowdsale *Crowdsale) PackTokenReward() []byte {
 	enc, err := crowdsale.abi.Pack("tokenReward")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackTokenReward is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x6e66f6e9.
 //
 // Solidity: function tokenReward() returns(address)
 func (crowdsale *Crowdsale) UnpackTokenReward(data []byte) (common.Address, error) {
 	out, err := crowdsale.abi.Unpack("tokenReward", data)
 	if err != nil {
 		return *new(common.Address), err
 	}
 	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
 	return out0, err
 }
 // CrowdsaleFundTransfer represents a FundTransfer event raised by the Crowdsale contract.
 type CrowdsaleFundTransfer struct {
 	Backer         common.Address
 	Amount         *big.Int
 	IsContribution bool
 	Raw            *types.Log // Blockchain specific contextual infos
 }
 const CrowdsaleFundTransferEventName = "FundTransfer"
 // ContractEventName returns the user-defined event name.
 func (CrowdsaleFundTransfer) ContractEventName() string {
 	return CrowdsaleFundTransferEventName
 }
 // UnpackFundTransferEvent is the Go binding that unpacks the event data emitted
 // by contract.
 //
 // Solidity: event FundTransfer(address backer, uint256 amount, bool isContribution)
 func (crowdsale *Crowdsale) UnpackFundTransferEvent(log *types.Log) (*CrowdsaleFundTransfer, error) {
 	event := "FundTransfer"
 	if log.Topics[0] != crowdsale.abi.Events[event].ID {
 		return nil, errors.New("event signature mismatch")
 	}
 	out := new(CrowdsaleFundTransfer)
 	if len(log.Data) > 0 {
 		if err := crowdsale.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
 			return nil, err
 		}
 	}
 	var indexed abi.Arguments
 	for _, arg := range crowdsale.abi.Events[event].Inputs {
 		if arg.Indexed {
 			indexed = append(indexed, arg)
 		}
 	}
 	if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil {
 		return nil, err
 	}
 	out.Raw = log
 	return out, nil
 }
--- a/accounts/abi/abigen/testdata/v2/dao.go.txt
+++ b/accounts/abi/abigen/testdata/v2/dao.go.txt
--- a/accounts/abi/abigen/testdata/v2/deeplynestedarray.go.txt
+++ b/accounts/abi/abigen/testdata/v2/deeplynestedarray.go.txt
@ -0,0 +1,114 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // DeeplyNestedArrayMetaData contains all meta data concerning the DeeplyNestedArray contract.
 var DeeplyNestedArrayMetaData = bind.MetaData{
 	ABI: "[{\"constant\":false,\"inputs\":[{\"name\":\"arr\",\"type\":\"uint64[3][4][5]\"}],\"name\":\"storeDeepUintArray\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"retrieveDeepArray\",\"outputs\":[{\"name\":\"\",\"type\":\"uint64[3][4][5]\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"deepUint64Array\",\"outputs\":[{\"name\":\"\",\"type\":\"uint64\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]",
 	ID:  "3a44c26b21f02743d5dbeb02d24a67bf41",
 	Bin: "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",
 }
 // DeeplyNestedArray is an auto generated Go binding around an Ethereum contract.
 type DeeplyNestedArray struct {
 	abi abi.ABI
 }
 // NewDeeplyNestedArray creates a new instance of DeeplyNestedArray.
 func NewDeeplyNestedArray() *DeeplyNestedArray {
 	parsed, err := DeeplyNestedArrayMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &DeeplyNestedArray{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *DeeplyNestedArray) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackDeepUint64Array is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x98ed1856.
 //
 // Solidity: function deepUint64Array(uint256 , uint256 , uint256 ) view returns(uint64)
 func (deeplyNestedArray *DeeplyNestedArray) PackDeepUint64Array(arg0 *big.Int, arg1 *big.Int, arg2 *big.Int) []byte {
 	enc, err := deeplyNestedArray.abi.Pack("deepUint64Array", arg0, arg1, arg2)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackDeepUint64Array is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x98ed1856.
 //
 // Solidity: function deepUint64Array(uint256 , uint256 , uint256 ) view returns(uint64)
 func (deeplyNestedArray *DeeplyNestedArray) UnpackDeepUint64Array(data []byte) (uint64, error) {
 	out, err := deeplyNestedArray.abi.Unpack("deepUint64Array", data)
 	if err != nil {
 		return *new(uint64), err
 	}
 	out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64)
 	return out0, err
 }
 // PackRetrieveDeepArray is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x8ed4573a.
 //
 // Solidity: function retrieveDeepArray() view returns(uint64[3][4][5])
 func (deeplyNestedArray *DeeplyNestedArray) PackRetrieveDeepArray() []byte {
 	enc, err := deeplyNestedArray.abi.Pack("retrieveDeepArray")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackRetrieveDeepArray is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x8ed4573a.
 //
 // Solidity: function retrieveDeepArray() view returns(uint64[3][4][5])
 func (deeplyNestedArray *DeeplyNestedArray) UnpackRetrieveDeepArray(data []byte) ([5][4][3]uint64, error) {
 	out, err := deeplyNestedArray.abi.Unpack("retrieveDeepArray", data)
 	if err != nil {
 		return *new([5][4][3]uint64), err
 	}
 	out0 := *abi.ConvertType(out[0], new([5][4][3]uint64)).(*[5][4][3]uint64)
 	return out0, err
 }
 // PackStoreDeepUintArray is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x34424855.
 //
 // Solidity: function storeDeepUintArray(uint64[3][4][5] arr) returns()
 func (deeplyNestedArray *DeeplyNestedArray) PackStoreDeepUintArray(arr [5][4][3]uint64) []byte {
 	enc, err := deeplyNestedArray.abi.Pack("storeDeepUintArray", arr)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
--- a/accounts/abi/abigen/testdata/v2/empty.go.txt
+++ b/accounts/abi/abigen/testdata/v2/empty.go.txt
@ -0,0 +1,52 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // EmptyMetaData contains all meta data concerning the Empty contract.
 var EmptyMetaData = bind.MetaData{
 	ABI: "[]",
 	ID:  "c4ce3210982aa6fc94dabe46dc1dbf454d",
 	Bin: "0x606060405260068060106000396000f3606060405200",
 }
 // Empty is an auto generated Go binding around an Ethereum contract.
 type Empty struct {
 	abi abi.ABI
 }
 // NewEmpty creates a new instance of Empty.
 func NewEmpty() *Empty {
 	parsed, err := EmptyMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &Empty{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *Empty) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
--- a/accounts/abi/abigen/testdata/v2/eventchecker.go.txt
+++ b/accounts/abi/abigen/testdata/v2/eventchecker.go.txt
@ -0,0 +1,261 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // EventCheckerMetaData contains all meta data concerning the EventChecker contract.
 var EventCheckerMetaData = bind.MetaData{
 	ABI: "[{\"type\":\"event\",\"name\":\"empty\",\"inputs\":[]},{\"type\":\"event\",\"name\":\"indexed\",\"inputs\":[{\"name\":\"addr\",\"type\":\"address\",\"indexed\":true},{\"name\":\"num\",\"type\":\"int256\",\"indexed\":true}]},{\"type\":\"event\",\"name\":\"mixed\",\"inputs\":[{\"name\":\"addr\",\"type\":\"address\",\"indexed\":true},{\"name\":\"num\",\"type\":\"int256\"}]},{\"type\":\"event\",\"name\":\"anonymous\",\"anonymous\":true,\"inputs\":[]},{\"type\":\"event\",\"name\":\"dynamic\",\"inputs\":[{\"name\":\"idxStr\",\"type\":\"string\",\"indexed\":true},{\"name\":\"idxDat\",\"type\":\"bytes\",\"indexed\":true},{\"name\":\"str\",\"type\":\"string\"},{\"name\":\"dat\",\"type\":\"bytes\"}]},{\"type\":\"event\",\"name\":\"unnamed\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"indexed\":true},{\"name\":\"\",\"type\":\"uint256\",\"indexed\":true}]}]",
 	ID:  "253d421f98e29b25315bde79c1251ab27c",
 }
 // EventChecker is an auto generated Go binding around an Ethereum contract.
 type EventChecker struct {
 	abi abi.ABI
 }
 // NewEventChecker creates a new instance of EventChecker.
 func NewEventChecker() *EventChecker {
 	parsed, err := EventCheckerMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &EventChecker{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *EventChecker) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // EventCheckerDynamic represents a dynamic event raised by the EventChecker contract.
 type EventCheckerDynamic struct {
 	IdxStr common.Hash
 	IdxDat common.Hash
 	Str    string
 	Dat    []byte
 	Raw    *types.Log // Blockchain specific contextual infos
 }
 const EventCheckerDynamicEventName = "dynamic"
 // ContractEventName returns the user-defined event name.
 func (EventCheckerDynamic) ContractEventName() string {
 	return EventCheckerDynamicEventName
 }
 // UnpackDynamicEvent is the Go binding that unpacks the event data emitted
 // by contract.
 //
 // Solidity: event dynamic(string indexed idxStr, bytes indexed idxDat, string str, bytes dat)
 func (eventChecker *EventChecker) UnpackDynamicEvent(log *types.Log) (*EventCheckerDynamic, error) {
 	event := "dynamic"
 	if log.Topics[0] != eventChecker.abi.Events[event].ID {
 		return nil, errors.New("event signature mismatch")
 	}
 	out := new(EventCheckerDynamic)
 	if len(log.Data) > 0 {
 		if err := eventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
 			return nil, err
 		}
 	}
 	var indexed abi.Arguments
 	for _, arg := range eventChecker.abi.Events[event].Inputs {
 		if arg.Indexed {
 			indexed = append(indexed, arg)
 		}
 	}
 	if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil {
 		return nil, err
 	}
 	out.Raw = log
 	return out, nil
 }
 // EventCheckerEmpty represents a empty event raised by the EventChecker contract.
 type EventCheckerEmpty struct {
 	Raw *types.Log // Blockchain specific contextual infos
 }
 const EventCheckerEmptyEventName = "empty"
 // ContractEventName returns the user-defined event name.
 func (EventCheckerEmpty) ContractEventName() string {
 	return EventCheckerEmptyEventName
 }
 // UnpackEmptyEvent is the Go binding that unpacks the event data emitted
 // by contract.
 //
 // Solidity: event empty()
 func (eventChecker *EventChecker) UnpackEmptyEvent(log *types.Log) (*EventCheckerEmpty, error) {
 	event := "empty"
 	if log.Topics[0] != eventChecker.abi.Events[event].ID {
 		return nil, errors.New("event signature mismatch")
 	}
 	out := new(EventCheckerEmpty)
 	if len(log.Data) > 0 {
 		if err := eventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
 			return nil, err
 		}
 	}
 	var indexed abi.Arguments
 	for _, arg := range eventChecker.abi.Events[event].Inputs {
 		if arg.Indexed {
 			indexed = append(indexed, arg)
 		}
 	}
 	if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil {
 		return nil, err
 	}
 	out.Raw = log
 	return out, nil
 }
 // EventCheckerIndexed represents a indexed event raised by the EventChecker contract.
 type EventCheckerIndexed struct {
 	Addr common.Address
 	Num  *big.Int
 	Raw  *types.Log // Blockchain specific contextual infos
 }
 const EventCheckerIndexedEventName = "indexed"
 // ContractEventName returns the user-defined event name.
 func (EventCheckerIndexed) ContractEventName() string {
 	return EventCheckerIndexedEventName
 }
 // UnpackIndexedEvent is the Go binding that unpacks the event data emitted
 // by contract.
 //
 // Solidity: event indexed(address indexed addr, int256 indexed num)
 func (eventChecker *EventChecker) UnpackIndexedEvent(log *types.Log) (*EventCheckerIndexed, error) {
 	event := "indexed"
 	if log.Topics[0] != eventChecker.abi.Events[event].ID {
 		return nil, errors.New("event signature mismatch")
 	}
 	out := new(EventCheckerIndexed)
 	if len(log.Data) > 0 {
 		if err := eventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
 			return nil, err
 		}
 	}
 	var indexed abi.Arguments
 	for _, arg := range eventChecker.abi.Events[event].Inputs {
 		if arg.Indexed {
 			indexed = append(indexed, arg)
 		}
 	}
 	if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil {
 		return nil, err
 	}
 	out.Raw = log
 	return out, nil
 }
 // EventCheckerMixed represents a mixed event raised by the EventChecker contract.
 type EventCheckerMixed struct {
 	Addr common.Address
 	Num  *big.Int
 	Raw  *types.Log // Blockchain specific contextual infos
 }
 const EventCheckerMixedEventName = "mixed"
 // ContractEventName returns the user-defined event name.
 func (EventCheckerMixed) ContractEventName() string {
 	return EventCheckerMixedEventName
 }
 // UnpackMixedEvent is the Go binding that unpacks the event data emitted
 // by contract.
 //
 // Solidity: event mixed(address indexed addr, int256 num)
 func (eventChecker *EventChecker) UnpackMixedEvent(log *types.Log) (*EventCheckerMixed, error) {
 	event := "mixed"
 	if log.Topics[0] != eventChecker.abi.Events[event].ID {
 		return nil, errors.New("event signature mismatch")
 	}
 	out := new(EventCheckerMixed)
 	if len(log.Data) > 0 {
 		if err := eventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
 			return nil, err
 		}
 	}
 	var indexed abi.Arguments
 	for _, arg := range eventChecker.abi.Events[event].Inputs {
 		if arg.Indexed {
 			indexed = append(indexed, arg)
 		}
 	}
 	if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil {
 		return nil, err
 	}
 	out.Raw = log
 	return out, nil
 }
 // EventCheckerUnnamed represents a unnamed event raised by the EventChecker contract.
 type EventCheckerUnnamed struct {
 	Arg0 *big.Int
 	Arg1 *big.Int
 	Raw  *types.Log // Blockchain specific contextual infos
 }
 const EventCheckerUnnamedEventName = "unnamed"
 // ContractEventName returns the user-defined event name.
 func (EventCheckerUnnamed) ContractEventName() string {
 	return EventCheckerUnnamedEventName
 }
 // UnpackUnnamedEvent is the Go binding that unpacks the event data emitted
 // by contract.
 //
 // Solidity: event unnamed(uint256 indexed arg0, uint256 indexed arg1)
 func (eventChecker *EventChecker) UnpackUnnamedEvent(log *types.Log) (*EventCheckerUnnamed, error) {
 	event := "unnamed"
 	if log.Topics[0] != eventChecker.abi.Events[event].ID {
 		return nil, errors.New("event signature mismatch")
 	}
 	out := new(EventCheckerUnnamed)
 	if len(log.Data) > 0 {
 		if err := eventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
 			return nil, err
 		}
 	}
 	var indexed abi.Arguments
 	for _, arg := range eventChecker.abi.Events[event].Inputs {
 		if arg.Indexed {
 			indexed = append(indexed, arg)
 		}
 	}
 	if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil {
 		return nil, err
 	}
 	out.Raw = log
 	return out, nil
 }
--- a/accounts/abi/abigen/testdata/v2/getter.go.txt
+++ b/accounts/abi/abigen/testdata/v2/getter.go.txt
@ -0,0 +1,89 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // GetterMetaData contains all meta data concerning the Getter contract.
 var GetterMetaData = bind.MetaData{
 	ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"getter\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"\",\"type\":\"int256\"},{\"name\":\"\",\"type\":\"bytes32\"}],\"type\":\"function\"}]",
 	ID:  "e23a74c8979fe93c9fff15e4f51535ad54",
 	Bin: "0x606060405260dc8060106000396000f3606060405260e060020a6000350463993a04b78114601a575b005b600060605260c0604052600260809081527f486900000000000000000000000000000000000000000000000000000000000060a05260017fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060e0829052610100819052606060c0908152600261012081905281906101409060a09080838184600060046012f1505081517fffff000000000000000000000000000000000000000000000000000000000000169091525050604051610160819003945092505050f3",
 }
 // Getter is an auto generated Go binding around an Ethereum contract.
 type Getter struct {
 	abi abi.ABI
 }
 // NewGetter creates a new instance of Getter.
 func NewGetter() *Getter {
 	parsed, err := GetterMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &Getter{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *Getter) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackGetter is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x993a04b7.
 //
 // Solidity: function getter() returns(string, int256, bytes32)
 func (getter *Getter) PackGetter() []byte {
 	enc, err := getter.abi.Pack("getter")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // GetterOutput serves as a container for the return parameters of contract
 // method Getter.
 type GetterOutput struct {
 	Arg0 string
 	Arg1 *big.Int
 	Arg2 [32]byte
 }
 // UnpackGetter is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x993a04b7.
 //
 // Solidity: function getter() returns(string, int256, bytes32)
 func (getter *Getter) UnpackGetter(data []byte) (GetterOutput, error) {
 	out, err := getter.abi.Unpack("getter", data)
 	outstruct := new(GetterOutput)
 	if err != nil {
 		return *outstruct, err
 	}
 	outstruct.Arg0 = *abi.ConvertType(out[0], new(string)).(*string)
 	outstruct.Arg1 = abi.ConvertType(out[1], new(big.Int)).(*big.Int)
 	outstruct.Arg2 = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte)
 	return *outstruct, err
 }
--- a/accounts/abi/abigen/testdata/v2/identifiercollision.go.txt
+++ b/accounts/abi/abigen/testdata/v2/identifiercollision.go.txt
@ -0,0 +1,102 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // IdentifierCollisionMetaData contains all meta data concerning the IdentifierCollision contract.
 var IdentifierCollisionMetaData = bind.MetaData{
 	ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"MyVar\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"_myVar\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]",
 	ID:  "1863c5622f8ac2c09c42f063ca883fe438",
 	Bin: "0x60806040523480156100115760006000fd5b50610017565b60c3806100256000396000f3fe608060405234801560105760006000fd5b506004361060365760003560e01c806301ad4d8714603c5780634ef1f0ad146058576036565b60006000fd5b60426074565b6040518082815260200191505060405180910390f35b605e607d565b6040518082815260200191505060405180910390f35b60006000505481565b60006000600050549050608b565b9056fea265627a7a7231582067c8d84688b01c4754ba40a2a871cede94ea1f28b5981593ab2a45b46ac43af664736f6c634300050c0032",
 }
 // IdentifierCollision is an auto generated Go binding around an Ethereum contract.
 type IdentifierCollision struct {
 	abi abi.ABI
 }
 // NewIdentifierCollision creates a new instance of IdentifierCollision.
 func NewIdentifierCollision() *IdentifierCollision {
 	parsed, err := IdentifierCollisionMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &IdentifierCollision{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *IdentifierCollision) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackMyVar is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x4ef1f0ad.
 //
 // Solidity: function MyVar() view returns(uint256)
 func (identifierCollision *IdentifierCollision) PackMyVar() []byte {
 	enc, err := identifierCollision.abi.Pack("MyVar")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackMyVar is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x4ef1f0ad.
 //
 // Solidity: function MyVar() view returns(uint256)
 func (identifierCollision *IdentifierCollision) UnpackMyVar(data []byte) (*big.Int, error) {
 	out, err := identifierCollision.abi.Unpack("MyVar", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
 // PackPubVar is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x01ad4d87.
 //
 // Solidity: function _myVar() view returns(uint256)
 func (identifierCollision *IdentifierCollision) PackPubVar() []byte {
 	enc, err := identifierCollision.abi.Pack("_myVar")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackPubVar is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x01ad4d87.
 //
 // Solidity: function _myVar() view returns(uint256)
 func (identifierCollision *IdentifierCollision) UnpackPubVar(data []byte) (*big.Int, error) {
 	out, err := identifierCollision.abi.Unpack("_myVar", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
--- a/accounts/abi/abigen/testdata/v2/inputchecker.go.txt
+++ b/accounts/abi/abigen/testdata/v2/inputchecker.go.txt
@ -0,0 +1,123 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // InputCheckerMetaData contains all meta data concerning the InputChecker contract.
 var InputCheckerMetaData = bind.MetaData{
 	ABI: "[{\"type\":\"function\",\"name\":\"noInput\",\"constant\":true,\"inputs\":[],\"outputs\":[]},{\"type\":\"function\",\"name\":\"namedInput\",\"constant\":true,\"inputs\":[{\"name\":\"str\",\"type\":\"string\"}],\"outputs\":[]},{\"type\":\"function\",\"name\":\"anonInput\",\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"string\"}],\"outputs\":[]},{\"type\":\"function\",\"name\":\"namedInputs\",\"constant\":true,\"inputs\":[{\"name\":\"str1\",\"type\":\"string\"},{\"name\":\"str2\",\"type\":\"string\"}],\"outputs\":[]},{\"type\":\"function\",\"name\":\"anonInputs\",\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"\",\"type\":\"string\"}],\"outputs\":[]},{\"type\":\"function\",\"name\":\"mixedInputs\",\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"str\",\"type\":\"string\"}],\"outputs\":[]}]",
 	ID:  "e551ce092312e54f54f45ffdf06caa4cdc",
 }
 // InputChecker is an auto generated Go binding around an Ethereum contract.
 type InputChecker struct {
 	abi abi.ABI
 }
 // NewInputChecker creates a new instance of InputChecker.
 func NewInputChecker() *InputChecker {
 	parsed, err := InputCheckerMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &InputChecker{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *InputChecker) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackAnonInput is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x3e708e82.
 //
 // Solidity: function anonInput(string ) returns()
 func (inputChecker *InputChecker) PackAnonInput(arg0 string) []byte {
 	enc, err := inputChecker.abi.Pack("anonInput", arg0)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackAnonInputs is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x28160527.
 //
 // Solidity: function anonInputs(string , string ) returns()
 func (inputChecker *InputChecker) PackAnonInputs(arg0 string, arg1 string) []byte {
 	enc, err := inputChecker.abi.Pack("anonInputs", arg0, arg1)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackMixedInputs is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xc689ebdc.
 //
 // Solidity: function mixedInputs(string , string str) returns()
 func (inputChecker *InputChecker) PackMixedInputs(arg0 string, str string) []byte {
 	enc, err := inputChecker.abi.Pack("mixedInputs", arg0, str)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackNamedInput is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x0d402005.
 //
 // Solidity: function namedInput(string str) returns()
 func (inputChecker *InputChecker) PackNamedInput(str string) []byte {
 	enc, err := inputChecker.abi.Pack("namedInput", str)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackNamedInputs is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x63c796ed.
 //
 // Solidity: function namedInputs(string str1, string str2) returns()
 func (inputChecker *InputChecker) PackNamedInputs(str1 string, str2 string) []byte {
 	enc, err := inputChecker.abi.Pack("namedInputs", str1, str2)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackNoInput is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x53539029.
 //
 // Solidity: function noInput() returns()
 func (inputChecker *InputChecker) PackNoInput() []byte {
 	enc, err := inputChecker.abi.Pack("noInput")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
--- a/accounts/abi/abigen/testdata/v2/interactor.go.txt
+++ b/accounts/abi/abigen/testdata/v2/interactor.go.txt
@ -0,0 +1,126 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // InteractorMetaData contains all meta data concerning the Interactor contract.
 var InteractorMetaData = bind.MetaData{
 	ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"transactString\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"deployString\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"str\",\"type\":\"string\"}],\"name\":\"transact\",\"outputs\":[],\"type\":\"function\"},{\"inputs\":[{\"name\":\"str\",\"type\":\"string\"}],\"type\":\"constructor\"}]",
 	ID:  "f63980878028f3242c9033fdc30fd21a81",
 	Bin: "0x6060604052604051610328380380610328833981016040528051018060006000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f10608d57805160ff19168380011785555b50607c9291505b8082111560ba57838155600101606b565b50505061026a806100be6000396000f35b828001600101855582156064579182015b828111156064578251826000505591602001919060010190609e565b509056606060405260e060020a60003504630d86a0e181146100315780636874e8091461008d578063d736c513146100ea575b005b610190600180546020600282841615610100026000190190921691909104601f810182900490910260809081016040526060828152929190828280156102295780601f106101fe57610100808354040283529160200191610229565b61019060008054602060026001831615610100026000190190921691909104601f810182900490910260809081016040526060828152929190828280156102295780601f106101fe57610100808354040283529160200191610229565b60206004803580820135601f81018490049093026080908101604052606084815261002f946024939192918401918190838280828437509496505050505050508060016000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f1061023157805160ff19168380011785555b506102619291505b808211156102665760008155830161017d565b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600f02600301f150905090810190601f1680156101f05780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b820191906000526020600020905b81548152906001019060200180831161020c57829003601f168201915b505050505081565b82800160010185558215610175579182015b82811115610175578251826000505591602001919060010190610243565b505050565b509056",
 }
 // Interactor is an auto generated Go binding around an Ethereum contract.
 type Interactor struct {
 	abi abi.ABI
 }
 // NewInteractor creates a new instance of Interactor.
 func NewInteractor() *Interactor {
 	parsed, err := InteractorMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &Interactor{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *Interactor) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackConstructor is the Go binding used to pack the parameters required for
 // contract deployment.
 //
 // Solidity: constructor(string str) returns()
 func (interactor *Interactor) PackConstructor(str string) []byte {
 	enc, err := interactor.abi.Pack("", str)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackDeployString is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x6874e809.
 //
 // Solidity: function deployString() returns(string)
 func (interactor *Interactor) PackDeployString() []byte {
 	enc, err := interactor.abi.Pack("deployString")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackDeployString is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x6874e809.
 //
 // Solidity: function deployString() returns(string)
 func (interactor *Interactor) UnpackDeployString(data []byte) (string, error) {
 	out, err := interactor.abi.Unpack("deployString", data)
 	if err != nil {
 		return *new(string), err
 	}
 	out0 := *abi.ConvertType(out[0], new(string)).(*string)
 	return out0, err
 }
 // PackTransact is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xd736c513.
 //
 // Solidity: function transact(string str) returns()
 func (interactor *Interactor) PackTransact(str string) []byte {
 	enc, err := interactor.abi.Pack("transact", str)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackTransactString is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x0d86a0e1.
 //
 // Solidity: function transactString() returns(string)
 func (interactor *Interactor) PackTransactString() []byte {
 	enc, err := interactor.abi.Pack("transactString")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackTransactString is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x0d86a0e1.
 //
 // Solidity: function transactString() returns(string)
 func (interactor *Interactor) UnpackTransactString(data []byte) (string, error) {
 	out, err := interactor.abi.Unpack("transactString", data)
 	if err != nil {
 		return *new(string), err
 	}
 	out0 := *abi.ConvertType(out[0], new(string)).(*string)
 	return out0, err
 }
--- a/accounts/abi/abigen/testdata/v2/nameconflict.go.txt
+++ b/accounts/abi/abigen/testdata/v2/nameconflict.go.txt
@ -0,0 +1,137 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // Oraclerequest is an auto generated low-level Go binding around an user-defined struct.
 type Oraclerequest struct {
 	Data  []byte
 	Data0 []byte
 }
 // NameConflictMetaData contains all meta data concerning the NameConflict contract.
 var NameConflictMetaData = bind.MetaData{
 	ABI: "[{\"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\":\"structoracle.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\":\"structoracle.request\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
 	ID:  "8f6e2703b307244ae6bd61ed94ce959cf9",
 	Bin: "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",
 }
 // NameConflict is an auto generated Go binding around an Ethereum contract.
 type NameConflict struct {
 	abi abi.ABI
 }
 // NewNameConflict creates a new instance of NameConflict.
 func NewNameConflict() *NameConflict {
 	parsed, err := NameConflictMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &NameConflict{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *NameConflict) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackAddRequest is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xcce7b048.
 //
 // Solidity: function addRequest((bytes,bytes) req) pure returns()
 func (nameConflict *NameConflict) PackAddRequest(req Oraclerequest) []byte {
 	enc, err := nameConflict.abi.Pack("addRequest", req)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackGetRequest is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xc2bb515f.
 //
 // Solidity: function getRequest() pure returns((bytes,bytes))
 func (nameConflict *NameConflict) PackGetRequest() []byte {
 	enc, err := nameConflict.abi.Pack("getRequest")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackGetRequest is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0xc2bb515f.
 //
 // Solidity: function getRequest() pure returns((bytes,bytes))
 func (nameConflict *NameConflict) UnpackGetRequest(data []byte) (Oraclerequest, error) {
 	out, err := nameConflict.abi.Unpack("getRequest", data)
 	if err != nil {
 		return *new(Oraclerequest), err
 	}
 	out0 := *abi.ConvertType(out[0], new(Oraclerequest)).(*Oraclerequest)
 	return out0, err
 }
 // NameConflictLog represents a log event raised by the NameConflict contract.
 type NameConflictLog struct {
 	Msg  *big.Int
 	Msg0 *big.Int
 	Raw  *types.Log // Blockchain specific contextual infos
 }
 const NameConflictLogEventName = "log"
 // ContractEventName returns the user-defined event name.
 func (NameConflictLog) ContractEventName() string {
 	return NameConflictLogEventName
 }
 // UnpackLogEvent is the Go binding that unpacks the event data emitted
 // by contract.
 //
 // Solidity: event log(int256 msg, int256 _msg)
 func (nameConflict *NameConflict) UnpackLogEvent(log *types.Log) (*NameConflictLog, error) {
 	event := "log"
 	if log.Topics[0] != nameConflict.abi.Events[event].ID {
 		return nil, errors.New("event signature mismatch")
 	}
 	out := new(NameConflictLog)
 	if len(log.Data) > 0 {
 		if err := nameConflict.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
 			return nil, err
 		}
 	}
 	var indexed abi.Arguments
 	for _, arg := range nameConflict.abi.Events[event].Inputs {
 		if arg.Indexed {
 			indexed = append(indexed, arg)
 		}
 	}
 	if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil {
 		return nil, err
 	}
 	out.Raw = log
 	return out, nil
 }
--- a/accounts/abi/abigen/testdata/v2/numericmethodname.go.txt
+++ b/accounts/abi/abigen/testdata/v2/numericmethodname.go.txt
@ -0,0 +1,129 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // NumericMethodNameMetaData contains all meta data concerning the NumericMethodName contract.
 var NumericMethodNameMetaData = bind.MetaData{
 	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_param\",\"type\":\"address\"}],\"name\":\"_1TestEvent\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"_1test\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"__1test\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"__2test\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
 	ID:  "a691b347afbc44b90dd9a1dfbc65661904",
 	Bin: "0x6080604052348015600f57600080fd5b5060958061001e6000396000f3fe6080604052348015600f57600080fd5b5060043610603c5760003560e01c80639d993132146041578063d02767c7146049578063ffa02795146051575b600080fd5b60476059565b005b604f605b565b005b6057605d565b005b565b565b56fea26469706673582212200382ca602dff96a7e2ba54657985e2b4ac423a56abe4a1f0667bc635c4d4371f64736f6c63430008110033",
 }
 // NumericMethodName is an auto generated Go binding around an Ethereum contract.
 type NumericMethodName struct {
 	abi abi.ABI
 }
 // NewNumericMethodName creates a new instance of NumericMethodName.
 func NewNumericMethodName() *NumericMethodName {
 	parsed, err := NumericMethodNameMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &NumericMethodName{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *NumericMethodName) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackE1test is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xffa02795.
 //
 // Solidity: function _1test() pure returns()
 func (numericMethodName *NumericMethodName) PackE1test() []byte {
 	enc, err := numericMethodName.abi.Pack("_1test")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackE1test0 is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xd02767c7.
 //
 // Solidity: function __1test() pure returns()
 func (numericMethodName *NumericMethodName) PackE1test0() []byte {
 	enc, err := numericMethodName.abi.Pack("__1test")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackE2test is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x9d993132.
 //
 // Solidity: function __2test() pure returns()
 func (numericMethodName *NumericMethodName) PackE2test() []byte {
 	enc, err := numericMethodName.abi.Pack("__2test")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // NumericMethodNameE1TestEvent represents a _1TestEvent event raised by the NumericMethodName contract.
 type NumericMethodNameE1TestEvent struct {
 	Param common.Address
 	Raw   *types.Log // Blockchain specific contextual infos
 }
 const NumericMethodNameE1TestEventEventName = "_1TestEvent"
 // ContractEventName returns the user-defined event name.
 func (NumericMethodNameE1TestEvent) ContractEventName() string {
 	return NumericMethodNameE1TestEventEventName
 }
 // UnpackE1TestEventEvent is the Go binding that unpacks the event data emitted
 // by contract.
 //
 // Solidity: event _1TestEvent(address _param)
 func (numericMethodName *NumericMethodName) UnpackE1TestEventEvent(log *types.Log) (*NumericMethodNameE1TestEvent, error) {
 	event := "_1TestEvent"
 	if log.Topics[0] != numericMethodName.abi.Events[event].ID {
 		return nil, errors.New("event signature mismatch")
 	}
 	out := new(NumericMethodNameE1TestEvent)
 	if len(log.Data) > 0 {
 		if err := numericMethodName.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
 			return nil, err
 		}
 	}
 	var indexed abi.Arguments
 	for _, arg := range numericMethodName.abi.Events[event].Inputs {
 		if arg.Indexed {
 			indexed = append(indexed, arg)
 		}
 	}
 	if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil {
 		return nil, err
 	}
 	out.Raw = log
 	return out, nil
 }
--- a/accounts/abi/abigen/testdata/v2/outputchecker.go.txt
+++ b/accounts/abi/abigen/testdata/v2/outputchecker.go.txt
@ -0,0 +1,253 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // OutputCheckerMetaData contains all meta data concerning the OutputChecker contract.
 var OutputCheckerMetaData = bind.MetaData{
 	ABI: "[{\"type\":\"function\",\"name\":\"noOutput\",\"constant\":true,\"inputs\":[],\"outputs\":[]},{\"type\":\"function\",\"name\":\"namedOutput\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"str\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"anonOutput\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"namedOutputs\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"str1\",\"type\":\"string\"},{\"name\":\"str2\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"collidingOutputs\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"str\",\"type\":\"string\"},{\"name\":\"Str\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"anonOutputs\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"mixedOutputs\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"str\",\"type\":\"string\"}]}]",
 	ID:  "cc1d4e235801a590b506d5130b0cca90a1",
 }
 // OutputChecker is an auto generated Go binding around an Ethereum contract.
 type OutputChecker struct {
 	abi abi.ABI
 }
 // NewOutputChecker creates a new instance of OutputChecker.
 func NewOutputChecker() *OutputChecker {
 	parsed, err := OutputCheckerMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &OutputChecker{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *OutputChecker) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackAnonOutput is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x008bda05.
 //
 // Solidity: function anonOutput() returns(string)
 func (outputChecker *OutputChecker) PackAnonOutput() []byte {
 	enc, err := outputChecker.abi.Pack("anonOutput")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackAnonOutput is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x008bda05.
 //
 // Solidity: function anonOutput() returns(string)
 func (outputChecker *OutputChecker) UnpackAnonOutput(data []byte) (string, error) {
 	out, err := outputChecker.abi.Unpack("anonOutput", data)
 	if err != nil {
 		return *new(string), err
 	}
 	out0 := *abi.ConvertType(out[0], new(string)).(*string)
 	return out0, err
 }
 // PackAnonOutputs is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x3c401115.
 //
 // Solidity: function anonOutputs() returns(string, string)
 func (outputChecker *OutputChecker) PackAnonOutputs() []byte {
 	enc, err := outputChecker.abi.Pack("anonOutputs")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // AnonOutputsOutput serves as a container for the return parameters of contract
 // method AnonOutputs.
 type AnonOutputsOutput struct {
 	Arg0 string
 	Arg1 string
 }
 // UnpackAnonOutputs is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x3c401115.
 //
 // Solidity: function anonOutputs() returns(string, string)
 func (outputChecker *OutputChecker) UnpackAnonOutputs(data []byte) (AnonOutputsOutput, error) {
 	out, err := outputChecker.abi.Unpack("anonOutputs", data)
 	outstruct := new(AnonOutputsOutput)
 	if err != nil {
 		return *outstruct, err
 	}
 	outstruct.Arg0 = *abi.ConvertType(out[0], new(string)).(*string)
 	outstruct.Arg1 = *abi.ConvertType(out[1], new(string)).(*string)
 	return *outstruct, err
 }
 // PackCollidingOutputs is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xeccbc1ee.
 //
 // Solidity: function collidingOutputs() returns(string str, string Str)
 func (outputChecker *OutputChecker) PackCollidingOutputs() []byte {
 	enc, err := outputChecker.abi.Pack("collidingOutputs")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // CollidingOutputsOutput serves as a container for the return parameters of contract
 // method CollidingOutputs.
 type CollidingOutputsOutput struct {
 	Str  string
 	Str0 string
 }
 // UnpackCollidingOutputs is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0xeccbc1ee.
 //
 // Solidity: function collidingOutputs() returns(string str, string Str)
 func (outputChecker *OutputChecker) UnpackCollidingOutputs(data []byte) (CollidingOutputsOutput, error) {
 	out, err := outputChecker.abi.Unpack("collidingOutputs", data)
 	outstruct := new(CollidingOutputsOutput)
 	if err != nil {
 		return *outstruct, err
 	}
 	outstruct.Str = *abi.ConvertType(out[0], new(string)).(*string)
 	outstruct.Str0 = *abi.ConvertType(out[1], new(string)).(*string)
 	return *outstruct, err
 }
 // PackMixedOutputs is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x21b77b44.
 //
 // Solidity: function mixedOutputs() returns(string, string str)
 func (outputChecker *OutputChecker) PackMixedOutputs() []byte {
 	enc, err := outputChecker.abi.Pack("mixedOutputs")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // MixedOutputsOutput serves as a container for the return parameters of contract
 // method MixedOutputs.
 type MixedOutputsOutput struct {
 	Arg0 string
 	Str  string
 }
 // UnpackMixedOutputs is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x21b77b44.
 //
 // Solidity: function mixedOutputs() returns(string, string str)
 func (outputChecker *OutputChecker) UnpackMixedOutputs(data []byte) (MixedOutputsOutput, error) {
 	out, err := outputChecker.abi.Unpack("mixedOutputs", data)
 	outstruct := new(MixedOutputsOutput)
 	if err != nil {
 		return *outstruct, err
 	}
 	outstruct.Arg0 = *abi.ConvertType(out[0], new(string)).(*string)
 	outstruct.Str = *abi.ConvertType(out[1], new(string)).(*string)
 	return *outstruct, err
 }
 // PackNamedOutput is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x5e632bd5.
 //
 // Solidity: function namedOutput() returns(string str)
 func (outputChecker *OutputChecker) PackNamedOutput() []byte {
 	enc, err := outputChecker.abi.Pack("namedOutput")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackNamedOutput is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x5e632bd5.
 //
 // Solidity: function namedOutput() returns(string str)
 func (outputChecker *OutputChecker) UnpackNamedOutput(data []byte) (string, error) {
 	out, err := outputChecker.abi.Unpack("namedOutput", data)
 	if err != nil {
 		return *new(string), err
 	}
 	out0 := *abi.ConvertType(out[0], new(string)).(*string)
 	return out0, err
 }
 // PackNamedOutputs is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x7970a189.
 //
 // Solidity: function namedOutputs() returns(string str1, string str2)
 func (outputChecker *OutputChecker) PackNamedOutputs() []byte {
 	enc, err := outputChecker.abi.Pack("namedOutputs")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // NamedOutputsOutput serves as a container for the return parameters of contract
 // method NamedOutputs.
 type NamedOutputsOutput struct {
 	Str1 string
 	Str2 string
 }
 // UnpackNamedOutputs is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x7970a189.
 //
 // Solidity: function namedOutputs() returns(string str1, string str2)
 func (outputChecker *OutputChecker) UnpackNamedOutputs(data []byte) (NamedOutputsOutput, error) {
 	out, err := outputChecker.abi.Unpack("namedOutputs", data)
 	outstruct := new(NamedOutputsOutput)
 	if err != nil {
 		return *outstruct, err
 	}
 	outstruct.Str1 = *abi.ConvertType(out[0], new(string)).(*string)
 	outstruct.Str2 = *abi.ConvertType(out[1], new(string)).(*string)
 	return *outstruct, err
 }
 // PackNoOutput is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x625f0306.
 //
 // Solidity: function noOutput() returns()
 func (outputChecker *OutputChecker) PackNoOutput() []byte {
 	enc, err := outputChecker.abi.Pack("noOutput")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
--- a/accounts/abi/abigen/testdata/v2/overload.go.txt
+++ b/accounts/abi/abigen/testdata/v2/overload.go.txt
@ -0,0 +1,159 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // OverloadMetaData contains all meta data concerning the Overload contract.
 var OverloadMetaData = bind.MetaData{
 	ABI: "[{\"constant\":false,\"inputs\":[{\"name\":\"i\",\"type\":\"uint256\"},{\"name\":\"j\",\"type\":\"uint256\"}],\"name\":\"foo\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"i\",\"type\":\"uint256\"}],\"name\":\"foo\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"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\"}]",
 	ID:  "f49f0ff7ed407de5c37214f49309072aec",
 	Bin: "0x608060405234801561001057600080fd5b50610153806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806304bc52f81461003b5780632fbebd3814610073575b600080fd5b6100716004803603604081101561005157600080fd5b8101908080359060200190929190803590602001909291905050506100a1565b005b61009f6004803603602081101561008957600080fd5b81019080803590602001909291905050506100e4565b005b7fae42e9514233792a47a1e4554624e83fe852228e1503f63cd383e8a431f4f46d8282604051808381526020018281526020019250505060405180910390a15050565b7f0423a1321222a0a8716c22b92fac42d85a45a612b696a461784d9fa537c81e5c816040518082815260200191505060405180910390a15056fea265627a7a72305820e22b049858b33291cbe67eeaece0c5f64333e439d27032ea8337d08b1de18fe864736f6c634300050a0032",
 }
 // Overload is an auto generated Go binding around an Ethereum contract.
 type Overload struct {
 	abi abi.ABI
 }
 // NewOverload creates a new instance of Overload.
 func NewOverload() *Overload {
 	parsed, err := OverloadMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &Overload{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *Overload) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackFoo is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x04bc52f8.
 //
 // Solidity: function foo(uint256 i, uint256 j) returns()
 func (overload *Overload) PackFoo(i *big.Int, j *big.Int) []byte {
 	enc, err := overload.abi.Pack("foo", i, j)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackFoo0 is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x2fbebd38.
 //
 // Solidity: function foo(uint256 i) returns()
 func (overload *Overload) PackFoo0(i *big.Int) []byte {
 	enc, err := overload.abi.Pack("foo0", i)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // OverloadBar represents a bar event raised by the Overload contract.
 type OverloadBar struct {
 	I   *big.Int
 	Raw *types.Log // Blockchain specific contextual infos
 }
 const OverloadBarEventName = "bar"
 // ContractEventName returns the user-defined event name.
 func (OverloadBar) ContractEventName() string {
 	return OverloadBarEventName
 }
 // UnpackBarEvent is the Go binding that unpacks the event data emitted
 // by contract.
 //
 // Solidity: event bar(uint256 i)
 func (overload *Overload) UnpackBarEvent(log *types.Log) (*OverloadBar, error) {
 	event := "bar"
 	if log.Topics[0] != overload.abi.Events[event].ID {
 		return nil, errors.New("event signature mismatch")
 	}
 	out := new(OverloadBar)
 	if len(log.Data) > 0 {
 		if err := overload.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
 			return nil, err
 		}
 	}
 	var indexed abi.Arguments
 	for _, arg := range overload.abi.Events[event].Inputs {
 		if arg.Indexed {
 			indexed = append(indexed, arg)
 		}
 	}
 	if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil {
 		return nil, err
 	}
 	out.Raw = log
 	return out, nil
 }
 // OverloadBar0 represents a bar0 event raised by the Overload contract.
 type OverloadBar0 struct {
 	I   *big.Int
 	J   *big.Int
 	Raw *types.Log // Blockchain specific contextual infos
 }
 const OverloadBar0EventName = "bar0"
 // ContractEventName returns the user-defined event name.
 func (OverloadBar0) ContractEventName() string {
 	return OverloadBar0EventName
 }
 // UnpackBar0Event is the Go binding that unpacks the event data emitted
 // by contract.
 //
 // Solidity: event bar(uint256 i, uint256 j)
 func (overload *Overload) UnpackBar0Event(log *types.Log) (*OverloadBar0, error) {
 	event := "bar0"
 	if log.Topics[0] != overload.abi.Events[event].ID {
 		return nil, errors.New("event signature mismatch")
 	}
 	out := new(OverloadBar0)
 	if len(log.Data) > 0 {
 		if err := overload.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
 			return nil, err
 		}
 	}
 	var indexed abi.Arguments
 	for _, arg := range overload.abi.Events[event].Inputs {
 		if arg.Indexed {
 			indexed = append(indexed, arg)
 		}
 	}
 	if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil {
 		return nil, err
 	}
 	out.Raw = log
 	return out, nil
 }
--- a/accounts/abi/abigen/testdata/v2/rangekeyword.go.txt
+++ b/accounts/abi/abigen/testdata/v2/rangekeyword.go.txt
@ -0,0 +1,64 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // RangeKeywordMetaData contains all meta data concerning the RangeKeyword contract.
 var RangeKeywordMetaData = bind.MetaData{
 	ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"range\",\"type\":\"uint256\"}],\"name\":\"functionWithKeywordParameter\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
 	ID:  "cec8c872ba06feb1b8f0a00e7b237eb226",
 	Bin: "0x608060405234801561001057600080fd5b5060dc8061001f6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063527a119f14602d575b600080fd5b60436004803603810190603f9190605b565b6045565b005b50565b6000813590506055816092565b92915050565b600060208284031215606e57606d608d565b5b6000607a848285016048565b91505092915050565b6000819050919050565b600080fd5b6099816083565b811460a357600080fd5b5056fea2646970667358221220d4f4525e2615516394055d369fb17df41c359e5e962734f27fd683ea81fd9db164736f6c63430008070033",
 }
 // RangeKeyword is an auto generated Go binding around an Ethereum contract.
 type RangeKeyword struct {
 	abi abi.ABI
 }
 // NewRangeKeyword creates a new instance of RangeKeyword.
 func NewRangeKeyword() *RangeKeyword {
 	parsed, err := RangeKeywordMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &RangeKeyword{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *RangeKeyword) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackFunctionWithKeywordParameter is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x527a119f.
 //
 // Solidity: function functionWithKeywordParameter(uint256 range) pure returns()
 func (rangeKeyword *RangeKeyword) PackFunctionWithKeywordParameter(arg0 *big.Int) []byte {
 	enc, err := rangeKeyword.abi.Pack("functionWithKeywordParameter", arg0)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
--- a/accounts/abi/abigen/testdata/v2/slicer.go.txt
+++ b/accounts/abi/abigen/testdata/v2/slicer.go.txt
@ -0,0 +1,152 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // SlicerMetaData contains all meta data concerning the Slicer contract.
 var SlicerMetaData = bind.MetaData{
 	ABI: "[{\"constant\":true,\"inputs\":[{\"name\":\"input\",\"type\":\"address[]\"}],\"name\":\"echoAddresses\",\"outputs\":[{\"name\":\"output\",\"type\":\"address[]\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"input\",\"type\":\"uint24[23]\"}],\"name\":\"echoFancyInts\",\"outputs\":[{\"name\":\"output\",\"type\":\"uint24[23]\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"input\",\"type\":\"int256[]\"}],\"name\":\"echoInts\",\"outputs\":[{\"name\":\"output\",\"type\":\"int256[]\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"input\",\"type\":\"bool[]\"}],\"name\":\"echoBools\",\"outputs\":[{\"name\":\"output\",\"type\":\"bool[]\"}],\"type\":\"function\"}]",
 	ID:  "082c0740ab6537c7169cb573d097c52112",
 	Bin: "0x606060405261015c806100126000396000f3606060405260e060020a6000350463be1127a3811461003c578063d88becc014610092578063e15a3db71461003c578063f637e5891461003c575b005b604080516020600480358082013583810285810185019096528085526100ee959294602494909392850192829185019084908082843750949650505050505050604080516020810190915260009052805b919050565b604080516102e0818101909252610138916004916102e491839060179083908390808284375090955050505050506102e0604051908101604052806017905b60008152602001906001900390816100d15790505081905061008d565b60405180806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600f02600301f1509050019250505060405180910390f35b60405180826102e0808381846000600461015cf15090500191505060405180910390f3",
 }
 // Slicer is an auto generated Go binding around an Ethereum contract.
 type Slicer struct {
 	abi abi.ABI
 }
 // NewSlicer creates a new instance of Slicer.
 func NewSlicer() *Slicer {
 	parsed, err := SlicerMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &Slicer{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *Slicer) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackEchoAddresses is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xbe1127a3.
 //
 // Solidity: function echoAddresses(address[] input) returns(address[] output)
 func (slicer *Slicer) PackEchoAddresses(input []common.Address) []byte {
 	enc, err := slicer.abi.Pack("echoAddresses", input)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackEchoAddresses is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0xbe1127a3.
 //
 // Solidity: function echoAddresses(address[] input) returns(address[] output)
 func (slicer *Slicer) UnpackEchoAddresses(data []byte) ([]common.Address, error) {
 	out, err := slicer.abi.Unpack("echoAddresses", data)
 	if err != nil {
 		return *new([]common.Address), err
 	}
 	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
 	return out0, err
 }
 // PackEchoBools is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xf637e589.
 //
 // Solidity: function echoBools(bool[] input) returns(bool[] output)
 func (slicer *Slicer) PackEchoBools(input []bool) []byte {
 	enc, err := slicer.abi.Pack("echoBools", input)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackEchoBools is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0xf637e589.
 //
 // Solidity: function echoBools(bool[] input) returns(bool[] output)
 func (slicer *Slicer) UnpackEchoBools(data []byte) ([]bool, error) {
 	out, err := slicer.abi.Unpack("echoBools", data)
 	if err != nil {
 		return *new([]bool), err
 	}
 	out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool)
 	return out0, err
 }
 // PackEchoFancyInts is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xd88becc0.
 //
 // Solidity: function echoFancyInts(uint24[23] input) returns(uint24[23] output)
 func (slicer *Slicer) PackEchoFancyInts(input [23]*big.Int) []byte {
 	enc, err := slicer.abi.Pack("echoFancyInts", input)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackEchoFancyInts is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0xd88becc0.
 //
 // Solidity: function echoFancyInts(uint24[23] input) returns(uint24[23] output)
 func (slicer *Slicer) UnpackEchoFancyInts(data []byte) ([23]*big.Int, error) {
 	out, err := slicer.abi.Unpack("echoFancyInts", data)
 	if err != nil {
 		return *new([23]*big.Int), err
 	}
 	out0 := *abi.ConvertType(out[0], new([23]*big.Int)).(*[23]*big.Int)
 	return out0, err
 }
 // PackEchoInts is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xe15a3db7.
 //
 // Solidity: function echoInts(int256[] input) returns(int256[] output)
 func (slicer *Slicer) PackEchoInts(input []*big.Int) []byte {
 	enc, err := slicer.abi.Pack("echoInts", input)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackEchoInts is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0xe15a3db7.
 //
 // Solidity: function echoInts(int256[] input) returns(int256[] output)
 func (slicer *Slicer) UnpackEchoInts(data []byte) ([]*big.Int, error) {
 	out, err := slicer.abi.Unpack("echoInts", data)
 	if err != nil {
 		return *new([]*big.Int), err
 	}
 	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
 	return out0, err
 }
--- a/accounts/abi/abigen/testdata/v2/structs-abi.go.txt
+++ b/accounts/abi/abigen/testdata/v2/structs-abi.go.txt
@ -0,0 +1,116 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package v1bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // Struct0 is an auto generated low-level Go binding around an user-defined struct.
 type Struct0 struct {
 	B [32]byte
 }
 // StructsMetaData contains all meta data concerning the Structs contract.
 var StructsMetaData = bind.MetaData{
 	ABI: "[{\"inputs\":[],\"name\":\"F\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"B\",\"type\":\"bytes32\"}],\"internalType\":\"structStructs.A[]\",\"name\":\"a\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"c\",\"type\":\"uint256[]\"},{\"internalType\":\"bool[]\",\"name\":\"d\",\"type\":\"bool[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"G\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"B\",\"type\":\"bytes32\"}],\"internalType\":\"structStructs.A[]\",\"name\":\"a\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
 	ID:  "Structs",
 }
 // Structs is an auto generated Go binding around an Ethereum contract.
 type Structs struct {
 	abi abi.ABI
 }
 // NewStructs creates a new instance of Structs.
 func NewStructs() *Structs {
 	parsed, err := StructsMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &Structs{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 <<<<<<< HEAD
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *Structs) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 =======
 // Use this to create the instance object passed to abigen v2 library functions Call,
 // Transact, etc.
 func (c *Structs) Instance(backend bind.ContractBackend, addr common.Address) bind.BoundContract {
 	return bind.NewBoundContract(backend, addr, c.abi)
 >>>>>>> 854c25e086 (accounts/abi/abigen: improve v2 template)
 }
 // F is the Go binding used to pack the parameters required for calling
 // the contract method 0x28811f59.
 //
 // Solidity: function F() view returns((bytes32)[] a, uint256[] c, bool[] d)
 func (structs *Structs) PackF() ([]byte, error) {
 	return structs.abi.Pack("F")
 }
 // FOutput serves as a container for the return parameters of contract
 // method F.
 type FOutput struct {
 	A []Struct0
 	C []*big.Int
 	D []bool
 }
 // UnpackF is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x28811f59.
 //
 // Solidity: function F() view returns((bytes32)[] a, uint256[] c, bool[] d)
 func (structs *Structs) UnpackF(data []byte) (*FOutput, error) {
 	out, err := structs.abi.Unpack("F", data)
 	if err != nil {
 		return nil, err
 	}
 	ret := new(FOutput)
 	ret.A = *abi.ConvertType(out[0], new([]Struct0)).(*[]Struct0)
 	ret.C = *abi.ConvertType(out[1], new([]*big.Int)).(*[]*big.Int)
 	ret.D = *abi.ConvertType(out[2], new([]bool)).(*[]bool)
 	return ret, nil
 }
 // G is the Go binding used to pack the parameters required for calling
 // the contract method 0x6fecb623.
 //
 // Solidity: function G() view returns((bytes32)[] a)
 func (structs *Structs) PackG() ([]byte, error) {
 	return structs.abi.Pack("G")
 }
 // UnpackG is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x6fecb623.
 //
 // Solidity: function G() view returns((bytes32)[] a)
 func (structs *Structs) UnpackG(data []byte) (*[]Struct0, error) {
 	out, err := structs.abi.Unpack("G", data)
 	if err != nil {
 		return nil, err
 	}
 	out0 := *abi.ConvertType(out[0], new([]Struct0)).(*[]Struct0)
 	return &out0, nil
 }
--- a/accounts/abi/abigen/testdata/v2/structs.go.txt
+++ b/accounts/abi/abigen/testdata/v2/structs.go.txt
@ -0,0 +1,119 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // Struct0 is an auto generated low-level Go binding around an user-defined struct.
 type Struct0 struct {
 	B [32]byte
 }
 // StructsMetaData contains all meta data concerning the Structs contract.
 var StructsMetaData = bind.MetaData{
 	ABI: "[{\"inputs\":[],\"name\":\"F\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"B\",\"type\":\"bytes32\"}],\"internalType\":\"structStructs.A[]\",\"name\":\"a\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"c\",\"type\":\"uint256[]\"},{\"internalType\":\"bool[]\",\"name\":\"d\",\"type\":\"bool[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"G\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"B\",\"type\":\"bytes32\"}],\"internalType\":\"structStructs.A[]\",\"name\":\"a\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
 	ID:  "920a35318e7581766aec7a17218628a91d",
 	Bin: "0x608060405234801561001057600080fd5b50610278806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806328811f591461003b5780636fecb6231461005b575b600080fd5b610043610070565b604051610052939291906101a0565b60405180910390f35b6100636100d6565b6040516100529190610186565b604080516002808252606082810190935282918291829190816020015b610095610131565b81526020019060019003908161008d575050805190915061026960611b9082906000906100be57fe5b60209081029190910101515293606093508392509050565b6040805160028082526060828101909352829190816020015b6100f7610131565b8152602001906001900390816100ef575050805190915061026960611b90829060009061012057fe5b602090810291909101015152905090565b60408051602081019091526000815290565b815260200190565b6000815180845260208085019450808401835b8381101561017b578151518752958201959082019060010161015e565b509495945050505050565b600060208252610199602083018461014b565b9392505050565b6000606082526101b3606083018661014b565b6020838203818501528186516101c98185610239565b91508288019350845b818110156101f3576101e5838651610143565b9484019492506001016101d2565b505084810360408601528551808252908201925081860190845b8181101561022b57825115158552938301939183019160010161020d565b509298975050505050505050565b9081526020019056fea2646970667358221220eb85327e285def14230424c52893aebecec1e387a50bb6b75fc4fdbed647f45f64736f6c63430006050033",
 }
 // Structs is an auto generated Go binding around an Ethereum contract.
 type Structs struct {
 	abi abi.ABI
 }
 // NewStructs creates a new instance of Structs.
 func NewStructs() *Structs {
 	parsed, err := StructsMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &Structs{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *Structs) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackF is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x28811f59.
 //
 // Solidity: function F() view returns((bytes32)[] a, uint256[] c, bool[] d)
 func (structs *Structs) PackF() []byte {
 	enc, err := structs.abi.Pack("F")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // FOutput serves as a container for the return parameters of contract
 // method F.
 type FOutput struct {
 	A []Struct0
 	C []*big.Int
 	D []bool
 }
 // UnpackF is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x28811f59.
 //
 // Solidity: function F() view returns((bytes32)[] a, uint256[] c, bool[] d)
 func (structs *Structs) UnpackF(data []byte) (FOutput, error) {
 	out, err := structs.abi.Unpack("F", data)
 	outstruct := new(FOutput)
 	if err != nil {
 		return *outstruct, err
 	}
 	outstruct.A = *abi.ConvertType(out[0], new([]Struct0)).(*[]Struct0)
 	outstruct.C = *abi.ConvertType(out[1], new([]*big.Int)).(*[]*big.Int)
 	outstruct.D = *abi.ConvertType(out[2], new([]bool)).(*[]bool)
 	return *outstruct, err
 }
 // PackG is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x6fecb623.
 //
 // Solidity: function G() view returns((bytes32)[] a)
 func (structs *Structs) PackG() []byte {
 	enc, err := structs.abi.Pack("G")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackG is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x6fecb623.
 //
 // Solidity: function G() view returns((bytes32)[] a)
 func (structs *Structs) UnpackG(data []byte) ([]Struct0, error) {
 	out, err := structs.abi.Unpack("G", data)
 	if err != nil {
 		return *new([]Struct0), err
 	}
 	out0 := *abi.ConvertType(out[0], new([]Struct0)).(*[]Struct0)
 	return out0, err
 }
--- a/accounts/abi/abigen/testdata/v2/token.go.txt
+++ b/accounts/abi/abigen/testdata/v2/token.go.txt
@ -0,0 +1,319 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // TokenMetaData contains all meta data concerning the Token contract.
 var TokenMetaData = bind.MetaData{
 	ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_from\",\"type\":\"address\"},{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"name\":\"\",\"type\":\"uint8\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_spender\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"},{\"name\":\"_extraData\",\"type\":\"bytes\"}],\"name\":\"approveAndCall\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"},{\"name\":\"\",\"type\":\"address\"}],\"name\":\"spentAllowance\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"},{\"name\":\"\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"inputs\":[{\"name\":\"initialSupply\",\"type\":\"uint256\"},{\"name\":\"tokenName\",\"type\":\"string\"},{\"name\":\"decimalUnits\",\"type\":\"uint8\"},{\"name\":\"tokenSymbol\",\"type\":\"string\"}],\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"}]",
 	ID:  "1317f51c845ce3bfb7c268e5337a825f12",
 	Bin: "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",
 }
 // Token is an auto generated Go binding around an Ethereum contract.
 type Token struct {
 	abi abi.ABI
 }
 // NewToken creates a new instance of Token.
 func NewToken() *Token {
 	parsed, err := TokenMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &Token{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *Token) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackConstructor is the Go binding used to pack the parameters required for
 // contract deployment.
 //
 // Solidity: constructor(uint256 initialSupply, string tokenName, uint8 decimalUnits, string tokenSymbol) returns()
 func (token *Token) PackConstructor(initialSupply *big.Int, tokenName string, decimalUnits uint8, tokenSymbol string) []byte {
 	enc, err := token.abi.Pack("", initialSupply, tokenName, decimalUnits, tokenSymbol)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackAllowance is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xdd62ed3e.
 //
 // Solidity: function allowance(address , address ) returns(uint256)
 func (token *Token) PackAllowance(arg0 common.Address, arg1 common.Address) []byte {
 	enc, err := token.abi.Pack("allowance", arg0, arg1)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackAllowance is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0xdd62ed3e.
 //
 // Solidity: function allowance(address , address ) returns(uint256)
 func (token *Token) UnpackAllowance(data []byte) (*big.Int, error) {
 	out, err := token.abi.Unpack("allowance", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
 // PackApproveAndCall is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xcae9ca51.
 //
 // Solidity: function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns(bool success)
 func (token *Token) PackApproveAndCall(spender common.Address, value *big.Int, extraData []byte) []byte {
 	enc, err := token.abi.Pack("approveAndCall", spender, value, extraData)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackApproveAndCall is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0xcae9ca51.
 //
 // Solidity: function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns(bool success)
 func (token *Token) UnpackApproveAndCall(data []byte) (bool, error) {
 	out, err := token.abi.Unpack("approveAndCall", data)
 	if err != nil {
 		return *new(bool), err
 	}
 	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
 	return out0, err
 }
 // PackBalanceOf is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x70a08231.
 //
 // Solidity: function balanceOf(address ) returns(uint256)
 func (token *Token) PackBalanceOf(arg0 common.Address) []byte {
 	enc, err := token.abi.Pack("balanceOf", arg0)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackBalanceOf is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x70a08231.
 //
 // Solidity: function balanceOf(address ) returns(uint256)
 func (token *Token) UnpackBalanceOf(data []byte) (*big.Int, error) {
 	out, err := token.abi.Unpack("balanceOf", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
 // PackDecimals is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x313ce567.
 //
 // Solidity: function decimals() returns(uint8)
 func (token *Token) PackDecimals() []byte {
 	enc, err := token.abi.Pack("decimals")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackDecimals is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x313ce567.
 //
 // Solidity: function decimals() returns(uint8)
 func (token *Token) UnpackDecimals(data []byte) (uint8, error) {
 	out, err := token.abi.Unpack("decimals", data)
 	if err != nil {
 		return *new(uint8), err
 	}
 	out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8)
 	return out0, err
 }
 // PackName is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x06fdde03.
 //
 // Solidity: function name() returns(string)
 func (token *Token) PackName() []byte {
 	enc, err := token.abi.Pack("name")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackName is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x06fdde03.
 //
 // Solidity: function name() returns(string)
 func (token *Token) UnpackName(data []byte) (string, error) {
 	out, err := token.abi.Unpack("name", data)
 	if err != nil {
 		return *new(string), err
 	}
 	out0 := *abi.ConvertType(out[0], new(string)).(*string)
 	return out0, err
 }
 // PackSpentAllowance is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xdc3080f2.
 //
 // Solidity: function spentAllowance(address , address ) returns(uint256)
 func (token *Token) PackSpentAllowance(arg0 common.Address, arg1 common.Address) []byte {
 	enc, err := token.abi.Pack("spentAllowance", arg0, arg1)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackSpentAllowance is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0xdc3080f2.
 //
 // Solidity: function spentAllowance(address , address ) returns(uint256)
 func (token *Token) UnpackSpentAllowance(data []byte) (*big.Int, error) {
 	out, err := token.abi.Unpack("spentAllowance", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
 // PackSymbol is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x95d89b41.
 //
 // Solidity: function symbol() returns(string)
 func (token *Token) PackSymbol() []byte {
 	enc, err := token.abi.Pack("symbol")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackSymbol is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x95d89b41.
 //
 // Solidity: function symbol() returns(string)
 func (token *Token) UnpackSymbol(data []byte) (string, error) {
 	out, err := token.abi.Unpack("symbol", data)
 	if err != nil {
 		return *new(string), err
 	}
 	out0 := *abi.ConvertType(out[0], new(string)).(*string)
 	return out0, err
 }
 // PackTransfer is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xa9059cbb.
 //
 // Solidity: function transfer(address _to, uint256 _value) returns()
 func (token *Token) PackTransfer(to common.Address, value *big.Int) []byte {
 	enc, err := token.abi.Pack("transfer", to, value)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackTransferFrom is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x23b872dd.
 //
 // Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool success)
 func (token *Token) PackTransferFrom(from common.Address, to common.Address, value *big.Int) []byte {
 	enc, err := token.abi.Pack("transferFrom", from, to, value)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackTransferFrom is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x23b872dd.
 //
 // Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool success)
 func (token *Token) UnpackTransferFrom(data []byte) (bool, error) {
 	out, err := token.abi.Unpack("transferFrom", data)
 	if err != nil {
 		return *new(bool), err
 	}
 	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
 	return out0, err
 }
 // TokenTransfer represents a Transfer event raised by the Token contract.
 type TokenTransfer struct {
 	From  common.Address
 	To    common.Address
 	Value *big.Int
 	Raw   *types.Log // Blockchain specific contextual infos
 }
 const TokenTransferEventName = "Transfer"
 // ContractEventName returns the user-defined event name.
 func (TokenTransfer) ContractEventName() string {
 	return TokenTransferEventName
 }
 // UnpackTransferEvent is the Go binding that unpacks the event data emitted
 // by contract.
 //
 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
 func (token *Token) UnpackTransferEvent(log *types.Log) (*TokenTransfer, error) {
 	event := "Transfer"
 	if log.Topics[0] != token.abi.Events[event].ID {
 		return nil, errors.New("event signature mismatch")
 	}
 	out := new(TokenTransfer)
 	if len(log.Data) > 0 {
 		if err := token.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
 			return nil, err
 		}
 	}
 	var indexed abi.Arguments
 	for _, arg := range token.abi.Events[event].Inputs {
 		if arg.Indexed {
 			indexed = append(indexed, arg)
 		}
 	}
 	if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil {
 		return nil, err
 	}
 	out.Raw = log
 	return out, nil
 }
--- a/accounts/abi/abigen/testdata/v2/tuple.go.txt
+++ b/accounts/abi/abigen/testdata/v2/tuple.go.txt
--- a/accounts/abi/abigen/testdata/v2/tupler.go.txt
+++ b/accounts/abi/abigen/testdata/v2/tupler.go.txt
@ -0,0 +1,89 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // TuplerMetaData contains all meta data concerning the Tupler contract.
 var TuplerMetaData = bind.MetaData{
 	ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"tuple\",\"outputs\":[{\"name\":\"a\",\"type\":\"string\"},{\"name\":\"b\",\"type\":\"int256\"},{\"name\":\"c\",\"type\":\"bytes32\"}],\"type\":\"function\"}]",
 	ID:  "a8f4d2061f55c712cfae266c426a1cd568",
 	Bin: "0x606060405260dc8060106000396000f3606060405260e060020a60003504633175aae28114601a575b005b600060605260c0604052600260809081527f486900000000000000000000000000000000000000000000000000000000000060a05260017fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060e0829052610100819052606060c0908152600261012081905281906101409060a09080838184600060046012f1505081517fffff000000000000000000000000000000000000000000000000000000000000169091525050604051610160819003945092505050f3",
 }
 // Tupler is an auto generated Go binding around an Ethereum contract.
 type Tupler struct {
 	abi abi.ABI
 }
 // NewTupler creates a new instance of Tupler.
 func NewTupler() *Tupler {
 	parsed, err := TuplerMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &Tupler{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *Tupler) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackTuple is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x3175aae2.
 //
 // Solidity: function tuple() returns(string a, int256 b, bytes32 c)
 func (tupler *Tupler) PackTuple() []byte {
 	enc, err := tupler.abi.Pack("tuple")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // TupleOutput serves as a container for the return parameters of contract
 // method Tuple.
 type TupleOutput struct {
 	A string
 	B *big.Int
 	C [32]byte
 }
 // UnpackTuple is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x3175aae2.
 //
 // Solidity: function tuple() returns(string a, int256 b, bytes32 c)
 func (tupler *Tupler) UnpackTuple(data []byte) (TupleOutput, error) {
 	out, err := tupler.abi.Unpack("tuple", data)
 	outstruct := new(TupleOutput)
 	if err != nil {
 		return *outstruct, err
 	}
 	outstruct.A = *abi.ConvertType(out[0], new(string)).(*string)
 	outstruct.B = abi.ConvertType(out[1], new(big.Int)).(*big.Int)
 	outstruct.C = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte)
 	return *outstruct, err
 }
--- a/accounts/abi/abigen/testdata/v2/underscorer.go.txt
+++ b/accounts/abi/abigen/testdata/v2/underscorer.go.txt
@ -0,0 +1,322 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package bindtests
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // UnderscorerMetaData contains all meta data concerning the Underscorer contract.
 var UnderscorerMetaData = bind.MetaData{
 	ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"LowerUpperCollision\",\"outputs\":[{\"name\":\"_res\",\"type\":\"int256\"},{\"name\":\"Res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"_under_scored_func\",\"outputs\":[{\"name\":\"_int\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"UnderscoredOutput\",\"outputs\":[{\"name\":\"_int\",\"type\":\"int256\"},{\"name\":\"_string\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"PurelyUnderscoredOutput\",\"outputs\":[{\"name\":\"_\",\"type\":\"int256\"},{\"name\":\"res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"UpperLowerCollision\",\"outputs\":[{\"name\":\"_Res\",\"type\":\"int256\"},{\"name\":\"res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"AllPurelyUnderscoredOutput\",\"outputs\":[{\"name\":\"_\",\"type\":\"int256\"},{\"name\":\"__\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"UpperUpperCollision\",\"outputs\":[{\"name\":\"_Res\",\"type\":\"int256\"},{\"name\":\"Res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"LowerLowerCollision\",\"outputs\":[{\"name\":\"_res\",\"type\":\"int256\"},{\"name\":\"res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]",
 	ID:  "5873a90ab43c925dfced86ad53f871f01d",
 	Bin: "0x6060604052341561000f57600080fd5b6103858061001e6000396000f30060606040526004361061008e576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806303a592131461009357806346546dbe146100c357806367e6633d146100ec5780639df4848514610181578063af7486ab146101b1578063b564b34d146101e1578063e02ab24d14610211578063e409ca4514610241575b600080fd5b341561009e57600080fd5b6100a6610271565b604051808381526020018281526020019250505060405180910390f35b34156100ce57600080fd5b6100d6610286565b6040518082815260200191505060405180910390f35b34156100f757600080fd5b6100ff61028e565b6040518083815260200180602001828103825283818151815260200191508051906020019080838360005b8381101561014557808201518184015260208101905061012a565b50505050905090810190601f1680156101725780820380516001836020036101000a031916815260200191505b50935050505060405180910390f35b341561018c57600080fd5b6101946102dc565b604051808381526020018281526020019250505060405180910390f35b34156101bc57600080fd5b6101c46102f1565b604051808381526020018281526020019250505060405180910390f35b34156101ec57600080fd5b6101f4610306565b604051808381526020018281526020019250505060405180910390f35b341561021c57600080fd5b61022461031b565b604051808381526020018281526020019250505060405180910390f35b341561024c57600080fd5b610254610330565b604051808381526020018281526020019250505060405180910390f35b60008060016002819150809050915091509091565b600080905090565b6000610298610345565b61013a8090506040805190810160405280600281526020017f7069000000000000000000000000000000000000000000000000000000000000815250915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b6020604051908101604052806000815250905600a165627a7a72305820d1a53d9de9d1e3d55cb3dc591900b63c4f1ded79114f7b79b332684840e186a40029",
 }
 // Underscorer is an auto generated Go binding around an Ethereum contract.
 type Underscorer struct {
 	abi abi.ABI
 }
 // NewUnderscorer creates a new instance of Underscorer.
 func NewUnderscorer() *Underscorer {
 	parsed, err := UnderscorerMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &Underscorer{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *Underscorer) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackAllPurelyUnderscoredOutput is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xb564b34d.
 //
 // Solidity: function AllPurelyUnderscoredOutput() view returns(int256 _, int256 __)
 func (underscorer *Underscorer) PackAllPurelyUnderscoredOutput() []byte {
 	enc, err := underscorer.abi.Pack("AllPurelyUnderscoredOutput")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // AllPurelyUnderscoredOutputOutput serves as a container for the return parameters of contract
 // method AllPurelyUnderscoredOutput.
 type AllPurelyUnderscoredOutputOutput struct {
 	Arg0 *big.Int
 	Arg1 *big.Int
 }
 // UnpackAllPurelyUnderscoredOutput is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0xb564b34d.
 //
 // Solidity: function AllPurelyUnderscoredOutput() view returns(int256 _, int256 __)
 func (underscorer *Underscorer) UnpackAllPurelyUnderscoredOutput(data []byte) (AllPurelyUnderscoredOutputOutput, error) {
 	out, err := underscorer.abi.Unpack("AllPurelyUnderscoredOutput", data)
 	outstruct := new(AllPurelyUnderscoredOutputOutput)
 	if err != nil {
 		return *outstruct, err
 	}
 	outstruct.Arg0 = abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	outstruct.Arg1 = abi.ConvertType(out[1], new(big.Int)).(*big.Int)
 	return *outstruct, err
 }
 // PackLowerLowerCollision is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xe409ca45.
 //
 // Solidity: function LowerLowerCollision() view returns(int256 _res, int256 res)
 func (underscorer *Underscorer) PackLowerLowerCollision() []byte {
 	enc, err := underscorer.abi.Pack("LowerLowerCollision")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // LowerLowerCollisionOutput serves as a container for the return parameters of contract
 // method LowerLowerCollision.
 type LowerLowerCollisionOutput struct {
 	Res  *big.Int
 	Res0 *big.Int
 }
 // UnpackLowerLowerCollision is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0xe409ca45.
 //
 // Solidity: function LowerLowerCollision() view returns(int256 _res, int256 res)
 func (underscorer *Underscorer) UnpackLowerLowerCollision(data []byte) (LowerLowerCollisionOutput, error) {
 	out, err := underscorer.abi.Unpack("LowerLowerCollision", data)
 	outstruct := new(LowerLowerCollisionOutput)
 	if err != nil {
 		return *outstruct, err
 	}
 	outstruct.Res = abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	outstruct.Res0 = abi.ConvertType(out[1], new(big.Int)).(*big.Int)
 	return *outstruct, err
 }
 // PackLowerUpperCollision is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x03a59213.
 //
 // Solidity: function LowerUpperCollision() view returns(int256 _res, int256 Res)
 func (underscorer *Underscorer) PackLowerUpperCollision() []byte {
 	enc, err := underscorer.abi.Pack("LowerUpperCollision")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // LowerUpperCollisionOutput serves as a container for the return parameters of contract
 // method LowerUpperCollision.
 type LowerUpperCollisionOutput struct {
 	Res  *big.Int
 	Res0 *big.Int
 }
 // UnpackLowerUpperCollision is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x03a59213.
 //
 // Solidity: function LowerUpperCollision() view returns(int256 _res, int256 Res)
 func (underscorer *Underscorer) UnpackLowerUpperCollision(data []byte) (LowerUpperCollisionOutput, error) {
 	out, err := underscorer.abi.Unpack("LowerUpperCollision", data)
 	outstruct := new(LowerUpperCollisionOutput)
 	if err != nil {
 		return *outstruct, err
 	}
 	outstruct.Res = abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	outstruct.Res0 = abi.ConvertType(out[1], new(big.Int)).(*big.Int)
 	return *outstruct, err
 }
 // PackPurelyUnderscoredOutput is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x9df48485.
 //
 // Solidity: function PurelyUnderscoredOutput() view returns(int256 _, int256 res)
 func (underscorer *Underscorer) PackPurelyUnderscoredOutput() []byte {
 	enc, err := underscorer.abi.Pack("PurelyUnderscoredOutput")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PurelyUnderscoredOutputOutput serves as a container for the return parameters of contract
 // method PurelyUnderscoredOutput.
 type PurelyUnderscoredOutputOutput struct {
 	Arg0 *big.Int
 	Res  *big.Int
 }
 // UnpackPurelyUnderscoredOutput is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x9df48485.
 //
 // Solidity: function PurelyUnderscoredOutput() view returns(int256 _, int256 res)
 func (underscorer *Underscorer) UnpackPurelyUnderscoredOutput(data []byte) (PurelyUnderscoredOutputOutput, error) {
 	out, err := underscorer.abi.Unpack("PurelyUnderscoredOutput", data)
 	outstruct := new(PurelyUnderscoredOutputOutput)
 	if err != nil {
 		return *outstruct, err
 	}
 	outstruct.Arg0 = abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	outstruct.Res = abi.ConvertType(out[1], new(big.Int)).(*big.Int)
 	return *outstruct, err
 }
 // PackUnderscoredOutput is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x67e6633d.
 //
 // Solidity: function UnderscoredOutput() view returns(int256 _int, string _string)
 func (underscorer *Underscorer) PackUnderscoredOutput() []byte {
 	enc, err := underscorer.abi.Pack("UnderscoredOutput")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnderscoredOutputOutput serves as a container for the return parameters of contract
 // method UnderscoredOutput.
 type UnderscoredOutputOutput struct {
 	Int    *big.Int
 	String string
 }
 // UnpackUnderscoredOutput is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x67e6633d.
 //
 // Solidity: function UnderscoredOutput() view returns(int256 _int, string _string)
 func (underscorer *Underscorer) UnpackUnderscoredOutput(data []byte) (UnderscoredOutputOutput, error) {
 	out, err := underscorer.abi.Unpack("UnderscoredOutput", data)
 	outstruct := new(UnderscoredOutputOutput)
 	if err != nil {
 		return *outstruct, err
 	}
 	outstruct.Int = abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	outstruct.String = *abi.ConvertType(out[1], new(string)).(*string)
 	return *outstruct, err
 }
 // PackUpperLowerCollision is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xaf7486ab.
 //
 // Solidity: function UpperLowerCollision() view returns(int256 _Res, int256 res)
 func (underscorer *Underscorer) PackUpperLowerCollision() []byte {
 	enc, err := underscorer.abi.Pack("UpperLowerCollision")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UpperLowerCollisionOutput serves as a container for the return parameters of contract
 // method UpperLowerCollision.
 type UpperLowerCollisionOutput struct {
 	Res  *big.Int
 	Res0 *big.Int
 }
 // UnpackUpperLowerCollision is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0xaf7486ab.
 //
 // Solidity: function UpperLowerCollision() view returns(int256 _Res, int256 res)
 func (underscorer *Underscorer) UnpackUpperLowerCollision(data []byte) (UpperLowerCollisionOutput, error) {
 	out, err := underscorer.abi.Unpack("UpperLowerCollision", data)
 	outstruct := new(UpperLowerCollisionOutput)
 	if err != nil {
 		return *outstruct, err
 	}
 	outstruct.Res = abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	outstruct.Res0 = abi.ConvertType(out[1], new(big.Int)).(*big.Int)
 	return *outstruct, err
 }
 // PackUpperUpperCollision is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xe02ab24d.
 //
 // Solidity: function UpperUpperCollision() view returns(int256 _Res, int256 Res)
 func (underscorer *Underscorer) PackUpperUpperCollision() []byte {
 	enc, err := underscorer.abi.Pack("UpperUpperCollision")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UpperUpperCollisionOutput serves as a container for the return parameters of contract
 // method UpperUpperCollision.
 type UpperUpperCollisionOutput struct {
 	Res  *big.Int
 	Res0 *big.Int
 }
 // UnpackUpperUpperCollision is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0xe02ab24d.
 //
 // Solidity: function UpperUpperCollision() view returns(int256 _Res, int256 Res)
 func (underscorer *Underscorer) UnpackUpperUpperCollision(data []byte) (UpperUpperCollisionOutput, error) {
 	out, err := underscorer.abi.Unpack("UpperUpperCollision", data)
 	outstruct := new(UpperUpperCollisionOutput)
 	if err != nil {
 		return *outstruct, err
 	}
 	outstruct.Res = abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	outstruct.Res0 = abi.ConvertType(out[1], new(big.Int)).(*big.Int)
 	return *outstruct, err
 }
 // PackUnderScoredFunc is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x46546dbe.
 //
 // Solidity: function _under_scored_func() view returns(int256 _int)
 func (underscorer *Underscorer) PackUnderScoredFunc() []byte {
 	enc, err := underscorer.abi.Pack("_under_scored_func")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackUnderScoredFunc is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x46546dbe.
 //
 // Solidity: function _under_scored_func() view returns(int256 _int)
 func (underscorer *Underscorer) UnpackUnderScoredFunc(data []byte) (*big.Int, error) {
 	out, err := underscorer.abi.Unpack("_under_scored_func", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
--- a/accounts/abi/argument.go
+++ b/accounts/abi/argument.go
@ -77,18 +77,18 @@ func (arguments Arguments) isTuple() bool {
 }
 // Unpack performs the operation hexdata -> Go format.
-func (arguments Arguments) Unpack(data []byte) ([]interface{}, error) {
+func (arguments Arguments) Unpack(data []byte) ([]any, 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 make([]interface{}, 0), nil
+		return make([]any, 0), nil
 	}
 	return arguments.UnpackValues(data)
 }
 // UnpackIntoMap performs the operation hexdata -> mapping of argument name to argument value.
-func (arguments Arguments) UnpackIntoMap(v map[string]interface{}, data []byte) error {
+func (arguments Arguments) UnpackIntoMap(v map[string]any, data []byte) error {
 	// Make sure map is not nil
 	if v == nil {
 		return errors.New("abi: cannot unpack into a nil map")
@ -110,7 +110,7 @@ func (arguments Arguments) UnpackIntoMap(v map[string]interface{}, data []byte)
 }
 // Copy performs the operation go format -> provided struct.
-func (arguments Arguments) Copy(v interface{}, values []interface{}) error {
+func (arguments Arguments) Copy(v any, values []any) error {
 	// make sure the passed value is arguments pointer
 	if reflect.Ptr != reflect.ValueOf(v).Kind() {
 		return fmt.Errorf("abi: Unpack(non-pointer %T)", v)
@ -127,8 +127,8 @@ func (arguments Arguments) Copy(v interface{}, values []interface{}) error {
 	return arguments.copyAtomic(v, values[0])
 }
-// unpackAtomic unpacks ( hexdata -> go ) a single value
+// copyAtomic copies ( hexdata -> go ) a single value
-func (arguments Arguments) copyAtomic(v interface{}, marshalledValues interface{}) error {
+func (arguments Arguments) copyAtomic(v any, marshalledValues any) error {
 	dst := reflect.ValueOf(v).Elem()
 	src := reflect.ValueOf(marshalledValues)
@ -139,7 +139,7 @@ func (arguments Arguments) copyAtomic(v interface{}, marshalledValues interface{
 }
 // copyTuple copies a batch of values from marshalledValues to v.
-func (arguments Arguments) copyTuple(v interface{}, marshalledValues []interface{}) error {
+func (arguments Arguments) copyTuple(v any, marshalledValues []any) error {
 	value := reflect.ValueOf(v).Elem()
 	nonIndexedArgs := arguments.NonIndexed()
@ -181,11 +181,17 @@ func (arguments Arguments) copyTuple(v interface{}, marshalledValues []interface
 // UnpackValues can be used to unpack ABI-encoded hexdata according to the ABI-specification,
 // without supplying a struct to unpack into. Instead, this method returns a list containing the
 // values. An atomic argument will be a list with one element.
-func (arguments Arguments) UnpackValues(data []byte) ([]interface{}, error) {
+func (arguments Arguments) UnpackValues(data []byte) ([]any, error) {
-	nonIndexedArgs := arguments.NonIndexed()
+	var (
-	retval := make([]interface{}, 0, len(nonIndexedArgs))
+		retval      = make([]any, 0)
-	virtualArgs := 0
+		virtualArgs = 0
-	for index, arg := range nonIndexedArgs {
+		index       = 0
 	)
 	for _, arg := range arguments {
 		if arg.Indexed {
 			continue
 		}
 		marshalledValue, err := toGoType((index+virtualArgs)*32, arg.Type, data)
 		if err != nil {
 			return nil, err
@ -208,18 +214,19 @@ func (arguments Arguments) UnpackValues(data []byte) ([]interface{}, error) {
 			virtualArgs += getTypeSize(arg.Type)/32 - 1
 		}
 		retval = append(retval, marshalledValue)
 		index++
 	}
 	return retval, nil
 }
 // PackValues performs the operation Go format -> Hexdata.
 // It is the semantic opposite of UnpackValues.
-func (arguments Arguments) PackValues(args []interface{}) ([]byte, error) {
+func (arguments Arguments) PackValues(args []any) ([]byte, error) {
 	return arguments.Pack(args...)
 }
 // Pack performs the operation Go format -> Hexdata.
-func (arguments Arguments) Pack(args ...interface{}) ([]byte, error) {
+func (arguments Arguments) Pack(args ...any) ([]byte, error) {
 	// Make sure arguments match up and pack them
 	abiArgs := arguments
 	if len(args) != len(abiArgs) {
--- a/accounts/abi/bind/auth.go
+++ b/accounts/abi/bind/auth.go
@ -1,179 +0,0 @@
 // Copyright 2016 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Lesser General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 //
 // The go-ethereum library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 // GNU Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 package bind
 import (
 	"context"
 	"crypto/ecdsa"
 	"errors"
 	"io"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/accounts/external"
 	"github.com/ethereum/go-ethereum/accounts/keystore"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/log"
 )
 // ErrNoChainID is returned whenever the user failed to specify a chain id.
 var ErrNoChainID = errors.New("no chain id specified")
 // ErrNotAuthorized is returned when an account is not properly unlocked.
 var ErrNotAuthorized = errors.New("not authorized to sign this account")
 // NewTransactor is a utility method to easily create a transaction signer from
 // an encrypted json key stream and the associated passphrase.
 //
 // Deprecated: Use NewTransactorWithChainID instead.
 func NewTransactor(keyin io.Reader, passphrase string) (*TransactOpts, error) {
 	log.Warn("WARNING: NewTransactor has been deprecated in favour of NewTransactorWithChainID")
 	json, err := io.ReadAll(keyin)
 	if err != nil {
 		return nil, err
 	}
 	key, err := keystore.DecryptKey(json, passphrase)
 	if err != nil {
 		return nil, err
 	}
 	return NewKeyedTransactor(key.PrivateKey), nil
 }
 // NewKeyStoreTransactor is a utility method to easily create a transaction signer from
 // a decrypted key from a keystore.
 //
 // Deprecated: Use NewKeyStoreTransactorWithChainID instead.
 func NewKeyStoreTransactor(keystore *keystore.KeyStore, account accounts.Account) (*TransactOpts, error) {
 	log.Warn("WARNING: NewKeyStoreTransactor has been deprecated in favour of NewTransactorWithChainID")
 	signer := types.HomesteadSigner{}
 	return &TransactOpts{
 		From: account.Address,
 		Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
 			if address != account.Address {
 				return nil, ErrNotAuthorized
 			}
 			signature, err := keystore.SignHash(account, signer.Hash(tx).Bytes())
 			if err != nil {
 				return nil, err
 			}
 			return tx.WithSignature(signer, signature)
 		},
 		Context: context.Background(),
 	}, nil
 }
 // NewKeyedTransactor is a utility method to easily create a transaction signer
 // from a single private key.
 //
 // Deprecated: Use NewKeyedTransactorWithChainID instead.
 func NewKeyedTransactor(key *ecdsa.PrivateKey) *TransactOpts {
 	log.Warn("WARNING: NewKeyedTransactor has been deprecated in favour of NewKeyedTransactorWithChainID")
 	keyAddr := crypto.PubkeyToAddress(key.PublicKey)
 	signer := types.HomesteadSigner{}
 	return &TransactOpts{
 		From: keyAddr,
 		Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
 			if address != keyAddr {
 				return nil, ErrNotAuthorized
 			}
 			signature, err := crypto.Sign(signer.Hash(tx).Bytes(), key)
 			if err != nil {
 				return nil, err
 			}
 			return tx.WithSignature(signer, signature)
 		},
 		Context: context.Background(),
 	}
 }
 // NewTransactorWithChainID is a utility method to easily create a transaction signer from
 // an encrypted json key stream and the associated passphrase.
 func NewTransactorWithChainID(keyin io.Reader, passphrase string, chainID *big.Int) (*TransactOpts, error) {
 	json, err := io.ReadAll(keyin)
 	if err != nil {
 		return nil, err
 	}
 	key, err := keystore.DecryptKey(json, passphrase)
 	if err != nil {
 		return nil, err
 	}
 	return NewKeyedTransactorWithChainID(key.PrivateKey, chainID)
 }
 // NewKeyStoreTransactorWithChainID is a utility method to easily create a transaction signer from
 // 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
 	}
 	signer := types.LatestSignerForChainID(chainID)
 	return &TransactOpts{
 		From: account.Address,
 		Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
 			if address != account.Address {
 				return nil, ErrNotAuthorized
 			}
 			signature, err := keystore.SignHash(account, signer.Hash(tx).Bytes())
 			if err != nil {
 				return nil, err
 			}
 			return tx.WithSignature(signer, signature)
 		},
 		Context: context.Background(),
 	}, nil
 }
 // NewKeyedTransactorWithChainID is a utility method to easily create a transaction signer
 // from a single private key.
 func NewKeyedTransactorWithChainID(key *ecdsa.PrivateKey, chainID *big.Int) (*TransactOpts, error) {
 	keyAddr := crypto.PubkeyToAddress(key.PublicKey)
 	if chainID == nil {
 		return nil, ErrNoChainID
 	}
 	signer := types.LatestSignerForChainID(chainID)
 	return &TransactOpts{
 		From: keyAddr,
 		Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
 			if address != keyAddr {
 				return nil, ErrNotAuthorized
 			}
 			signature, err := crypto.Sign(signer.Hash(tx).Bytes(), key)
 			if err != nil {
 				return nil, err
 			}
 			return tx.WithSignature(signer, signature)
 		},
 		Context: context.Background(),
 	}, nil
 }
 // NewClefTransactor is a utility method to easily create a transaction signer
 // with a clef backend.
 func NewClefTransactor(clef *external.ExternalSigner, account accounts.Account) *TransactOpts {
 	return &TransactOpts{
 		From: account.Address,
 		Signer: func(address common.Address, transaction *types.Transaction) (*types.Transaction, error) {
 			if address != account.Address {
 				return nil, ErrNotAuthorized
 			}
 			return clef.SignTx(account, transaction, nil) // Clef enforces its own chain id
 		},
 		Context: context.Background(),
 	}
 }
--- a/accounts/abi/bind/old.go
+++ b/accounts/abi/bind/old.go
@ -0,0 +1,294 @@
 // Copyright 2016 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Lesser General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 //
 // The go-ethereum library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 // GNU Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 // Package bind is the runtime for abigen v1 generated contract bindings.
 // Deprecated: please use github.com/ethereum/go-ethereum/bind/v2
 package bind
 import (
 	"context"
 	"crypto/ecdsa"
 	"errors"
 	"io"
 	"math/big"
 	"strings"
 	"sync"
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/abigen"
 	bind2 "github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/accounts/external"
 	"github.com/ethereum/go-ethereum/accounts/keystore"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/log"
 )
 // Bind generates a v1 contract binding.
 // Deprecated: binding generation has moved to github.com/ethereum/go-ethereum/accounts/abi/abigen
 func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, libs map[string]string, aliases map[string]string) (string, error) {
 	return abigen.Bind(types, abis, bytecodes, fsigs, pkg, libs, aliases)
 }
 // auth.go
 // ErrNoChainID is returned whenever the user failed to specify a chain id.
 var ErrNoChainID = errors.New("no chain id specified")
 // ErrNotAuthorized is returned when an account is not properly unlocked.
 var ErrNotAuthorized = bind2.ErrNotAuthorized
 // NewTransactor is a utility method to easily create a transaction signer from
 // an encrypted json key stream and the associated passphrase.
 //
 // Deprecated: Use NewTransactorWithChainID instead.
 func NewTransactor(keyin io.Reader, passphrase string) (*TransactOpts, error) {
 	log.Warn("WARNING: NewTransactor has been deprecated in favour of NewTransactorWithChainID")
 	json, err := io.ReadAll(keyin)
 	if err != nil {
 		return nil, err
 	}
 	key, err := keystore.DecryptKey(json, passphrase)
 	if err != nil {
 		return nil, err
 	}
 	return NewKeyedTransactor(key.PrivateKey), nil
 }
 // NewKeyStoreTransactor is a utility method to easily create a transaction signer from
 // a decrypted key from a keystore.
 //
 // Deprecated: Use NewKeyStoreTransactorWithChainID instead.
 func NewKeyStoreTransactor(keystore *keystore.KeyStore, account accounts.Account) (*TransactOpts, error) {
 	log.Warn("WARNING: NewKeyStoreTransactor has been deprecated in favour of NewTransactorWithChainID")
 	signer := types.HomesteadSigner{}
 	return &TransactOpts{
 		From: account.Address,
 		Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
 			if address != account.Address {
 				return nil, ErrNotAuthorized
 			}
 			signature, err := keystore.SignHash(account, signer.Hash(tx).Bytes())
 			if err != nil {
 				return nil, err
 			}
 			return tx.WithSignature(signer, signature)
 		},
 		Context: context.Background(),
 	}, nil
 }
 // NewKeyedTransactor is a utility method to easily create a transaction signer
 // from a single private key.
 //
 // Deprecated: Use NewKeyedTransactorWithChainID instead.
 func NewKeyedTransactor(key *ecdsa.PrivateKey) *TransactOpts {
 	log.Warn("WARNING: NewKeyedTransactor has been deprecated in favour of NewKeyedTransactorWithChainID")
 	keyAddr := crypto.PubkeyToAddress(key.PublicKey)
 	signer := types.HomesteadSigner{}
 	return &TransactOpts{
 		From: keyAddr,
 		Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
 			if address != keyAddr {
 				return nil, ErrNotAuthorized
 			}
 			signature, err := crypto.Sign(signer.Hash(tx).Bytes(), key)
 			if err != nil {
 				return nil, err
 			}
 			return tx.WithSignature(signer, signature)
 		},
 		Context: context.Background(),
 	}
 }
 // NewTransactorWithChainID is a utility method to easily create a transaction signer from
 // an encrypted json key stream and the associated passphrase.
 func NewTransactorWithChainID(keyin io.Reader, passphrase string, chainID *big.Int) (*TransactOpts, error) {
 	json, err := io.ReadAll(keyin)
 	if err != nil {
 		return nil, err
 	}
 	key, err := keystore.DecryptKey(json, passphrase)
 	if err != nil {
 		return nil, err
 	}
 	return NewKeyedTransactorWithChainID(key.PrivateKey, chainID)
 }
 // NewKeyStoreTransactorWithChainID is a utility method to easily create a transaction signer from
 // a decrypted key from a keystore.
 func NewKeyStoreTransactorWithChainID(keystore *keystore.KeyStore, account accounts.Account, chainID *big.Int) (*TransactOpts, error) {
 	// New version panics for chainID == nil, catch it here.
 	if chainID == nil {
 		return nil, ErrNoChainID
 	}
 	return bind2.NewKeyStoreTransactor(keystore, account, chainID), nil
 }
 // NewKeyedTransactorWithChainID is a utility method to easily create a transaction signer
 // from a single private key.
 func NewKeyedTransactorWithChainID(key *ecdsa.PrivateKey, chainID *big.Int) (*TransactOpts, error) {
 	// New version panics for chainID == nil, catch it here.
 	if chainID == nil {
 		return nil, ErrNoChainID
 	}
 	return bind2.NewKeyedTransactor(key, chainID), nil
 }
 // NewClefTransactor is a utility method to easily create a transaction signer
 // with a clef backend.
 func NewClefTransactor(clef *external.ExternalSigner, account accounts.Account) *TransactOpts {
 	return bind2.NewClefTransactor(clef, account)
 }
 // backend.go
 var (
 	// ErrNoCode is returned by call and transact operations for which the requested
 	// recipient contract to operate on does not exist in the state db or does not
 	// have any code associated with it (i.e. self-destructed).
 	ErrNoCode = bind2.ErrNoCode
 	// ErrNoPendingState is raised when attempting to perform a pending state action
 	// on a backend that doesn't implement PendingContractCaller.
 	ErrNoPendingState = bind2.ErrNoPendingState
 	// ErrNoBlockHashState is raised when attempting to perform a block hash action
 	// on a backend that doesn't implement BlockHashContractCaller.
 	ErrNoBlockHashState = bind2.ErrNoBlockHashState
 	// ErrNoCodeAfterDeploy is returned by WaitDeployed if contract creation leaves
 	// an empty contract behind.
 	ErrNoCodeAfterDeploy = bind2.ErrNoCodeAfterDeploy
 )
 // ContractCaller defines the methods needed to allow operating with a contract on a read
 // only basis.
 type ContractCaller = bind2.ContractCaller
 // PendingContractCaller defines methods to perform contract calls on the pending state.
 // Call will try to discover this interface when access to the pending state is requested.
 // If the backend does not support the pending state, Call returns ErrNoPendingState.
 type PendingContractCaller = bind2.PendingContractCaller
 // 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 = bind2.BlockHashContractCaller
 // 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 = bind2.ContractTransactor
 // DeployBackend wraps the operations needed by WaitMined and WaitDeployed.
 type DeployBackend = bind2.DeployBackend
 // ContractFilterer defines the methods needed to access log events using one-off
 // queries or continuous event subscriptions.
 type ContractFilterer = bind2.ContractFilterer
 // ContractBackend defines the methods needed to work with contracts on a read-write basis.
 type ContractBackend = bind2.ContractBackend
 // base.go
 type SignerFn = bind2.SignerFn
 type CallOpts = bind2.CallOpts
 type TransactOpts = bind2.TransactOpts
 type FilterOpts = bind2.FilterOpts
 type WatchOpts = bind2.WatchOpts
 type BoundContract = bind2.BoundContract
 func NewBoundContract(address common.Address, abi abi.ABI, caller ContractCaller, transactor ContractTransactor, filterer ContractFilterer) *BoundContract {
 	return bind2.NewBoundContract(address, abi, caller, transactor, filterer)
 }
 func DeployContract(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend ContractBackend, params ...interface{}) (common.Address, *types.Transaction, *BoundContract, error) {
 	packed, err := abi.Pack("", params...)
 	if err != nil {
 		return common.Address{}, nil, nil, err
 	}
 	addr, tx, err := bind2.DeployContract(opts, bytecode, backend, packed)
 	if err != nil {
 		return common.Address{}, nil, nil, err
 	}
 	contract := NewBoundContract(addr, abi, backend, backend, backend)
 	return addr, tx, contract, nil
 }
 // MetaData collects all metadata for a bound contract.
 type MetaData struct {
 	Bin       string            // runtime bytecode (as a hex string)
 	ABI       string            // the raw ABI definition (JSON)
 	Sigs      map[string]string // 4byte identifier -> function signature
 	mu        sync.Mutex
 	parsedABI *abi.ABI
 }
 // GetAbi returns the parsed ABI definition.
 func (m *MetaData) GetAbi() (*abi.ABI, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	if m.parsedABI != nil {
 		return m.parsedABI, nil
 	}
 	if parsed, err := abi.JSON(strings.NewReader(m.ABI)); err != nil {
 		return nil, err
 	} else {
 		m.parsedABI = &parsed
 	}
 	return m.parsedABI, nil
 }
 // util.go
 // WaitMined waits for tx to be mined on the blockchain.
 // It stops waiting when the context is canceled.
 func WaitMined(ctx context.Context, b DeployBackend, tx *types.Transaction) (*types.Receipt, error) {
 	return bind2.WaitMined(ctx, b, tx.Hash())
 }
 // WaitMinedHash waits for a transaction with the provided hash to be mined on the blockchain.
 // It stops waiting when the context is canceled.
 func WaitMinedHash(ctx context.Context, b DeployBackend, hash common.Hash) (*types.Receipt, error) {
 	return bind2.WaitMined(ctx, b, hash)
 }
 // WaitDeployed waits for a contract deployment transaction and returns the on-chain
 // contract address when it is mined. It stops waiting when ctx is canceled.
 func WaitDeployed(ctx context.Context, b DeployBackend, tx *types.Transaction) (common.Address, error) {
 	if tx.To() != nil {
 		return common.Address{}, errors.New("tx is not contract creation")
 	}
 	return bind2.WaitDeployed(ctx, b, tx.Hash())
 }
 // WaitDeployedHash waits for a contract deployment transaction with the provided hash and returns the on-chain
 // contract address when it is mined. It stops waiting when ctx is canceled.
 func WaitDeployedHash(ctx context.Context, b DeployBackend, hash common.Hash) (common.Address, error) {
 	return bind2.WaitDeployed(ctx, b, hash)
 }
--- a/accounts/abi/bind/v2/auth.go
+++ b/accounts/abi/bind/v2/auth.go
@ -0,0 +1,96 @@
 // Copyright 2016 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Lesser General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 //
 // The go-ethereum library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 // GNU Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 package bind
 import (
 	"context"
 	"crypto/ecdsa"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/accounts/external"
 	"github.com/ethereum/go-ethereum/accounts/keystore"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 )
 // ErrNotAuthorized is returned when an account is not properly unlocked.
 var ErrNotAuthorized = errors.New("not authorized to sign this account")
 // NewKeyStoreTransactor is a utility method to easily create a transaction signer from
 // a decrypted key from a keystore.
 func NewKeyStoreTransactor(keystore *keystore.KeyStore, account accounts.Account, chainID *big.Int) *TransactOpts {
 	if chainID == nil {
 		panic("nil chainID")
 	}
 	signer := types.LatestSignerForChainID(chainID)
 	return &TransactOpts{
 		From: account.Address,
 		Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
 			if address != account.Address {
 				return nil, ErrNotAuthorized
 			}
 			signature, err := keystore.SignHash(account, signer.Hash(tx).Bytes())
 			if err != nil {
 				return nil, err
 			}
 			return tx.WithSignature(signer, signature)
 		},
 		Context: context.Background(),
 	}
 }
 // NewKeyedTransactor is a utility method to easily create a transaction signer
 // from a single private key.
 func NewKeyedTransactor(key *ecdsa.PrivateKey, chainID *big.Int) *TransactOpts {
 	if chainID == nil {
 		panic("nil chainID")
 	}
 	keyAddr := crypto.PubkeyToAddress(key.PublicKey)
 	signer := types.LatestSignerForChainID(chainID)
 	return &TransactOpts{
 		From: keyAddr,
 		Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
 			if address != keyAddr {
 				return nil, ErrNotAuthorized
 			}
 			signature, err := crypto.Sign(signer.Hash(tx).Bytes(), key)
 			if err != nil {
 				return nil, err
 			}
 			return tx.WithSignature(signer, signature)
 		},
 		Context: context.Background(),
 	}
 }
 // NewClefTransactor is a utility method to easily create a transaction signer
 // with a clef backend.
 func NewClefTransactor(clef *external.ExternalSigner, account accounts.Account) *TransactOpts {
 	return &TransactOpts{
 		From: account.Address,
 		Signer: func(address common.Address, transaction *types.Transaction) (*types.Transaction, error) {
 			if address != account.Address {
 				return nil, ErrNotAuthorized
 			}
 			return clef.SignTx(account, transaction, nil) // Clef enforces its own chain id
 		},
 		Context: context.Background(),
 	}
 }
--- a/accounts/abi/bind/v2/backend.go
+++ b/accounts/abi/bind/v2/backend.go
@ -43,6 +43,11 @@ var (
 	// ErrNoCodeAfterDeploy is returned by WaitDeployed if contract creation leaves
 	// an empty contract behind.
 	ErrNoCodeAfterDeploy = errors.New("no contract code after deployment")
 	// ErrNoAddressInReceipt is returned by WaitDeployed when the receipt for the
 	// transaction hash does not contain a contract address. This error may indicate
 	// that the transaction hash was not a CREATE transaction.
 	ErrNoAddressInReceipt = errors.New("no contract address in receipt")
 )
 // ContractCaller defines the methods needed to allow operating with a contract on a read
@ -84,6 +89,11 @@ type BlockHashContractCaller interface {
 // 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)
@ -93,38 +103,6 @@ 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
 }
 // 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.
@ -133,9 +111,23 @@ type DeployBackend interface {
 	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
 	ContractTransactor
 	ContractFilterer
 }
 // Backend combines all backend methods used in this package. This type is provided for
 // convenience. It is meant to be used when you need to hold a reference to a backend that
 // is used for both deployment and contract interaction.
 type Backend interface {
 	DeployBackend
 	ContractBackend
 }
--- a/accounts/abi/bind/v2/base.go
+++ b/accounts/abi/bind/v2/base.go
@ -25,10 +25,10 @@ import (
 	"sync"
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/event"
 )
@ -64,6 +64,7 @@ type TransactOpts struct {
 	GasFeeCap  *big.Int         // Gas fee cap to use for the 1559 transaction execution (nil = gas price oracle)
 	GasTipCap  *big.Int         // Gas priority fee cap to use for the 1559 transaction execution (nil = gas price oracle)
 	GasLimit   uint64           // Gas limit to set for the transaction execution (0 = estimate)
 	AccessList types.AccessList // Access list to set for the transaction execution (nil = no access list)
 	Context context.Context // Network context to support cancellation and timeouts (nil = no timeout)
@ -88,25 +89,42 @@ type WatchOpts struct {
 // MetaData collects all metadata for a bound contract.
 type MetaData struct {
 	Bin  string      // deployer bytecode (as a hex string)
 	ABI  string      // the raw ABI definition (JSON)
 	Deps []*MetaData // library dependencies of the contract
 	// For bindings that were compiled from combined-json ID is the Solidity
 	// library pattern: a 34 character prefix of the hex encoding of the keccak256
 	// hash of the fully qualified 'library name', i.e. the path of the source file.
 	//
 	// For contracts compiled from the ABI definition alone, this is the type name
 	// of the contract (as specified in the ABI definition or overridden via the
 	// --type flag).
 	//
 	// This is a unique identifier of a contract within a compilation unit. When
 	// used as part of a multi-contract deployment with library dependencies, the
 	// ID is used to link contracts during deployment using [LinkAndDeploy].
 	ID string
 	mu        sync.Mutex
-	Sigs map[string]string
+	parsedABI *abi.ABI
 	Bin  string
 	ABI  string
 	ab   *abi.ABI
 }
-func (m *MetaData) GetAbi() (*abi.ABI, error) {
+// ParseABI returns the parsed ABI specification, or an error if the string
 // representation of the ABI set in the MetaData instance could not be parsed.
 func (m *MetaData) ParseABI() (*abi.ABI, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	if m.ab != nil {
+
-		return m.ab, nil
+	if m.parsedABI != nil {
 		return m.parsedABI, nil
 	}
 	if parsed, err := abi.JSON(strings.NewReader(m.ABI)); err != nil {
 		return nil, err
 	} else {
-		m.ab = &parsed
+		m.parsedABI = &parsed
 	}
-	return m.ab, nil
+	return m.parsedABI, nil
 }
 // BoundContract is the base wrapper object that reflects a contract on the
@ -132,95 +150,24 @@ func NewBoundContract(address common.Address, abi abi.ABI, caller ContractCaller
 	}
 }
 // DeployContract deploys a contract onto the Ethereum blockchain and binds the
 // deployment address with a Go wrapper.
 func DeployContract(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend ContractBackend, params ...interface{}) (common.Address, *types.Transaction, *BoundContract, error) {
 	// Otherwise try to deploy the contract
 	c := NewBoundContract(common.Address{}, abi, backend, backend, backend)
 	input, err := c.abi.Pack("", params...)
 	if err != nil {
 		return common.Address{}, nil, nil, err
 	}
 	tx, err := c.transact(opts, nil, append(bytecode, input...))
 	if err != nil {
 		return common.Address{}, nil, nil, err
 	}
 	c.address = crypto.CreateAddress(opts.From, tx.Nonce())
 	return c.address, tx, c, nil
 }
 // Call invokes the (constant) contract method with params as input values and
 // sets the output to result. The result type might be a single field for simple
 // returns, a slice of interfaces for anonymous returns and a struct for named
 // returns.
-func (c *BoundContract) Call(opts *CallOpts, results *[]interface{}, method string, params ...interface{}) error {
+func (c *BoundContract) Call(opts *CallOpts, results *[]any, method string, params ...any) error {
 	// Don't crash on a lazy user
 	if opts == nil {
 		opts = new(CallOpts)
 	}
 	if results == nil {
-		results = new([]interface{})
+		results = new([]any)
 	}
 	// Pack the input, call and unpack the results
 	input, err := c.abi.Pack(method, params...)
 	if err != nil {
 		return err
 	}
-	var (
+
-		msg    = ethereum.CallMsg{From: opts.From, To: &c.address, Data: input}
+	output, err := c.call(opts, input)
 		ctx    = ensureContext(opts.Context)
 		code   []byte
 		output []byte
 	)
 	if opts.Pending {
 		pb, ok := c.caller.(PendingContractCaller)
 		if !ok {
 			return ErrNoPendingState
 		}
 		output, err = pb.PendingCallContract(ctx, msg)
 	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 = pb.PendingCodeAt(ctx, c.address); err != nil {
 				return err
 			} else if len(code) == 0 {
 				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 {
 			return err
 		}
 		if len(output) == 0 {
 			// Make sure we have a contract to operate on, and bail out otherwise.
 			if code, err = c.caller.CodeAt(ctx, c.address, opts.BlockNumber); err != nil {
 				return err
 			} else if len(code) == 0 {
 				return ErrNoCode
 			}
 		}
 	}
 	if len(*results) == 0 {
 		res, err := c.abi.Unpack(method, output)
@ -231,26 +178,97 @@ func (c *BoundContract) Call(opts *CallOpts, results *[]interface{}, method stri
 	return c.abi.UnpackIntoInterface(res[0], method, output)
 }
 // CallRaw executes an eth_call against the contract with the raw calldata as
 // input.  It returns the call's return data or an error.
 func (c *BoundContract) CallRaw(opts *CallOpts, input []byte) ([]byte, error) {
 	return c.call(opts, input)
 }
 func (c *BoundContract) call(opts *CallOpts, input []byte) ([]byte, error) {
 	// Don't crash on a lazy user
 	if opts == nil {
 		opts = new(CallOpts)
 	}
 	var (
 		msg    = ethereum.CallMsg{From: opts.From, To: &c.address, Data: input}
 		ctx    = ensureContext(opts.Context)
 		code   []byte
 		output []byte
 		err    error
 	)
 	if opts.Pending {
 		pb, ok := c.caller.(PendingContractCaller)
 		if !ok {
 			return nil, ErrNoPendingState
 		}
 		output, err = pb.PendingCallContract(ctx, msg)
 		if err != nil {
 			return nil, err
 		}
 		if len(output) == 0 {
 			// Make sure we have a contract to operate on, and bail out otherwise.
 			if code, err = pb.PendingCodeAt(ctx, c.address); err != nil {
 				return nil, err
 			} else if len(code) == 0 {
 				return nil, ErrNoCode
 			}
 		}
 	} else if opts.BlockHash != (common.Hash{}) {
 		bh, ok := c.caller.(BlockHashContractCaller)
 		if !ok {
 			return nil, ErrNoBlockHashState
 		}
 		output, err = bh.CallContractAtHash(ctx, msg, opts.BlockHash)
 		if err != nil {
 			return nil, 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 nil, err
 			} else if len(code) == 0 {
 				return nil, ErrNoCode
 			}
 		}
 	} else {
 		output, err = c.caller.CallContract(ctx, msg, opts.BlockNumber)
 		if err != nil {
 			return nil, err
 		}
 		if len(output) == 0 {
 			// Make sure we have a contract to operate on, and bail out otherwise.
 			if code, err = c.caller.CodeAt(ctx, c.address, opts.BlockNumber); err != nil {
 				return nil, err
 			} else if len(code) == 0 {
 				return nil, ErrNoCode
 			}
 		}
 	}
 	return output, nil
 }
 // Transact invokes the (paid) contract method with params as input values.
-func (c *BoundContract) Transact(opts *TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+func (c *BoundContract) Transact(opts *TransactOpts, method string, params ...any) (*types.Transaction, error) {
 	// Otherwise pack up the parameters and invoke the contract
 	input, err := c.abi.Pack(method, params...)
 	if err != nil {
 		return nil, err
 	}
 	// todo(rjl493456442) check the method is payable or not,
 	// reject invalid transaction at the first place
 	return c.transact(opts, &c.address, input)
 }
 // 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 the method is payable or not,
 	// reject invalid transaction at the first place
 	return c.transact(opts, &c.address, calldata)
 }
 // RawCreationTransact creates and submits a contract-creation transaction with
 // the given calldata as the input.
 func (c *BoundContract) RawCreationTransact(opts *TransactOpts, calldata []byte) (*types.Transaction, error) {
 	return c.transact(opts, nil, calldata)
 }
 // Transfer initiates a plain transaction to move funds to the contract, calling
 // its default method if one is available.
 func (c *BoundContract) Transfer(opts *TransactOpts) (*types.Transaction, error) {
@ -307,13 +325,14 @@ func (c *BoundContract) createDynamicTx(opts *TransactOpts, contract *common.Add
 		Gas:        gasLimit,
 		Value:      value,
 		Data:       input,
 		AccessList: opts.AccessList,
 	}
 	return types.NewTx(baseTx), nil
 }
 func (c *BoundContract) createLegacyTx(opts *TransactOpts, contract *common.Address, input []byte) (*types.Transaction, error) {
-	if opts.GasFeeCap != nil || opts.GasTipCap != nil {
+	if opts.GasFeeCap != nil || opts.GasTipCap != nil || opts.AccessList != nil {
-		return nil, errors.New("maxFeePerGas or maxPriorityFeePerGas specified but london is not active yet")
+		return nil, errors.New("maxFeePerGas or maxPriorityFeePerGas or accessList specified but london is not active yet")
 	}
 	// Normalize value
 	value := opts.Value
@ -371,6 +390,7 @@ func (c *BoundContract) estimateGasLimit(opts *TransactOpts, contract *common.Ad
 		GasFeeCap:  gasFeeCap,
 		Value:      value,
 		Data:       input,
 		AccessList: opts.AccessList,
 	}
 	return c.transactor.EstimateGas(ensureContext(opts.Context), msg)
 }
@ -431,14 +451,13 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i
 // FilterLogs filters contract logs for past blocks, returning the necessary
 // channels to construct a strongly typed bound iterator on top of them.
-func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) {
+func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]any) (chan types.Log, event.Subscription, error) {
 	// Don't crash on a lazy user
 	if opts == nil {
 		opts = new(FilterOpts)
 	}
 	// Append the event selector to the query parameters and construct the topic set
-	query = append([][]interface{}{{c.abi.Events[name].ID}}, query...)
+	query = append([][]any{{c.abi.Events[name].ID}}, query...)
 	topics, err := abi.MakeTopics(query...)
 	if err != nil {
 		return nil, nil, err
@ -461,7 +480,7 @@ func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]int
 	if err != nil {
 		return nil, nil, err
 	}
-	sub, err := event.NewSubscription(func(quit <-chan struct{}) error {
+	sub := event.NewSubscription(func(quit <-chan struct{}) error {
 		for _, log := range buff {
 			select {
 			case logs <- log:
@ -470,23 +489,20 @@ func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]int
 			}
 		}
 		return nil
-	}), nil
+	})
 	if err != nil {
 		return nil, nil, err
 	}
 	return logs, sub, nil
 }
 // WatchLogs filters subscribes to contract logs for future blocks, returning a
 // subscription object that can be used to tear down the watcher.
-func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) {
+func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]any) (chan types.Log, event.Subscription, error) {
 	// Don't crash on a lazy user
 	if opts == nil {
 		opts = new(WatchOpts)
 	}
 	// Append the event selector to the query parameters and construct the topic set
-	query = append([][]interface{}{{c.abi.Events[name].ID}}, query...)
+	query = append([][]any{{c.abi.Events[name].ID}}, query...)
 	topics, err := abi.MakeTopics(query...)
 	if err != nil {
@ -510,7 +526,7 @@ func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]inter
 }
 // UnpackLog unpacks a retrieved log into the provided output structure.
-func (c *BoundContract) UnpackLog(out interface{}, event string, log types.Log) error {
+func (c *BoundContract) UnpackLog(out any, event string, log types.Log) error {
 	// Anonymous events are not supported.
 	if len(log.Topics) == 0 {
 		return errNoEventSignature
@ -533,7 +549,7 @@ func (c *BoundContract) UnpackLog(out interface{}, event string, log types.Log)
 }
 // UnpackLogIntoMap unpacks a retrieved log into the provided map.
-func (c *BoundContract) UnpackLogIntoMap(out map[string]interface{}, event string, log types.Log) error {
+func (c *BoundContract) UnpackLogIntoMap(out map[string]any, event string, log types.Log) error {
 	// Anonymous events are not supported.
 	if len(log.Topics) == 0 {
 		return errNoEventSignature
--- a/accounts/abi/bind/v2/base_test.go
+++ b/accounts/abi/bind/v2/base_test.go
@ -26,7 +26,7 @@ import (
 	"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/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
--- a/accounts/abi/bind/v2/dep_tree.go
+++ b/accounts/abi/bind/v2/dep_tree.go
@ -0,0 +1,167 @@
 // Copyright 2025 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Lesser General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 //
 // The go-ethereum library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 // GNU Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 package bind
 import (
 	"encoding/hex"
 	"fmt"
 	"maps"
 	"strings"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // DeploymentParams contains parameters needed to deploy one or more contracts via LinkAndDeploy
 type DeploymentParams struct {
 	// list of all contracts targeted for the deployment
 	Contracts []*MetaData
 	// optional map of ABI-encoded constructor inputs keyed by the MetaData.ID.
 	Inputs map[string][]byte
 	// optional map of override addresses for specifying already-deployed
 	// contracts.  It is keyed by the MetaData.ID.
 	Overrides map[string]common.Address
 }
 // validate determines whether the contracts specified in the DeploymentParams
 // instance have embedded deployer code in their provided MetaData instances.
 func (d *DeploymentParams) validate() error {
 	for _, meta := range d.Contracts {
 		if meta.Bin == "" {
 			return fmt.Errorf("cannot deploy contract %s: deployer code missing from metadata", meta.ID)
 		}
 	}
 	return nil
 }
 // DeploymentResult contains information about the result of a pending
 // deployment made by LinkAndDeploy.
 type DeploymentResult struct {
 	// Map of contract MetaData.ID to pending deployment transaction
 	Txs map[string]*types.Transaction
 	// Map of contract MetaData.ID to the address where it will be deployed
 	Addresses map[string]common.Address
 }
 // DeployFn deploys a contract given a deployer and optional input.  It returns
 // the address and a pending transaction, or an error if the deployment failed.
 type DeployFn func(input, deployer []byte) (common.Address, *types.Transaction, error)
 // depTreeDeployer is responsible for taking a dependency, deploying-and-linking
 // its components in the proper order. A depTreeDeployer cannot be used after
 // calling LinkAndDeploy other than to retrieve the deployment result.
 type depTreeDeployer struct {
 	deployedAddrs map[string]common.Address
 	deployerTxs   map[string]*types.Transaction
 	inputs        map[string][]byte // map of the root contract pattern to the constructor input (if there is any)
 	deployFn      DeployFn
 }
 func newDepTreeDeployer(deployParams *DeploymentParams, deployFn DeployFn) *depTreeDeployer {
 	deployedAddrs := maps.Clone(deployParams.Overrides)
 	if deployedAddrs == nil {
 		deployedAddrs = make(map[string]common.Address)
 	}
 	inputs := deployParams.Inputs
 	if inputs == nil {
 		inputs = make(map[string][]byte)
 	}
 	return &depTreeDeployer{
 		deployFn:      deployFn,
 		deployedAddrs: deployedAddrs,
 		deployerTxs:   make(map[string]*types.Transaction),
 		inputs:        inputs,
 	}
 }
 // linkAndDeploy deploys a contract and it's dependencies.  Because libraries
 // can in-turn have their own library dependencies, linkAndDeploy performs
 // deployment recursively (deepest-dependency first).  The address of the
 // pending contract deployment for the top-level contract is returned.
 func (d *depTreeDeployer) linkAndDeploy(metadata *MetaData) (common.Address, error) {
 	// Don't re-deploy aliased or previously-deployed contracts
 	if addr, ok := d.deployedAddrs[metadata.ID]; ok {
 		return addr, nil
 	}
 	// If this contract/library depends on other libraries deploy them
 	// (and their dependencies) first
 	deployerCode := metadata.Bin
 	for _, dep := range metadata.Deps {
 		addr, err := d.linkAndDeploy(dep)
 		if err != nil {
 			return common.Address{}, err
 		}
 		// Link their deployed addresses into the bytecode to produce
 		deployerCode = strings.ReplaceAll(deployerCode, "__$"+dep.ID+"$__", strings.ToLower(addr.String()[2:]))
 	}
 	// Finally, deploy the top-level contract.
 	code, err := hex.DecodeString(deployerCode[2:])
 	if err != nil {
 		panic(fmt.Sprintf("error decoding contract deployer hex %s:\n%v", deployerCode[2:], err))
 	}
 	addr, tx, err := d.deployFn(d.inputs[metadata.ID], code)
 	if err != nil {
 		return common.Address{}, err
 	}
 	d.deployedAddrs[metadata.ID] = addr
 	d.deployerTxs[metadata.ID] = tx
 	return addr, nil
 }
 // result returns a DeploymentResult instance referencing contracts deployed
 // and not including any overrides specified for this deployment.
 func (d *depTreeDeployer) result() *DeploymentResult {
 	// filter the override addresses from the deployed address set.
 	for pattern := range d.deployedAddrs {
 		if _, ok := d.deployerTxs[pattern]; !ok {
 			delete(d.deployedAddrs, pattern)
 		}
 	}
 	return &DeploymentResult{
 		Txs:       d.deployerTxs,
 		Addresses: d.deployedAddrs,
 	}
 }
 // LinkAndDeploy performs the contract deployment specified by params using the
 // provided DeployFn to create, sign and submit transactions.
 //
 // Contracts can depend on libraries, which in-turn can have their own library
 // dependencies.  Therefore, LinkAndDeploy performs the deployment recursively,
 // starting with libraries (and contracts) that don't have dependencies, and
 // progressing through the contracts that depend upon them.
 //
 // If an error is encountered, the returned DeploymentResult only contains
 // entries for the contracts whose deployment submission succeeded.
 //
 // LinkAndDeploy performs creation and submission of creation transactions,
 // but does not ensure that the contracts are included in the chain.
 func LinkAndDeploy(params *DeploymentParams, deploy DeployFn) (*DeploymentResult, error) {
 	if err := params.validate(); err != nil {
 		return nil, err
 	}
 	deployer := newDepTreeDeployer(params, deploy)
 	for _, contract := range params.Contracts {
 		if _, err := deployer.linkAndDeploy(contract); err != nil {
 			return deployer.result(), err
 		}
 	}
 	return deployer.result(), nil
 }
--- a/accounts/abi/bind/v2/dep_tree_test.go
+++ b/accounts/abi/bind/v2/dep_tree_test.go
@ -0,0 +1,370 @@
 // Copyright 2024 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Lesser General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 //
 // The go-ethereum library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 // GNU Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 package bind
 import (
 	"fmt"
 	"regexp"
 	"testing"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"golang.org/x/exp/rand"
 )
 type linkTestCase struct {
 	// map of pattern to unlinked bytecode (for the purposes of tests just contains the patterns of its dependencies)
 	libCodes      map[string]string
 	contractCodes map[string]string
 	overrides map[string]common.Address
 }
 func copyMetaData(m *MetaData) *MetaData {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	var deps []*MetaData
 	if len(m.Deps) > 0 {
 		for _, dep := range m.Deps {
 			deps = append(deps, copyMetaData(dep))
 		}
 	}
 	return &MetaData{
 		Bin:       m.Bin,
 		ABI:       m.ABI,
 		Deps:      deps,
 		ID:        m.ID,
 		parsedABI: m.parsedABI,
 	}
 }
 func makeLinkTestCase(input map[rune][]rune, overrides map[rune]common.Address) *linkTestCase {
 	codes := make(map[string]string)
 	libCodes := make(map[string]string)
 	contractCodes := make(map[string]string)
 	inputMap := make(map[rune]map[rune]struct{})
 	// set of solidity patterns for all contracts that are known to be libraries
 	libs := make(map[string]struct{})
 	// map of test contract id (rune) to the solidity library pattern (hash of that rune)
 	patternMap := map[rune]string{}
 	for contract, deps := range input {
 		inputMap[contract] = make(map[rune]struct{})
 		if _, ok := patternMap[contract]; !ok {
 			patternMap[contract] = crypto.Keccak256Hash([]byte(string(contract))).String()[2:36]
 		}
 		for _, dep := range deps {
 			if _, ok := patternMap[dep]; !ok {
 				patternMap[dep] = crypto.Keccak256Hash([]byte(string(dep))).String()[2:36]
 			}
 			codes[patternMap[contract]] = codes[patternMap[contract]] + fmt.Sprintf("__$%s$__", patternMap[dep])
 			inputMap[contract][dep] = struct{}{}
 			libs[patternMap[dep]] = struct{}{}
 		}
 	}
 	overridesPatterns := make(map[string]common.Address)
 	for contractId, overrideAddr := range overrides {
 		pattern := crypto.Keccak256Hash([]byte(string(contractId))).String()[2:36]
 		overridesPatterns[pattern] = overrideAddr
 	}
 	for _, pattern := range patternMap {
 		if _, ok := libs[pattern]; ok {
 			// if the library didn't depend on others, give it some dummy code to not bork deployment logic down-the-line
 			if len(codes[pattern]) == 0 {
 				libCodes[pattern] = "ff"
 			} else {
 				libCodes[pattern] = codes[pattern]
 			}
 		} else {
 			contractCodes[pattern] = codes[pattern]
 		}
 	}
 	return &linkTestCase{
 		libCodes,
 		contractCodes,
 		overridesPatterns,
 	}
 }
 var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 type linkTestCaseInput struct {
 	input          map[rune][]rune
 	overrides      map[rune]struct{}
 	expectDeployed map[rune]struct{}
 }
 // linkDeps will return a set of root dependencies and their sub-dependencies connected via the Deps field
 func linkDeps(deps map[string]*MetaData) []*MetaData {
 	roots := make(map[string]struct{})
 	for pattern := range deps {
 		roots[pattern] = struct{}{}
 	}
 	connectedDeps := make(map[string]*MetaData)
 	for pattern, dep := range deps {
 		connectedDeps[pattern] = internalLinkDeps(dep, deps, &roots)
 	}
 	var rootMetadatas []*MetaData
 	for pattern := range roots {
 		dep := connectedDeps[pattern]
 		rootMetadatas = append(rootMetadatas, dep)
 	}
 	return rootMetadatas
 }
 // internalLinkDeps is the internal recursing logic of linkDeps:
 // It links the contract referred to by MetaData given the depMap (map of solidity
 // link pattern to contract metadata object), deleting contract entries from the
 // roots map if they were referenced as dependencies.  It returns a new MetaData
 // object which is the linked version of metadata parameter.
 func internalLinkDeps(metadata *MetaData, depMap map[string]*MetaData, roots *map[string]struct{}) *MetaData {
 	linked := copyMetaData(metadata)
 	depPatterns := parseLibraryDeps(metadata.Bin)
 	for _, pattern := range depPatterns {
 		delete(*roots, pattern)
 		connectedDep := internalLinkDeps(depMap[pattern], depMap, roots)
 		linked.Deps = append(linked.Deps, connectedDep)
 	}
 	return linked
 }
 func testLinkCase(tcInput linkTestCaseInput) error {
 	var (
 		testAddr       = crypto.PubkeyToAddress(testKey.PublicKey)
 		overridesAddrs = make(map[common.Address]struct{})
 		overrideAddrs  = make(map[rune]common.Address)
 	)
 	// generate deterministic addresses for the override set.
 	rand.Seed(42)
 	for contract := range tcInput.overrides {
 		var addr common.Address
 		rand.Read(addr[:])
 		overrideAddrs[contract] = addr
 		overridesAddrs[addr] = struct{}{}
 	}
 	tc := makeLinkTestCase(tcInput.input, overrideAddrs)
 	allContracts := make(map[rune]struct{})
 	for contract, deps := range tcInput.input {
 		allContracts[contract] = struct{}{}
 		for _, dep := range deps {
 			allContracts[dep] = struct{}{}
 		}
 	}
 	var testAddrNonce uint64
 	mockDeploy := func(input []byte, deployer []byte) (common.Address, *types.Transaction, error) {
 		contractAddr := crypto.CreateAddress(testAddr, testAddrNonce)
 		testAddrNonce++
 		if len(deployer) >= 20 {
 			// assert that this contract only references libs that are known to be deployed or in the override set
 			for i := 0; i < len(deployer); i += 20 {
 				var dep common.Address
 				dep.SetBytes(deployer[i : i+20])
 				if _, ok := overridesAddrs[dep]; !ok {
 					return common.Address{}, nil, fmt.Errorf("reference to dependent contract that has not yet been deployed: %x\n", dep)
 				}
 			}
 		}
 		overridesAddrs[contractAddr] = struct{}{}
 		// we don't care about the txs themselves for the sake of the linking tests.  so we can return nil for them in the mock deployer
 		return contractAddr, nil, nil
 	}
 	contracts := make(map[string]*MetaData)
 	overrides := make(map[string]common.Address)
 	for pattern, bin := range tc.contractCodes {
 		contracts[pattern] = &MetaData{ID: pattern, Bin: "0x" + bin}
 	}
 	for pattern, bin := range tc.libCodes {
 		contracts[pattern] = &MetaData{
 			Bin: "0x" + bin,
 			ID:  pattern,
 		}
 	}
 	contractsList := linkDeps(contracts)
 	for pattern, override := range tc.overrides {
 		overrides[pattern] = override
 	}
 	deployParams := &DeploymentParams{
 		Contracts: contractsList,
 		Overrides: overrides,
 	}
 	res, err := LinkAndDeploy(deployParams, mockDeploy)
 	if err != nil {
 		return err
 	}
 	if len(res.Txs) != len(tcInput.expectDeployed) {
 		return fmt.Errorf("got %d deployed contracts. expected %d.\n", len(res.Addresses), len(tcInput.expectDeployed))
 	}
 	for contract := range tcInput.expectDeployed {
 		pattern := crypto.Keccak256Hash([]byte(string(contract))).String()[2:36]
 		if _, ok := res.Addresses[pattern]; !ok {
 			return fmt.Errorf("expected contract %s was not deployed\n", string(contract))
 		}
 	}
 	return nil
 }
 func TestContractLinking(t *testing.T) {
 	for i, tc := range []linkTestCaseInput{
 		// test simple contract without any dependencies or overrides
 		{
 			map[rune][]rune{
 				'a': {}},
 			map[rune]struct{}{},
 			map[rune]struct{}{
 				'a': {}},
 		},
 		// test deployment of a contract that depends on somes libraries.
 		{
 			map[rune][]rune{
 				'a': {'b', 'c', 'd', 'e'}},
 			map[rune]struct{}{},
 			map[rune]struct{}{
 				'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}},
 		},
 		// test deployment of a contract that depends on some libraries,
 		// one of which has its own library dependencies.
 		{
 			map[rune][]rune{
 				'a': {'b', 'c', 'd', 'e'},
 				'e': {'f', 'g', 'h', 'i'}},
 			map[rune]struct{}{},
 			map[rune]struct{}{
 				'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}},
 		},
 		// test single contract only without deps
 		{
 			map[rune][]rune{
 				'a': {}},
 			map[rune]struct{}{},
 			map[rune]struct{}{
 				'a': {},
 			},
 		},
 		// test that libraries at different levels of the tree can share deps,
 		// and that these shared deps will only be deployed once.
 		{
 			map[rune][]rune{
 				'a': {'b', 'c', 'd', 'e'},
 				'e': {'f', 'g', 'h', 'i', 'm'},
 				'i': {'j', 'k', 'l', 'm'}},
 			map[rune]struct{}{},
 			map[rune]struct{}{
 				'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}, 'j': {}, 'k': {}, 'l': {}, 'm': {},
 			},
 		},
 		// test two contracts can be deployed which don't share deps
 		linkTestCaseInput{
 			map[rune][]rune{
 				'a': {'b', 'c', 'd', 'e'},
 				'f': {'g', 'h', 'i', 'j'}},
 			map[rune]struct{}{},
 			map[rune]struct{}{
 				'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}, 'j': {},
 			},
 		},
 		// test two contracts can be deployed which share deps
 		linkTestCaseInput{
 			map[rune][]rune{
 				'a': {'b', 'c', 'd', 'e'},
 				'f': {'g', 'c', 'd', 'h'}},
 			map[rune]struct{}{},
 			map[rune]struct{}{
 				'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {},
 			},
 		},
 		// test one contract with overrides for all lib deps
 		linkTestCaseInput{
 			map[rune][]rune{
 				'a': {'b', 'c', 'd', 'e'}},
 			map[rune]struct{}{'b': {}, 'c': {}, 'd': {}, 'e': {}},
 			map[rune]struct{}{
 				'a': {}},
 		},
 		// test one contract with overrides for some lib deps
 		linkTestCaseInput{
 			map[rune][]rune{
 				'a': {'b', 'c'}},
 			map[rune]struct{}{'b': {}, 'c': {}},
 			map[rune]struct{}{
 				'a': {}},
 		},
 		// test deployment of a contract with overrides
 		linkTestCaseInput{
 			map[rune][]rune{
 				'a': {}},
 			map[rune]struct{}{'a': {}},
 			map[rune]struct{}{},
 		},
 		// two contracts ('a' and 'f') share some dependencies.  contract 'a' is marked as an override.  expect that any of
 		// its depdencies that aren't shared with 'f' are not deployed.
 		linkTestCaseInput{map[rune][]rune{
 			'a': {'b', 'c', 'd', 'e'},
 			'f': {'g', 'c', 'd', 'h'}},
 			map[rune]struct{}{'a': {}},
 			map[rune]struct{}{
 				'f': {}, 'g': {}, 'c': {}, 'd': {}, 'h': {}},
 		},
 		// test nested libraries that share deps at different levels of the tree... with override.
 		// same condition as above test:  no sub-dependencies of
 		{
 			map[rune][]rune{
 				'a': {'b', 'c', 'd', 'e'},
 				'e': {'f', 'g', 'h', 'i', 'm'},
 				'i': {'j', 'k', 'l', 'm'},
 				'l': {'n', 'o', 'p'}},
 			map[rune]struct{}{
 				'i': {},
 			},
 			map[rune]struct{}{
 				'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'm': {}},
 		},
 	} {
 		if err := testLinkCase(tc); err != nil {
 			t.Fatalf("test case %d failed: %v", i, err)
 		}
 	}
 }
 func parseLibraryDeps(unlinkedCode string) (res []string) {
 	reMatchSpecificPattern, err := regexp.Compile(`__\$([a-f0-9]+)\$__`)
 	if err != nil {
 		panic(err)
 	}
 	for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(unlinkedCode, -1) {
 		res = append(res, match[1])
 	}
 	return res
 }
--- a/accounts/abi/bind/v2/generate_test.go
+++ b/accounts/abi/bind/v2/generate_test.go
@ -0,0 +1,102 @@
 // Copyright 2024 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Lesser General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 //
 // The go-ethereum library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 // GNU Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 package bind_test
 import (
 	"encoding/json"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 	"github.com/ethereum/go-ethereum/accounts/abi/abigen"
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/common/compiler"
 	"github.com/ethereum/go-ethereum/crypto"
 )
 // Run go generate to recreate the test bindings.
 //
 //go:generate go run github.com/ethereum/go-ethereum/cmd/abigen -v2 -combined-json internal/contracts/db/combined-abi.json -type DBStats -pkg db -out internal/contracts/db/bindings.go
 //go:generate go run github.com/ethereum/go-ethereum/cmd/abigen -v2 -combined-json internal/contracts/events/combined-abi.json -type C -pkg events -out internal/contracts/events/bindings.go
 //go:generate go run github.com/ethereum/go-ethereum/cmd/abigen -v2 -combined-json internal/contracts/nested_libraries/combined-abi.json -type C1 -pkg nested_libraries -out internal/contracts/nested_libraries/bindings.go
 //go:generate go run github.com/ethereum/go-ethereum/cmd/abigen -v2 -combined-json internal/contracts/solc_errors/combined-abi.json -type C -pkg solc_errors -out internal/contracts/solc_errors/bindings.go
 //go:generate go run github.com/ethereum/go-ethereum/cmd/abigen -v2 -combined-json internal/contracts/uint256arrayreturn/combined-abi.json -type C -pkg uint256arrayreturn -out internal/contracts/uint256arrayreturn/bindings.go
 // TestBindingGeneration tests that re-running generation of bindings does not result in
 // mutations to the binding code.
 func TestBindingGeneration(t *testing.T) {
 	matches, _ := filepath.Glob("internal/contracts/*")
 	var dirs []string
 	for _, match := range matches {
 		f, _ := os.Stat(match)
 		if f.IsDir() {
 			dirs = append(dirs, f.Name())
 		}
 	}
 	for _, dir := range dirs {
 		var (
 			abis  []string
 			bins  []string
 			types []string
 			libs  = make(map[string]string)
 		)
 		basePath := filepath.Join("internal/contracts", dir)
 		combinedJsonPath := filepath.Join(basePath, "combined-abi.json")
 		abiBytes, err := os.ReadFile(combinedJsonPath)
 		if err != nil {
 			t.Fatalf("error trying to read file %s: %v", combinedJsonPath, err)
 		}
 		contracts, err := compiler.ParseCombinedJSON(abiBytes, "", "", "", "")
 		if err != nil {
 			t.Fatalf("Failed to read contract information from json output: %v", err)
 		}
 		for name, contract := range contracts {
 			// fully qualified name is of the form <solFilePath>:<type>
 			nameParts := strings.Split(name, ":")
 			typeName := nameParts[len(nameParts)-1]
 			abi, err := json.Marshal(contract.Info.AbiDefinition) // Flatten the compiler parse
 			if err != nil {
 				utils.Fatalf("Failed to parse ABIs from compiler output: %v", err)
 			}
 			abis = append(abis, string(abi))
 			bins = append(bins, contract.Code)
 			types = append(types, typeName)
 			// Derive the library placeholder which is a 34 character prefix of the
 			// hex encoding of the keccak256 hash of the fully qualified library name.
 			// Note that the fully qualified library name is the path of its source
 			// file and the library name separated by ":".
 			libPattern := crypto.Keccak256Hash([]byte(name)).String()[2:36] // the first 2 chars are 0x
 			libs[libPattern] = typeName
 		}
 		code, err := abigen.BindV2(types, abis, bins, dir, libs, make(map[string]string))
 		if err != nil {
 			t.Fatalf("error creating bindings for package %s: %v", dir, err)
 		}
 		existingBindings, err := os.ReadFile(filepath.Join(basePath, "bindings.go"))
 		if err != nil {
 			t.Fatalf("ReadFile returned error: %v", err)
 		}
 		if code != string(existingBindings) {
 			t.Fatalf("code mismatch for %s", dir)
 		}
 	}
 }
--- a/accounts/abi/bind/v2/internal/contracts/db/bindings.go
+++ b/accounts/abi/bind/v2/internal/contracts/db/bindings.go
@ -0,0 +1,293 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package db
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // DBStats is an auto generated low-level Go binding around an user-defined struct.
 type DBStats struct {
 	Gets    *big.Int
 	Inserts *big.Int
 	Mods    *big.Int
 }
 // DBMetaData contains all meta data concerning the DB contract.
 var DBMetaData = bind.MetaData{
 	ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"key\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"length\",\"type\":\"uint256\"}],\"name\":\"Insert\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"key\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"KeyedInsert\",\"type\":\"event\"},{\"stateMutability\":\"nonpayable\",\"type\":\"fallback\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"k\",\"type\":\"uint256\"}],\"name\":\"get\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getNamedStatParams\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"gets\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inserts\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"mods\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getStatParams\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getStatsStruct\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"gets\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inserts\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"mods\",\"type\":\"uint256\"}],\"internalType\":\"structDB.Stats\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"k\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"v\",\"type\":\"uint256\"}],\"name\":\"insert\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}]",
 	ID:  "253cc2574e2f8b5e909644530e4934f6ac",
 	Bin: "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",
 }
 // DB is an auto generated Go binding around an Ethereum contract.
 type DB struct {
 	abi abi.ABI
 }
 // NewDB creates a new instance of DB.
 func NewDB() *DB {
 	parsed, err := DBMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &DB{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *DB) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackGet is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x9507d39a.
 //
 // Solidity: function get(uint256 k) returns(uint256)
 func (dB *DB) PackGet(k *big.Int) []byte {
 	enc, err := dB.abi.Pack("get", k)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackGet is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x9507d39a.
 //
 // Solidity: function get(uint256 k) returns(uint256)
 func (dB *DB) UnpackGet(data []byte) (*big.Int, error) {
 	out, err := dB.abi.Unpack("get", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
 // PackGetNamedStatParams is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xe369ba3b.
 //
 // Solidity: function getNamedStatParams() view returns(uint256 gets, uint256 inserts, uint256 mods)
 func (dB *DB) PackGetNamedStatParams() []byte {
 	enc, err := dB.abi.Pack("getNamedStatParams")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // GetNamedStatParamsOutput serves as a container for the return parameters of contract
 // method GetNamedStatParams.
 type GetNamedStatParamsOutput struct {
 	Gets    *big.Int
 	Inserts *big.Int
 	Mods    *big.Int
 }
 // UnpackGetNamedStatParams is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0xe369ba3b.
 //
 // Solidity: function getNamedStatParams() view returns(uint256 gets, uint256 inserts, uint256 mods)
 func (dB *DB) UnpackGetNamedStatParams(data []byte) (GetNamedStatParamsOutput, error) {
 	out, err := dB.abi.Unpack("getNamedStatParams", data)
 	outstruct := new(GetNamedStatParamsOutput)
 	if err != nil {
 		return *outstruct, err
 	}
 	outstruct.Gets = abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	outstruct.Inserts = abi.ConvertType(out[1], new(big.Int)).(*big.Int)
 	outstruct.Mods = abi.ConvertType(out[2], new(big.Int)).(*big.Int)
 	return *outstruct, err
 }
 // PackGetStatParams is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x6fcb9c70.
 //
 // Solidity: function getStatParams() view returns(uint256, uint256, uint256)
 func (dB *DB) PackGetStatParams() []byte {
 	enc, err := dB.abi.Pack("getStatParams")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // GetStatParamsOutput serves as a container for the return parameters of contract
 // method GetStatParams.
 type GetStatParamsOutput struct {
 	Arg0 *big.Int
 	Arg1 *big.Int
 	Arg2 *big.Int
 }
 // UnpackGetStatParams is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x6fcb9c70.
 //
 // Solidity: function getStatParams() view returns(uint256, uint256, uint256)
 func (dB *DB) UnpackGetStatParams(data []byte) (GetStatParamsOutput, error) {
 	out, err := dB.abi.Unpack("getStatParams", data)
 	outstruct := new(GetStatParamsOutput)
 	if err != nil {
 		return *outstruct, err
 	}
 	outstruct.Arg0 = abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	outstruct.Arg1 = abi.ConvertType(out[1], new(big.Int)).(*big.Int)
 	outstruct.Arg2 = abi.ConvertType(out[2], new(big.Int)).(*big.Int)
 	return *outstruct, err
 }
 // PackGetStatsStruct is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xee8161e0.
 //
 // Solidity: function getStatsStruct() view returns((uint256,uint256,uint256))
 func (dB *DB) PackGetStatsStruct() []byte {
 	enc, err := dB.abi.Pack("getStatsStruct")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackGetStatsStruct is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0xee8161e0.
 //
 // Solidity: function getStatsStruct() view returns((uint256,uint256,uint256))
 func (dB *DB) UnpackGetStatsStruct(data []byte) (DBStats, error) {
 	out, err := dB.abi.Unpack("getStatsStruct", data)
 	if err != nil {
 		return *new(DBStats), err
 	}
 	out0 := *abi.ConvertType(out[0], new(DBStats)).(*DBStats)
 	return out0, err
 }
 // PackInsert is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x1d834a1b.
 //
 // Solidity: function insert(uint256 k, uint256 v) returns(uint256)
 func (dB *DB) PackInsert(k *big.Int, v *big.Int) []byte {
 	enc, err := dB.abi.Pack("insert", k, v)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackInsert is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x1d834a1b.
 //
 // Solidity: function insert(uint256 k, uint256 v) returns(uint256)
 func (dB *DB) UnpackInsert(data []byte) (*big.Int, error) {
 	out, err := dB.abi.Unpack("insert", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
 // DBInsert represents a Insert event raised by the DB contract.
 type DBInsert struct {
 	Key    *big.Int
 	Value  *big.Int
 	Length *big.Int
 	Raw    *types.Log // Blockchain specific contextual infos
 }
 const DBInsertEventName = "Insert"
 // ContractEventName returns the user-defined event name.
 func (DBInsert) ContractEventName() string {
 	return DBInsertEventName
 }
 // UnpackInsertEvent is the Go binding that unpacks the event data emitted
 // by contract.
 //
 // Solidity: event Insert(uint256 key, uint256 value, uint256 length)
 func (dB *DB) UnpackInsertEvent(log *types.Log) (*DBInsert, error) {
 	event := "Insert"
 	if log.Topics[0] != dB.abi.Events[event].ID {
 		return nil, errors.New("event signature mismatch")
 	}
 	out := new(DBInsert)
 	if len(log.Data) > 0 {
 		if err := dB.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
 			return nil, err
 		}
 	}
 	var indexed abi.Arguments
 	for _, arg := range dB.abi.Events[event].Inputs {
 		if arg.Indexed {
 			indexed = append(indexed, arg)
 		}
 	}
 	if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil {
 		return nil, err
 	}
 	out.Raw = log
 	return out, nil
 }
 // DBKeyedInsert represents a KeyedInsert event raised by the DB contract.
 type DBKeyedInsert struct {
 	Key   *big.Int
 	Value *big.Int
 	Raw   *types.Log // Blockchain specific contextual infos
 }
 const DBKeyedInsertEventName = "KeyedInsert"
 // ContractEventName returns the user-defined event name.
 func (DBKeyedInsert) ContractEventName() string {
 	return DBKeyedInsertEventName
 }
 // UnpackKeyedInsertEvent is the Go binding that unpacks the event data emitted
 // by contract.
 //
 // Solidity: event KeyedInsert(uint256 indexed key, uint256 value)
 func (dB *DB) UnpackKeyedInsertEvent(log *types.Log) (*DBKeyedInsert, error) {
 	event := "KeyedInsert"
 	if log.Topics[0] != dB.abi.Events[event].ID {
 		return nil, errors.New("event signature mismatch")
 	}
 	out := new(DBKeyedInsert)
 	if len(log.Data) > 0 {
 		if err := dB.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
 			return nil, err
 		}
 	}
 	var indexed abi.Arguments
 	for _, arg := range dB.abi.Events[event].Inputs {
 		if arg.Indexed {
 			indexed = append(indexed, arg)
 		}
 	}
 	if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil {
 		return nil, err
 	}
 	out.Raw = log
 	return out, nil
 }
--- a/accounts/abi/bind/v2/internal/contracts/db/combined-abi.json
+++ b/accounts/abi/bind/v2/internal/contracts/db/combined-abi.json
--- a/accounts/abi/bind/v2/internal/contracts/db/contract.sol
+++ b/accounts/abi/bind/v2/internal/contracts/db/contract.sol
@ -0,0 +1,66 @@
 // SPDX-License-Identifier: GPL-3.0
 pragma solidity >=0.7.0 <0.9.0;
 contract DB {
    uint balance = 0;
    mapping(uint => uint) private _store;
    uint[] private _keys;
    struct Stats {
        uint gets;
        uint inserts;
        uint mods; // modifications
    }
    Stats _stats;
    event KeyedInsert(uint indexed key, uint value);
    event Insert(uint key, uint value, uint length);
    constructor() {
        _stats = Stats(0, 0, 0);
    }
    // insert adds a key value to the store, returning the new length of the store.
    function insert(uint k, uint v) external returns (uint) {
        // No need to store 0 values
        if (v == 0) {
            return _keys.length;
        }
        // Check if a key is being overriden
        if (_store[k] == 0) {
            _keys.push(k);
            _stats.inserts++;
        } else {
            _stats.mods++;
        }
        _store[k] = v;
        emit Insert(k, v, _keys.length);
        emit KeyedInsert(k, v);
        return _keys.length;
    }
    function get(uint k) public returns (uint) {
        _stats.gets++;
        return _store[k];
    }
    function getStatParams() public view returns (uint, uint, uint) {
        return (_stats.gets, _stats.inserts, _stats.mods);
    }
    function getNamedStatParams() public view returns (uint gets, uint inserts, uint mods) {
        return (_stats.gets, _stats.inserts, _stats.mods);
    }
    function getStatsStruct() public view returns (Stats memory) {
        return _stats;
    }
    receive() external payable {
        balance += msg.value;
    }
    fallback(bytes calldata _input) external returns (bytes memory _output) {
        _output = _input;
    }
 }
--- a/accounts/abi/bind/v2/internal/contracts/events/bindings.go
+++ b/accounts/abi/bind/v2/internal/contracts/events/bindings.go
@ -0,0 +1,160 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package events
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // CMetaData contains all meta data concerning the C contract.
 var CMetaData = bind.MetaData{
 	ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"data\",\"type\":\"uint256\"}],\"name\":\"basic1\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"data\",\"type\":\"uint256\"}],\"name\":\"basic2\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"EmitMulti\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"EmitOne\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
 	ID:  "55ef3c19a0ab1c1845f9e347540c1e51f5",
 	Bin: "0x6080604052348015600e575f5ffd5b506101a08061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610034575f3560e01c8063cb49374914610038578063e8e49a7114610042575b5f5ffd5b61004061004c565b005b61004a6100fd565b005b60017f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd207600260405161007e9190610151565b60405180910390a260037f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd20760046040516100b89190610151565b60405180910390a25f15157f3b29b9f6d15ba80d866afb3d70b7548ab1ffda3ef6e65f35f1cb05b0e2b29f4e60016040516100f39190610151565b60405180910390a2565b60017f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd207600260405161012f9190610151565b60405180910390a2565b5f819050919050565b61014b81610139565b82525050565b5f6020820190506101645f830184610142565b9291505056fea26469706673582212207331c79de16a73a1639c4c4b3489ea78a3ed35fe62a178824f586df12672ac0564736f6c634300081c0033",
 }
 // C is an auto generated Go binding around an Ethereum contract.
 type C struct {
 	abi abi.ABI
 }
 // NewC creates a new instance of C.
 func NewC() *C {
 	parsed, err := CMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &C{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *C) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackEmitMulti is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xcb493749.
 //
 // Solidity: function EmitMulti() returns()
 func (c *C) PackEmitMulti() []byte {
 	enc, err := c.abi.Pack("EmitMulti")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackEmitOne is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xe8e49a71.
 //
 // Solidity: function EmitOne() returns()
 func (c *C) PackEmitOne() []byte {
 	enc, err := c.abi.Pack("EmitOne")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // CBasic1 represents a basic1 event raised by the C contract.
 type CBasic1 struct {
 	Id   *big.Int
 	Data *big.Int
 	Raw  *types.Log // Blockchain specific contextual infos
 }
 const CBasic1EventName = "basic1"
 // ContractEventName returns the user-defined event name.
 func (CBasic1) ContractEventName() string {
 	return CBasic1EventName
 }
 // UnpackBasic1Event is the Go binding that unpacks the event data emitted
 // by contract.
 //
 // Solidity: event basic1(uint256 indexed id, uint256 data)
 func (c *C) UnpackBasic1Event(log *types.Log) (*CBasic1, error) {
 	event := "basic1"
 	if log.Topics[0] != c.abi.Events[event].ID {
 		return nil, errors.New("event signature mismatch")
 	}
 	out := new(CBasic1)
 	if len(log.Data) > 0 {
 		if err := c.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
 			return nil, err
 		}
 	}
 	var indexed abi.Arguments
 	for _, arg := range c.abi.Events[event].Inputs {
 		if arg.Indexed {
 			indexed = append(indexed, arg)
 		}
 	}
 	if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil {
 		return nil, err
 	}
 	out.Raw = log
 	return out, nil
 }
 // CBasic2 represents a basic2 event raised by the C contract.
 type CBasic2 struct {
 	Flag bool
 	Data *big.Int
 	Raw  *types.Log // Blockchain specific contextual infos
 }
 const CBasic2EventName = "basic2"
 // ContractEventName returns the user-defined event name.
 func (CBasic2) ContractEventName() string {
 	return CBasic2EventName
 }
 // UnpackBasic2Event is the Go binding that unpacks the event data emitted
 // by contract.
 //
 // Solidity: event basic2(bool indexed flag, uint256 data)
 func (c *C) UnpackBasic2Event(log *types.Log) (*CBasic2, error) {
 	event := "basic2"
 	if log.Topics[0] != c.abi.Events[event].ID {
 		return nil, errors.New("event signature mismatch")
 	}
 	out := new(CBasic2)
 	if len(log.Data) > 0 {
 		if err := c.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
 			return nil, err
 		}
 	}
 	var indexed abi.Arguments
 	for _, arg := range c.abi.Events[event].Inputs {
 		if arg.Indexed {
 			indexed = append(indexed, arg)
 		}
 	}
 	if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil {
 		return nil, err
 	}
 	out.Raw = log
 	return out, nil
 }
--- a/accounts/abi/bind/v2/internal/contracts/events/combined-abi.json
+++ b/accounts/abi/bind/v2/internal/contracts/events/combined-abi.json
@ -0,0 +1 @@
 {"contracts":{"contract.sol:C":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"data","type":"uint256"}],"name":"basic1","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bool","name":"flag","type":"bool"},{"indexed":false,"internalType":"uint256","name":"data","type":"uint256"}],"name":"basic2","type":"event"},{"inputs":[],"name":"EmitMulti","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"EmitOne","outputs":[],"stateMutability":"nonpayable","type":"function"}],"bin":"6080604052348015600e575f5ffd5b506101a08061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610034575f3560e01c8063cb49374914610038578063e8e49a7114610042575b5f5ffd5b61004061004c565b005b61004a6100fd565b005b60017f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd207600260405161007e9190610151565b60405180910390a260037f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd20760046040516100b89190610151565b60405180910390a25f15157f3b29b9f6d15ba80d866afb3d70b7548ab1ffda3ef6e65f35f1cb05b0e2b29f4e60016040516100f39190610151565b60405180910390a2565b60017f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd207600260405161012f9190610151565b60405180910390a2565b5f819050919050565b61014b81610139565b82525050565b5f6020820190506101645f830184610142565b9291505056fea26469706673582212207331c79de16a73a1639c4c4b3489ea78a3ed35fe62a178824f586df12672ac0564736f6c634300081c0033"}},"version":"0.8.28+commit.7893614a.Darwin.appleclang"}
--- a/accounts/abi/bind/v2/internal/contracts/events/contract.sol
+++ b/accounts/abi/bind/v2/internal/contracts/events/contract.sol
@ -0,0 +1,36 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.26;
 contract C {
    event basic1(
        uint256 indexed id,
        uint256 data
    );
    event basic2(
        bool indexed flag,
        uint256 data
    );
    function EmitOne() public {
        emit basic1(
            uint256(1),
            uint256(2));
    }
    // emit multiple events, different types
    function EmitMulti() public {
        emit basic1(
            uint256(1),
            uint256(2));
        emit basic1(
            uint256(3),
            uint256(4));
        emit basic2(
            false,
            uint256(1));
    }
    constructor() {
        // do something with these
    }
 }
--- a/accounts/abi/bind/v2/internal/contracts/nested_libraries/abi.json
+++ b/accounts/abi/bind/v2/internal/contracts/nested_libraries/abi.json
--- a/accounts/abi/bind/v2/internal/contracts/nested_libraries/bindings.go
+++ b/accounts/abi/bind/v2/internal/contracts/nested_libraries/bindings.go
@ -0,0 +1,486 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package nested_libraries
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // C1MetaData contains all meta data concerning the C1 contract.
 var C1MetaData = bind.MetaData{
 	ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"v1\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"v2\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"Do\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"res\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
 	ID:  "ae26158f1824f3918bd66724ee8b6eb7c9",
 	Bin: "0x6080604052348015600e575f5ffd5b506040516103983803806103988339818101604052810190602e91906066565b5050609d565b5f5ffd5b5f819050919050565b6048816038565b81146051575f5ffd5b50565b5f815190506060816041565b92915050565b5f5f6040838503121560795760786034565b5b5f6084858286016054565b92505060206093858286016054565b9150509250929050565b6102ee806100aa5f395ff3fe608060405234801561000f575f5ffd5b5060043610610029575f3560e01c80632ad112721461002d575b5f5ffd5b6100476004803603810190610042919061019e565b61005d565b60405161005491906101d8565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad112725f6040518263ffffffff1660e01b81526004016100979190610200565b602060405180830381865af41580156100b2573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100d6919061022d565b73__$5f33a1fab8ea7d932b4bc8c5e7dcd90bc2$__632ad11272856040518263ffffffff1660e01b815260040161010d9190610200565b602060405180830381865af4158015610128573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014c919061022d565b6101569190610285565b6101609190610285565b9050919050565b5f5ffd5b5f819050919050565b61017d8161016b565b8114610187575f5ffd5b50565b5f8135905061019881610174565b92915050565b5f602082840312156101b3576101b2610167565b5b5f6101c08482850161018a565b91505092915050565b6101d28161016b565b82525050565b5f6020820190506101eb5f8301846101c9565b92915050565b6101fa8161016b565b82525050565b5f6020820190506102135f8301846101f1565b92915050565b5f8151905061022781610174565b92915050565b5f6020828403121561024257610241610167565b5b5f61024f84828501610219565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61028f8261016b565b915061029a8361016b565b92508282019050808211156102b2576102b1610258565b5b9291505056fea26469706673582212205d4715a8d20a3a0a43113e268ec8868b3c3ce24f7cbdb8735b4eeeebf0b5565164736f6c634300081c0033",
 	Deps: []*bind.MetaData{
 		&L1MetaData,
 		&L4MetaData,
 	},
 }
 // C1 is an auto generated Go binding around an Ethereum contract.
 type C1 struct {
 	abi abi.ABI
 }
 // NewC1 creates a new instance of C1.
 func NewC1() *C1 {
 	parsed, err := C1MetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &C1{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *C1) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackConstructor is the Go binding used to pack the parameters required for
 // contract deployment.
 //
 // Solidity: constructor(uint256 v1, uint256 v2) returns()
 func (c1 *C1) PackConstructor(v1 *big.Int, v2 *big.Int) []byte {
 	enc, err := c1.abi.Pack("", v1, v2)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackDo is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x2ad11272.
 //
 // Solidity: function Do(uint256 val) pure returns(uint256 res)
 func (c1 *C1) PackDo(val *big.Int) []byte {
 	enc, err := c1.abi.Pack("Do", val)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackDo is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x2ad11272.
 //
 // Solidity: function Do(uint256 val) pure returns(uint256 res)
 func (c1 *C1) UnpackDo(data []byte) (*big.Int, error) {
 	out, err := c1.abi.Unpack("Do", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
 // C2MetaData contains all meta data concerning the C2 contract.
 var C2MetaData = bind.MetaData{
 	ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"v1\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"v2\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"Do\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"res\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
 	ID:  "78ef2840de5b706112ca2dbfa765501a89",
 	Bin: "0x6080604052348015600e575f5ffd5b506040516103983803806103988339818101604052810190602e91906066565b5050609d565b5f5ffd5b5f819050919050565b6048816038565b81146051575f5ffd5b50565b5f815190506060816041565b92915050565b5f5f6040838503121560795760786034565b5b5f6084858286016054565b92505060206093858286016054565b9150509250929050565b6102ee806100aa5f395ff3fe608060405234801561000f575f5ffd5b5060043610610029575f3560e01c80632ad112721461002d575b5f5ffd5b6100476004803603810190610042919061019e565b61005d565b60405161005491906101d8565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad112725f6040518263ffffffff1660e01b81526004016100979190610200565b602060405180830381865af41580156100b2573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100d6919061022d565b73__$6070639404c39b5667691bb1f9177e1eac$__632ad11272856040518263ffffffff1660e01b815260040161010d9190610200565b602060405180830381865af4158015610128573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014c919061022d565b6101569190610285565b6101609190610285565b9050919050565b5f5ffd5b5f819050919050565b61017d8161016b565b8114610187575f5ffd5b50565b5f8135905061019881610174565b92915050565b5f602082840312156101b3576101b2610167565b5b5f6101c08482850161018a565b91505092915050565b6101d28161016b565b82525050565b5f6020820190506101eb5f8301846101c9565b92915050565b6101fa8161016b565b82525050565b5f6020820190506102135f8301846101f1565b92915050565b5f8151905061022781610174565b92915050565b5f6020828403121561024257610241610167565b5b5f61024f84828501610219565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61028f8261016b565b915061029a8361016b565b92508282019050808211156102b2576102b1610258565b5b9291505056fea2646970667358221220dd394981f1e9fefa4d88bac1c4f1da4131779c7d3bd4189958d278e57e96d96f64736f6c634300081c0033",
 	Deps: []*bind.MetaData{
 		&L1MetaData,
 		&L4bMetaData,
 	},
 }
 // C2 is an auto generated Go binding around an Ethereum contract.
 type C2 struct {
 	abi abi.ABI
 }
 // NewC2 creates a new instance of C2.
 func NewC2() *C2 {
 	parsed, err := C2MetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &C2{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *C2) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackConstructor is the Go binding used to pack the parameters required for
 // contract deployment.
 //
 // Solidity: constructor(uint256 v1, uint256 v2) returns()
 func (c2 *C2) PackConstructor(v1 *big.Int, v2 *big.Int) []byte {
 	enc, err := c2.abi.Pack("", v1, v2)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackDo is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x2ad11272.
 //
 // Solidity: function Do(uint256 val) pure returns(uint256 res)
 func (c2 *C2) PackDo(val *big.Int) []byte {
 	enc, err := c2.abi.Pack("Do", val)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackDo is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x2ad11272.
 //
 // Solidity: function Do(uint256 val) pure returns(uint256 res)
 func (c2 *C2) UnpackDo(data []byte) (*big.Int, error) {
 	out, err := c2.abi.Unpack("Do", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
 // L1MetaData contains all meta data concerning the L1 contract.
 var L1MetaData = bind.MetaData{
 	ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"Do\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
 	ID:  "ffc1393672b8ed81d0c8093ffcb0e7fbe8",
 	Bin: "0x61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f5ffd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f5ffd5b5f819050919050565b607e81606e565b81146087575f5ffd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea26469706673582212200161c5f22d130a2b7ec6cf22e0910e42e32c2881fa4a8a01455f524f63cf218d64736f6c634300081c0033",
 }
 // L1 is an auto generated Go binding around an Ethereum contract.
 type L1 struct {
 	abi abi.ABI
 }
 // NewL1 creates a new instance of L1.
 func NewL1() *L1 {
 	parsed, err := L1MetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &L1{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *L1) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackDo is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x2ad11272.
 //
 // Solidity: function Do(uint256 val) pure returns(uint256)
 func (l1 *L1) PackDo(val *big.Int) []byte {
 	enc, err := l1.abi.Pack("Do", val)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackDo is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x2ad11272.
 //
 // Solidity: function Do(uint256 val) pure returns(uint256)
 func (l1 *L1) UnpackDo(data []byte) (*big.Int, error) {
 	out, err := l1.abi.Unpack("Do", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
 // L2MetaData contains all meta data concerning the L2 contract.
 var L2MetaData = bind.MetaData{
 	ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"Do\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
 	ID:  "2ce896a6dd38932d354f317286f90bc675",
 	Bin: "0x61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f5ffd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f5ffd5b5f819050919050565b610108816100f6565b8114610112575f5ffd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea264697066735822122026999f96e14b0e279909ca5972343113c358e93a904569409a86866e2064f0fa64736f6c634300081c0033",
 	Deps: []*bind.MetaData{
 		&L1MetaData,
 	},
 }
 // L2 is an auto generated Go binding around an Ethereum contract.
 type L2 struct {
 	abi abi.ABI
 }
 // NewL2 creates a new instance of L2.
 func NewL2() *L2 {
 	parsed, err := L2MetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &L2{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *L2) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackDo is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x2ad11272.
 //
 // Solidity: function Do(uint256 val) pure returns(uint256)
 func (l2 *L2) PackDo(val *big.Int) []byte {
 	enc, err := l2.abi.Pack("Do", val)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackDo is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x2ad11272.
 //
 // Solidity: function Do(uint256 val) pure returns(uint256)
 func (l2 *L2) UnpackDo(data []byte) (*big.Int, error) {
 	out, err := l2.abi.Unpack("Do", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
 // L2bMetaData contains all meta data concerning the L2b contract.
 var L2bMetaData = bind.MetaData{
 	ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"Do\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
 	ID:  "fd1474cf57f7ed48491e8bfdfd0d172adf",
 	Bin: "0x61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f5ffd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f5ffd5b5f819050919050565b610108816100f6565b8114610112575f5ffd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea2646970667358221220d6e7078682642d273736fd63baaa28538fe72495816c810fa0e77034de385dc564736f6c634300081c0033",
 	Deps: []*bind.MetaData{
 		&L1MetaData,
 	},
 }
 // L2b is an auto generated Go binding around an Ethereum contract.
 type L2b struct {
 	abi abi.ABI
 }
 // NewL2b creates a new instance of L2b.
 func NewL2b() *L2b {
 	parsed, err := L2bMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &L2b{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *L2b) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackDo is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x2ad11272.
 //
 // Solidity: function Do(uint256 val) pure returns(uint256)
 func (l2b *L2b) PackDo(val *big.Int) []byte {
 	enc, err := l2b.abi.Pack("Do", val)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackDo is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x2ad11272.
 //
 // Solidity: function Do(uint256 val) pure returns(uint256)
 func (l2b *L2b) UnpackDo(data []byte) (*big.Int, error) {
 	out, err := l2b.abi.Unpack("Do", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
 // L3MetaData contains all meta data concerning the L3 contract.
 var L3MetaData = bind.MetaData{
 	ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"Do\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
 	ID:  "d03b97f5e1a564374023a72ac7d1806773",
 	Bin: "0x61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f5ffd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f5ffd5b5f819050919050565b607e81606e565b81146087575f5ffd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea264697066735822122094cfcb0ce039318885cc58f6d8e609e6e4bec575e1a046d3d15ea2e01e97241e64736f6c634300081c0033",
 }
 // L3 is an auto generated Go binding around an Ethereum contract.
 type L3 struct {
 	abi abi.ABI
 }
 // NewL3 creates a new instance of L3.
 func NewL3() *L3 {
 	parsed, err := L3MetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &L3{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *L3) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackDo is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x2ad11272.
 //
 // Solidity: function Do(uint256 val) pure returns(uint256)
 func (l3 *L3) PackDo(val *big.Int) []byte {
 	enc, err := l3.abi.Pack("Do", val)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackDo is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x2ad11272.
 //
 // Solidity: function Do(uint256 val) pure returns(uint256)
 func (l3 *L3) UnpackDo(data []byte) (*big.Int, error) {
 	out, err := l3.abi.Unpack("Do", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
 // L4MetaData contains all meta data concerning the L4 contract.
 var L4MetaData = bind.MetaData{
 	ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"Do\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
 	ID:  "5f33a1fab8ea7d932b4bc8c5e7dcd90bc2",
 	Bin: "0x6102d161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f5ffd5b610052600480360381019061004d91906101a9565b610068565b60405161005f91906101e3565b60405180910390f35b5f600173__$d03b97f5e1a564374023a72ac7d1806773$__632ad11272846040518263ffffffff1660e01b81526004016100a291906101e3565b602060405180830381865af41580156100bd573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610210565b73__$2ce896a6dd38932d354f317286f90bc675$__632ad11272856040518263ffffffff1660e01b815260040161011891906101e3565b602060405180830381865af4158015610133573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906101579190610210565b6101619190610268565b61016b9190610268565b9050919050565b5f5ffd5b5f819050919050565b61018881610176565b8114610192575f5ffd5b50565b5f813590506101a38161017f565b92915050565b5f602082840312156101be576101bd610172565b5b5f6101cb84828501610195565b91505092915050565b6101dd81610176565b82525050565b5f6020820190506101f65f8301846101d4565b92915050565b5f8151905061020a8161017f565b92915050565b5f6020828403121561022557610224610172565b5b5f610232848285016101fc565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61027282610176565b915061027d83610176565b92508282019050808211156102955761029461023b565b5b9291505056fea2646970667358221220531485f0b9ff78ba5ef06ef345aaddccec3ad15d1460014ccd7c2a58d36d0d4464736f6c634300081c0033",
 	Deps: []*bind.MetaData{
 		&L2MetaData,
 		&L3MetaData,
 	},
 }
 // L4 is an auto generated Go binding around an Ethereum contract.
 type L4 struct {
 	abi abi.ABI
 }
 // NewL4 creates a new instance of L4.
 func NewL4() *L4 {
 	parsed, err := L4MetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &L4{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *L4) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackDo is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x2ad11272.
 //
 // Solidity: function Do(uint256 val) pure returns(uint256)
 func (l4 *L4) PackDo(val *big.Int) []byte {
 	enc, err := l4.abi.Pack("Do", val)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackDo is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x2ad11272.
 //
 // Solidity: function Do(uint256 val) pure returns(uint256)
 func (l4 *L4) UnpackDo(data []byte) (*big.Int, error) {
 	out, err := l4.abi.Unpack("Do", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
 // L4bMetaData contains all meta data concerning the L4b contract.
 var L4bMetaData = bind.MetaData{
 	ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"Do\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
 	ID:  "6070639404c39b5667691bb1f9177e1eac",
 	Bin: "0x61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f5ffd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$fd1474cf57f7ed48491e8bfdfd0d172adf$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f5ffd5b5f819050919050565b610108816100f6565b8114610112575f5ffd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea264697066735822122008a2478fd2427f180ace529e137b69337cb655dc21d6426de37054c32e821c6a64736f6c634300081c0033",
 	Deps: []*bind.MetaData{
 		&L2bMetaData,
 	},
 }
 // L4b is an auto generated Go binding around an Ethereum contract.
 type L4b struct {
 	abi abi.ABI
 }
 // NewL4b creates a new instance of L4b.
 func NewL4b() *L4b {
 	parsed, err := L4bMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &L4b{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *L4b) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackDo is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0x2ad11272.
 //
 // Solidity: function Do(uint256 val) pure returns(uint256)
 func (l4b *L4b) PackDo(val *big.Int) []byte {
 	enc, err := l4b.abi.Pack("Do", val)
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackDo is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0x2ad11272.
 //
 // Solidity: function Do(uint256 val) pure returns(uint256)
 func (l4b *L4b) UnpackDo(data []byte) (*big.Int, error) {
 	out, err := l4b.abi.Unpack("Do", data)
 	if err != nil {
 		return new(big.Int), err
 	}
 	out0 := abi.ConvertType(out[0], new(big.Int)).(*big.Int)
 	return out0, err
 }
--- a/accounts/abi/bind/v2/internal/contracts/nested_libraries/combined-abi.json
+++ b/accounts/abi/bind/v2/internal/contracts/nested_libraries/combined-abi.json
--- a/accounts/abi/bind/v2/internal/contracts/nested_libraries/contract.sol
+++ b/accounts/abi/bind/v2/internal/contracts/nested_libraries/contract.sol
@ -0,0 +1,76 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.26;
 //  L1
 //   \
 //     L2  L3   L1
 //      \ /    /
 //       L4   /
 //        \  /
 //         C1
 //
 library L1 {
    function Do(uint256 val) public pure returns (uint256) {
        return uint256(1);
    }
 }
 library L2 {
    function Do(uint256 val) public pure returns (uint256) {
        return L1.Do(val) + uint256(1);
    }
 }
 library L3 {
    function Do(uint256 val) public pure returns (uint256) {
        return uint256(1);
    }
 }
 library L4 {
    function Do(uint256 val) public pure returns (uint256) {
        return L2.Do(uint256(val)) + L3.Do(uint256(val)) + uint256(1);
    }
 }
 contract C1 {
    function Do(uint256 val) public pure  returns (uint256 res) {
        return L4.Do(uint256(val)) + L1.Do(uint256(0)) + uint256(1);
    }
    constructor(uint256 v1, uint256 v2) {
        // do something with these
    }
 }
 // second contract+libraries: slightly different library deps than V1, but sharing several
 //  L1
 //   \
 //     L2b  L3  L1
 //      \  /   /
 //       L4b  /
 //        \  /
 //         C2
 //
 library L4b {
        function Do(uint256 val) public pure returns (uint256) {
            return L2b.Do(uint256(val)) + uint256(1);
        }
 }
 library L2b {
        function Do(uint256 val) public pure returns (uint256) {
            return L1.Do(uint256(val)) + uint256(1);
        }
 }
 contract C2 {
    function Do(uint256 val) public pure  returns (uint256 res) {
        return L4b.Do(uint256(val)) + L1.Do(uint256(0)) + uint256(1);
    }
    constructor(uint256 v1, uint256 v2) {
        // do something with these
    }
 }
--- a/accounts/abi/bind/v2/internal/contracts/solc_errors/bindings.go
+++ b/accounts/abi/bind/v2/internal/contracts/solc_errors/bindings.go
@ -0,0 +1,217 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package solc_errors
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // CMetaData contains all meta data concerning the C contract.
 var CMetaData = bind.MetaData{
 	ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"arg1\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"arg2\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"arg3\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"arg4\",\"type\":\"bool\"}],\"name\":\"BadThing\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"arg1\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"arg2\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"arg3\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"arg4\",\"type\":\"uint256\"}],\"name\":\"BadThing2\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Bar\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"Foo\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
 	ID:  "55ef3c19a0ab1c1845f9e347540c1e51f5",
 	Bin: "0x6080604052348015600e575f5ffd5b506101c58061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610034575f3560e01c8063b0a378b014610038578063bfb4ebcf14610042575b5f5ffd5b61004061004c565b005b61004a610092565b005b5f6001600260036040517fd233a24f00000000000000000000000000000000000000000000000000000000815260040161008994939291906100ef565b60405180910390fd5b5f600160025f6040517fbb6a82f10000000000000000000000000000000000000000000000000000000081526004016100ce949392919061014c565b60405180910390fd5b5f819050919050565b6100e9816100d7565b82525050565b5f6080820190506101025f8301876100e0565b61010f60208301866100e0565b61011c60408301856100e0565b61012960608301846100e0565b95945050505050565b5f8115159050919050565b61014681610132565b82525050565b5f60808201905061015f5f8301876100e0565b61016c60208301866100e0565b61017960408301856100e0565b610186606083018461013d565b9594505050505056fea26469706673582212206a82b4c28576e4483a81102558271cfefc891cd63b95440dea521185c1ff6a2a64736f6c634300081c0033",
 }
 // C is an auto generated Go binding around an Ethereum contract.
 type C struct {
 	abi abi.ABI
 }
 // NewC creates a new instance of C.
 func NewC() *C {
 	parsed, err := CMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &C{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *C) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackBar is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xb0a378b0.
 //
 // Solidity: function Bar() pure returns()
 func (c *C) PackBar() []byte {
 	enc, err := c.abi.Pack("Bar")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // PackFoo is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xbfb4ebcf.
 //
 // Solidity: function Foo() pure returns()
 func (c *C) PackFoo() []byte {
 	enc, err := c.abi.Pack("Foo")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackError attempts to decode the provided error data using user-defined
 // error definitions.
 func (c *C) UnpackError(raw []byte) (any, error) {
 	if bytes.Equal(raw[:4], c.abi.Errors["BadThing"].ID.Bytes()[:4]) {
 		return c.UnpackBadThingError(raw[4:])
 	}
 	if bytes.Equal(raw[:4], c.abi.Errors["BadThing2"].ID.Bytes()[:4]) {
 		return c.UnpackBadThing2Error(raw[4:])
 	}
 	return nil, errors.New("Unknown error")
 }
 // CBadThing represents a BadThing error raised by the C contract.
 type CBadThing struct {
 	Arg1 *big.Int
 	Arg2 *big.Int
 	Arg3 *big.Int
 	Arg4 bool
 }
 // ErrorID returns the hash of canonical representation of the error's signature.
 //
 // Solidity: error BadThing(uint256 arg1, uint256 arg2, uint256 arg3, bool arg4)
 func CBadThingErrorID() common.Hash {
 	return common.HexToHash("0xbb6a82f123854747ef4381e30e497f934a3854753fec99a69c35c30d4b46714d")
 }
 // UnpackBadThingError is the Go binding used to decode the provided
 // error data into the corresponding Go error struct.
 //
 // Solidity: error BadThing(uint256 arg1, uint256 arg2, uint256 arg3, bool arg4)
 func (c *C) UnpackBadThingError(raw []byte) (*CBadThing, error) {
 	out := new(CBadThing)
 	if err := c.abi.UnpackIntoInterface(out, "BadThing", raw); err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 // CBadThing2 represents a BadThing2 error raised by the C contract.
 type CBadThing2 struct {
 	Arg1 *big.Int
 	Arg2 *big.Int
 	Arg3 *big.Int
 	Arg4 *big.Int
 }
 // ErrorID returns the hash of canonical representation of the error's signature.
 //
 // Solidity: error BadThing2(uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4)
 func CBadThing2ErrorID() common.Hash {
 	return common.HexToHash("0xd233a24f02271fe7c9470e060d0fda6447a142bf12ab31fed7ab65affd546175")
 }
 // UnpackBadThing2Error is the Go binding used to decode the provided
 // error data into the corresponding Go error struct.
 //
 // Solidity: error BadThing2(uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4)
 func (c *C) UnpackBadThing2Error(raw []byte) (*CBadThing2, error) {
 	out := new(CBadThing2)
 	if err := c.abi.UnpackIntoInterface(out, "BadThing2", raw); err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 // C2MetaData contains all meta data concerning the C2 contract.
 var C2MetaData = bind.MetaData{
 	ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"arg1\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"arg2\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"arg3\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"arg4\",\"type\":\"bool\"}],\"name\":\"BadThing\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Foo\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
 	ID:  "78ef2840de5b706112ca2dbfa765501a89",
 	Bin: "0x6080604052348015600e575f5ffd5b506101148061001c5f395ff3fe6080604052348015600e575f5ffd5b50600436106026575f3560e01c8063bfb4ebcf14602a575b5f5ffd5b60306032565b005b5f600160025f6040517fbb6a82f1000000000000000000000000000000000000000000000000000000008152600401606c949392919060a3565b60405180910390fd5b5f819050919050565b6085816075565b82525050565b5f8115159050919050565b609d81608b565b82525050565b5f60808201905060b45f830187607e565b60bf6020830186607e565b60ca6040830185607e565b60d560608301846096565b9594505050505056fea2646970667358221220e90bf647ffc897060e44b88d54995ed0c03c988fbccaf034375c2ff4e594690764736f6c634300081c0033",
 }
 // C2 is an auto generated Go binding around an Ethereum contract.
 type C2 struct {
 	abi abi.ABI
 }
 // NewC2 creates a new instance of C2.
 func NewC2() *C2 {
 	parsed, err := C2MetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &C2{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *C2) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackFoo is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xbfb4ebcf.
 //
 // Solidity: function Foo() pure returns()
 func (c2 *C2) PackFoo() []byte {
 	enc, err := c2.abi.Pack("Foo")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackError attempts to decode the provided error data using user-defined
 // error definitions.
 func (c2 *C2) UnpackError(raw []byte) (any, error) {
 	if bytes.Equal(raw[:4], c2.abi.Errors["BadThing"].ID.Bytes()[:4]) {
 		return c2.UnpackBadThingError(raw[4:])
 	}
 	return nil, errors.New("Unknown error")
 }
 // C2BadThing represents a BadThing error raised by the C2 contract.
 type C2BadThing struct {
 	Arg1 *big.Int
 	Arg2 *big.Int
 	Arg3 *big.Int
 	Arg4 bool
 }
 // ErrorID returns the hash of canonical representation of the error's signature.
 //
 // Solidity: error BadThing(uint256 arg1, uint256 arg2, uint256 arg3, bool arg4)
 func C2BadThingErrorID() common.Hash {
 	return common.HexToHash("0xbb6a82f123854747ef4381e30e497f934a3854753fec99a69c35c30d4b46714d")
 }
 // UnpackBadThingError is the Go binding used to decode the provided
 // error data into the corresponding Go error struct.
 //
 // Solidity: error BadThing(uint256 arg1, uint256 arg2, uint256 arg3, bool arg4)
 func (c2 *C2) UnpackBadThingError(raw []byte) (*C2BadThing, error) {
 	out := new(C2BadThing)
 	if err := c2.abi.UnpackIntoInterface(out, "BadThing", raw); err != nil {
 		return nil, err
 	}
 	return out, nil
 }
--- a/accounts/abi/bind/v2/internal/contracts/solc_errors/combined-abi.json
+++ b/accounts/abi/bind/v2/internal/contracts/solc_errors/combined-abi.json
@ -0,0 +1 @@
 {"contracts":{"contract.sol:C":{"abi":[{"inputs":[{"internalType":"uint256","name":"arg1","type":"uint256"},{"internalType":"uint256","name":"arg2","type":"uint256"},{"internalType":"uint256","name":"arg3","type":"uint256"},{"internalType":"bool","name":"arg4","type":"bool"}],"name":"BadThing","type":"error"},{"inputs":[{"internalType":"uint256","name":"arg1","type":"uint256"},{"internalType":"uint256","name":"arg2","type":"uint256"},{"internalType":"uint256","name":"arg3","type":"uint256"},{"internalType":"uint256","name":"arg4","type":"uint256"}],"name":"BadThing2","type":"error"},{"inputs":[],"name":"Bar","outputs":[],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"Foo","outputs":[],"stateMutability":"pure","type":"function"}],"bin":"6080604052348015600e575f5ffd5b506101c58061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610034575f3560e01c8063b0a378b014610038578063bfb4ebcf14610042575b5f5ffd5b61004061004c565b005b61004a610092565b005b5f6001600260036040517fd233a24f00000000000000000000000000000000000000000000000000000000815260040161008994939291906100ef565b60405180910390fd5b5f600160025f6040517fbb6a82f10000000000000000000000000000000000000000000000000000000081526004016100ce949392919061014c565b60405180910390fd5b5f819050919050565b6100e9816100d7565b82525050565b5f6080820190506101025f8301876100e0565b61010f60208301866100e0565b61011c60408301856100e0565b61012960608301846100e0565b95945050505050565b5f8115159050919050565b61014681610132565b82525050565b5f60808201905061015f5f8301876100e0565b61016c60208301866100e0565b61017960408301856100e0565b610186606083018461013d565b9594505050505056fea26469706673582212206a82b4c28576e4483a81102558271cfefc891cd63b95440dea521185c1ff6a2a64736f6c634300081c0033"},"contract.sol:C2":{"abi":[{"inputs":[{"internalType":"uint256","name":"arg1","type":"uint256"},{"internalType":"uint256","name":"arg2","type":"uint256"},{"internalType":"uint256","name":"arg3","type":"uint256"},{"internalType":"bool","name":"arg4","type":"bool"}],"name":"BadThing","type":"error"},{"inputs":[],"name":"Foo","outputs":[],"stateMutability":"pure","type":"function"}],"bin":"6080604052348015600e575f5ffd5b506101148061001c5f395ff3fe6080604052348015600e575f5ffd5b50600436106026575f3560e01c8063bfb4ebcf14602a575b5f5ffd5b60306032565b005b5f600160025f6040517fbb6a82f1000000000000000000000000000000000000000000000000000000008152600401606c949392919060a3565b60405180910390fd5b5f819050919050565b6085816075565b82525050565b5f8115159050919050565b609d81608b565b82525050565b5f60808201905060b45f830187607e565b60bf6020830186607e565b60ca6040830185607e565b60d560608301846096565b9594505050505056fea2646970667358221220e90bf647ffc897060e44b88d54995ed0c03c988fbccaf034375c2ff4e594690764736f6c634300081c0033"}},"version":"0.8.28+commit.7893614a.Darwin.appleclang"}
--- a/accounts/abi/bind/v2/internal/contracts/solc_errors/contract.sol
+++ b/accounts/abi/bind/v2/internal/contracts/solc_errors/contract.sol
@ -0,0 +1,36 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.26;
 error BadThing(uint256 arg1, uint256 arg2, uint256 arg3, bool arg4);
 error BadThing2(uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4);
 contract C {
    function Foo() public pure {
        revert BadThing({
            arg1: uint256(0),
            arg2: uint256(1),
            arg3: uint256(2),
            arg4: false
        });
    }
    function Bar() public pure {
        revert BadThing2({
            arg1: uint256(0),
            arg2: uint256(1),
            arg3: uint256(2),
            arg4: uint256(3)
        });
    }
 }
 // purpose of this is to test that generation of metadata for contract that emits one error produces valid Go code
 contract C2 {
    function Foo() public pure {
        revert BadThing({
            arg1: uint256(0),
            arg2: uint256(1),
            arg3: uint256(2),
            arg4: false
        });
    }
 }
--- a/accounts/abi/bind/v2/internal/contracts/uint256arrayreturn/bindings.go
+++ b/accounts/abi/bind/v2/internal/contracts/uint256arrayreturn/bindings.go
@ -0,0 +1,77 @@
 // Code generated via abigen V2 - DO NOT EDIT.
 // This file is a generated binding and any manual changes will be lost.
 package uint256arrayreturn
 import (
 	"bytes"
 	"errors"
 	"math/big"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 // Reference imports to suppress errors if they are not otherwise used.
 var (
 	_ = bytes.Equal
 	_ = errors.New
 	_ = big.NewInt
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = abi.ConvertType
 )
 // MyContractMetaData contains all meta data concerning the MyContract contract.
 var MyContractMetaData = bind.MetaData{
 	ABI: "[{\"inputs\":[],\"name\":\"GetNums\",\"outputs\":[{\"internalType\":\"uint256[5]\",\"name\":\"\",\"type\":\"uint256[5]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
 	ID:  "e48e83c9c45b19a47bd451eedc725a6bff",
 	Bin: "0x6080604052348015600e575f5ffd5b506101a78061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610029575f3560e01c8063bd6d10071461002d575b5f5ffd5b61003561004b565b6040516100429190610158565b60405180910390f35b610053610088565b5f6040518060a001604052805f8152602001600181526020016002815260200160038152602001600481525090508091505090565b6040518060a00160405280600590602082028036833780820191505090505090565b5f60059050919050565b5f81905092915050565b5f819050919050565b5f819050919050565b6100d9816100c7565b82525050565b5f6100ea83836100d0565b60208301905092915050565b5f602082019050919050565b61010b816100aa565b61011581846100b4565b9250610120826100be565b805f5b8381101561015057815161013787826100df565b9650610142836100f6565b925050600181019050610123565b505050505050565b5f60a08201905061016b5f830184610102565b9291505056fea2646970667358221220ef76cc678ca215c3e9e5261e3f33ac1cb9901c3186c2af167bfcd8f03b3b864c64736f6c634300081c0033",
 }
 // MyContract is an auto generated Go binding around an Ethereum contract.
 type MyContract struct {
 	abi abi.ABI
 }
 // NewMyContract creates a new instance of MyContract.
 func NewMyContract() *MyContract {
 	parsed, err := MyContractMetaData.ParseABI()
 	if err != nil {
 		panic(errors.New("invalid ABI: " + err.Error()))
 	}
 	return &MyContract{abi: *parsed}
 }
 // Instance creates a wrapper for a deployed contract instance at the given address.
 // Use this to create the instance object passed to abigen v2 library functions Call, Transact, etc.
 func (c *MyContract) Instance(backend bind.ContractBackend, addr common.Address) *bind.BoundContract {
 	return bind.NewBoundContract(addr, c.abi, backend, backend, backend)
 }
 // PackGetNums is the Go binding used to pack the parameters required for calling
 // the contract method with ID 0xbd6d1007.
 //
 // Solidity: function GetNums() pure returns(uint256[5])
 func (myContract *MyContract) PackGetNums() []byte {
 	enc, err := myContract.abi.Pack("GetNums")
 	if err != nil {
 		panic(err)
 	}
 	return enc
 }
 // UnpackGetNums is the Go binding that unpacks the parameters returned
 // from invoking the contract method with ID 0xbd6d1007.
 //
 // Solidity: function GetNums() pure returns(uint256[5])
 func (myContract *MyContract) UnpackGetNums(data []byte) ([5]*big.Int, error) {
 	out, err := myContract.abi.Unpack("GetNums", data)
 	if err != nil {
 		return *new([5]*big.Int), err
 	}
 	out0 := *abi.ConvertType(out[0], new([5]*big.Int)).(*[5]*big.Int)
 	return out0, err
 }
--- a/accounts/abi/bind/v2/internal/contracts/uint256arrayreturn/combined-abi.json
+++ b/accounts/abi/bind/v2/internal/contracts/uint256arrayreturn/combined-abi.json
@ -0,0 +1 @@
 {"contracts":{"contract.sol:MyContract":{"abi":[{"inputs":[],"name":"GetNums","outputs":[{"internalType":"uint256[5]","name":"","type":"uint256[5]"}],"stateMutability":"pure","type":"function"}],"bin":"6080604052348015600e575f5ffd5b506101a78061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610029575f3560e01c8063bd6d10071461002d575b5f5ffd5b61003561004b565b6040516100429190610158565b60405180910390f35b610053610088565b5f6040518060a001604052805f8152602001600181526020016002815260200160038152602001600481525090508091505090565b6040518060a00160405280600590602082028036833780820191505090505090565b5f60059050919050565b5f81905092915050565b5f819050919050565b5f819050919050565b6100d9816100c7565b82525050565b5f6100ea83836100d0565b60208301905092915050565b5f602082019050919050565b61010b816100aa565b61011581846100b4565b9250610120826100be565b805f5b8381101561015057815161013787826100df565b9650610142836100f6565b925050600181019050610123565b505050505050565b5f60a08201905061016b5f830184610102565b9291505056fea2646970667358221220ef76cc678ca215c3e9e5261e3f33ac1cb9901c3186c2af167bfcd8f03b3b864c64736f6c634300081c0033"}},"version":"0.8.28+commit.7893614a.Darwin.appleclang"}
--- a/accounts/abi/bind/v2/internal/contracts/uint256arrayreturn/contract.sol
+++ b/accounts/abi/bind/v2/internal/contracts/uint256arrayreturn/contract.sol
@ -0,0 +1,10 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.26;
 contract MyContract {
    // emit multiple events, different types
    function GetNums() public pure returns (uint256[5] memory) {
        uint256[5] memory myNums = [uint256(0), uint256(1), uint256(2), uint256(3), uint256(4)];
        return myNums;
    }
 }
--- a/accounts/abi/bind/v2/lib.go
+++ b/accounts/abi/bind/v2/lib.go
@ -0,0 +1,243 @@
 // Copyright 2024 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Lesser General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 //
 // The go-ethereum library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 // GNU Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 // Package bind implements utilities for interacting with Solidity contracts.
 // This is the 'runtime' for contract bindings generated with the abigen command.
 // It includes methods for calling/transacting, filtering chain history for
 // specific custom Solidity event types, and creating event subscriptions to monitor the
 // chain for event occurrences.
 //
 // Two methods for contract deployment are provided:
 //   - [DeployContract] is intended to be used for deployment of a single contract.
 //   - [LinkAndDeploy] is intended for the deployment of multiple
 //     contracts, potentially with library dependencies.
 package bind
 import (
 	"errors"
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/event"
 )
 // ContractEvent is a type constraint for ABI event types.
 type ContractEvent interface {
 	ContractEventName() string
 }
 // FilterEvents filters a historical block range for instances of emission of a
 // specific event type from a specified contract.  It returns an error if the
 // provided filter opts are invalid or the backend is closed.
 //
 // FilterEvents is intended to be used with contract event unpack methods in
 // bindings generated with the abigen --v2 flag. It should be
 // preferred over BoundContract.FilterLogs.
 func FilterEvents[Ev ContractEvent](c *BoundContract, opts *FilterOpts, unpack func(*types.Log) (*Ev, error), topics ...[]any) (*EventIterator[Ev], error) {
 	var e Ev
 	logs, sub, err := c.FilterLogs(opts, e.ContractEventName(), topics...)
 	if err != nil {
 		return nil, err
 	}
 	return &EventIterator[Ev]{unpack: unpack, logs: logs, sub: sub}, nil
 }
 // WatchEvents creates an event subscription to notify when logs of the
 // specified event type are emitted from the given contract. Received logs are
 // unpacked and forwarded to sink.  If topics are specified, only events are
 // forwarded which match the topics.
 //
 // WatchEvents returns a subscription or an error if the provided WatchOpts are
 // invalid or the backend is closed.
 //
 // WatchEvents is intended to be used with contract event unpack methods in
 // bindings generated with the abigen --v2 flag. It should be
 // preferred over BoundContract.WatchLogs.
 func WatchEvents[Ev ContractEvent](c *BoundContract, opts *WatchOpts, unpack func(*types.Log) (*Ev, error), sink chan<- *Ev, topics ...[]any) (event.Subscription, error) {
 	var e Ev
 	logs, sub, err := c.WatchLogs(opts, e.ContractEventName(), topics...)
 	if err != nil {
 		return nil, err
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
 		for {
 			select {
 			case log := <-logs:
 				// New log arrived, parse the event and forward to the user
 				ev, err := unpack(&log)
 				if err != nil {
 					return err
 				}
 				select {
 				case sink <- ev:
 				case err := <-sub.Err():
 					return err
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
 				return err
 			case <-quit:
 				return nil
 			}
 		}
 	}), nil
 }
 // EventIterator is an object for iterating over the results of a event log
 // filter call.
 type EventIterator[T any] struct {
 	current *T
 	unpack  func(*types.Log) (*T, error)
 	logs    <-chan types.Log
 	sub     ethereum.Subscription
 	fail    error // error to hold reason for iteration failure
 	closed  bool  // true if Close has been called
 }
 // Value returns the current value of the iterator, or nil if there isn't one.
 func (it *EventIterator[T]) Value() *T {
 	return it.current
 }
 // Next advances the iterator to the subsequent event (if there is one),
 // returning true if the iterator advanced.
 //
 // If the attempt to convert the raw log object to an instance of T using the
 // unpack function provided via FilterEvents returns an error: that error is
 // returned and subsequent calls to Next will not advance the iterator.
 func (it *EventIterator[T]) Next() (advanced bool) {
 	// If the iterator failed with an error, don't proceed
 	if it.fail != nil || it.closed {
 		return false
 	}
 	// if the iterator is still active, block until a log is received or the
 	// underlying subscription terminates.
 	select {
 	case log := <-it.logs:
 		res, err := it.unpack(&log)
 		if err != nil {
 			it.fail = err
 			return false
 		}
 		it.current = res
 		return true
 	case <-it.sub.Err():
 		// regardless of how the subscription ends, still be able to iterate
 		// over any unread logs.
 		select {
 		case log := <-it.logs:
 			res, err := it.unpack(&log)
 			if err != nil {
 				it.fail = err
 				return false
 			}
 			it.current = res
 			return true
 		default:
 			return false
 		}
 	}
 }
 // Error returns an error if iteration has failed.
 func (it *EventIterator[T]) Error() error {
 	return it.fail
 }
 // Close releases any pending underlying resources.  Any subsequent calls to
 // Next will not advance the iterator, but the current value remains accessible.
 func (it *EventIterator[T]) Close() error {
 	it.closed = true
 	it.sub.Unsubscribe()
 	return nil
 }
 // Call performs an eth_call to a contract with optional call data.
 //
 // To call a function that doesn't return any output, pass nil as the unpack
 // function. This can be useful if you just want to check that the function
 // doesn't revert.
 //
 // Call is intended to be used with contract method unpack methods in
 // bindings generated with the abigen --v2 flag. It should be
 // preferred over BoundContract.Call
 func Call[T any](c *BoundContract, opts *CallOpts, calldata []byte, unpack func([]byte) (T, error)) (T, error) {
 	var defaultResult T
 	packedOutput, err := c.CallRaw(opts, calldata)
 	if err != nil {
 		return defaultResult, err
 	}
 	if unpack == nil {
 		if len(packedOutput) > 0 {
 			return defaultResult, errors.New("contract returned data, but no unpack function was given")
 		}
 		return defaultResult, nil
 	}
 	res, err := unpack(packedOutput)
 	if err != nil {
 		return defaultResult, err
 	}
 	return res, err
 }
 // Transact creates and submits a transaction to a contract with optional input
 // data.
 //
 // Transact is identical to BoundContract.RawTransact, and is provided as a
 // package-level method so that interactions with contracts whose bindings were
 // generated with the abigen --v2 flag are consistent (they do not require
 // calling methods on the BoundContract instance).
 func Transact(c *BoundContract, opt *TransactOpts, data []byte) (*types.Transaction, error) {
 	return c.RawTransact(opt, data)
 }
 // DeployContract creates and submits a deployment transaction based on the
 // deployer bytecode and optional ABI-encoded constructor input.  It returns
 // the address and creation transaction of the pending contract, or an error
 // if the creation failed.
 //
 // To initiate the deployment of multiple contracts with one method call, see the
 // [LinkAndDeploy] method.
 func DeployContract(opts *TransactOpts, bytecode []byte, backend ContractBackend, constructorInput []byte) (common.Address, *types.Transaction, error) {
 	c := NewBoundContract(common.Address{}, abi.ABI{}, backend, backend, backend)
 	tx, err := c.RawCreationTransact(opts, append(bytecode, constructorInput...))
 	if err != nil {
 		return common.Address{}, nil, err
 	}
 	return crypto.CreateAddress(opts.From, tx.Nonce()), tx, nil
 }
 // DefaultDeployer returns a DeployFn that signs and submits creation transactions
 // using the given signer.
 //
 // The DeployFn returned by DefaultDeployer should be used by LinkAndDeploy in
 // almost all cases, unless a custom DeployFn implementation is needed.
 func DefaultDeployer(opts *TransactOpts, backend ContractBackend) DeployFn {
 	return func(input []byte, deployer []byte) (common.Address, *types.Transaction, error) {
 		addr, tx, err := DeployContract(opts, deployer, backend, input)
 		if err != nil {
 			return common.Address{}, nil, err
 		}
 		return addr, tx, nil
 	}
 }
--- a/accounts/abi/bind/v2/util.go
+++ b/accounts/abi/bind/v2/util.go
@ -29,13 +29,13 @@ import (
 // WaitMined waits for tx to be mined on the blockchain.
 // It stops waiting when the context is canceled.
-func WaitMined(ctx context.Context, b DeployBackend, tx *types.Transaction) (*types.Receipt, error) {
+func WaitMined(ctx context.Context, b DeployBackend, txHash common.Hash) (*types.Receipt, error) {
 	queryTicker := time.NewTicker(time.Second)
 	defer queryTicker.Stop()
-	logger := log.New("hash", tx.Hash())
+	logger := log.New("hash", txHash)
 	for {
-		receipt, err := b.TransactionReceipt(ctx, tx.Hash())
+		receipt, err := b.TransactionReceipt(ctx, txHash)
 		if err == nil {
 			return receipt, nil
 		}
@ -55,18 +55,16 @@ func WaitMined(ctx context.Context, b DeployBackend, tx *types.Transaction) (*ty
 	}
 }
-// WaitDeployed waits for a contract deployment transaction and returns the on-chain
+// WaitDeployed waits for a contract deployment transaction with the provided hash and
-// contract address when it is mined. It stops waiting when ctx is canceled.
+// returns the on-chain contract address when it is mined. It stops waiting when ctx is
-func WaitDeployed(ctx context.Context, b DeployBackend, tx *types.Transaction) (common.Address, error) {
+// canceled.
-	if tx.To() != nil {
+func WaitDeployed(ctx context.Context, b DeployBackend, hash common.Hash) (common.Address, error) {
-		return common.Address{}, errors.New("tx is not contract creation")
+	receipt, err := WaitMined(ctx, b, hash)
 	}
 	receipt, err := WaitMined(ctx, b, tx)
 	if err != nil {
 		return common.Address{}, err
 	}
 	if receipt.ContractAddress == (common.Address{}) {
-		return common.Address{}, errors.New("zero address")
+		return common.Address{}, ErrNoAddressInReceipt
 	}
 	// Check that code has indeed been deployed at the address.
 	// This matters on pre-Homestead chains: OOG in the constructor
--- a/accounts/abi/event_test.go
+++ b/accounts/abi/event_test.go
@ -331,7 +331,6 @@ func TestEventTupleUnpack(t *testing.T) {
 	for _, tc := range testCases {
 		assert := assert.New(t)
 		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
 			err := unpackTestEventData(tc.dest, tc.data, tc.jsonLog, assert)
 			if tc.error == "" {
--- a/accounts/abi/pack_test.go
+++ b/accounts/abi/pack_test.go
@ -34,7 +34,6 @@ import (
 func TestPack(t *testing.T) {
 	t.Parallel()
 	for i, test := range packUnpackTests {
 		i, test := i, test
 		t.Run(strconv.Itoa(i), func(t *testing.T) {
 			t.Parallel()
 			encb, err := hex.DecodeString(test.packed)
--- a/accounts/abi/reflect.go
+++ b/accounts/abi/reflect.go
@ -24,7 +24,7 @@ import (
 	"strings"
 )
-// ConvertType converts an interface of a runtime type into a interface of the
+// ConvertType converts an interface of a runtime type into an interface of the
 // given type, e.g. turn this code:
 //
 //	var fields []reflect.StructField
@ -33,7 +33,7 @@ import (
 //			Name: "X",
 //			Type: reflect.TypeOf(new(big.Int)),
 //			Tag:  reflect.StructTag("json:\"" + "x" + "\""),
-//	}
+//	})
 //
 // into:
 //
--- a/accounts/abi/reflect_test.go
+++ b/accounts/abi/reflect_test.go
@ -172,7 +172,6 @@ var reflectTests = []reflectTest{
 func TestReflectNameToStruct(t *testing.T) {
 	t.Parallel()
 	for _, test := range reflectTests {
 		test := test
 		t.Run(test.name, func(t *testing.T) {
 			t.Parallel()
 			m, err := mapArgNamesToStructFields(test.args, reflect.ValueOf(test.struc))
--- a/accounts/abi/topics.go
+++ b/accounts/abi/topics.go
@ -24,6 +24,7 @@ import (
 	"reflect"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/crypto"
 )
@ -41,8 +42,7 @@ func MakeTopics(query ...[]interface{}) ([][]common.Hash, error) {
 			case common.Address:
 				copy(topic[common.HashLength-common.AddressLength:], rule[:])
 			case *big.Int:
-				blob := rule.Bytes()
+				copy(topic[:], math.U256Bytes(new(big.Int).Set(rule)))
 				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 solidity documentation, indexed event
+				// todo(rjl493456442) according to 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,6 +17,7 @@
 package abi
 import (
 	"math"
 	"math/big"
 	"reflect"
 	"testing"
@ -55,9 +56,27 @@ func TestMakeTopics(t *testing.T) {
 			false,
 		},
 		{
-			"support *big.Int types in topics",
+			"support positive *big.Int types in topics",
-			args{[][]interface{}{{big.NewInt(1).Lsh(big.NewInt(2), 254)}}},
+			args{[][]interface{}{
-			[][]common.Hash{{common.Hash{128}}},
+				{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")},
 			},
 			false,
 		},
 		{
@ -118,7 +137,6 @@ 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...)
@ -131,6 +149,23 @@ func TestMakeTopics(t *testing.T) {
 			}
 		})
 	}
 	t.Run("does not mutate big.Int", func(t *testing.T) {
 		t.Parallel()
 		want := [][]common.Hash{{common.HexToHash("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")}}
 		in := big.NewInt(-1)
 		got, err := MakeTopics([]interface{}{in})
 		if err != nil {
 			t.Fatalf("makeTopics() error = %v", err)
 		}
 		if !reflect.DeepEqual(got, want) {
 			t.Fatalf("makeTopics() = %v, want %v", got, want)
 		}
 		if orig := big.NewInt(-1); in.Cmp(orig) != 0 {
 			t.Fatalf("makeTopics() mutated an input parameter from %v to %v", orig, in)
 		}
 	})
 }
 type args struct {
@ -354,7 +389,6 @@ func TestParseTopics(t *testing.T) {
 	tests := setupTopicsTests()
 	for _, tt := range tests {
 		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			createObj := tt.args.createObj()
@ -374,7 +408,6 @@ func TestParseTopicsIntoMap(t *testing.T) {
 	tests := setupTopicsTests()
 	for _, tt := range tests {
 		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			outMap := make(map[string]interface{})
--- a/accounts/abi/type.go
+++ b/accounts/abi/type.go
@ -64,6 +64,9 @@ type Type struct {
 var (
 	// typeRegex parses the abi sub types
 	typeRegex = regexp.MustCompile("([a-zA-Z]+)(([0-9]+)(x([0-9]+))?)?")
 	// sliceSizeRegex grab the slice size
 	sliceSizeRegex = regexp.MustCompile("[0-9]+")
 )
 // NewType creates a new reflection type of abi type given in t.
@ -91,8 +94,7 @@ func NewType(t string, internalType string, components []ArgumentMarshaling) (ty
 		// grab the last cell and create a type from there
 		sliced := t[i:]
 		// grab the slice size with regexp
-		re := regexp.MustCompile("[0-9]+")
+		intz := sliceSizeRegex.FindAllString(sliced, -1)
 		intz := re.FindAllString(sliced, -1)
 		if len(intz) == 0 {
 			// is a slice
@ -179,9 +181,6 @@ func NewType(t string, internalType string, components []ArgumentMarshaling) (ty
 				return Type{}, errors.New("abi: purely anonymous or underscored field is not supported")
 			}
 			fieldName := ResolveNameConflict(name, func(s string) bool { return used[s] })
 			if err != nil {
 				return Type{}, err
 			}
 			used[fieldName] = true
 			if !isValidFieldName(fieldName) {
 				return Type{}, fmt.Errorf("field %d has invalid name", idx)
@ -220,8 +219,13 @@ func NewType(t string, internalType string, components []ArgumentMarshaling) (ty
 		typ.T = FunctionTy
 		typ.Size = 24
 	default:
 		if strings.HasPrefix(internalType, "contract ") {
 			typ.Size = 20
 			typ.T = AddressTy
 		} else {
 			return Type{}, fmt.Errorf("unsupported arg type: %s", t)
 		}
 	}
 	return
 }
--- a/accounts/abi/type_test.go
+++ b/accounts/abi/type_test.go
@ -25,7 +25,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 )
-// typeWithoutStringer is a alias for the Type type which simply doesn't implement
+// typeWithoutStringer is an alias for the Type type which simply doesn't implement
 // the stringer interface to allow printing type details in the tests below.
 type typeWithoutStringer Type
--- a/accounts/abi/unpack_test.go
+++ b/accounts/abi/unpack_test.go
@ -31,6 +31,46 @@ import (
 	"github.com/stretchr/testify/require"
 )
 func BenchmarkUnpack(b *testing.B) {
 	testCases := []struct {
 		def    string
 		packed string
 	}{
 		{
 			def:    `[{"type": "uint32"}]`,
 			packed: "0000000000000000000000000000000000000000000000000000000000000001",
 		},
 		{
 			def: `[{"type": "uint32[]"}]`,
 			packed: "0000000000000000000000000000000000000000000000000000000000000020" +
 				"0000000000000000000000000000000000000000000000000000000000000002" +
 				"0000000000000000000000000000000000000000000000000000000000000001" +
 				"0000000000000000000000000000000000000000000000000000000000000002",
 		},
 	}
 	for i, test := range testCases {
 		b.Run(strconv.Itoa(i), func(b *testing.B) {
 			def := fmt.Sprintf(`[{ "name" : "method", "type": "function", "outputs": %s}]`, test.def)
 			abi, err := JSON(strings.NewReader(def))
 			if err != nil {
 				b.Fatalf("invalid ABI definition %s: %v", def, err)
 			}
 			encb, err := hex.DecodeString(test.packed)
 			if err != nil {
 				b.Fatalf("invalid hex %s: %v", test.packed, err)
 			}
 			b.ResetTimer()
 			var result any
 			for range b.N {
 				result, _ = abi.Unpack("method", encb)
 			}
 			_ = result
 		})
 	}
 }
 // TestUnpack tests the general pack/unpack tests in packing_test.go
 func TestUnpack(t *testing.T) {
 	t.Parallel()
@ -389,7 +429,6 @@ func TestMethodMultiReturn(t *testing.T) {
 		"Can not unpack into a slice with wrong types",
 	}}
 	for _, tc := range testCases {
 		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
 			require := require.New(t)
 			err := abi.UnpackIntoInterface(tc.dest, "multi", data)
@ -947,7 +986,7 @@ func TestOOMMaliciousInput(t *testing.T) {
 		}
 		encb, err := hex.DecodeString(test.enc)
 		if err != nil {
-			t.Fatalf("invalid hex: %s" + test.enc)
+			t.Fatalf("invalid hex: %s", test.enc)
 		}
 		_, err = abi.Methods["method"].Outputs.UnpackValues(encb)
 		if err == nil {
--- a/accounts/accounts.go
+++ b/accounts/accounts.go
@ -195,7 +195,7 @@ func TextHash(data []byte) []byte {
 //
 // This gives context to the signed message and prevents signing of transactions.
 func TextAndHash(data []byte) ([]byte, string) {
-	msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(data), string(data))
+	msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(data), data)
 	hasher := sha3.NewLegacyKeccak256()
 	hasher.Write([]byte(msg))
 	return hasher.Sum(nil), msg
@ -214,7 +214,9 @@ const (
 	// of starting any background processes such as automatic key derivation.
 	WalletOpened
-	// WalletDropped
+	// WalletDropped is fired when a wallet is removed or disconnected, either via USB
 	// or due to a filesystem event in the keystore. This event indicates that the wallet
 	// is no longer available for operations.
 	WalletDropped
 )
--- a/accounts/external/backend.go
+++ b/accounts/external/backend.go
@ -205,7 +205,7 @@ func (api *ExternalSigner) SignTx(account accounts.Account, tx *types.Transactio
 		to = &t
 	}
 	args := &apitypes.SendTxArgs{
-		Data:  &data,
+		Input: &data,
 		Nonce: hexutil.Uint64(tx.Nonce()),
 		Value: hexutil.Big(*tx.Value()),
 		Gas:   hexutil.Uint64(tx.Gas()),
@ -215,7 +215,7 @@ func (api *ExternalSigner) SignTx(account accounts.Account, tx *types.Transactio
 	switch tx.Type() {
 	case types.LegacyTxType, types.AccessListTxType:
 		args.GasPrice = (*hexutil.Big)(tx.GasPrice())
-	case types.DynamicFeeTxType:
+	case types.DynamicFeeTxType, types.BlobTxType, types.SetCodeTxType:
 		args.MaxFeePerGas = (*hexutil.Big)(tx.GasFeeCap())
 		args.MaxPriorityFeePerGas = (*hexutil.Big)(tx.GasTipCap())
 	default:
@ -235,6 +235,17 @@ func (api *ExternalSigner) SignTx(account accounts.Account, tx *types.Transactio
 		accessList := tx.AccessList()
 		args.AccessList = &accessList
 	}
 	if tx.Type() == types.BlobTxType {
 		args.BlobHashes = tx.BlobHashes()
 		sidecar := tx.BlobTxSidecar()
 		if sidecar == nil {
 			return nil, errors.New("blobs must be present for signing")
 		}
 		args.Blobs = sidecar.Blobs
 		args.Commitments = sidecar.Commitments
 		args.Proofs = sidecar.Proofs
 	}
 	var res signTransactionResult
 	if err := api.client.Call(&res, "account_signTransaction", args); err != nil {
 		return nil, err
--- a/accounts/keystore/account_cache.go
+++ b/accounts/keystore/account_cache.go
@ -22,6 +22,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
 	"slices"
 	"sort"
 	"strings"
 	"sync"
@ -31,7 +32,6 @@ import (
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
 	"golang.org/x/exp/slices"
 )
 // Minimum amount of time between cache reloads. This limit applies if the platform does
@ -44,8 +44,7 @@ func byURL(a, b accounts.Account) int {
 	return a.URL.Cmp(b.URL)
 }
-// AmbiguousAddrError is returned when attempting to unlock
+// AmbiguousAddrError is returned when an address matches multiple files.
 // an address for which more than one file exists.
 type AmbiguousAddrError struct {
 	Addr    common.Address
 	Matches []accounts.Account
--- a/accounts/keystore/account_cache_test.go
+++ b/accounts/keystore/account_cache_test.go
@ -23,6 +23,7 @@ import (
 	"os"
 	"path/filepath"
 	"reflect"
 	"slices"
 	"testing"
 	"time"
@ -30,7 +31,6 @@ import (
 	"github.com/davecgh/go-spew/spew"
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/common"
 	"golang.org/x/exp/slices"
 )
 var (
@ -51,7 +51,7 @@ var (
 	}
 )
-// waitWatcherStarts waits up to 1s for the keystore watcher to start.
+// waitWatcherStart waits up to 1s for the keystore watcher to start.
 func waitWatcherStart(ks *KeyStore) bool {
 	// On systems where file watch is not supported, just return "ok".
 	if !ks.cache.watcher.enabled() {
@ -86,7 +86,7 @@ func waitForAccounts(wantAccounts []accounts.Account, ks *KeyStore) error {
 func TestWatchNewFile(t *testing.T) {
 	t.Parallel()
-	dir, ks := tmpKeyStore(t, false)
+	dir, ks := tmpKeyStore(t)
 	// Ensure the watcher is started before adding any files.
 	ks.Accounts()
@ -114,7 +114,7 @@ func TestWatchNewFile(t *testing.T) {
 func TestWatchNoDir(t *testing.T) {
 	t.Parallel()
 	// Create ks but not the directory that it watches.
-	dir := filepath.Join(os.TempDir(), fmt.Sprintf("eth-keystore-watchnodir-test-%d-%d", os.Getpid(), rand.Int()))
+	dir := filepath.Join(t.TempDir(), fmt.Sprintf("eth-keystore-watchnodir-test-%d-%d", os.Getpid(), rand.Int()))
 	ks := NewKeyStore(dir, LightScryptN, LightScryptP)
 	list := ks.Accounts()
 	if len(list) > 0 {
@ -126,7 +126,6 @@ func TestWatchNoDir(t *testing.T) {
 	}
 	// Create the directory and copy a key file into it.
 	os.MkdirAll(dir, 0700)
 	defer os.RemoveAll(dir)
 	file := filepath.Join(dir, "aaa")
 	if err := cp.CopyFile(file, cachetestAccounts[0].URL.Path); err != nil {
 		t.Fatal(err)
@ -325,7 +324,8 @@ func TestUpdatedKeyfileContents(t *testing.T) {
 	t.Parallel()
 	// Create a temporary keystore to test with
-	dir := filepath.Join(os.TempDir(), fmt.Sprintf("eth-keystore-updatedkeyfilecontents-test-%d-%d", os.Getpid(), rand.Int()))
+	dir := t.TempDir()
 	ks := NewKeyStore(dir, LightScryptN, LightScryptP)
 	list := ks.Accounts()
@ -335,9 +335,7 @@ func TestUpdatedKeyfileContents(t *testing.T) {
 	if !waitWatcherStart(ks) {
 		t.Fatal("keystore watcher didn't start in time")
 	}
-	// Create the directory and copy a key file into it.
+	// Copy a key file into it
 	os.MkdirAll(dir, 0700)
 	defer os.RemoveAll(dir)
 	file := filepath.Join(dir, "aaa")
 	// Place one of our testfiles in there
--- a/accounts/keystore/keystore.go
+++ b/accounts/keystore/keystore.go
@ -87,15 +87,6 @@ func NewKeyStore(keydir string, scryptN, scryptP int) *KeyStore {
 	return ks
 }
 // NewPlaintextKeyStore creates a keystore for the given directory.
 // Deprecated: Use NewKeyStore.
 func NewPlaintextKeyStore(keydir string) *KeyStore {
 	keydir, _ = filepath.Abs(keydir)
 	ks := &KeyStore{storage: &keyStorePlain{keydir}}
 	ks.init(keydir)
 	return ks
 }
 func (ks *KeyStore) init(keydir string) {
 	// Lock the mutex since the account cache might call back with events
 	ks.mu.Lock()
@ -321,11 +312,10 @@ func (ks *KeyStore) Unlock(a accounts.Account, passphrase string) error {
 // Lock removes the private key with the given address from memory.
 func (ks *KeyStore) Lock(addr common.Address) error {
 	ks.mu.Lock()
-	if unl, found := ks.unlocked[addr]; found {
+	unl, found := ks.unlocked[addr]
 	ks.mu.Unlock()
 	if found {
 		ks.expire(addr, unl, time.Duration(0)*time.Nanosecond)
 	} else {
 		ks.mu.Unlock()
 	}
 	return nil
 }
@ -509,7 +499,5 @@ func (ks *KeyStore) isUpdating() bool {
 // zeroKey zeroes a private key in memory.
 func zeroKey(k *ecdsa.PrivateKey) {
 	b := k.D.Bits()
-	for i := range b {
+	clear(b)
 		b[i] = 0
 	}
 }
--- a/accounts/keystore/keystore_test.go
+++ b/accounts/keystore/keystore_test.go
@ -20,6 +20,7 @@ import (
 	"math/rand"
 	"os"
 	"runtime"
 	"slices"
 	"strings"
 	"sync"
 	"sync/atomic"
@ -30,14 +31,13 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/event"
 	"golang.org/x/exp/slices"
 )
 var testSigData = make([]byte, 32)
 func TestKeyStore(t *testing.T) {
 	t.Parallel()
-	dir, ks := tmpKeyStore(t, true)
+	dir, ks := tmpKeyStore(t)
 	a, err := ks.NewAccount("foo")
 	if err != nil {
@ -72,7 +72,7 @@ func TestKeyStore(t *testing.T) {
 func TestSign(t *testing.T) {
 	t.Parallel()
-	_, ks := tmpKeyStore(t, true)
+	_, ks := tmpKeyStore(t)
 	pass := "" // not used but required by API
 	a1, err := ks.NewAccount(pass)
@ -89,7 +89,7 @@ func TestSign(t *testing.T) {
 func TestSignWithPassphrase(t *testing.T) {
 	t.Parallel()
-	_, ks := tmpKeyStore(t, true)
+	_, ks := tmpKeyStore(t)
 	pass := "passwd"
 	acc, err := ks.NewAccount(pass)
@ -117,7 +117,7 @@ func TestSignWithPassphrase(t *testing.T) {
 func TestTimedUnlock(t *testing.T) {
 	t.Parallel()
-	_, ks := tmpKeyStore(t, true)
+	_, ks := tmpKeyStore(t)
 	pass := "foo"
 	a1, err := ks.NewAccount(pass)
@ -152,7 +152,7 @@ func TestTimedUnlock(t *testing.T) {
 func TestOverrideUnlock(t *testing.T) {
 	t.Parallel()
-	_, ks := tmpKeyStore(t, false)
+	_, ks := tmpKeyStore(t)
 	pass := "foo"
 	a1, err := ks.NewAccount(pass)
@ -193,7 +193,7 @@ func TestOverrideUnlock(t *testing.T) {
 // This test should fail under -race if signing races the expiration goroutine.
 func TestSignRace(t *testing.T) {
 	t.Parallel()
-	_, ks := tmpKeyStore(t, false)
+	_, ks := tmpKeyStore(t)
 	// Create a test account.
 	a1, err := ks.NewAccount("")
@ -238,7 +238,7 @@ func waitForKsUpdating(t *testing.T, ks *KeyStore, wantStatus bool, maxTime time
 func TestWalletNotifierLifecycle(t *testing.T) {
 	t.Parallel()
 	// Create a temporary keystore to test with
-	_, ks := tmpKeyStore(t, false)
+	_, ks := tmpKeyStore(t)
 	// Ensure that the notification updater is not running yet
 	time.Sleep(250 * time.Millisecond)
@ -284,7 +284,7 @@ type walletEvent struct {
 // or deleted from the keystore.
 func TestWalletNotifications(t *testing.T) {
 	t.Parallel()
-	_, ks := tmpKeyStore(t, false)
+	_, ks := tmpKeyStore(t)
 	// Subscribe to the wallet feed and collect events.
 	var (
@ -343,10 +343,10 @@ func TestWalletNotifications(t *testing.T) {
 	checkEvents(t, wantEvents, events)
 }
-// TestImportExport tests the import functionality of a keystore.
+// TestImportECDSA tests the import functionality of a keystore.
 func TestImportECDSA(t *testing.T) {
 	t.Parallel()
-	_, ks := tmpKeyStore(t, true)
+	_, ks := tmpKeyStore(t)
 	key, err := crypto.GenerateKey()
 	if err != nil {
 		t.Fatalf("failed to generate key: %v", key)
@ -362,10 +362,10 @@ func TestImportECDSA(t *testing.T) {
 	}
 }
-// TestImportECDSA tests the import and export functionality of a keystore.
+// TestImportExport tests the import and export functionality of a keystore.
 func TestImportExport(t *testing.T) {
 	t.Parallel()
-	_, ks := tmpKeyStore(t, true)
+	_, ks := tmpKeyStore(t)
 	acc, err := ks.NewAccount("old")
 	if err != nil {
 		t.Fatalf("failed to create account: %v", acc)
@ -374,7 +374,7 @@ func TestImportExport(t *testing.T) {
 	if err != nil {
 		t.Fatalf("failed to export account: %v", acc)
 	}
-	_, ks2 := tmpKeyStore(t, true)
+	_, ks2 := tmpKeyStore(t)
 	if _, err = ks2.Import(json, "old", "old"); err == nil {
 		t.Errorf("importing with invalid password succeeded")
 	}
@ -394,7 +394,7 @@ func TestImportExport(t *testing.T) {
 // This test should fail under -race if importing races.
 func TestImportRace(t *testing.T) {
 	t.Parallel()
-	_, ks := tmpKeyStore(t, true)
+	_, ks := tmpKeyStore(t)
 	acc, err := ks.NewAccount("old")
 	if err != nil {
 		t.Fatalf("failed to create account: %v", acc)
@ -403,7 +403,7 @@ func TestImportRace(t *testing.T) {
 	if err != nil {
 		t.Fatalf("failed to export account: %v", acc)
 	}
-	_, ks2 := tmpKeyStore(t, true)
+	_, ks2 := tmpKeyStore(t)
 	var atom atomic.Uint32
 	var wg sync.WaitGroup
 	wg.Add(2)
@ -457,11 +457,7 @@ func checkEvents(t *testing.T, want []walletEvent, have []walletEvent) {
 	}
 }
-func tmpKeyStore(t *testing.T, encrypted bool) (string, *KeyStore) {
+func tmpKeyStore(t *testing.T) (string, *KeyStore) {
 	d := t.TempDir()
-	newKs := NewPlaintextKeyStore
+	return d, NewKeyStore(d, veryLightScryptN, veryLightScryptP)
 	if encrypted {
 		newKs = func(kd string) *KeyStore { return NewKeyStore(kd, veryLightScryptN, veryLightScryptP) }
 	}
 	return d, newKs(d)
 }
--- 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)
 }
-// Encryptdata encrypts the data given as 'data' with the password 'auth'.
+// EncryptDataV3 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/testdata/dupes/1
+++ b/accounts/keystore/testdata/dupes/1
@ -1 +0,0 @@
 {"address":"f466859ead1932d743d622cb74fc058882e8648a","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3}
--- a/accounts/keystore/testdata/dupes/2
+++ b/accounts/keystore/testdata/dupes/2
@ -1 +0,0 @@
 {"address":"f466859ead1932d743d622cb74fc058882e8648a","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3}
--- a/accounts/keystore/testdata/dupes/foo
+++ b/accounts/keystore/testdata/dupes/foo
@ -1 +0,0 @@
 {"address":"7ef5a6135f1fd6a02593eedc869c6d41d934aef8","crypto":{"cipher":"aes-128-ctr","ciphertext":"1d0839166e7a15b9c1333fc865d69858b22df26815ccf601b28219b6192974e1","cipherparams":{"iv":"8df6caa7ff1b00c4e871f002cb7921ed"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"e5e6ef3f4ea695f496b643ebd3f75c0aa58ef4070e90c80c5d3fb0241bf1595c"},"mac":"6d16dfde774845e4585357f24bce530528bc69f4f84e1e22880d34fa45c273e5"},"id":"950077c7-71e3-4c44-a4a1-143919141ed4","version":3}
--- a/accounts/manager.go
+++ b/accounts/manager.go
@ -29,12 +29,9 @@ import (
 // the manager will buffer in its channel.
 const managerSubBufferSize = 50
-// Config contains the settings of the global account manager.
+// Config is a legacy struct which is not used
 //
 // TODO(rjl493456442, karalabe, holiman): Get rid of this when account management
 // is removed in favor of Clef.
 type Config struct {
-	InsecureUnlockAllowed bool // Whether account unlocking in insecure environment is allowed
+	InsecureUnlockAllowed bool // Unused legacy-parameter
 }
 // newBackendEvent lets the manager know it should
@ -47,7 +44,6 @@ type newBackendEvent struct {
 // Manager is an overarching account manager that can communicate with various
 // backends for signing transactions.
 type Manager struct {
 	config      *Config                    // Global account manager configurations
 	backends    map[reflect.Type][]Backend // Index of backends currently registered
 	updaters    []event.Subscription       // Wallet update subscriptions for all backends
 	updates     chan WalletEvent           // Subscription sink for backend wallet changes
@ -78,7 +74,6 @@ func NewManager(config *Config, backends ...Backend) *Manager {
 	}
 	// Assemble the account manager and return
 	am := &Manager{
 		config:      config,
 		backends:    make(map[reflect.Type][]Backend),
 		updaters:    subs,
 		updates:     updates,
@ -98,16 +93,14 @@ 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
 }
 // Config returns the configuration of account manager.
 func (am *Manager) Config() *Config {
 	return am.config
 }
 // AddBackend starts the tracking of an additional backend for wallet updates.
 // cmd/geth assumes once this func returns the backends have been already integrated.
 func (am *Manager) AddBackend(backend Backend) {
--- a/accounts/scwallet/hub.go
+++ b/accounts/scwallet/hub.go
@ -95,6 +95,7 @@ func (hub *Hub) readPairings() error {
 		}
 		return err
 	}
 	defer pairingFile.Close()
 	pairingData, err := io.ReadAll(pairingFile)
 	if err != nil {
@ -241,7 +242,7 @@ func (hub *Hub) refreshWallets() {
 			card.Disconnect(pcsc.LeaveCard)
 			continue
 		}
-		// Card connected, start tracking in amongs the wallets
+		// Card connected, start tracking among the wallets
 		hub.wallets[reader] = wallet
 		events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletArrived})
 	}
--- a/accounts/scwallet/securechannel.go
+++ b/accounts/scwallet/securechannel.go
@ -20,7 +20,6 @@ import (
 	"bytes"
 	"crypto/aes"
 	"crypto/cipher"
 	"crypto/elliptic"
 	"crypto/rand"
 	"crypto/sha256"
 	"crypto/sha512"
@ -72,11 +71,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())
+	secret, _ := crypto.S256().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),
+		publicKey: crypto.FromECDSAPub(&key.PublicKey),
 	}, nil
 }
--- a/accounts/scwallet/wallet.go
+++ b/accounts/scwallet/wallet.go
@ -73,6 +73,14 @@ var (
 	DerivationSignatureHash = sha256.Sum256(common.Hash{}.Bytes())
 )
 var (
 	// PinRegexp is the regular expression used to validate PIN codes.
 	pinRegexp = regexp.MustCompile(`^[0-9]{6,}$`)
 	// PukRegexp is the regular expression used to validate PUK codes.
 	pukRegexp = regexp.MustCompile(`^[0-9]{12,}$`)
 )
 // List of APDU command-related constants
 const (
 	claISO7816  = 0
@ -380,7 +388,7 @@ func (w *Wallet) Open(passphrase string) error {
 	case passphrase == "":
 		return ErrPINUnblockNeeded
 	case status.PinRetryCount > 0:
-		if !regexp.MustCompile(`^[0-9]{6,}$`).MatchString(passphrase) {
+		if !pinRegexp.MatchString(passphrase) {
 			w.log.Error("PIN needs to be at least 6 digits")
 			return ErrPINNeeded
 		}
@ -388,7 +396,7 @@ func (w *Wallet) Open(passphrase string) error {
 			return err
 		}
 	default:
-		if !regexp.MustCompile(`^[0-9]{12,}$`).MatchString(passphrase) {
+		if !pukRegexp.MatchString(passphrase) {
 			w.log.Error("PUK needs to be at least 12 digits")
 			return ErrPINUnblockNeeded
 		}
--- a/accounts/usbwallet/hub.go
+++ b/accounts/usbwallet/hub.go
@ -26,7 +26,7 @@ import (
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/karalabe/usb"
+	"github.com/karalabe/hid"
 )
 // LedgerScheme is the protocol scheme prefixing account and wallet URLs.
@ -73,7 +73,7 @@ func NewLedgerHub() (*Hub, error) {
 	return newHub(LedgerScheme, 0x2c97, []uint16{
 		// Device definitions taken from
-		// https://github.com/LedgerHQ/ledger-live/blob/38012bc8899e0f07149ea9cfe7e64b2c146bc92b/libs/ledgerjs/packages/devices/src/index.ts
+		// https://github.com/LedgerHQ/ledger-live/blob/595cb73b7e6622dbbcfc11867082ddc886f1bf01/libs/ledgerjs/packages/devices/src/index.ts
 		// Original product IDs
 		0x0000, /* Ledger Blue */
@ -81,18 +81,14 @@ func NewLedgerHub() (*Hub, error) {
 		0x0004, /* Ledger Nano X */
 		0x0005, /* Ledger Nano S Plus */
 		0x0006, /* Ledger Nano FTS */
 		0x0007, /* Ledger Flex */
-		0x0015, /* HID + U2F + WebUSB Ledger Blue */
+		0x0000, /* WebUSB Ledger Blue */
-		0x1015, /* HID + U2F + WebUSB Ledger Nano S */
+		0x1000, /* WebUSB Ledger Nano S */
-		0x4015, /* HID + U2F + WebUSB Ledger Nano X */
+		0x4000, /* WebUSB Ledger Nano X */
-		0x5015, /* HID + U2F + WebUSB Ledger Nano S Plus */
+		0x5000, /* WebUSB Ledger Nano S Plus */
-		0x6015, /* HID + U2F + WebUSB Ledger Nano FTS */
+		0x6000, /* WebUSB Ledger Nano FTS */
-
+		0x7000, /* WebUSB Ledger Flex */
 		0x0011, /* HID + WebUSB Ledger Blue */
 		0x1011, /* HID + WebUSB Ledger Nano S */
 		0x4011, /* HID + WebUSB Ledger Nano X */
 		0x5011, /* HID + WebUSB Ledger Nano S Plus */
 		0x6011, /* HID + WebUSB Ledger Nano FTS */
 	}, 0xffa0, 0, newLedgerDriver)
 }
@ -109,7 +105,7 @@ func NewTrezorHubWithWebUSB() (*Hub, error) {
 // newHub creates a new hardware wallet manager for generic USB devices.
 func newHub(scheme string, vendorID uint16, productIDs []uint16, usageID uint16, endpointID int, makeDriver func(log.Logger) driver) (*Hub, error) {
-	if !usb.Supported() {
+	if !hid.Supported() {
 		return nil, errors.New("unsupported platform")
 	}
 	hub := &Hub{
@ -155,7 +151,7 @@ func (hub *Hub) refreshWallets() {
 		return
 	}
 	// Retrieve the current list of USB wallet devices
-	var devices []usb.DeviceInfo
+	var devices []hid.DeviceInfo
 	if runtime.GOOS == "linux" {
 		// hidapi on Linux opens the device during enumeration to retrieve some infos,
@ -170,7 +166,7 @@ func (hub *Hub) refreshWallets() {
 			return
 		}
 	}
-	infos, err := usb.Enumerate(hub.vendorID, 0)
+	infos, err := hid.Enumerate(hub.vendorID, 0)
 	if err != nil {
 		failcount := hub.enumFails.Add(1)
 		if runtime.GOOS == "linux" {
@ -185,8 +181,11 @@ func (hub *Hub) refreshWallets() {
 	for _, info := range infos {
 		for _, id := range hub.productIDs {
 			// We check both the raw ProductID (legacy) and just the upper byte, as Ledger
 			// uses `MMII`, encoding a model (MM) and an interface bitfield (II)
 			mmOnly := info.ProductID & 0xff00
 			// Windows and Macos use UsageID matching, Linux uses Interface matching
-			if info.ProductID == id && (info.UsagePage == hub.usageID || info.Interface == hub.endpointID) {
+			if (info.ProductID == id || mmOnly == id) && (info.UsagePage == hub.usageID || info.Interface == hub.endpointID) {
 				devices = append(devices, info)
 				break
 			}
--- a/accounts/usbwallet/ledger.go
+++ b/accounts/usbwallet/ledger.go
@ -16,7 +16,7 @@
 // This file contains the implementation for interacting with the Ledger hardware
 // wallets. The wire protocol spec can be found in the Ledger Blue GitHub repo:
-// https://raw.githubusercontent.com/LedgerHQ/blue-app-eth/master/doc/ethapp.asc
+// https://github.com/LedgerHQ/app-ethereum/blob/develop/doc/ethapp.adoc
 package usbwallet
@ -279,7 +279,7 @@ func (w *ledgerDriver) ledgerDerive(derivationPath []uint32) (common.Address, er
 	}
 	hexstr := reply[1 : 1+int(reply[0])]
-	// Decode the hex sting into an Ethereum address and return
+	// Decode the hex string into an Ethereum address and return
 	var address common.Address
 	if _, err = hex.Decode(address[:], hexstr); err != nil {
 		return common.Address{}, err
@ -338,10 +338,24 @@ func (w *ledgerDriver) ledgerSign(derivationPath []uint32, tx *types.Transaction
 			return common.Address{}, nil, err
 		}
 	} else {
 		if tx.Type() == types.DynamicFeeTxType {
 			if txrlp, err = rlp.EncodeToBytes([]interface{}{chainID, tx.Nonce(), tx.GasTipCap(), tx.GasFeeCap(), tx.Gas(), tx.To(), tx.Value(), tx.Data(), tx.AccessList()}); err != nil {
 				return common.Address{}, nil, err
 			}
 			// append type to transaction
 			txrlp = append([]byte{tx.Type()}, txrlp...)
 		} else if tx.Type() == types.AccessListTxType {
 			if txrlp, err = rlp.EncodeToBytes([]interface{}{chainID, tx.Nonce(), tx.GasPrice(), tx.Gas(), tx.To(), tx.Value(), tx.Data(), tx.AccessList()}); err != nil {
 				return common.Address{}, nil, err
 			}
 			// append type to transaction
 			txrlp = append([]byte{tx.Type()}, txrlp...)
 		} else if tx.Type() == types.LegacyTxType {
 			if txrlp, err = rlp.EncodeToBytes([]interface{}{tx.Nonce(), tx.GasPrice(), tx.Gas(), tx.To(), tx.Value(), tx.Data(), chainID, big.NewInt(0), big.NewInt(0)}); err != nil {
 				return common.Address{}, nil, err
 			}
 		}
 	}
 	payload := append(path, txrlp...)
 	// Send the request and wait for the response
@ -353,8 +367,10 @@ func (w *ledgerDriver) ledgerSign(derivationPath []uint32, tx *types.Transaction
 	// Chunk size selection to mitigate an underlying RLP deserialization issue on the ledger app.
 	// https://github.com/LedgerHQ/app-ethereum/issues/409
 	chunk := 255
 	if tx.Type() == types.LegacyTxType {
 		for ; len(payload)%chunk <= ledgerEip155Size; chunk-- {
 		}
 	}
 	for len(payload) > 0 {
 		// Calculate the size of the next data chunk
@ -381,9 +397,12 @@ func (w *ledgerDriver) ledgerSign(derivationPath []uint32, tx *types.Transaction
 	if chainID == nil {
 		signer = new(types.HomesteadSigner)
 	} else {
-		signer = types.NewEIP155Signer(chainID)
+		signer = types.LatestSignerForChainID(chainID)
 		// For non-legacy transactions, V is 0 or 1, no need to subtract here.
 		if tx.Type() == types.LegacyTxType {
 			signature[64] -= byte(chainID.Uint64()*2 + 35)
 		}
 	}
 	signed, err := tx.WithSignature(signer, signature)
 	if err != nil {
 		return common.Address{}, nil, err
--- a/accounts/usbwallet/trezor.go
+++ b/accounts/usbwallet/trezor.go
@ -33,7 +33,7 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/golang/protobuf/proto"
+	"google.golang.org/protobuf/proto"
 )
 // ErrTrezorPINNeeded is returned if opening the trezor requires a PIN code. In
--- a/accounts/usbwallet/trezor/messages-common.pb.go
+++ b/accounts/usbwallet/trezor/messages-common.pb.go
--- a/accounts/usbwallet/trezor/messages-common.proto
+++ b/accounts/usbwallet/trezor/messages-common.proto
@ -5,6 +5,8 @@
 syntax = "proto2";
 package hw.trezor.messages.common;
 option go_package  = "github.com/ethereum/go-ethereum/accounts/usbwallet/trezor";
 /**
 * Response: Success of the previous request
 * @end
--- a/accounts/usbwallet/trezor/messages-ethereum.pb.go
+++ b/accounts/usbwallet/trezor/messages-ethereum.pb.go
--- a/Show more
+++ b/Show more
		`@ -0,0 +1 @@`
							{"contracts":{"contract.sol:C":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"data","type":"uint256"}],"name":"basic1","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bool","name":"flag","type":"bool"},{"indexed":false,"internalType":"uint256","name":"data","type":"uint256"}],"name":"basic2","type":"event"},{"inputs":[],"name":"EmitMulti","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"EmitOne","outputs":[],"stateMutability":"nonpayable","type":"function"}],"bin":"6080604052348015600e575f5ffd5b506101a08061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610034575f3560e01c8063cb49374914610038578063e8e49a7114610042575b5f5ffd5b61004061004c565b005b61004a6100fd565b005b60017f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd207600260405161007e9190610151565b60405180910390a260037f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd20760046040516100b89190610151565b60405180910390a25f15157f3b29b9f6d15ba80d866afb3d70b7548ab1ffda3ef6e65f35f1cb05b0e2b29f4e60016040516100f39190610151565b60405180910390a2565b60017f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd207600260405161012f9190610151565b60405180910390a2565b5f819050919050565b61014b81610139565b82525050565b5f6020820190506101645f830184610142565b9291505056fea26469706673582212207331c79de16a73a1639c4c4b3489ea78a3ed35fe62a178824f586df12672ac0564736f6c634300081c0033"}},"version":"0.8.28+commit.7893614a.Darwin.appleclang"}
		`@ -0,0 +1 @@`
							{"contracts":{"contract.sol:MyContract":{"abi":[{"inputs":[],"name":"GetNums","outputs":[{"internalType":"uint256[5]","name":"","type":"uint256[5]"}],"stateMutability":"pure","type":"function"}],"bin":"6080604052348015600e575f5ffd5b506101a78061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610029575f3560e01c8063bd6d10071461002d575b5f5ffd5b61003561004b565b6040516100429190610158565b60405180910390f35b610053610088565b5f6040518060a001604052805f8152602001600181526020016002815260200160038152602001600481525090508091505090565b6040518060a00160405280600590602082028036833780820191505090505090565b5f60059050919050565b5f81905092915050565b5f819050919050565b5f819050919050565b6100d9816100c7565b82525050565b5f6100ea83836100d0565b60208301905092915050565b5f602082019050919050565b61010b816100aa565b61011581846100b4565b9250610120826100be565b805f5b8381101561015057815161013787826100df565b9650610142836100f6565b925050600181019050610123565b505050505050565b5f60a08201905061016b5f830184610102565b9291505056fea2646970667358221220ef76cc678ca215c3e9e5261e3f33ac1cb9901c3186c2af167bfcd8f03b3b864c64736f6c634300081c0033"}},"version":"0.8.28+commit.7893614a.Darwin.appleclang"}
		`@ -1 +0,0 @@`
			`{"address":"f466859ead1932d743d622cb74fc058882e8648a","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3}`
		`@ -1 +0,0 @@`
			`{"address":"7ef5a6135f1fd6a02593eedc869c6d41d934aef8","crypto":{"cipher":"aes-128-ctr","ciphertext":"1d0839166e7a15b9c1333fc865d69858b22df26815ccf601b28219b6192974e1","cipherparams":{"iv":"8df6caa7ff1b00c4e871f002cb7921ed"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"e5e6ef3f4ea695f496b643ebd3f75c0aa58ef4070e90c80c5d3fb0241bf1595c"},"mac":"6d16dfde774845e4585357f24bce530528bc69f4f84e1e22880d34fa45c273e5"},"id":"950077c7-71e3-4c44-a4a1-143919141ed4","version":3}`