internal/build: parse buildbot tag better

.golangci.yml

@@ -19,25 +19,10 @@ linters:
     - govet
     - ineffassign
     - misspell
+    # - staticcheck
     - unconvert
+    # - unused
     - varcheck
-    - typecheck
-    - unused
-    - staticcheck
-    - bidichk
-    - durationcheck
-    - exportloopref
-    - gosec
-    - whitespace
-
-    # - structcheck # lots of false positives
-    # - errcheck #lot of false positives
-    # - contextcheck
-    # - errchkjson # lots of false positives
-    # - errorlint # this check crashes
-    # - exhaustive # silly check
-    # - makezero # false positives
-    # - nilerr # several intentional
 
 linters-settings:
   gofmt:
@@ -45,29 +30,21 @@ linters-settings:
   goconst:
     min-len: 3 # minimum length of string constant
     min-occurrences: 6 # minimum number of occurrences
-  gosec:
-    excludes:
-      - G404 # Use of weak random number generator - lots of FP
-      - G107 # Potential http request -- those are intentional
-      - G306 # G306: Expect WriteFile permissions to be 0600 or less
 
 issues:
   exclude-rules:
-    - path: crypto/bn256/cloudflare/optate.go
+    - path: crypto/blake2b/
+      linters:
+        - deadcode
+    - path: crypto/bn256/cloudflare
+      linters:
+        - deadcode
+    - path: p2p/discv5/
+      linters:
+        - deadcode
+    - path: core/vm/instructions_test.go
+      linters:
+        - goconst
+    - path: cmd/faucet/
       linters:
         - deadcode
-        - staticcheck
-    - path: internal/build/pgp.go
-      text: 'SA1019: package golang.org/x/crypto/openpgp is deprecated'
-    - path: core/vm/contracts.go
-      text: 'SA1019: package golang.org/x/crypto/ripemd160 is deprecated'
-    - path: accounts/usbwallet/trezor.go
-      text: 'SA1019: package github.com/golang/protobuf/proto is deprecated'
-    - path: accounts/usbwallet/trezor/
-      text: 'SA1019: package github.com/golang/protobuf/proto is deprecated'
-  exclude:
-    - 'SA1019: event.TypeMux is deprecated: use Feed'
-    - 'SA1019: strings.Title is deprecated'
-    - 'SA1019: strings.Title has been deprecated since Go 1.18 and an alternative has been available since Go 1.0: The rule Title uses for word boundaries does not handle Unicode punctuation properly. Use golang.org/x/text/cases instead.'
-    - 'SA1029: should not use built-in type string as key for value'
-    - 'G306: Expect WriteFile permissions to be 0600 or less'

.mailmap

@@ -1,237 +1,123 @@
-Aaron Buchwald <aaron.buchwald56@gmail.com>
+Jeffrey Wilcke <jeffrey@ethereum.org>
+Jeffrey Wilcke <jeffrey@ethereum.org> <geffobscura@gmail.com>
+Jeffrey Wilcke <jeffrey@ethereum.org> <obscuren@obscura.com>
+Jeffrey Wilcke <jeffrey@ethereum.org> <obscuren@users.noreply.github.com>
 
-Aaron Kumavis <kumavis@users.noreply.github.com>
+Viktor Trón <viktor.tron@gmail.com>
 
-Abel Nieto <abel.nieto90@gmail.com>
-Abel Nieto <abel.nieto90@gmail.com> <anietoro@uwaterloo.ca>
+Joseph Goulden <joegoulden@gmail.com>
 
-Afri Schoedon <58883403+q9f@users.noreply.github.com>
-Afri Schoedon <5chdn@users.noreply.github.com> <58883403+q9f@users.noreply.github.com>
+Nick Savers <nicksavers@gmail.com>
 
-Alec Perseghin <aperseghin@gmail.com>
+Maran Hidskes <maran.hidskes@gmail.com>
 
-Aleksey Smyrnov <i@soar.name>
-
-Alex Leverington <alex@ethdev.com>
-Alex Leverington <alex@ethdev.com> <subtly@users.noreply.github.com>
-
-Alex Pozhilenkov <alex_pozhilenkov@adoriasoft.com>
-Alex Pozhilenkov <alex_pozhilenkov@adoriasoft.com> <leshiy12345678@gmail.com>
-
-Alexey Akhunov <akhounov@gmail.com>
-
-Alon Muroch <alonmuroch@gmail.com>
-
-Andrey Petrov <shazow@gmail.com>
-Andrey Petrov <shazow@gmail.com> <andrey.petrov@shazow.net>
-
-Arkadiy Paronyan <arkadiy@ethdev.com>
-
-Armin Braun <me@obrown.io>
-
-Aron Fischer <github@aron.guru> <homotopycolimit@users.noreply.github.com>
-
-Austin Roberts <code@ausiv.com>
-Austin Roberts <code@ausiv.com> <git@ausiv.com>
+Taylor Gerring <taylor.gerring@gmail.com>
+Taylor Gerring <taylor.gerring@gmail.com> <taylor.gerring@ethereum.org>
 
 Bas van Kervel <bas@ethdev.com>
 Bas van Kervel <bas@ethdev.com> <basvankervel@ziggo.nl>
 Bas van Kervel <bas@ethdev.com> <basvankervel@gmail.com>
 Bas van Kervel <bas@ethdev.com> <bas-vk@users.noreply.github.com>
 
-Boqin Qin <bobbqqin@bupt.edu.cn>
-Boqin Qin <bobbqqin@bupt.edu.cn> <Bobbqqin@gmail.com>
+Sven Ehlert <sven@ethdev.com>
 
-Casey Detrio <cdetrio@gmail.com>
+Vitalik Buterin <v@buterin.com>
 
-Cheng Li <lob4tt@gmail.com>
-
-Chris Ziogas <ziogaschr@gmail.com>
-Chris Ziogas <ziogaschr@gmail.com> <ziogas_chr@hotmail.com>
+Marian Oancea <contact@siteshop.ro>
 
 Christoph Jentzsch <jentzsch.software@gmail.com>
 
-Diederik Loerakker <proto@protolambda.com>
+Heiko Hees <heiko@heiko.org>
+
+Alex Leverington <alex@ethdev.com>
+Alex Leverington <alex@ethdev.com> <subtly@users.noreply.github.com>
+
+Zsolt Felföldi <zsfelfoldi@gmail.com>
+
+Gavin Wood <i@gavwood.com>
+
+Martin Becze <mjbecze@gmail.com>
+Martin Becze <mjbecze@gmail.com> <wanderer@users.noreply.github.com>
 
 Dimitry Khokhlov <winsvega@mail.ru>
 
-Domino Valdano <dominoplural@gmail.com>
-Domino Valdano <dominoplural@gmail.com> <jeff@okcupid.com>
+Roman Mandeleil <roman.mandeleil@gmail.com>
 
-Edgar Aroutiounian <edgar.factorial@gmail.com>
+Alec Perseghin <aperseghin@gmail.com>
 
-Elliot Shepherd <elliot@identitii.com>
+Alon Muroch <alonmuroch@gmail.com>
+
+Arkadiy Paronyan <arkadiy@ethdev.com>
+
+Jae Kwon <jkwon.work@gmail.com>
+
+Aaron Kumavis <kumavis@users.noreply.github.com>
+
+Nick Dodson <silentcicero@outlook.com>
+
+Jason Carver <jacarver@linkedin.com>
+Jason Carver <jacarver@linkedin.com> <ut96caarrs@snkmail.com>
+
+Joseph Chow <ethereum@outlook.com>
+Joseph Chow <ethereum@outlook.com> ethers <TODO>
 
 Enrique Fynn <enriquefynn@gmail.com>
 
-Enrique Fynn <me@enriquefynn.com>
-Enrique Fynn <me@enriquefynn.com> <enriquefynn@gmail.com>
+Vincent G <caktux@gmail.com>
 
-Ernesto del Toro <ernesto.deltoro@gmail.com>
-Ernesto del Toro <ernesto.deltoro@gmail.com> <ernestodeltoro@users.noreply.github.com>
+RJ Catalano <catalanor0220@gmail.com>
+RJ Catalano <catalanor0220@gmail.com> <rj@erisindustries.com>
 
-Everton Fraga <ev@ethereum.org>
+Nchinda Nchinda <nchinda2@gmail.com>
+
+Aron Fischer <github@aron.guru> <homotopycolimit@users.noreply.github.com>
+
+Vlad Gluhovsky <gluk256@users.noreply.github.com>
+
+Ville Sundell <github@solarius.fi>
+
+Elliot Shepherd <elliot@identitii.com>
+
+Yohann Léon <sybiload@gmail.com>
+
+Gregg Dourgarian <greggd@tempworks.com>
+
+Casey Detrio <cdetrio@gmail.com>
+
+Jens Agerberg <github@agerberg.me>
+
+Nick Johnson <arachnid@notdot.net>
+
+Henning Diedrich <hd@eonblast.com>
+Henning Diedrich <hd@eonblast.com> Drake Burroughs <wildfyre@hotmail.com>
 
 Felix Lange <fjl@twurst.com>
 Felix Lange <fjl@twurst.com> <fjl@users.noreply.github.com>
 
+Максим Чусовлянов <mchusovlianov@gmail.com>
+
+Louis Holbrook <dev@holbrook.no>
+Louis Holbrook <dev@holbrook.no> <nolash@users.noreply.github.com>
+
+Thomas Bocek <tom@tomp2p.net>
+
+Victor Tran <vu.tran54@gmail.com>
+
+Justin Drake <drakefjustin@gmail.com>
+
 Frank Wang <eternnoir@gmail.com>
 
 Gary Rong <garyrong0905@gmail.com>
 
-Gavin Wood <i@gavwood.com>
-
-Gregg Dourgarian <greggd@tempworks.com>
-
-Guillaume Ballet <gballet@gmail.com>
-Guillaume Ballet <gballet@gmail.com> <3272758+gballet@users.noreply.github.com>
-
 Guillaume Nicolas <guin56@gmail.com>
 
-Hanjiang Yu <delacroix.yu@gmail.com>
-Hanjiang Yu <delacroix.yu@gmail.com> <42531996+de1acr0ix@users.noreply.github.com>
-
-Heiko Hees <heiko@heiko.org>
-
-Henning Diedrich <hd@eonblast.com>
-Henning Diedrich <hd@eonblast.com> Drake Burroughs <wildfyre@hotmail.com>
-
-Hwanjo Heo <34005989+hwanjo@users.noreply.github.com>
-
-Iskander (Alex) Sharipov <quasilyte@gmail.com>
-Iskander (Alex) Sharipov <quasilyte@gmail.com> <i.sharipov@corp.vk.com>
-
-Jae Kwon <jkwon.work@gmail.com>
-
-Janoš Guljaš <janos@resenje.org> <janos@users.noreply.github.com>
-Janoš Guljaš <janos@resenje.org> Janos Guljas <janos@resenje.org>
-
-Jared Wasinger <j-wasinger@hotmail.com>
-
-Jason Carver <jacarver@linkedin.com>
-Jason Carver <jacarver@linkedin.com> <ut96caarrs@snkmail.com>
-
-Javier Peletier <jm@epiclabs.io>
-Javier Peletier <jm@epiclabs.io> <jpeletier@users.noreply.github.com>
-
-Jeffrey Wilcke <jeffrey@ethereum.org>
-Jeffrey Wilcke <jeffrey@ethereum.org> <geffobscura@gmail.com>
-Jeffrey Wilcke <jeffrey@ethereum.org> <obscuren@obscura.com>
-Jeffrey Wilcke <jeffrey@ethereum.org> <obscuren@users.noreply.github.com>
-
-Jens Agerberg <github@agerberg.me>
-
-Joseph Chow <ethereum@outlook.com>
-Joseph Chow <ethereum@outlook.com> ethers <TODO>
-
-
-Joseph Goulden <joegoulden@gmail.com>
-
-Justin Drake <drakefjustin@gmail.com>
-
-Kenso Trabing <ktrabing@acm.org>
-Kenso Trabing <ktrabing@acm.org> <kenso.trabing@bloomwebsite.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>
-
-Maran Hidskes <maran.hidskes@gmail.com>
-
-Marian Oancea <contact@siteshop.ro>
-
-Martin Becze <mjbecze@gmail.com>
-Martin Becze <mjbecze@gmail.com> <wanderer@users.noreply.github.com>
-
-Martin Lundfall <martin.lundfall@protonmail.com>
-
-Matt Garnett <14004106+lightclient@users.noreply.github.com>
-
-Matthew Halpern <matthalp@gmail.com>
-Matthew Halpern <matthalp@gmail.com> <matthalp@google.com>
-
-Michael Riabzev <michael@starkware.co>
-
-Nchinda Nchinda <nchinda2@gmail.com>
-
-Nick Dodson <silentcicero@outlook.com>
-
-Nick Johnson <arachnid@notdot.net>
-
-Nick Savers <nicksavers@gmail.com>
-
-Nishant Das <nishdas93@gmail.com>
-Nishant Das <nishdas93@gmail.com> <nish1993@hotmail.com>
-
-Olivier Hervieu <olivier.hervieu@gmail.com>
-
-Pascal Dierich <pascal@merkleplant.xyz>
-Pascal Dierich <pascal@merkleplant.xyz> <pascal@pascaldierich.com>
-
-RJ Catalano <catalanor0220@gmail.com>
-RJ Catalano <catalanor0220@gmail.com> <rj@erisindustries.com>
-
-Ralph Caraveo <deckarep@gmail.com>
-
-Rene Lubov <41963722+renaynay@users.noreply.github.com>
-
-Robert Zaremba <robert@zaremba.ch>
-Robert Zaremba <robert@zaremba.ch> <robert.zaremba@scale-it.pl>
-
-Roman Mandeleil <roman.mandeleil@gmail.com>
-
 Sorin Neacsu <sorin.neacsu@gmail.com>
 Sorin Neacsu <sorin.neacsu@gmail.com> <sorin@users.noreply.github.com>
 
-Sven Ehlert <sven@ethdev.com>
-
-Taylor Gerring <taylor.gerring@gmail.com>
-Taylor Gerring <taylor.gerring@gmail.com> <taylor.gerring@ethereum.org>
-
-Thomas Bocek <tom@tomp2p.net>
-
-Tim Cooijmans <timcooijmans@gmail.com>
-
 Valentin Wüstholz <wuestholz@gmail.com>
 Valentin Wüstholz <wuestholz@gmail.com> <wuestholz@users.noreply.github.com>
 
-Victor Tran <vu.tran54@gmail.com>
+Armin Braun <me@obrown.io>
 
-Viktor Trón <viktor.tron@gmail.com>
-
-Ville Sundell <github@solarius.fi>
-
-Vincent G <caktux@gmail.com>
-
-Vitalik Buterin <v@buterin.com>
-
-Vlad Gluhovsky <gluk256@gmail.com>
-Vlad Gluhovsky <gluk256@gmail.com> <gluk256@users.noreply.github.com>
-
-Wenshao Zhong <wzhong20@uic.edu>
-Wenshao Zhong <wzhong20@uic.edu> <11510383@mail.sustc.edu.cn>
-Wenshao Zhong <wzhong20@uic.edu> <374662347@qq.com>
-
-Will Villanueva <hello@willvillanueva.com>
-
-Xiaobing Jiang <s7v7nislands@gmail.com>
-
-Xudong Liu <33193253+r1cs@users.noreply.github.com>
-
-Yohann Léon <sybiload@gmail.com>
-
-Zachinquarantine <Zachinquarantine@protonmail.com>
-Zachinquarantine <Zachinquarantine@protonmail.com> <zachinquarantine@yahoo.com>
-
-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>
+Ernesto del Toro <ernesto.deltoro@gmail.com>
+Ernesto del Toro <ernesto.deltoro@gmail.com> <ernestodeltoro@users.noreply.github.com>

AUTHORS

@@ -1,46 +1,27 @@
 # This is the official list of go-ethereum authors for copyright purposes.
 
-6543 <6543@obermui.de>
 a e r t h <aerth@users.noreply.github.com>
-Aaron Buchwald <aaron.buchwald56@gmail.com>
 Abel Nieto <abel.nieto90@gmail.com>
+Abel Nieto <anietoro@uwaterloo.ca>
 Adam Babik <a.babik@designfortress.com>
-Adam Schmideg <adamschmideg@users.noreply.github.com>
 Aditya <adityasripal@gmail.com>
-Aditya Arora <arora.aditya520@gmail.com>
 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>
-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 Beregszaszi <alex@rtfs.hu>
 Alex Leverington <alex@ethdev.com>
-Alex Mazalov <mazalov@gmail.com>
-Alex Pozhilenkov <alex_pozhilenkov@adoriasoft.com>
-Alex Prut <1648497+alexprut@users.noreply.github.com>
 Alex Wu <wuyiding@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>
-Ali Atiia <42751398+aliatiia@users.noreply.github.com>
 Ali Hajimirza <Ali92hm@users.noreply.github.com>
 am2rican5 <am2rican5@gmail.com>
-AmitBRD <60668103+AmitBRD@users.noreply.github.com>
-Anatole <62328077+a2br@users.noreply.github.com>
 Andrea Franz <andrea@gravityblast.com>
-Andrei Maiboroda <andrei@ethereum.org>
+Andrey Petrov <andrey.petrov@shazow.net>
 Andrey Petrov <shazow@gmail.com>
 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>
 Arba Sasmoyo <arba.sasmoyo@gmail.com>
@@ -48,26 +29,19 @@ Armani Ferrante <armaniferrante@berkeley.edu>
 Armin Braun <me@obrown.io>
 Aron Fischer <github@aron.guru>
 atsushi-ishibashi <atsushi.ishibashi@finatext.com>
-Austin Roberts <code@ausiv.com>
 ayeowch <ayeowch@gmail.com>
 b00ris <b00ris@mail.ru>
-b1ackd0t <blackd0t@protonmail.com>
 bailantaotao <Edwin@maicoin.com>
 baizhenxuan <nkbai@163.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>
 benma <mbencun@gmail.com>
 Benoit Verkindt <benoit.verkindt@gmail.com>
-Binacs <bin646891055@gmail.com>
 bloonfield <bloonfield@163.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>
-Brandon Harden <b.harden92@gmail.com>
 Brent <bmperrea@gmail.com>
 Brian Schroeder <bts@gmail.com>
 Bruno Škvorc <bruno@skvorc.me>
@@ -75,58 +49,36 @@ C. Brown <hackdom@majoolr.io>
 Caesar Chad <BLUE.WEB.GEEK@gmail.com>
 Casey Detrio <cdetrio@gmail.com>
 CDsigma <cdsigma271@gmail.com>
-Ceelog <chenwei@ceelog.org>
-Ceyhun Onur <ceyhun.onur@avalabs.org>
-chabashilah <doumodoumo@gmail.com>
 changhong <changhong.yu@shanbay.com>
 Chase Wright <mysticryuujin@gmail.com>
 Chen Quan <terasum@163.com>
-Cheng Li <lob4tt@gmail.com>
-chenglin <910372762@qq.com>
 chenyufeng <yufengcode@gmail.com>
-Chris Pacia <ctpacia@gmail.com>
-Chris Ziogas <ziogaschr@gmail.com>
 Christian Muehlhaeuser <muesli@gmail.com>
 Christoph Jentzsch <jentzsch.software@gmail.com>
-chuwt <weitaochu@gmail.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>
 Crispin Flowerday <crispin@bitso.com>
 croath <croathliu@gmail.com>
 cui <523516579@qq.com>
-Dan DeGreef <dan.degreef@gmail.com>
 Dan Kinsley <dan@joincivil.com>
-Dan Sosedoff <dan.sosedoff@gmail.com>
 Daniel A. Nagy <nagy.da@gmail.com>
-Daniel Perez <daniel@perez.sh>
 Daniel Sloof <goapsychadelic@gmail.com>
-Darioush Jalali <darioush.jalali@avalabs.org>
 Darrel Herbst <dherbst@gmail.com>
 Dave Appleton <calistralabs@gmail.com>
 Dave McGregor <dave.s.mcgregor@gmail.com>
-David Cai <davidcai1993@yahoo.com>
 David Huie <dahuie@gmail.com>
-Denver <aeharvlee@gmail.com>
-Derek Chiang <me@derekchiang.com>
 Derek Gottfrid <derek@codecubed.com>
-Di Peng <pendyaaa@gmail.com>
-Diederik Loerakker <proto@protolambda.com>
 Diego Siqueira <DiSiqueira@users.noreply.github.com>
 Diep Pham <mrfavadi@gmail.com>
 dipingxian2 <39109351+dipingxian2@users.noreply.github.com>
-divergencetech <94644849+divergencetech@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>
+Domino Valdano <jeff@okcupid.com>
 Dragan Milic <dragan@netice9.com>
 dragonvslinux <35779158+dragononcrypto@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>
@@ -134,189 +86,131 @@ Elias Naur <elias.naur@gmail.com>
 Elliot Shepherd <elliot@identitii.com>
 Emil <mursalimovemeel@gmail.com>
 emile <emile@users.noreply.github.com>
-Emmanuel T Odeke <odeke@ualberta.ca>
-Eng Zer Jun <engzerjun@gmail.com>
+Enrique Fynn <enriquefynn@gmail.com>
 Enrique Fynn <me@enriquefynn.com>
-Enrique Ortiz <hi@enriqueortiz.dev>
 EOS Classic <info@eos-classic.io>
 Erichin <erichinbato@gmail.com>
 Ernesto del Toro <ernesto.deltoro@gmail.com>
 Ethan Buchman <ethan@coinculture.info>
 ethersphere <thesw@rm.eth>
-Eugene Lepeico <eugenelepeico@gmail.com>
 Eugene Valeyev <evgen.povt@gmail.com>
 Evangelos Pappas <epappas@evalonlabs.com>
-Everton Fraga <ev@ethereum.org>
 Evgeny <awesome.observer@yandex.com>
 Evgeny Danilenko <6655321@bk.ru>
 evgk <evgeniy.kamyshev@gmail.com>
-Evolution404 <35091674+Evolution404@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 Strozberg <48066928+FelStroz@users.noreply.github.com>
 Felix Lange <fjl@twurst.com>
 Ferenc Szabo <frncmx@gmail.com>
 ferhat elmas <elmas.ferhat@gmail.com>
-Ferran Borreguero <ferranbt@protonmail.com>
 Fiisio <liangcszzu@163.com>
-Fire Man <55934298+basdevelop@users.noreply.github.com>
-flowerofdream <775654398@qq.com>
-fomotrader <82184770+fomotrader@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>
 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>
 George Ornbo <george@shapeshed.com>
-Giuseppe Bertone <bertone.giuseppe@gmail.com>
-Greg Colvin <greg@colvin.org>
 Gregg Dourgarian <greggd@tempworks.com>
-Gregory Markou <16929357+GregTheGreek@users.noreply.github.com>
-Guifel <toowik@gmail.com>
 Guilherme Salgado <gsalgado@gmail.com>
 Guillaume Ballet <gballet@gmail.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>
 Gísli Kristjánsson <gislik@hamstur.is>
 Ha ĐANG <dvietha@gmail.com>
 HackyMiner <hackyminer@gmail.com>
 hadv <dvietha@gmail.com>
-Hanjiang Yu <delacroix.yu@gmail.com>
 Hao Bryan Cheng <haobcheng@gmail.com>
-Hao Duan <duanhao0814@gmail.com>
 HAOYUatHZ <37070449+HAOYUatHZ@users.noreply.github.com>
-Harry Dutton <me@bytejedi.com>
-haryu703 <34744512+haryu703@users.noreply.github.com>
-Hendrik Hofstadt <hendrik@nexantic.com>
 Henning Diedrich <hd@eonblast.com>
-henopied <13500516+henopied@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>
 Husam Ibrahim <39692071+HusamIbrahim@users.noreply.github.com>
-Hwanjo Heo <34005989+hwanjo@users.noreply.github.com>
 hydai <z54981220@gmail.com>
 Hyung-Kyu Hqueue Choi <hyungkyu.choi@gmail.com>
-Håvard Anda Estensen <haavard.ae@gmail.com>
 Ian Macalinao <me@ian.pw>
 Ian Norden <iannordenn@gmail.com>
-icodezjb <icodezjb@163.com>
-Ikko Ashimine <eltociear@gmail.com>
-Ilan Gitter <8359193+gitteri@users.noreply.github.com>
-ImanSharaf <78227895+ImanSharaf@users.noreply.github.com>
 Isidoro Ghezzi <isidoro.ghezzi@icloud.com>
 Iskander (Alex) Sharipov <quasilyte@gmail.com>
-Ivan Bogatyy <bogatyi@gmail.com>
 Ivan Daniluk <ivan.daniluk@gmail.com>
 Ivo Georgiev <ivo@strem.io>
-jacksoom <lifengliu1994@gmail.com>
 Jae Kwon <jkwon.work@gmail.com>
-James Prestwich <10149425+prestwich@users.noreply.github.com>
 Jamie Pitts <james.pitts@gmail.com>
-Janoš Guljaš <janos@resenje.org>
-Jared Wasinger <j-wasinger@hotmail.com>
+Janos Guljas <janos@resenje.org>
+Janoš Guljaš <janos@users.noreply.github.com>
 Jason Carver <jacarver@linkedin.com>
 Javier Peletier <jm@epiclabs.io>
+Javier Peletier <jpeletier@users.noreply.github.com>
 Javier Sagredo <jasataco@gmail.com>
 Jay <codeholic.arena@gmail.com>
 Jay Guo <guojiannan1101@gmail.com>
 Jaynti Kanani <jdkanani@gmail.com>
 Jeff Prestes <jeffprestes@gmail.com>
 Jeff R. Allen <jra@nella.org>
-Jeff Wentworth <jeff@curvegrid.com>
 Jeffery Robert Walsh <rlxrlps@gmail.com>
 Jeffrey Wilcke <jeffrey@ethereum.org>
 Jens Agerberg <github@agerberg.me>
 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>
-jk-jeongkyun <45347815+jeongkyun-oh@users.noreply.github.com>
 jkcomment <jkcomment@gmail.com>
-JoeGruffins <34998433+JoeGruffins@users.noreply.github.com>
 Joel Burget <joelburget@gmail.com>
 John C. Vernaleo <john@netpurgatory.com>
-John Difool <johndifoolpi@gmail.com>
 Johns Beharry <johns@peakshift.com>
 Jonas <felberj@users.noreply.github.com>
 Jonathan Brown <jbrown@bluedroplet.com>
-Jonathan Chappelow <chappjc@users.noreply.github.com>
-Jonathan Gimeno <jgimeno@gmail.com>
 JoranHonig <JoranHonig@users.noreply.github.com>
 Jordan Krage <jmank88@gmail.com>
-Jorropo <jorropo.pgm@gmail.com>
 Joseph Chow <ethereum@outlook.com>
-Joshua Colvin <jcolvin@offchainlabs.com>
-Joshua Gutow <jbgutow@gmail.com>
-jovijovi <mageyul@hotmail.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 Drake <drakefjustin@gmail.com>
-Justus <jus@gtsbr.org>
-Kawashima <91420903+sscodereth@users.noreply.github.com>
+jwasinger <j-wasinger@hotmail.com>
 ken10100147 <sunhongping@kanjian.com>
 Kenji Siu <kenji@isuntv.com>
+Kenso Trabing <kenso.trabing@bloomwebsite.com>
 Kenso Trabing <ktrabing@acm.org>
 Kevin <denk.kevin@web.de>
 kevin.xu <cming.xu@gmail.com>
-KibGzr <kibgzr@gmail.com>
 kiel barry <kiel.j.barry@gmail.com>
-kilic <onurkilic1004@gmail.com>
 kimmylin <30611210+kimmylin@users.noreply.github.com>
 Kitten King <53072918+kittenking@users.noreply.github.com>
 knarfeh <hejun1874@gmail.com>
 Kobi Gurkan <kobigurk@gmail.com>
-komika <komika@komika.org>
 Konrad Feldmeier <konrad@brainbot.com>
 Kris Shinn <raggamuffin.music@gmail.com>
-Kristofer Peterson <svenski123@users.noreply.github.com>
-Kumar Anirudha <mail@anirudha.dev>
 Kurkó Mihály <kurkomisi@users.noreply.github.com>
 Kushagra Sharma <ksharm01@gmail.com>
 Kwuaint <34888408+kwuaint@users.noreply.github.com>
 Kyuntae Ethan Kim <ethan.kyuntae.kim@gmail.com>
-Lee Bousfield <ljbousfield@gmail.com>
+ledgerwatch <akhounov@gmail.com>
 Lefteris Karapetsas <lefteris@refu.co>
 Leif Jurvetson <leijurv@gmail.com>
 Leo Shklovskii <leo@thermopylae.net>
 LeoLiao <leofantast@gmail.com>
 Lewis Marshall <lewis@lmars.net>
 lhendre <lhendre2@gmail.com>
-Li Dongwei <lidw1988@126.com>
+Liang Ma <liangma.ul@gmail.com>
 Liang Ma <liangma@liangbit.com>
 Liang ZOU <liang.d.zou@gmail.com>
-libby kent <viskovitzzz@gmail.com>
 libotony <liboliqi@gmail.com>
-LieutenantRoger <dijsky_2015@hotmail.com>
 ligi <ligi@ligi.de>
 Lio李欧 <lionello@users.noreply.github.com>
-lmittmann <lmittmann@users.noreply.github.com>
 Lorenzo Manacorda <lorenzo@kinvolk.io>
 Louis Holbrook <dev@holbrook.no>
 Luca Zeug <luclu@users.noreply.github.com>
-Lucas Hendren <lhendre2@gmail.com>
-lzhfromustc <43191155+lzhfromustc@users.noreply.github.com>
 Magicking <s@6120.eu>
 manlio <manlio.poltronieri@gmail.com>
 Maran Hidskes <maran.hidskes@gmail.com>
 Marek Kotewicz <marek.kotewicz@gmail.com>
-Mariano Cortesi <mcortesi@gmail.com>
 Marius van der Wijden <m.vanderwijden@live.de>
 Mark <markya0616@gmail.com>
 Mark Rushakoff <mark.rushakoff@gmail.com>
@@ -324,193 +218,108 @@ mark.lin <mark@maicoin.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>
-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 K <1036969+mkrump@users.noreply.github.com>
 Matthew Di Ferrante <mattdf@users.noreply.github.com>
 Matthew Halpern <matthalp@gmail.com>
+Matthew Halpern <matthalp@google.com>
 Matthew Wampler-Doty <matthew.wampler.doty@gmail.com>
 Max Sistemich <mafrasi2@googlemail.com>
-Maxim Zhiburt <zhiburt@gmail.com>
 Maximilian Meister <mmeister@suse.de>
-me020523 <me020523@gmail.com>
-Melvin Junhee Woo <melvin.woo@groundx.xyz>
-meowsbits <b5c6@protonmail.com>
 Micah Zoltu <micah@zoltu.net>
-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>
-Mikhail Mikheev <mmvsha73@gmail.com>
-milesvant <milesvant@gmail.com>
-Miro <mirokuratczyk@users.noreply.github.com>
 Miya Chen <miyatlchen@gmail.com>
 Mohanson <mohanson@outlook.com>
 mr_franklin <mr_franklin@126.com>
-Mudit Gupta <guptamudit@ymail.com>
 Mymskmkt <1847234666@qq.com>
 Nalin Bhardwaj <nalinbhardwaj@nibnalin.me>
-Natsu Kagami <natsukagami@gmail.com>
 Nchinda Nchinda <nchinda2@gmail.com>
-nebojsa94 <nebojsa94@users.noreply.github.com>
 necaremus <necaremus@gmail.com>
-nedifi <103940716+nedifi@users.noreply.github.com>
 needkane <604476380@qq.com>
 Nguyen Kien Trung <trung.n.k@gmail.com>
 Nguyen Sy Thanh Son <thanhson1085@gmail.com>
-Nic Jansma <nic@nicj.net>
 Nick Dodson <silentcicero@outlook.com>
 Nick Johnson <arachnid@notdot.net>
-Nicolas Feignon <nfeignon@gmail.com>
 Nicolas Guillaume <gunicolas@sqli.com>
-Nikita Kozhemyakin <enginegl.ec@gmail.com>
-Nikola Madjarevic <nikola.madjarevic@gmail.com>
 Nilesh Trivedi <nilesh@hypertrack.io>
 Nimrod Gutman <nimrod.gutman@gmail.com>
-Nishant Das <nishdas93@gmail.com>
 njupt-moon <1015041018@njupt.edu.cn>
 nkbai <nkbai@163.com>
-noam-alchemy <76969113+noam-alchemy@users.noreply.github.com>
 nobody <ddean2009@163.com>
 Noman <noman@noman.land>
-nujabes403 <nujabes403@gmail.com>
-Nye Liu <nyet@nyet.org>
 Oleg Kovalov <iamolegkovalov@gmail.com>
 Oli Bye <olibye@users.noreply.github.com>
-Oliver Tale-Yazdi <oliver@perun.network>
-Olivier Hervieu <olivier.hervieu@gmail.com>
-Or Neeman <oneeman@gmail.com>
-Osoro Bironga <fanosoro@gmail.com>
 Osuke <arget-fee.free.dgm@hotmail.co.jp>
-Pantelis Peslis <pespantelis@gmail.com>
-Pascal Dierich <pascal@merkleplant.xyz>
-Patrick O'Grady <prohb125@gmail.com>
-Pau <pau@dabax.net>
 Paul Berg <hello@paulrberg.com>
 Paul Litvak <litvakpol@012.net.il>
-Paul-Armand Verhaegen <paularmand.verhaegen@gmail.com>
 Paulo L F Casaretto <pcasaretto@gmail.com>
 Paweł Bylica <chfast@gmail.com>
-Pedro Gomes <otherview@gmail.com>
 Pedro Pombeiro <PombeirP@users.noreply.github.com>
 Peter Broadhurst <peter@themumbles.net>
-peter cresswell <pcresswell@gmail.com>
 Peter Pratscher <pratscher@gmail.com>
-Peter Simard <petesimard56@gmail.com>
 Petr Mikusek <petr@mikusek.info>
 Philip Schlump <pschlump@gmail.com>
 Pierre Neter <pierreneter@gmail.com>
-Pierre R <p.rousset@gmail.com>
-piersy <pierspowlesland@gmail.com>
 PilkyuJung <anothel1@naver.com>
-Piotr Dyraga <piotr.dyraga@keep.network>
-ploui <64719999+ploui@users.noreply.github.com>
-Preston Van Loon <preston@prysmaticlabs.com>
-Prince Sinha <sinhaprince013@gmail.com>
+protolambda <proto@protolambda.com>
 Péter Szilágyi <peterke@gmail.com>
 qd-ethan <31876119+qdgogogo@users.noreply.github.com>
-Qian Bin <cola.tin.com@gmail.com>
-Quest Henkart <qhenkart@gmail.com>
-Rachel Franks <nfranks@protonmail.com>
-Rafael Matias <rafael@skyle.net>
 Raghav Sood <raghavsood@gmail.com>
 Ralph Caraveo <deckarep@gmail.com>
+Ralph Caraveo III <deckarep@gmail.com>
 Ramesh Nair <ram@hiddentao.com>
-rangzen <public@l-homme.com>
 reinerRubin <tolstov.georgij@gmail.com>
-Rene Lubov <41963722+renaynay@users.noreply.github.com>
 rhaps107 <dod-source@yandex.ru>
 Ricardo Catalinas Jiménez <r@untroubled.be>
 Ricardo Domingos <ricardohsd@gmail.com>
 Richard Hart <richardhart92@gmail.com>
-Rick <rick.no@groundx.xyz>
 RJ Catalano <catalanor0220@gmail.com>
 Rob <robert@rojotek.com>
 Rob Mulholand <rmulholand@8thlight.com>
-Robert Zaremba <robert@zaremba.ch>
+Robert Zaremba <robert.zaremba@scale-it.pl>
 Roc Yu <rociiu0112@gmail.com>
-Roman Mazalov <83914728+gopherxyz@users.noreply.github.com>
-Ross <9055337+Chadsr@users.noreply.github.com>
 Runchao Han <elvisage941102@gmail.com>
 Russ Cox <rsc@golang.org>
 Ryan Schneider <ryanleeschneider@gmail.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>
-Sammy Libre <7374093+sammy007@users.noreply.github.com>
 Samuel Marks <samuelmarks@gmail.com>
-sanskarkhare <sanskarkhare47@gmail.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>
-Serhat Şevki Dinçer <jfcgauss@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>
+Sheldon <11510383@mail.sustc.edu.cn>
+Sheldon <374662347@qq.com>
 Shintaro Kaneko <kaneshin0120@gmail.com>
-shiqinfeng1 <150627601@qq.com>
 Shuai Qi <qishuai231@gmail.com>
-Shude Li <islishude@gmail.com>
 Shunsuke Watanabe <ww.shunsuke@gmail.com>
 silence <wangsai.silence@qq.com>
 Simon Jentzsch <simon@slock.it>
-Sina Mahmoodi <1591639+s1na@users.noreply.github.com>
-sixdays <lj491685571@126.com>
-SjonHortensius <SjonHortensius@users.noreply.github.com>
-Slava Karpenko <slavikus@gmail.com>
 slumber1122 <slumber1122@gmail.com>
 Smilenator <yurivanenko@yandex.ru>
-soc1c <soc1c@users.noreply.github.com>
 Sorin Neacsu <sorin.neacsu@gmail.com>
-Sparty <vignesh.crysis@gmail.com>
 Stein Dekker <dekker.stein@gmail.com>
 Steve Gattuso <steve@stevegattuso.me>
 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>
 sunxiaojun2014 <sunxiaojun-xy@360.cn>
-Suriyaa Sundararuban <isc.suriyaa@gmail.com>
-Sylvain Laurent <s@6120.eu>
-Taeik Lim <sibera21@gmail.com>
 tamirms <tamir@trello.com>
-Tangui Clairet <tangui.clairet@gmail.com>
-Tatsuya Shimoda <tacoo@users.noreply.github.com>
 Taylor Gerring <taylor.gerring@gmail.com>
 TColl <38299499+TColl@users.noreply.github.com>
 terasum <terasum@163.com>
-tgyKomgo <52910426+tgyKomgo@users.noreply.github.com>
-Thad Guidry <thadguidry@gmail.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>
-Tim Cooijmans <timcooijmans@gmail.com>
-Tobias Hildebrandt <79341166+tobias-hildebrandt@users.noreply.github.com>
 Tosh Camille <tochecamille@gmail.com>
 tsarpaul <Litvakpol@012.net.il>
-Tyler Chambers <2775339+tylerchambers@users.noreply.github.com>
 tzapu <alex@tzapu.com>
-ucwong <ucwong@126.com>
-uji <49834542+uji@users.noreply.github.com>
 ult-bobonovski <alex@ultiledger.io>
-Valentin Trinqué <ValentinTrinque@users.noreply.github.com>
 Valentin Wüstholz <wuestholz@gmail.com>
 Vedhavyas Singareddi <vedhavyas.singareddi@gmail.com>
 Victor Farazdagi <simple.square@gmail.com>
@@ -521,71 +330,40 @@ Ville Sundell <github@solarius.fi>
 vim88 <vim88vim88@gmail.com>
 Vincent G <caktux@gmail.com>
 Vincent Serpoul <vincent@serpoul.com>
-Vinod Damle <vdamle@users.noreply.github.com>
 Vitalik Buterin <v@buterin.com>
 Vitaly Bogdanov <vsbogd@gmail.com>
 Vitaly V <vvelikodny@gmail.com>
 Vivek Anand <vivekanand1101@users.noreply.github.com>
+Vlad <gluk256@gmail.com>
 Vlad Bokov <razum2um@mail.ru>
-Vlad Gluhovsky <gluk256@gmail.com>
-Ward Bradt <wardbradt5@gmail.com>
-Water <44689567+codeoneline@users.noreply.github.com>
-wbt <wbt@users.noreply.github.com>
+Vlad Gluhovsky <gluk256@users.noreply.github.com>
 weimumu <934657014@qq.com>
 Wenbiao Zheng <delweng@gmail.com>
-Wenshao Zhong <wzhong20@uic.edu>
-Will Villanueva <hello@willvillanueva.com>
-William Morriss <wjmelements@gmail.com>
 William Setzer <bootstrapsetzer@gmail.com>
 williambannas <wrschwartz@wpi.edu>
-wuff1996 <33193253+wuff1996@users.noreply.github.com>
 Wuxiang <wuxiangzhou2010@gmail.com>
-Xiaobing Jiang <s7v7nislands@gmail.com>
 xiekeyang <xiekeyang@users.noreply.github.com>
 xincaosu <xincaosu@126.com>
-xinluyin <31590468+xinluyin@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>
 YH-Zhou <yanhong.zhou05@gmail.com>
-Yihau Chen <a122092487@gmail.com>
 Yohann Léon <sybiload@gmail.com>
 Yoichi Hirai <i@yoichihirai.com>
-Yole <007yuyue@gmail.com>
 Yondon Fu <yondon.fu@gmail.com>
 YOSHIDA Masanori <masanori.yoshida@gmail.com>
 yoza <yoza.is12s@gmail.com>
-yumiel yoomee1313 <yumiel.ko@groundx.xyz>
 Yusup <awklsgrep@gmail.com>
-yutianwu <wzxingbupt@gmail.com>
-ywzqwwt <39263032+ywzqwwt@users.noreply.github.com>
-zaccoding <zaccoding725@gmail.com>
 Zach <zach.ramsay@gmail.com>
-Zachinquarantine <Zachinquarantine@protonmail.com>
 zah <zahary@gmail.com>
 Zahoor Mohamed <zahoor@zahoor.in>
 Zak Cole <zak@beattiecole.com>
-zcheng9 <zcheng9@hawk.iit.edu>
 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>
 Zhenguo Niu <Niu.ZGlinux@gmail.com>
-zhiqiangxu <652732310@qq.com>
-Zhou Zhiyao <ZHOU0250@e.ntu.edu.sg>
-Ziyuan Zhong <zzy.albert@163.com>
 Zoe Nolan <github@zoenolan.org>
-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>
 大彬 <hz_stb@163.com>
-沉风 <myself659@users.noreply.github.com>
 贺鹏飞 <hpf@hackerful.cn>
-陈佳 <chenjiablog@gmail.com>
 유용환 <33824408+eric-yoo@users.noreply.github.com>

Dockerfile

@@ -14,7 +14,7 @@ COPY go.sum /go-ethereum/
 RUN cd /go-ethereum && go mod download
 
 ADD . /go-ethereum
-RUN cd /go-ethereum && go run build/ci.go install -static ./cmd/geth
+RUN cd /go-ethereum && go run build/ci.go install ./cmd/geth
 
 # Pull Geth into a second stage deploy alpine container
 FROM alpine:latest

Dockerfile.alltools

@@ -14,7 +14,7 @@ COPY go.sum /go-ethereum/
 RUN cd /go-ethereum && go mod download
 
 ADD . /go-ethereum
-RUN cd /go-ethereum && go run build/ci.go install -static
+RUN cd /go-ethereum && go run build/ci.go install
 
 # Pull all binaries into a second stage deploy alpine container
 FROM alpine:latest

README.md

@@ -42,7 +42,7 @@ directory.
 |   `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/dapp/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`).                                                                                                                                                                                                                                 |
+|   `rlpdump`   | Developer utility tool to convert binary RLP ([Recursive Length Prefix](https://eth.wiki/en/fundamentals/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`).                                                                                                                                                                                                                                 |
 |   `puppeth`   | a CLI wizard that aids in creating a new Ethereum network.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 
 ## Running `geth`
@@ -188,7 +188,7 @@ accessible from the outside.
 
 As a developer, sooner rather than later you'll want to start interacting with `geth` and the
 Ethereum network via your own programs and not manually through the console. To aid
-this, `geth` has built-in support for a JSON-RPC based APIs ([standard APIs](https://ethereum.github.io/execution-apis/api-documentation/)
+this, `geth` has built-in support for a JSON-RPC based APIs ([standard APIs](https://eth.wiki/json-rpc/API)
 and [`geth` specific APIs](https://geth.ethereum.org/docs/rpc/server)).
 These can be exposed via HTTP, WebSockets and IPC (UNIX sockets on UNIX based
 platforms, and named pipes on Windows).
@@ -211,7 +211,7 @@ HTTP based JSON-RPC API options:
   * `--ws.api` API's offered over the WS-RPC interface (default: `eth,net,web3`)
   * `--ws.origins` Origins from which to accept websockets 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`)
+  * `--ipcapi` API's offered over the IPC-RPC interface (default: `admin,debug,eth,miner,net,personal,shh,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
@@ -297,7 +297,7 @@ $ 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)
+With the bootnode online, it will display an [`enode` URL](https://eth.wiki/en/fundamentals/enode-url-format)
 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.

accounts/abi/abi.go

@@ -95,7 +95,7 @@ func (abi ABI) getArguments(name string, data []byte) (Arguments, error) {
 		args = event.Inputs
 	}
 	if args == nil {
-		return nil, fmt.Errorf("abi: could not locate named method or event: %s", name)
+		return nil, errors.New("abi: could not locate named method or event")
 	}
 	return args, nil
 }
@@ -164,7 +164,7 @@ func (abi *ABI) UnmarshalJSON(data []byte) error {
 		case "constructor":
 			abi.Constructor = NewMethod("", "", Constructor, field.StateMutability, field.Constant, field.Payable, field.Inputs, nil)
 		case "function":
-			name := ResolveNameConflict(field.Name, func(s string) bool { _, ok := abi.Methods[s]; return ok })
+			name := overloadedName(field.Name, func(s string) bool { _, ok := abi.Methods[s]; return ok })
 			abi.Methods[name] = NewMethod(name, field.Name, Function, field.StateMutability, field.Constant, field.Payable, field.Inputs, field.Outputs)
 		case "fallback":
 			// New introduced function type in v0.6.0, check more detail
@@ -184,11 +184,9 @@ func (abi *ABI) UnmarshalJSON(data []byte) error {
 			}
 			abi.Receive = NewMethod("", "", Receive, field.StateMutability, field.Constant, field.Payable, nil, nil)
 		case "event":
-			name := ResolveNameConflict(field.Name, func(s string) bool { _, ok := abi.Events[s]; return ok })
+			name := overloadedName(field.Name, func(s string) bool { _, ok := abi.Events[s]; return ok })
 			abi.Events[name] = NewEvent(name, field.Name, field.Anonymous, field.Inputs)
 		case "error":
-			// Errors cannot be overloaded or overridden but are inherited,
-			// no need to resolve the name conflict here.
 			abi.Errors[field.Name] = NewError(field.Name, field.Inputs)
 		default:
 			return fmt.Errorf("abi: could not recognize type %v of field %v", field.Type, field.Name)
@@ -253,3 +251,20 @@ func UnpackRevert(data []byte) (string, error) {
 	}
 	return unpacked[0].(string), nil
 }
+
+// overloadedName returns the next available name for a given thing.
+// Needed since solidity allows for overloading.
+//
+// e.g. if the abi contains Methods send, send1
+// overloadedName would return send2 for input send.
+//
+// overloadedName works for methods, events and errors.
+func overloadedName(rawName string, isAvail func(string) bool) string {
+	name := rawName
+	ok := isAvail(name)
+	for idx := 0; ok; idx++ {
+		name = fmt.Sprintf("%s%d", rawName, idx)
+		ok = isAvail(name)
+	}
+	return name
+}

accounts/abi/abi_test.go

@@ -1038,7 +1038,9 @@ func TestABI_EventById(t *testing.T) {
 		}
 		if event == nil {
 			t.Errorf("We should find a event for topic %s, test #%d", topicID.Hex(), testnum)
-		} else if event.ID != topicID {
+		}
+
+		if event.ID != topicID {
 			t.Errorf("Event id %s does not match topic %s, test #%d", event.ID.Hex(), topicID.Hex(), testnum)
 		}
 

accounts/abi/argument.go

@@ -18,7 +18,6 @@ package abi
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"reflect"
 	"strings"
@@ -80,7 +79,7 @@ func (arguments Arguments) isTuple() bool {
 func (arguments Arguments) Unpack(data []byte) ([]interface{}, error) {
 	if len(data) == 0 {
 		if len(arguments.NonIndexed()) != 0 {
-			return nil, errors.New("abi: attempting to unmarshall an empty string while arguments are expected")
+			return nil, fmt.Errorf("abi: attempting to unmarshall an empty string while arguments are expected")
 		}
 		return make([]interface{}, 0), nil
 	}
@@ -91,11 +90,11 @@ func (arguments Arguments) Unpack(data []byte) ([]interface{}, error) {
 func (arguments Arguments) UnpackIntoMap(v map[string]interface{}, data []byte) error {
 	// Make sure map is not nil
 	if v == nil {
-		return errors.New("abi: cannot unpack into a nil map")
+		return fmt.Errorf("abi: cannot unpack into a nil map")
 	}
 	if len(data) == 0 {
 		if len(arguments.NonIndexed()) != 0 {
-			return errors.New("abi: attempting to unmarshall an empty string while arguments are expected")
+			return fmt.Errorf("abi: attempting to unmarshall an empty string while arguments are expected")
 		}
 		return nil // Nothing to unmarshal, return
 	}
@@ -117,7 +116,7 @@ func (arguments Arguments) Copy(v interface{}, values []interface{}) error {
 	}
 	if len(values) == 0 {
 		if len(arguments.NonIndexed()) != 0 {
-			return errors.New("abi: attempting to copy no values while arguments are expected")
+			return fmt.Errorf("abi: attempting to copy no values while arguments are expected")
 		}
 		return nil // Nothing to copy, return
 	}

accounts/abi/bind/backends/simulated.go

@@ -63,13 +63,11 @@ type SimulatedBackend struct {
 	database   ethdb.Database   // In memory database to store our testing data
 	blockchain *core.BlockChain // Ethereum blockchain to handle the consensus
 
-	mu              sync.Mutex
-	pendingBlock    *types.Block   // Currently pending block that will be imported on request
-	pendingState    *state.StateDB // Currently pending state that will be the active on request
-	pendingReceipts types.Receipts // Currently receipts for the pending block
+	mu           sync.Mutex
+	pendingBlock *types.Block   // Currently pending block that will be imported on request
+	pendingState *state.StateDB // Currently pending state that will be the active on request
 
-	events       *filters.EventSystem  // for filtering log events live
-	filterSystem *filters.FilterSystem // for filtering database logs
+	events *filters.EventSystem // Event system for filtering log events live
 
 	config *params.ChainConfig
 }
@@ -86,12 +84,8 @@ func NewSimulatedBackendWithDatabase(database ethdb.Database, alloc core.Genesis
 		database:   database,
 		blockchain: blockchain,
 		config:     genesis.Config,
+		events:     filters.NewEventSystem(&filterBackend{database, blockchain}, false),
 	}
-
-	filterBackend := &filterBackend{database, blockchain, backend}
-	backend.filterSystem = filters.NewFilterSystem(filterBackend, filters.Config{})
-	backend.events = filters.NewEventSystem(backend.filterSystem, false)
-
 	backend.rollback(blockchain.CurrentBlock())
 	return backend
 }
@@ -111,20 +105,16 @@ func (b *SimulatedBackend) Close() error {
 
 // Commit imports all the pending transactions as a single block and starts a
 // fresh new state.
-func (b *SimulatedBackend) Commit() common.Hash {
+func (b *SimulatedBackend) Commit() {
 	b.mu.Lock()
 	defer b.mu.Unlock()
 
 	if _, err := b.blockchain.InsertChain([]*types.Block{b.pendingBlock}); err != nil {
 		panic(err) // This cannot happen unless the simulator is wrong, fail in that case
 	}
-	blockHash := b.pendingBlock.Hash()
-
 	// Using the last inserted block here makes it possible to build on a side
 	// chain after a fork.
 	b.rollback(b.pendingBlock)
-
-	return blockHash
 }
 
 // Rollback aborts all pending transactions, reverting to the last committed state.
@@ -614,7 +604,7 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallM
 			// User specified the legacy gas field, convert to 1559 gas typing
 			call.GasFeeCap, call.GasTipCap = call.GasPrice, call.GasPrice
 		} else {
-			// User specified 1559 gas fields (or none), use those
+			// User specified 1559 gas feilds (or none), use those
 			if call.GasFeeCap == nil {
 				call.GasFeeCap = new(big.Int)
 			}
@@ -672,7 +662,7 @@ func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transa
 		return fmt.Errorf("invalid transaction nonce: got %d, want %d", tx.Nonce(), nonce)
 	}
 	// Include tx in chain
-	blocks, receipts := core.GenerateChain(b.config, block, ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) {
+	blocks, _ := core.GenerateChain(b.config, block, ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) {
 		for _, tx := range b.pendingBlock.Transactions() {
 			block.AddTxWithChain(b.blockchain, tx)
 		}
@@ -682,7 +672,6 @@ func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transa
 
 	b.pendingBlock = blocks[0]
 	b.pendingState, _ = state.New(b.pendingBlock.Root(), stateDB.Database(), nil)
-	b.pendingReceipts = receipts[0]
 	return nil
 }
 
@@ -694,7 +683,7 @@ func (b *SimulatedBackend) FilterLogs(ctx context.Context, query ethereum.Filter
 	var filter *filters.Filter
 	if query.BlockHash != nil {
 		// Block filter requested, construct a single-shot filter
-		filter = b.filterSystem.NewBlockFilter(*query.BlockHash, query.Addresses, query.Topics)
+		filter = filters.NewBlockFilter(&filterBackend{b.database, b.blockchain}, *query.BlockHash, query.Addresses, query.Topics)
 	} else {
 		// Initialize unset filter boundaries to run from genesis to chain head
 		from := int64(0)
@@ -706,7 +695,7 @@ func (b *SimulatedBackend) FilterLogs(ctx context.Context, query ethereum.Filter
 			to = query.ToBlock.Int64()
 		}
 		// Construct the range filter
-		filter = b.filterSystem.NewRangeFilter(from, to, query.Addresses, query.Topics)
+		filter = filters.NewRangeFilter(&filterBackend{b.database, b.blockchain}, from, to, query.Addresses, query.Topics)
 	}
 	// Run the filter and return all the logs
 	logs, err := filter.Logs(ctx)
@@ -827,13 +816,11 @@ func (m callMsg) AccessList() types.AccessList { return m.CallMsg.AccessList }
 // filterBackend implements filters.Backend to support filtering for logs without
 // taking bloom-bits acceleration structures into account.
 type filterBackend struct {
-	db      ethdb.Database
-	bc      *core.BlockChain
-	backend *SimulatedBackend
+	db ethdb.Database
+	bc *core.BlockChain
 }
 
-func (fb *filterBackend) ChainDb() ethdb.Database { return fb.db }
-
+func (fb *filterBackend) ChainDb() ethdb.Database  { return fb.db }
 func (fb *filterBackend) EventMux() *event.TypeMux { panic("not supported") }
 
 func (fb *filterBackend) HeaderByNumber(ctx context.Context, block rpc.BlockNumber) (*types.Header, error) {
@@ -847,10 +834,6 @@ func (fb *filterBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*t
 	return fb.bc.GetHeaderByHash(hash), nil
 }
 
-func (fb *filterBackend) PendingBlockAndReceipts() (*types.Block, types.Receipts) {
-	return fb.backend.pendingBlock, fb.backend.pendingReceipts
-}
-
 func (fb *filterBackend) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error) {
 	number := rawdb.ReadHeaderNumber(fb.db, hash)
 	if number == nil {
@@ -859,8 +842,19 @@ func (fb *filterBackend) GetReceipts(ctx context.Context, hash common.Hash) (typ
 	return rawdb.ReadReceipts(fb.db, hash, *number, fb.bc.Config()), nil
 }
 
-func (fb *filterBackend) GetLogs(ctx context.Context, hash common.Hash, number uint64) ([][]*types.Log, error) {
-	logs := rawdb.ReadLogs(fb.db, hash, number, fb.bc.Config())
+func (fb *filterBackend) GetLogs(ctx context.Context, hash common.Hash) ([][]*types.Log, error) {
+	number := rawdb.ReadHeaderNumber(fb.db, hash)
+	if number == nil {
+		return nil, nil
+	}
+	receipts := rawdb.ReadReceipts(fb.db, hash, *number, fb.bc.Config())
+	if receipts == nil {
+		return nil, nil
+	}
+	logs := make([][]*types.Log, len(receipts))
+	for i, receipt := range receipts {
+		logs[i] = receipt.Logs
+	}
 	return logs, nil
 }
 

accounts/abi/bind/backends/simulated_test.go

@@ -655,7 +655,8 @@ func TestHeaderByNumber(t *testing.T) {
 	}
 	if latestBlockHeader == nil {
 		t.Errorf("received a nil block header")
-	} else if latestBlockHeader.Number.Uint64() != uint64(0) {
+	}
+	if latestBlockHeader.Number.Uint64() != uint64(0) {
 		t.Errorf("expected block header number 0, instead got %v", latestBlockHeader.Number.Uint64())
 	}
 
@@ -1335,42 +1336,3 @@ func TestForkResendTx(t *testing.T) {
 		t.Errorf("TX included in wrong block: %d", h)
 	}
 }
-
-func TestCommitReturnValue(t *testing.T) {
-	testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
-	sim := simTestBackend(testAddr)
-	defer sim.Close()
-
-	startBlockHeight := sim.blockchain.CurrentBlock().NumberU64()
-
-	// Test if Commit returns the correct block hash
-	h1 := sim.Commit()
-	if h1 != sim.blockchain.CurrentBlock().Hash() {
-		t.Error("Commit did not return the hash of the last block.")
-	}
-
-	// Create a block in the original chain (containing a transaction to force different block hashes)
-	head, _ := sim.HeaderByNumber(context.Background(), nil) // Should be child's, good enough
-	gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1))
-	_tx := types.NewTransaction(0, testAddr, big.NewInt(1000), params.TxGas, gasPrice, nil)
-	tx, _ := types.SignTx(_tx, types.HomesteadSigner{}, testKey)
-	sim.SendTransaction(context.Background(), tx)
-	h2 := sim.Commit()
-
-	// Create another block in the original chain
-	sim.Commit()
-
-	// Fork at the first bock
-	if err := sim.Fork(context.Background(), h1); err != nil {
-		t.Errorf("forking: %v", err)
-	}
-
-	// Test if Commit returns the correct block hash after the reorg
-	h2fork := sim.Commit()
-	if h2 == h2fork {
-		t.Error("The block in the fork and the original block are the same block!")
-	}
-	if sim.blockchain.GetHeader(h2fork, startBlockHeight+2) == nil {
-		t.Error("Could not retrieve the just created block (side-chain)")
-	}
-}

accounts/abi/bind/base_test.go

@@ -115,6 +115,7 @@ func (mc *mockPendingCaller) PendingCallContract(ctx context.Context, call ether
 }
 
 func TestPassingBlockNumber(t *testing.T) {
+
 	mc := &mockPendingCaller{
 		mockCaller: &mockCaller{
 			codeAtBytes: []byte{1, 2, 3},
@@ -487,11 +488,3 @@ func TestCall(t *testing.T) {
 		}
 	}
 }
-
-// TestCrashers contains some strings which previously caused the abi codec to crash.
-func TestCrashers(t *testing.T) {
-	abi.JSON(strings.NewReader(`[{"inputs":[{"type":"tuple[]","components":[{"type":"bool","name":"_1"}]}]}]`))
-	abi.JSON(strings.NewReader(`[{"inputs":[{"type":"tuple[]","components":[{"type":"bool","name":"&"}]}]}]`))
-	abi.JSON(strings.NewReader(`[{"inputs":[{"type":"tuple[]","components":[{"type":"bool","name":"----"}]}]}]`))
-	abi.JSON(strings.NewReader(`[{"inputs":[{"type":"tuple[]","components":[{"type":"bool","name":"foo.Bar"}]}]}]`))
-}

accounts/abi/bind/bind.go

@@ -43,43 +43,6 @@ const (
 	LangObjC
 )
 
-func isKeyWord(arg string) bool {
-	switch arg {
-	case "break":
-	case "case":
-	case "chan":
-	case "const":
-	case "continue":
-	case "default":
-	case "defer":
-	case "else":
-	case "fallthrough":
-	case "for":
-	case "func":
-	case "go":
-	case "goto":
-	case "if":
-	case "import":
-	case "interface":
-	case "iota":
-	case "map":
-	case "make":
-	case "new":
-	case "package":
-	case "range":
-	case "return":
-	case "select":
-	case "struct":
-	case "switch":
-	case "type":
-	case "var":
-	default:
-		return false
-	}
-
-	return true
-}
-
 // 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
@@ -136,7 +99,6 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 			// Normalize the method for capital cases and non-anonymous inputs/outputs
 			normalized := original
 			normalizedName := methodNormalizer[lang](alias(aliases, original.Name))
-
 			// Ensure there is no duplicated identifier
 			var identifiers = callIdentifiers
 			if !original.IsConstant() {
@@ -146,12 +108,11 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 				return "", fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName)
 			}
 			identifiers[normalizedName] = true
-
 			normalized.Name = normalizedName
 			normalized.Inputs = make([]abi.Argument, len(original.Inputs))
 			copy(normalized.Inputs, original.Inputs)
 			for j, input := range normalized.Inputs {
-				if input.Name == "" || isKeyWord(input.Name) {
+				if input.Name == "" {
 					normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j)
 				}
 				if hasStruct(input.Type) {
@@ -191,22 +152,12 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 			eventIdentifiers[normalizedName] = true
 			normalized.Name = normalizedName
 
-			used := make(map[string]bool)
 			normalized.Inputs = make([]abi.Argument, len(original.Inputs))
 			copy(normalized.Inputs, original.Inputs)
 			for j, input := range normalized.Inputs {
-				if input.Name == "" || isKeyWord(input.Name) {
+				if input.Name == "" {
 					normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j)
 				}
-				// 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)] {
-						used[capitalise(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)
 				}
@@ -481,22 +432,15 @@ func bindStructTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
 		if s, exist := structs[id]; exist {
 			return s.Name
 		}
-		var (
-			names  = make(map[string]bool)
-			fields []*tmplField
-		)
+		var fields []*tmplField
 		for i, elem := range kind.TupleElems {
-			name := capitalise(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})
+			field := bindStructTypeGo(*elem, structs)
+			fields = append(fields, &tmplField{Type: field, Name: capitalise(kind.TupleRawNames[i]), SolKind: *elem})
 		}
 		name := kind.TupleRawName
 		if name == "" {
 			name = fmt.Sprintf("Struct%d", len(structs))
 		}
-		name = capitalise(name)
-
 		structs[id] = &tmplStruct{
 			Name:   name,
 			Fields: fields,

accounts/abi/bind/bind_test.go

@@ -1954,91 +1954,6 @@ var bindTests = []struct {
 			}
 		`,
 	},
-	{
-		name: `NameConflict`,
-		contract: `
-		// SPDX-License-Identifier: GPL-3.0
-		pragma solidity >=0.4.22 <0.9.0;
-		contract oracle {
-			struct request {
-				 bytes data;
-				 bytes _data;
-			}
-			event log (int msg, int _msg);
-			function addRequest(request memory req) public pure {}
-			function getRequest() pure public returns (request memory) {
-				 return request("", "");
-			}
-		}
-		`,
-		bytecode: []string{"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"},
-		abi:      []string{`[ { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "int256", "name": "msg", "type": "int256" }, { "indexed": false, "internalType": "int256", "name": "_msg", "type": "int256" } ], "name": "log", "type": "event" }, { "inputs": [ { "components": [ { "internalType": "bytes", "name": "data", "type": "bytes" }, { "internalType": "bytes", "name": "_data", "type": "bytes" } ], "internalType": "struct oracle.request", "name": "req", "type": "tuple" } ], "name": "addRequest", "outputs": [], "stateMutability": "pure", "type": "function" }, { "inputs": [], "name": "getRequest", "outputs": [ { "components": [ { "internalType": "bytes", "name": "data", "type": "bytes" }, { "internalType": "bytes", "name": "_data", "type": "bytes" } ], "internalType": "struct oracle.request", "name": "", "type": "tuple" } ], "stateMutability": "pure", "type": "function" } ]`},
-		imports: `
-			"math/big"
-
-			"github.com/ethereum/go-ethereum/accounts/abi/bind"
-			"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
-			"github.com/ethereum/go-ethereum/core"
-			"github.com/ethereum/go-ethereum/crypto"
-			"github.com/ethereum/go-ethereum/eth/ethconfig"
-		`,
-		tester: `
-			var (
-				key, _  = crypto.GenerateKey()
-				user, _ = bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
-				sim     = backends.NewSimulatedBackend(core.GenesisAlloc{user.From: {Balance: big.NewInt(1000000000000000000)}}, ethconfig.Defaults.Miner.GasCeil)
-			)
-			defer sim.Close()
-
-			_, tx, _, err := DeployNameConflict(user, sim)
-			if err != nil {
-				t.Fatalf("DeployNameConflict() got err %v; want nil err", err)
-			}
-			sim.Commit()
-			
-			if _, err = bind.WaitDeployed(nil, sim, tx); err != nil {
-				t.Logf("Deployment tx: %+v", tx)
-				t.Errorf("bind.WaitDeployed(nil, %T, <deployment tx>) got err %v; want nil err", sim, err)
-			}
-		`,
-	},
-	{
-		name: "RangeKeyword",
-		contract: `
-		// SPDX-License-Identifier: GPL-3.0
-		pragma solidity >=0.4.22 <0.9.0;
-		contract keywordcontract {
-			function functionWithKeywordParameter(range uint256) public pure {}
-		}
-		`,
-		bytecode: []string{"0x608060405234801561001057600080fd5b5060dc8061001f6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063527a119f14602d575b600080fd5b60436004803603810190603f9190605b565b6045565b005b50565b6000813590506055816092565b92915050565b600060208284031215606e57606d608d565b5b6000607a848285016048565b91505092915050565b6000819050919050565b600080fd5b6099816083565b811460a357600080fd5b5056fea2646970667358221220d4f4525e2615516394055d369fb17df41c359e5e962734f27fd683ea81fd9db164736f6c63430008070033"},
-		abi:      []string{`[{"inputs":[{"internalType":"uint256","name":"range","type":"uint256"}],"name":"functionWithKeywordParameter","outputs":[],"stateMutability":"pure","type":"function"}]`},
-		imports: `
-			"math/big"
-
-			"github.com/ethereum/go-ethereum/accounts/abi/bind"
-			"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
-			"github.com/ethereum/go-ethereum/core"
-			"github.com/ethereum/go-ethereum/crypto"
-			"github.com/ethereum/go-ethereum/eth/ethconfig"
-		`,
-		tester: `
-			var (
-				key, _  = crypto.GenerateKey()
-				user, _ = bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
-				sim     = backends.NewSimulatedBackend(core.GenesisAlloc{user.From: {Balance: big.NewInt(1000000000000000000)}}, ethconfig.Defaults.Miner.GasCeil)
-			)
-			_, tx, _, err := DeployRangeKeyword(user, sim)
-			if err != nil {
-				t.Fatalf("error deploying contract: %v", err)
-			}
-			sim.Commit()
-
-			if _, err = bind.WaitDeployed(nil, sim, tx); err != nil {
-				t.Errorf("error deploying the contract: %v", err)
-			}
-		`,
-	},
 }
 
 // Tests that packages generated by the binder can be successfully compiled and

accounts/abi/error.go

@@ -1,4 +1,4 @@
-// Copyright 2016 The go-ethereum Authors
+// Copyright 2021 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
@@ -30,13 +30,11 @@ type Error struct {
 	Name   string
 	Inputs Arguments
 	str    string
-
 	// Sig contains the string signature according to the ABI spec.
-	// e.g.	 error foo(uint32 a, int b) = "foo(uint32,int256)"
+	// e.g.	 event foo(uint32 a, int b) = "foo(uint32,int256)"
 	// Please note that "int" is substitute for its canonical representation "int256"
 	Sig string
-
-	// ID returns the canonical representation of the error's signature used by the
+	// ID returns the canonical representation of the event's signature used by the
 	// abi definition to identify event names and types.
 	ID common.Hash
 }

accounts/abi/error_handling.go

@@ -73,6 +73,7 @@ func typeCheck(t Type, value reflect.Value) error {
 	} else {
 		return nil
 	}
+
 }
 
 // typeErr returns a formatted type casting error.

accounts/abi/event.go

@@ -29,27 +29,24 @@ import (
 // don't get the signature canonical representation as the first LOG topic.
 type Event struct {
 	// Name is the event name used for internal representation. It's derived from
-	// the raw name and a suffix will be added in the case of event overloading.
+	// the raw name and a suffix will be added in the case of a event overload.
 	//
 	// e.g.
 	// These are two events that have the same name:
 	// * foo(int,int)
 	// * foo(uint,uint)
-	// The event name of the first one will be resolved as foo while the second one
+	// The event name of the first one wll be resolved as foo while the second one
 	// will be resolved as foo0.
 	Name string
-
 	// RawName is the raw event name parsed from ABI.
 	RawName   string
 	Anonymous bool
 	Inputs    Arguments
 	str       string
-
 	// Sig contains the string signature according to the ABI spec.
 	// e.g.	 event foo(uint32 a, int b) = "foo(uint32,int256)"
 	// Please note that "int" is substitute for its canonical representation "int256"
 	Sig string
-
 	// ID returns the canonical representation of the event's signature used by the
 	// abi definition to identify event names and types.
 	ID common.Hash

accounts/abi/event_test.go

@@ -161,6 +161,7 @@ func TestEventMultiValueWithArrayUnpack(t *testing.T) {
 }
 
 func TestEventTupleUnpack(t *testing.T) {
+
 	type EventTransfer struct {
 		Value *big.Int
 	}

accounts/abi/reflect.go

@@ -99,7 +99,7 @@ func mustArrayToByteSlice(value reflect.Value) reflect.Value {
 func set(dst, src reflect.Value) error {
 	dstType, srcType := dst.Type(), src.Type()
 	switch {
-	case dstType.Kind() == reflect.Interface && dst.Elem().IsValid() && (dst.Elem().Type().Kind() == reflect.Ptr || dst.Elem().CanSet()):
+	case dstType.Kind() == reflect.Interface && dst.Elem().IsValid():
 		return set(dst.Elem(), src)
 	case dstType.Kind() == reflect.Ptr && dstType.Elem() != reflect.TypeOf(big.Int{}):
 		return set(dst.Elem(), src)
@@ -220,6 +220,7 @@ func mapArgNamesToStructFields(argNames []string, value reflect.Value) (map[stri
 
 	// second round ~~~
 	for _, argName := range argNames {
+
 		structFieldName := ToCamelCase(argName)
 
 		if structFieldName == "" {

accounts/abi/reflect_test.go

@@ -32,7 +32,7 @@ type reflectTest struct {
 
 var reflectTests = []reflectTest{
 	{
-		name: "OneToOneCorrespondence",
+		name: "OneToOneCorrespondance",
 		args: []string{"fieldA"},
 		struc: struct {
 			FieldA int `abi:"fieldA"`

accounts/abi/selector_parser.go

@@ -1,19 +1,3 @@
-// Copyright 2022 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
 package abi
 
 import (
@@ -166,7 +150,7 @@ func ParseSelector(unescapedSelector string) (SelectorMarshaling, error) {
 		return SelectorMarshaling{}, fmt.Errorf("failed to parse selector '%s': unexpected string '%s'", unescapedSelector, rest)
 	}
 
-	// Reassemble the fake ABI and construct the JSON
+	// Reassemble the fake ABI and constuct the JSON
 	fakeArgs, err := assembleArgs(args)
 	if err != nil {
 		return SelectorMarshaling{}, fmt.Errorf("failed to parse selector: %v", err)

accounts/abi/selector_parser_test.go

@@ -1,19 +1,3 @@
-// Copyright 2022 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
 package abi
 
 import (

accounts/abi/topics_test.go

@@ -1,4 +1,4 @@
-// Copyright 2020 The go-ethereum Authors
+// Copyright 2019 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

accounts/abi/type.go

@@ -23,8 +23,6 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
-	"unicode"
-	"unicode/utf8"
 
 	"github.com/ethereum/go-ethereum/common"
 )
@@ -163,26 +161,19 @@ func NewType(t string, internalType string, components []ArgumentMarshaling) (ty
 			elems      []*Type
 			names      []string
 			expression string // canonical parameter expression
-			used       = make(map[string]bool)
 		)
 		expression += "("
+		overloadedNames := make(map[string]string)
 		for idx, c := range components {
 			cType, err := NewType(c.Type, c.InternalType, c.Components)
 			if err != nil {
 				return Type{}, err
 			}
-			name := ToCamelCase(c.Name)
-			if name == "" {
-				return Type{}, errors.New("abi: purely anonymous or underscored field is not supported")
-			}
-			fieldName := ResolveNameConflict(name, func(s string) bool { return used[s] })
+			fieldName, err := overloadedArgName(c.Name, overloadedNames)
 			if err != nil {
 				return Type{}, err
 			}
-			used[fieldName] = true
-			if !isValidFieldName(fieldName) {
-				return Type{}, fmt.Errorf("field %d has invalid name", idx)
-			}
+			overloadedNames[fieldName] = fieldName
 			fields = append(fields, reflect.StructField{
 				Name: fieldName, // reflect.StructOf will panic for any exported field.
 				Type: cType.GetType(),
@@ -259,6 +250,20 @@ func (t Type) GetType() reflect.Type {
 	}
 }
 
+func overloadedArgName(rawName string, names map[string]string) (string, error) {
+	fieldName := ToCamelCase(rawName)
+	if fieldName == "" {
+		return "", errors.New("abi: purely anonymous or underscored field is not supported")
+	}
+	// Handle overloaded fieldNames
+	_, ok := names[fieldName]
+	for idx := 0; ok; idx++ {
+		fieldName = fmt.Sprintf("%s%d", ToCamelCase(rawName), idx)
+		_, ok = names[fieldName]
+	}
+	return fieldName, nil
+}
+
 // String implements Stringer.
 func (t Type) String() (out string) {
 	return t.stringKind
@@ -394,30 +399,3 @@ func getTypeSize(t Type) int {
 	}
 	return 32
 }
-
-// isLetter reports whether a given 'rune' is classified as a Letter.
-// This method is copied from reflect/type.go
-func isLetter(ch rune) bool {
-	return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_' || ch >= utf8.RuneSelf && unicode.IsLetter(ch)
-}
-
-// isValidFieldName checks if a string is a valid (struct) field name or not.
-//
-// According to the language spec, a field name should be an identifier.
-//
-// identifier = letter { letter | unicode_digit } .
-// letter = unicode_letter | "_" .
-// This method is copied from reflect/type.go
-func isValidFieldName(fieldName string) bool {
-	for i, c := range fieldName {
-		if i == 0 && !isLetter(c) {
-			return false
-		}
-
-		if !(isLetter(c) || unicode.IsDigit(c)) {
-			return false
-		}
-	}
-
-	return len(fieldName) > 0
-}

accounts/abi/unpack.go

@@ -115,6 +115,7 @@ func ReadFixedBytes(t Type, word []byte) (interface{}, error) {
 
 	reflect.Copy(array, reflect.ValueOf(word[0:t.Size]))
 	return array.Interface(), nil
+
 }
 
 // forEachUnpack iteratively unpack elements.
@@ -254,7 +255,7 @@ func toGoType(index int, t Type, output []byte) (interface{}, error) {
 
 // lengthPrefixPointsTo interprets a 32 byte slice as an offset and then determines which indices to look to decode the type.
 func lengthPrefixPointsTo(index int, output []byte) (start int, length int, err error) {
-	bigOffsetEnd := new(big.Int).SetBytes(output[index : index+32])
+	bigOffsetEnd := big.NewInt(0).SetBytes(output[index : index+32])
 	bigOffsetEnd.Add(bigOffsetEnd, common.Big32)
 	outputLength := big.NewInt(int64(len(output)))
 
@@ -267,9 +268,11 @@ func lengthPrefixPointsTo(index int, output []byte) (start int, length int, err
 	}
 
 	offsetEnd := int(bigOffsetEnd.Uint64())
-	lengthBig := new(big.Int).SetBytes(output[offsetEnd-32 : offsetEnd])
+	lengthBig := big.NewInt(0).SetBytes(output[offsetEnd-32 : offsetEnd])
 
-	totalSize := new(big.Int).Add(bigOffsetEnd, lengthBig)
+	totalSize := big.NewInt(0)
+	totalSize.Add(totalSize, bigOffsetEnd)
+	totalSize.Add(totalSize, lengthBig)
 	if totalSize.BitLen() > 63 {
 		return 0, 0, fmt.Errorf("abi: length larger than int64: %v", totalSize)
 	}
@@ -284,7 +287,7 @@ func lengthPrefixPointsTo(index int, output []byte) (start int, length int, err
 
 // tuplePointsTo resolves the location reference for dynamic tuple.
 func tuplePointsTo(index int, output []byte) (start int, err error) {
-	offset := new(big.Int).SetBytes(output[index : index+32])
+	offset := big.NewInt(0).SetBytes(output[index : index+32])
 	outputLen := big.NewInt(int64(len(output)))
 
 	if offset.Cmp(outputLen) > 0 {

accounts/abi/unpack_test.go

@@ -352,11 +352,6 @@ func TestMethodMultiReturn(t *testing.T) {
 		&[]interface{}{&expected.Int, &expected.String},
 		"",
 		"Can unpack into a slice",
-	}, {
-		&[]interface{}{&bigint, ""},
-		&[]interface{}{&expected.Int, expected.String},
-		"",
-		"Can unpack into a slice without indirection",
 	}, {
 		&[2]interface{}{&bigint, new(string)},
 		&[2]interface{}{&expected.Int, &expected.String},
@@ -429,7 +424,7 @@ func TestMultiReturnWithStringArray(t *testing.T) {
 	}
 	buff := new(bytes.Buffer)
 	buff.Write(common.Hex2Bytes("000000000000000000000000000000000000000000000000000000005c1b78ea0000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000001a055690d9db80000000000000000000000000000ab1257528b3782fb40d7ed5f72e624b744dffb2f00000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000008457468657265756d000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001048656c6c6f2c20457468657265756d2100000000000000000000000000000000"))
-	temp, _ := new(big.Int).SetString("30000000000000000000", 10)
+	temp, _ := big.NewInt(0).SetString("30000000000000000000", 10)
 	ret1, ret1Exp := new([3]*big.Int), [3]*big.Int{big.NewInt(1545304298), big.NewInt(6), temp}
 	ret2, ret2Exp := new(common.Address), common.HexToAddress("ab1257528b3782fb40d7ed5f72e624b744dffb2f")
 	ret3, ret3Exp := new([2]string), [2]string{"Ethereum", "Hello, Ethereum!"}

accounts/abi/utils.go

@@ -1,41 +0,0 @@
-// Copyright 2022 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package abi
-
-import "fmt"
-
-// ResolveNameConflict returns the next available name for a given thing.
-// This helper can be used for lots of purposes:
-//
-// - In solidity function overloading is supported, this function can fix
-//   the name conflicts of overloaded functions.
-// - In golang binding generation, the parameter(in function, event, error,
-//	 and struct definition) name will be converted to camelcase style which
-//	 may eventually lead to name conflicts.
-//
-// Name conflicts are mostly resolved by adding number suffix.
-// 	 e.g. if the abi contains Methods send, send1
-//   ResolveNameConflict would return send2 for input send.
-func ResolveNameConflict(rawName string, used func(string) bool) string {
-	name := rawName
-	ok := used(name)
-	for idx := 0; ok; idx++ {
-		name = fmt.Sprintf("%s%d", rawName, idx)
-		ok = used(name)
-	}
-	return name
-}

accounts/external/backend.go

@@ -152,6 +152,10 @@ func (api *ExternalSigner) SelfDerive(bases []accounts.DerivationPath, chain eth
 	log.Error("operation SelfDerive not supported on external signers")
 }
 
+func (api *ExternalSigner) signHash(account accounts.Account, hash []byte) ([]byte, error) {
+	return []byte{}, fmt.Errorf("operation not supported on external signers")
+}
+
 // SignData signs keccak256(data). The mimetype parameter describes the type of data being signed
 func (api *ExternalSigner) SignData(account accounts.Account, mimeType string, data []byte) ([]byte, error) {
 	var res hexutil.Bytes

accounts/keystore/account_cache_test.go

@@ -318,7 +318,7 @@ func waitForAccounts(wantAccounts []accounts.Account, ks *KeyStore) error {
 func TestUpdatedKeyfileContents(t *testing.T) {
 	t.Parallel()
 
-	// Create a temporary keystore to test with
+	// Create a temporary kesytore to test with
 	rand.Seed(time.Now().UnixNano())
 	dir := filepath.Join(os.TempDir(), fmt.Sprintf("eth-keystore-updatedkeyfilecontents-test-%d-%d", os.Getpid(), rand.Int()))
 	ks := NewKeyStore(dir, LightScryptN, LightScryptP)
@@ -383,7 +383,7 @@ func TestUpdatedKeyfileContents(t *testing.T) {
 	time.Sleep(1000 * time.Millisecond)
 
 	// Now replace file contents with crap
-	if err := os.WriteFile(file, []byte("foo"), 0600); err != nil {
+	if err := os.WriteFile(file, []byte("foo"), 0644); err != nil {
 		t.Fatal(err)
 		return
 	}

accounts/keystore/file_cache.go

@@ -39,7 +39,7 @@ type fileCache struct {
 func (fc *fileCache) scan(keyDir string) (mapset.Set, mapset.Set, mapset.Set, error) {
 	t0 := time.Now()
 
-	// List all the files from the keystore folder
+	// List all the failes from the keystore folder
 	files, err := os.ReadDir(keyDir)
 	if err != nil {
 		return nil, nil, nil, err
@@ -61,7 +61,7 @@ func (fc *fileCache) scan(keyDir string) (mapset.Set, mapset.Set, mapset.Set, er
 			log.Trace("Ignoring file on account scan", "path", path)
 			continue
 		}
-		// Gather the set of all and freshly modified files
+		// Gather the set of all and fresly modified files
 		all.Add(path)
 
 		info, err := fi.Info()

accounts/keystore/keystore_test.go

@@ -214,7 +214,7 @@ func TestSignRace(t *testing.T) {
 // Tests that the wallet notifier loop starts and stops correctly based on the
 // addition and removal of wallet event subscriptions.
 func TestWalletNotifierLifecycle(t *testing.T) {
-	// Create a temporary keystore to test with
+	// Create a temporary kesytore to test with
 	_, ks := tmpKeyStore(t, false)
 
 	// Ensure that the notification updater is not running yet
@@ -377,6 +377,7 @@ func TestImportExport(t *testing.T) {
 	if _, err = ks2.Import(json, "new", "new"); err == nil {
 		t.Errorf("importing a key twice succeeded")
 	}
+
 }
 
 // TestImportRace tests the keystore on races.
@@ -401,6 +402,7 @@ func TestImportRace(t *testing.T) {
 			if _, err := ks2.Import(json, "new", "new"); err != nil {
 				atomic.AddUint32(&atom, 1)
 			}
+
 		}()
 	}
 	wg.Wait()

accounts/keystore/passphrase.go

@@ -138,6 +138,7 @@ func (ks keyStorePassphrase) JoinPath(filename string) string {
 
 // Encryptdata encrypts the data given as 'data' with the password 'auth'.
 func EncryptDataV3(data, auth []byte, scryptN, scryptP int) (CryptoJSON, error) {
+
 	salt := make([]byte, 32)
 	if _, err := io.ReadFull(rand.Reader, salt); err != nil {
 		panic("reading from crypto/rand failed: " + err.Error())
@@ -340,6 +341,7 @@ func getKDFKey(cryptoJSON CryptoJSON, auth string) ([]byte, error) {
 		r := ensureInt(cryptoJSON.KDFParams["r"])
 		p := ensureInt(cryptoJSON.KDFParams["p"])
 		return scrypt.Key(authArray, salt, n, r, p, dkLen)
+
 	} else if cryptoJSON.KDF == "pbkdf2" {
 		c := ensureInt(cryptoJSON.KDFParams["c"])
 		prf := cryptoJSON.KDFParams["prf"].(string)

accounts/keystore/passphrase_test.go

@@ -52,7 +52,7 @@ func TestKeyEncryptDecrypt(t *testing.T) {
 			t.Errorf("test %d: key address mismatch: have %x, want %x", i, key.Address, address)
 		}
 		// Recrypt with a new password and start over
-		password += "new data appended" // nolint: gosec
+		password += "new data appended"
 		if keyjson, err = EncryptKey(key, password, veryLightScryptN, veryLightScryptP); err != nil {
 			t.Errorf("test %d: failed to recrypt key %v", i, err)
 		}

accounts/scwallet/securechannel.go

@@ -178,7 +178,7 @@ func (s *SecureChannelSession) mutuallyAuthenticate() error {
 		return err
 	}
 	if response.Sw1 != 0x90 || response.Sw2 != 0x00 {
-		return fmt.Errorf("got unexpected response from MUTUALLY_AUTHENTICATE: %#x%x", response.Sw1, response.Sw2)
+		return fmt.Errorf("got unexpected response from MUTUALLY_AUTHENTICATE: 0x%x%x", response.Sw1, response.Sw2)
 	}
 
 	if len(response.Data) != scSecretLength {
@@ -261,7 +261,7 @@ func (s *SecureChannelSession) transmitEncrypted(cla, ins, p1, p2 byte, data []b
 	rapdu.deserialize(plainData)
 
 	if rapdu.Sw1 != sw1Ok {
-		return nil, fmt.Errorf("unexpected response status Cla=%#x, Ins=%#x, Sw=%#x%x", cla, ins, rapdu.Sw1, rapdu.Sw2)
+		return nil, fmt.Errorf("unexpected response status Cla=0x%x, Ins=0x%x, Sw=0x%x%x", cla, ins, rapdu.Sw1, rapdu.Sw2)
 	}
 
 	return rapdu, nil

accounts/scwallet/wallet.go

@@ -167,7 +167,7 @@ func transmit(card *pcsc.Card, command *commandAPDU) (*responseAPDU, error) {
 	}
 
 	if response.Sw1 != sw1Ok {
-		return nil, fmt.Errorf("unexpected insecure response status Cla=%#x, Ins=%#x, Sw=%#x%x", command.Cla, command.Ins, response.Sw1, response.Sw2)
+		return nil, fmt.Errorf("unexpected insecure response status Cla=0x%x, Ins=0x%x, Sw=0x%x%x", command.Cla, command.Ins, response.Sw1, response.Sw2)
 	}
 
 	return response, nil

accounts/url_test.go

@@ -32,10 +32,9 @@ func TestURLParsing(t *testing.T) {
 		t.Errorf("expected: %v, got: %v", "ethereum.org", url.Path)
 	}
 
-	for _, u := range []string{"ethereum.org", ""} {
-		if _, err = parseURL(u); err == nil {
-			t.Errorf("input %v, expected err, got: nil", u)
-		}
+	_, err = parseURL("ethereum.org")
+	if err == nil {
+		t.Error("expected err, got: nil")
 	}
 }
 

accounts/usbwallet/trezor.go

@@ -196,10 +196,10 @@ func (w *trezorDriver) trezorDerive(derivationPath []uint32) (common.Address, er
 	if _, err := w.trezorExchange(&trezor.EthereumGetAddress{AddressN: derivationPath}, address); err != nil {
 		return common.Address{}, err
 	}
-	if addr := address.GetAddressBin(); len(addr) > 0 { // Older firmwares use binary formats
+	if addr := address.GetAddressBin(); len(addr) > 0 { // Older firmwares use binary fomats
 		return common.BytesToAddress(addr), nil
 	}
-	if addr := address.GetAddressHex(); len(addr) > 0 { // Newer firmwares use hexadecimal formats
+	if addr := address.GetAddressHex(); len(addr) > 0 { // Newer firmwares use hexadecimal fomats
 		return common.HexToAddress(addr), nil
 	}
 	return common.Address{}, errors.New("missing derived address")

accounts/usbwallet/wallet.go

@@ -380,7 +380,7 @@ func (w *wallet) selfDerive() {
 					// of legacy-ledger, the first account on the legacy-path will
 					// be shown to the user, even if we don't actively track it
 					if i < len(nextAddrs)-1 {
-						w.log.Info("Skipping tracking first account on legacy path, use personal.deriveAccount(<url>,<path>, false) to track",
+						w.log.Info("Skipping trakcking first account on legacy path, use personal.deriveAccount(<url>,<path>, false) to track",
 							"path", path, "address", nextAddrs[i])
 						break
 					}
@@ -526,6 +526,7 @@ func (w *wallet) signHash(account accounts.Account, hash []byte) ([]byte, error)
 
 // SignData signs keccak256(data). The mimetype parameter describes the type of data being signed
 func (w *wallet) SignData(account accounts.Account, mimeType string, data []byte) ([]byte, error) {
+
 	// Unless we are doing 712 signing, simply dispatch to signHash
 	if !(mimeType == accounts.MimetypeTypedData && len(data) == 66 && data[0] == 0x19 && data[1] == 0x01) {
 		return w.signHash(account, crypto.Keccak256(data))

build/checksums.txt

@@ -1,38 +1,58 @@
 # This file contains sha256 checksums of optional build dependencies.
 
-9920d3306a1ac536cdd2c796d6cb3c54bc559c226fc3cc39c32f1e0bd7f50d2a  go1.18.5.src.tar.gz
-828eeca8b5abea3e56921df8fa4b1101380a5ebcfee10acbc8ffe7ec0bf5876b  go1.18.5.darwin-amd64.tar.gz
-923a377c6fc9a2c789f5db61c24b8f64133f7889056897449891f256af34065f  go1.18.5.darwin-arm64.tar.gz
-c3d90264a706e2d88cfb44126dc6f0d008a48f00732e04bc377cea1a2b716a7c  go1.18.5.freebsd-386.tar.gz
-0de23843c568d388bc0f0e390a8966938cccaae0d74b698325f7175bac04e0c6  go1.18.5.freebsd-amd64.tar.gz
-0c44f85d146c6f98c34e8ff436a42af22e90e36fe232d3d9d3101f23fd61362b  go1.18.5.linux-386.tar.gz
-9e5de37f9c49942c601b191ac5fba404b868bfc21d446d6960acc12283d6e5f2  go1.18.5.linux-amd64.tar.gz
-006f6622718212363fa1ff004a6ab4d87bbbe772ec5631bab7cac10be346e4f1  go1.18.5.linux-arm64.tar.gz
-d5ac34ac5f060a5274319aa04b7b11e41b123bd7887d64efb5f44ead236957af  go1.18.5.linux-armv6l.tar.gz
-2e37fb9c7cbaedd4e729492d658aa4cde821fc94117391a8105c13b25ca1c84b  go1.18.5.linux-ppc64le.tar.gz
-e3d536e7873639f85353e892444f83b14cb6670603961f215986ae8e28e8e07a  go1.18.5.linux-s390x.tar.gz
-7b3142ec0c5db991e7f73a231662a92429b90ee151fe47557acb566d8d9ae4d3  go1.18.5.windows-386.zip
-73753620602d4b4469770040c53db55e5dd6af2ad07ecc18f71f164c3224eaad  go1.18.5.windows-amd64.zip
-4d154626affff12ef73ea1017af0e5b52dbc839ef92f6f9e76cf4f71278a5744  go1.18.5.windows-arm64.zip
+efd43e0f1402e083b73a03d444b7b6576bb4c539ac46208b63a916b69aca4088  go1.18.1.src.tar.gz
+3703e9a0db1000f18c0c7b524f3d378aac71219b4715a6a4c5683eb639f41a4d  go1.18.1.darwin-amd64.tar.gz
+6d5641a06edba8cd6d425fb0adad06bad80e2afe0fa91b4aa0e5aed1bc78f58e  go1.18.1.darwin-arm64.tar.gz
+b9a9063d4265d8ccc046c9b314194d6eadc47e56d0d637db81e98e68aad45035  go1.18.1.freebsd-386.tar.gz
+2bc1c138d645e37dbbc63517dd1cf1bf33fc4cb95f442a6384df0418b5134e9f  go1.18.1.freebsd-amd64.tar.gz
+9a8df5dde9058f08ac01ecfaae42534610db398e487138788c01da26a0d41ff9  go1.18.1.linux-386.tar.gz
+b3b815f47ababac13810fc6021eb73d65478e0b2db4b09d348eefad9581a2334  go1.18.1.linux-amd64.tar.gz
+56a91851c97fb4697077abbca38860f735c32b38993ff79b088dac46e4735633  go1.18.1.linux-arm64.tar.gz
+9edc01c8e7db64e9ceeffc8258359e027812886ceca3444e83c4eb96ddb068ee  go1.18.1.linux-armv6l.tar.gz
+33db623d1eecf362fe365107c12efc90eff0b9609e0b3345e258388019cb552a  go1.18.1.linux-ppc64le.tar.gz
+5d9301324148ed4dbfaa0800da43a843ffd65c834ee73fcf087255697c925f74  go1.18.1.linux-s390x.tar.gz
+49ae65551acbfaa57b52fbefa0350b2072512ae3103b8cf1a919a02626dbc743  go1.18.1.windows-386.zip
+c30bc3f1f7314a953fe208bd9cd5e24bd9403392a6c556ced3677f9f70f71fe1  go1.18.1.windows-amd64.zip
+2c4a8265030eac37f906634f5c13c22c3d0ea725f2488e1bca005c6b981653d7  go1.18.1.windows-arm64.zip
 
-658078aaaf7608693f37c4cf1380b2af418ab8b2d23fdb33e7e2d4339328590e  golangci-lint-1.46.2-darwin-amd64.tar.gz
-81f9b4afd62ec5e612ef8bc3b1d612a88b56ff289874831845cdad394427385f  golangci-lint-1.46.2-darwin-arm64.tar.gz
-943486e703e62ec55ecd90caeb22bcd39f8cc3962a93eec18c06b7bae12cb46f  golangci-lint-1.46.2-freebsd-386.tar.gz
-a75dd9ba7e08e8315c411697171db5375c0f6a1ece9e6fbeb9e9a4386822e17d  golangci-lint-1.46.2-freebsd-amd64.tar.gz
-83eedca1af72e8be055a1235177eb1b33524fbf08bec5730df2e6c3efade2b23  golangci-lint-1.46.2-freebsd-armv6.tar.gz
-513d276c490de6f82baa01f9346d8d78b385f2ae97608f42f05d1f0f1314cd54  golangci-lint-1.46.2-freebsd-armv7.tar.gz
-461a60016d516c69d406dc3e2d4957b722dbe684b7085dfac4802d0f84409e27  golangci-lint-1.46.2-linux-386.tar.gz
-242cd4f2d6ac0556e315192e8555784d13da5d1874e51304711570769c4f2b9b  golangci-lint-1.46.2-linux-amd64.tar.gz
-ff5448ada2b3982581984d64b0dec614dba0a3ea4cab2d6a343c77927fc89f7e  golangci-lint-1.46.2-linux-arm64.tar.gz
-177f5210ef04aee282bfbc6ec519d36af5fb7d2b2c8d3f4ea5e59fdba71b0a27  golangci-lint-1.46.2-linux-armv6.tar.gz
-10dd512a36ee978a1009edbca3ba3af410f0fda8df4d85f0e4793a24213870cc  golangci-lint-1.46.2-linux-armv7.tar.gz
-67779fa517c688c9db1090c3c456117d95c6b92979c623fe8cce8fb84251f21e  golangci-lint-1.46.2-linux-mips64.tar.gz
-c085f0f57bdccbb2c902a41b72ce210a3dfff16ca856789374745ab52004b6ee  golangci-lint-1.46.2-linux-mips64le.tar.gz
-abecef6421499248e58ed75d2938bc12b4b1f98b057f25060680b77bb51a881e  golangci-lint-1.46.2-linux-ppc64le.tar.gz
-134843a8f5c5c182c11979ea75f5866945d54757b2a04f3e5e04a0cf4fbf3a39  golangci-lint-1.46.2-linux-riscv64.tar.gz
-9fe21a9476567aafe7a2e1a926b9641a39f920d4c0ea8eda9d968bc6136337f9  golangci-lint-1.46.2-linux-s390x.tar.gz
-b48a421ec12a43f8fc8f977b9cf7d4a1ea1c4b97f803a238de7d3ce4ab23a84b  golangci-lint-1.46.2-windows-386.zip
-604acc1378a566abb0eac799362f3a37b7fcb5fa2268aeb2d5d954c829367301  golangci-lint-1.46.2-windows-amd64.zip
-927def10db073da9687594072e6a3d9c891f67fa897105a2cfd715e018e7386c  golangci-lint-1.46.2-windows-arm64.zip
-729b76ed1d8b4e2612e38772b211503cb940e00a137bbaace1aa066f7c943737  golangci-lint-1.46.2-windows-armv6.zip
-ea27c86d91e0b245ecbcfbf6cdb4ac0522d4bc6dca56bba02ea1bc77ad2917ac  golangci-lint-1.46.2-windows-armv7.zip
+03c181fc1bb29ea3e73cbb23399c43b081063833a7cf7554b94e5a98308df53e  golangci-lint-1.45.2-linux-riscv64.deb
+08a50bbbf451ede6d5354179eb3e14a5634e156dfa92cb9a2606f855a637e35b  golangci-lint-1.45.2-linux-ppc64le.rpm
+0d12f6ec1296b5a70e392aa88cd2295cceef266165eb7028e675f455515dd1c9  golangci-lint-1.45.2-linux-armv7.deb
+10f2846e2e50e4ea8ae426ee62dcd2227b23adddd8e991aa3c065927ac948735  golangci-lint-1.45.2-linux-ppc64le.deb
+1463049b744871168095e3e8f687247d6040eeb895955b869889ea151e0603ab  golangci-lint-1.45.2-linux-arm64.tar.gz
+15720f9c4c6f9324af695f081dc189adc7751b255759e78d7b2df1d7e9192533  golangci-lint-1.45.2-linux-amd64.deb
+166d922e4d3cfe3d47786c590154a9c8ea689dff0aa92b73d2f5fc74fc570c29  golangci-lint-1.45.2-linux-arm64.rpm
+1a3754c69f7cc19ab89cbdcc2550da4cf9abb3120383c6b3bd440c1ec22da2e6  golangci-lint-1.45.2-freebsd-386.tar.gz
+1dec0aa46d4f0d241863b573f70129bdf1de9c595cf51172a840a588a4cd9fc5  golangci-lint-1.45.2-windows-amd64.zip
+3198453806517c1ad988229f5e758ef850e671203f46d6905509df5bdf4dc24b  golangci-lint-1.45.2-freebsd-armv7.tar.gz
+46a3cd1749d7b98adc2dc01510ddbe21abe42689c8a53fb0e81662713629f215  golangci-lint-1.45.2-linux-386.deb
+4e28bfb593d464b9e160f2acd5b71993836a183270bf8299b78ad31f7a168c0d  golangci-lint-1.45.2-linux-arm64.deb
+5157a58c8f9ab85c33af2e46f0d7c57a3b1e8953b81d61130e292e09f545cfab  golangci-lint-1.45.2-linux-mips64le.tar.gz
+518cd027644129fbf8ec4f02bd6f9ad7278aae826f92b63c80d4d0819ddde49a  golangci-lint-1.45.2-linux-armv6.rpm
+595ad6c6dade4c064351bc309f411703e457f8ffbb7a1806b3d8ee713333427f  golangci-lint-1.45.2-linux-amd64.tar.gz
+6994d6c80f0730751090986184a3481b4be2e6b6e84416238a2b857910045a4f  golangci-lint-1.45.2-windows-arm64.zip
+6c81652fc340118811b487f713c441fc6f527800bf5fd11b8929d08124efa015  golangci-lint-1.45.2-linux-armv7.tar.gz
+726cb045559b7518bafdd3459de70a0647c087eb1b4634627a4b2e95b1258580  golangci-lint-1.45.2-freebsd-amd64.tar.gz
+77df3774cdfda49b956d4a0e676da9a9b883f496ee37293c530770fef6b1d24e  golangci-lint-1.45.2-linux-mips64.deb
+7a9840f279a7d5d405bb434e101c2290964b3729630ac2add29280b962b7b9a5  golangci-lint-1.45.2-windows-armv6.zip
+7d4bf9a5d80ec467aaaf66e78dbdcab567bbc6ba8151334c714eee58766aae32  golangci-lint-1.45.2-windows-armv7.zip
+7e5f8821d39bb11d273b0841b34355f56bd5a45a2d5179f0d09e614e0efc0482  golangci-lint-1.45.2-linux-s390x.rpm
+828de1bde796b23d8656b17a8885fbd879ef612795d62d1e4618126b419728b5  golangci-lint-1.45.2-linux-mips64.rpm
+879a52107a797678a03c175cc7cf441411a14a01f66dc87f70bdfa304a4129a6  golangci-lint-1.45.2-windows-386.zip
+87b6c7e3a3769f7d9abeb3bb82119b3c91e3c975300f6834fdeef8b2e37c98ff  golangci-lint-1.45.2-linux-amd64.rpm
+8b605c6d686c8af53ecc4ef39544541eeb1644d34cc10f9ffc5087808210c4ff  golangci-lint-1.45.2-linux-s390x.deb
+9427dbf51d0ac6f73a0f992838bd40c817470cc5bf6c8e2e2bea6fac46d7af6e  golangci-lint-1.45.2-linux-ppc64le.tar.gz
+995e509e895ca6a64ffc7395ac884d5961bdec98423cb896b17f345a9b4a19cf  golangci-lint-1.45.2-darwin-amd64.tar.gz
+a3f36278f2ea5516341e9071a2df6e65df272be80230b5406a12b72c6d425bee  golangci-lint-1.45.2-linux-armv7.rpm
+a5e12c50c23e87ac1deffc872f92ae85427b1198604969399805ae47cfe43f08  golangci-lint-1.45.2-linux-riscv64.tar.gz
+aa8fa1be0729dbc2fbc4e01e82027097613eee74bd686ebef20f860b01fff8b3  golangci-lint-1.45.2-freebsd-armv6.tar.gz
+c2b9669decc1b638cf2ee9060571af4e255f6dfcbb225c293e3a7ee4bb2c7217  golangci-lint-1.45.2-darwin-arm64.tar.gz
+dfa8bdaf0387aec1cd5c1aa8857f67b2bbdfc2e42efce540c8fb9bbe3e8af302  golangci-lint-1.45.2-linux-armv6.tar.gz
+eb8b8539dd017eee5c131ea9b875893ab2cebeeca41e8c6624907fb02224d643  golangci-lint-1.45.2-linux-386.rpm
+ed6c7e17a857f30d715c5302fa250d95936936b277024bffea201187a257d7a7  golangci-lint-1.45.2-linux-armv6.deb
+ef4d0154ace4001f01b288baeb118176242efb4fd163e178763e3213b77ef30b  golangci-lint-1.45.2-linux-mips64le.deb
+ef7002a2229f5ff5ba201a715fcf877664ea88decbe58e69d163293913024955  golangci-lint-1.45.2-linux-s390x.tar.gz
+f13ecbd09228632e6bbe91a8324bd675c406eed22eb6d2c1e8192eed9ec4f914  golangci-lint-1.45.2-linux-386.tar.gz
+f4cd9cfb09252f51699407277512263cae8409b665dd764f55a34738d0e89edc  golangci-lint-1.45.2-linux-riscv64.rpm
+fb1945dc59d37c9d14bf0a4aea11ea8651fa0e1d582ea80c4c44d0a536c08893  golangci-lint-1.45.2-linux-mips64.tar.gz
+fe542c22738010f453c735a3c410decfd3784d1bd394b395c298ee298fc4c606  golangci-lint-1.45.2-linux-mips64le.rpm

build/ci.go

@@ -149,7 +149,7 @@ var (
 	// This is the version of go that will be downloaded by
 	//
 	//     go run ci.go install -dlgo
-	dlgoVersion = "1.18.5"
+	dlgoVersion = "1.18.1"
 )
 
 var GOBIN, _ = filepath.Abs(filepath.Join("build", "bin"))
@@ -200,10 +200,9 @@ func main() {
 
 func doInstall(cmdline []string) {
 	var (
-		dlgo       = flag.Bool("dlgo", false, "Download Go and build with it")
-		arch       = flag.String("arch", "", "Architecture to cross build for")
-		cc         = flag.String("cc", "", "C compiler to cross build with")
-		staticlink = flag.Bool("static", false, "Create statically-linked executable")
+		dlgo = flag.Bool("dlgo", false, "Download Go and build with it")
+		arch = flag.String("arch", "", "Architecture to cross build for")
+		cc   = flag.String("cc", "", "C compiler to cross build with")
 	)
 	flag.CommandLine.Parse(cmdline)
 
@@ -214,12 +213,9 @@ func doInstall(cmdline []string) {
 		tc.Root = build.DownloadGo(csdb, dlgoVersion)
 	}
 
-	// Disable CLI markdown doc generation in release builds.
-	buildTags := []string{"urfave_cli_no_docs"}
-
 	// Configure the build.
 	env := build.Env()
-	gobuild := tc.Go("build", buildFlags(env, *staticlink, buildTags)...)
+	gobuild := tc.Go("build", buildFlags(env)...)
 
 	// arm64 CI builders are memory-constrained and can't handle concurrent builds,
 	// better disable it. This check isn't the best, it should probably
@@ -252,7 +248,7 @@ func doInstall(cmdline []string) {
 }
 
 // buildFlags returns the go tool flags for building.
-func buildFlags(env build.Environment, staticLinking bool, buildTags []string) (flags []string) {
+func buildFlags(env build.Environment) (flags []string) {
 	var ld []string
 	if env.Commit != "" {
 		ld = append(ld, "-X", "main.gitCommit="+env.Commit)
@@ -263,24 +259,14 @@ func buildFlags(env build.Environment, staticLinking bool, buildTags []string) (
 	if runtime.GOOS == "darwin" {
 		ld = append(ld, "-s")
 	}
+	// Enforce the stacksize to 8M, which is the case on most platforms apart from
+	// alpine Linux.
 	if runtime.GOOS == "linux" {
-		// Enforce the stacksize to 8M, which is the case on most platforms apart from
-		// alpine Linux.
-		extld := []string{"-Wl,-z,stack-size=0x800000"}
-		if staticLinking {
-			extld = append(extld, "-static")
-			// Under static linking, use of certain glibc features must be
-			// disabled to avoid shared library dependencies.
-			buildTags = append(buildTags, "osusergo", "netgo")
-		}
-		ld = append(ld, "-extldflags", "'"+strings.Join(extld, " ")+"'")
+		ld = append(ld, "-extldflags", "-Wl,-z,stack-size=0x800000")
 	}
 	if len(ld) > 0 {
 		flags = append(flags, "-ldflags", strings.Join(ld, " "))
 	}
-	if len(buildTags) > 0 {
-		flags = append(flags, "-tags", strings.Join(buildTags, ","))
-	}
 	return flags
 }
 
@@ -347,7 +333,7 @@ func doLint(cmdline []string) {
 
 // downloadLinter downloads and unpacks golangci-lint.
 func downloadLinter(cachedir string) string {
-	const version = "1.46.2"
+	const version = "1.45.2"
 
 	csdb := build.MustLoadChecksums("build/checksums.txt")
 	arch := runtime.GOARCH
@@ -475,7 +461,7 @@ func maybeSkipArchive(env build.Environment) {
 		log.Printf("skipping archive creation because this is a cron job")
 		os.Exit(0)
 	}
-	if env.Branch != "master" && !strings.HasPrefix(env.Tag, "v1.") {
+	if env.Branch != "master" && env.Branch != "buildbot-testing" && !strings.HasPrefix(env.Tag, "v1.") {
 		log.Printf("skipping archive creation because branch %q, tag %q is not on the inclusion list", env.Branch, env.Tag)
 		os.Exit(0)
 	}
@@ -608,7 +594,7 @@ func doDocker(cmdline []string) {
 			}
 			if mismatch {
 				// Build numbers mismatching, retry in a short time to
-				// avoid concurrent fails in both publisher images. If
+				// avoid concurrent failes in both publisher images. If
 				// however the retry failed too, it means the concurrent
 				// builder is still crunching, let that do the publish.
 				if i == 0 {

build/deb/ethereum/completions/bash/geth

@@ -1,16 +0,0 @@
-_geth_bash_autocomplete() {
-  if [[ "${COMP_WORDS[0]}" != "source" ]]; then
-    local cur opts base
-    COMPREPLY=()
-    cur="${COMP_WORDS[COMP_CWORD]}"
-    if [[ "$cur" == "-"* ]]; then
-      opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} ${cur} --generate-bash-completion )
-    else
-      opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} --generate-bash-completion )
-    fi
-    COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
-    return 0
-  fi
-}
-
-complete -o bashdefault -o default -o nospace -F _geth_bash_autocomplete geth

build/deb/ethereum/completions/zsh/_geth

@@ -1,18 +0,0 @@
-_geth_zsh_autocomplete() {
-  local -a opts
-  local cur
-  cur=${words[-1]}
-  if [[ "$cur" == "-"* ]]; then
-    opts=("${(@f)$(${words[@]:0:#words[@]-1} ${cur} --generate-bash-completion)}")
-  else
-    opts=("${(@f)$(${words[@]:0:#words[@]-1} --generate-bash-completion)}")
-  fi
-
-  if [[ "${opts[1]}" != "" ]]; then
-    _describe 'values' opts
-  else
-    _files
-  fi
-}
-
-compdef _geth_zsh_autocomplete geth

build/deb/ethereum/deb.install

@@ -1,5 +1 @@
 build/bin/{{.BinaryName}} usr/bin
-{{- if eq .BinaryName "geth" }}
-build/deb/ethereum/completions/bash/geth etc/bash_completion.d
-build/deb/ethereum/completions/zsh/_geth usr/share/zsh/vendor-completions
-{{end -}}

build/update-license.go

@@ -14,7 +14,6 @@
 // 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/>.
 
-//go:build none
 // +build none
 
 /*
@@ -68,9 +67,7 @@ var (
 		"common/bitutil/bitutil",
 		"common/prque/",
 		"consensus/ethash/xor.go",
-		"crypto/blake2b/",
 		"crypto/bn256/",
-		"crypto/bls12381/",
 		"crypto/ecies/",
 		"graphql/graphiql.go",
 		"internal/jsre/deps",

cmd/abidump/main.go

@@ -1,18 +1,18 @@
-// Copyright 2020 The go-ethereum Authors
-// This file is part of go-ethereum.
+// Copyright 2019 The go-ethereum Authors
+// This file is part of the go-ethereum library.
 //
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// The 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.
 //
-// go-ethereum is distributed in the hope that it will be useful,
+// 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 General Public License for more details.
+// GNU Lesser General Public License for more details.
 //
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 
 package main
 

cmd/abigen/main.go

@@ -21,16 +21,18 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"path/filepath"
 	"regexp"
 	"strings"
 
+	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/common/compiler"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/internal/flags"
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
@@ -39,44 +41,60 @@ var (
 	gitDate   = ""
 
 	app *cli.App
-)
 
-var (
 	// Flags needed by abigen
-	abiFlag = &cli.StringFlag{
+	abiFlag = cli.StringFlag{
 		Name:  "abi",
 		Usage: "Path to the Ethereum contract ABI json to bind, - for STDIN",
 	}
-	binFlag = &cli.StringFlag{
+	binFlag = cli.StringFlag{
 		Name:  "bin",
 		Usage: "Path to the Ethereum contract bytecode (generate deploy method)",
 	}
-	typeFlag = &cli.StringFlag{
+	typeFlag = cli.StringFlag{
 		Name:  "type",
 		Usage: "Struct name for the binding (default = package name)",
 	}
-	jsonFlag = &cli.StringFlag{
+	jsonFlag = cli.StringFlag{
 		Name:  "combined-json",
-		Usage: "Path to the combined-json file generated by compiler, - for STDIN",
+		Usage: "Path to the combined-json file generated by compiler",
 	}
-	excFlag = &cli.StringFlag{
+	solFlag = cli.StringFlag{
+		Name:  "sol",
+		Usage: "Path to the Ethereum contract Solidity source to build and bind",
+	}
+	solcFlag = cli.StringFlag{
+		Name:  "solc",
+		Usage: "Solidity compiler to use if source builds are requested",
+		Value: "solc",
+	}
+	vyFlag = cli.StringFlag{
+		Name:  "vy",
+		Usage: "Path to the Ethereum contract Vyper source to build and bind",
+	}
+	vyperFlag = cli.StringFlag{
+		Name:  "vyper",
+		Usage: "Vyper compiler to use if source builds are requested",
+		Value: "vyper",
+	}
+	excFlag = cli.StringFlag{
 		Name:  "exc",
 		Usage: "Comma separated types to exclude from binding",
 	}
-	pkgFlag = &cli.StringFlag{
+	pkgFlag = cli.StringFlag{
 		Name:  "pkg",
 		Usage: "Package name to generate the binding into",
 	}
-	outFlag = &cli.StringFlag{
+	outFlag = cli.StringFlag{
 		Name:  "out",
 		Usage: "Output file for the generated binding (default = stdout)",
 	}
-	langFlag = &cli.StringFlag{
+	langFlag = cli.StringFlag{
 		Name:  "lang",
 		Usage: "Destination language for the bindings (go, java, objc)",
 		Value: "go",
 	}
-	aliasFlag = &cli.StringFlag{
+	aliasFlag = cli.StringFlag{
 		Name:  "alias",
 		Usage: "Comma separated aliases for function and event renaming, e.g. original1=alias1, original2=alias2",
 	}
@@ -84,29 +102,32 @@ var (
 
 func init() {
 	app = flags.NewApp(gitCommit, gitDate, "ethereum checkpoint helper tool")
-	app.Name = "abigen"
 	app.Flags = []cli.Flag{
 		abiFlag,
 		binFlag,
 		typeFlag,
 		jsonFlag,
+		solFlag,
+		solcFlag,
+		vyFlag,
+		vyperFlag,
 		excFlag,
 		pkgFlag,
 		outFlag,
 		langFlag,
 		aliasFlag,
 	}
-	app.Action = abigen
+	app.Action = utils.MigrateFlags(abigen)
+	cli.CommandHelpTemplate = flags.OriginCommandHelpTemplate
 }
 
 func abigen(c *cli.Context) error {
-	utils.CheckExclusive(c, abiFlag, jsonFlag) // Only one source can be selected.
-
-	if c.String(pkgFlag.Name) == "" {
+	utils.CheckExclusive(c, abiFlag, jsonFlag, solFlag, vyFlag) // Only one source can be selected.
+	if c.GlobalString(pkgFlag.Name) == "" {
 		utils.Fatalf("No destination package specified (--pkg)")
 	}
 	var lang bind.Lang
-	switch c.String(langFlag.Name) {
+	switch c.GlobalString(langFlag.Name) {
 	case "go":
 		lang = bind.LangGo
 	case "java":
@@ -115,7 +136,7 @@ func abigen(c *cli.Context) error {
 		lang = bind.LangObjC
 		utils.Fatalf("Objc binding generation is uncompleted")
 	default:
-		utils.Fatalf("Unsupported destination language \"%s\" (--lang)", c.String(langFlag.Name))
+		utils.Fatalf("Unsupported destination language \"%s\" (--lang)", c.GlobalString(langFlag.Name))
 	}
 	// If the entire solidity code was specified, build and bind based on that
 	var (
@@ -126,13 +147,13 @@ func abigen(c *cli.Context) error {
 		libs    = make(map[string]string)
 		aliases = make(map[string]string)
 	)
-	if c.String(abiFlag.Name) != "" {
+	if c.GlobalString(abiFlag.Name) != "" {
 		// Load up the ABI, optional bytecode and type name from the parameters
 		var (
 			abi []byte
 			err error
 		)
-		input := c.String(abiFlag.Name)
+		input := c.GlobalString(abiFlag.Name)
 		if input == "-" {
 			abi, err = io.ReadAll(os.Stdin)
 		} else {
@@ -144,7 +165,7 @@ func abigen(c *cli.Context) error {
 		abis = append(abis, string(abi))
 
 		var bin []byte
-		if binFile := c.String(binFlag.Name); binFile != "" {
+		if binFile := c.GlobalString(binFlag.Name); binFile != "" {
 			if bin, err = os.ReadFile(binFile); err != nil {
 				utils.Fatalf("Failed to read input bytecode: %v", err)
 			}
@@ -154,32 +175,47 @@ func abigen(c *cli.Context) error {
 		}
 		bins = append(bins, string(bin))
 
-		kind := c.String(typeFlag.Name)
+		kind := c.GlobalString(typeFlag.Name)
 		if kind == "" {
-			kind = c.String(pkgFlag.Name)
+			kind = c.GlobalString(pkgFlag.Name)
 		}
 		types = append(types, kind)
 	} else {
 		// Generate the list of types to exclude from binding
 		exclude := make(map[string]bool)
-		for _, kind := range strings.Split(c.String(excFlag.Name), ",") {
+		for _, kind := range strings.Split(c.GlobalString(excFlag.Name), ",") {
 			exclude[strings.ToLower(kind)] = true
 		}
+		var err error
 		var contracts map[string]*compiler.Contract
 
-		if c.IsSet(jsonFlag.Name) {
-			var (
-				input      = c.String(jsonFlag.Name)
-				jsonOutput []byte
-				err        error
-			)
-			if input == "-" {
-				jsonOutput, err = io.ReadAll(os.Stdin)
-			} else {
-				jsonOutput, err = os.ReadFile(input)
-			}
+		switch {
+		case c.GlobalIsSet(solFlag.Name):
+			contracts, err = compiler.CompileSolidity(c.GlobalString(solcFlag.Name), c.GlobalString(solFlag.Name))
 			if err != nil {
-				utils.Fatalf("Failed to read combined-json: %v", err)
+				utils.Fatalf("Failed to build Solidity contract: %v", err)
+			}
+		case c.GlobalIsSet(vyFlag.Name):
+			output, err := compiler.CompileVyper(c.GlobalString(vyperFlag.Name), c.GlobalString(vyFlag.Name))
+			if err != nil {
+				utils.Fatalf("Failed to build Vyper contract: %v", err)
+			}
+			contracts = make(map[string]*compiler.Contract)
+			for n, contract := range output {
+				name := n
+				// Sanitize the combined json names to match the
+				// format expected by solidity.
+				if !strings.Contains(n, ":") {
+					// Remove extra path components
+					name = abi.ToCamelCase(strings.TrimSuffix(filepath.Base(name), ".vy"))
+				}
+				contracts[name] = contract
+			}
+
+		case c.GlobalIsSet(jsonFlag.Name):
+			jsonOutput, err := os.ReadFile(c.GlobalString(jsonFlag.Name))
+			if err != nil {
+				utils.Fatalf("Failed to read combined-json from compiler: %v", err)
 			}
 			contracts, err = compiler.ParseCombinedJSON(jsonOutput, "", "", "", "")
 			if err != nil {
@@ -201,37 +237,33 @@ func abigen(c *cli.Context) error {
 			nameParts := strings.Split(name, ":")
 			types = append(types, nameParts[len(nameParts)-1])
 
-			// 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
+			libPattern := crypto.Keccak256Hash([]byte(name)).String()[2:36]
 			libs[libPattern] = nameParts[len(nameParts)-1]
 		}
 	}
 	// Extract all aliases from the flags
-	if c.IsSet(aliasFlag.Name) {
+	if c.GlobalIsSet(aliasFlag.Name) {
 		// We support multi-versions for aliasing
 		// e.g.
 		//      foo=bar,foo2=bar2
 		//      foo:bar,foo2:bar2
 		re := regexp.MustCompile(`(?:(\w+)[:=](\w+))`)
-		submatches := re.FindAllStringSubmatch(c.String(aliasFlag.Name), -1)
+		submatches := re.FindAllStringSubmatch(c.GlobalString(aliasFlag.Name), -1)
 		for _, match := range submatches {
 			aliases[match[1]] = match[2]
 		}
 	}
 	// Generate the contract binding
-	code, err := bind.Bind(types, abis, bins, sigs, c.String(pkgFlag.Name), lang, libs, aliases)
+	code, err := bind.Bind(types, abis, bins, sigs, c.GlobalString(pkgFlag.Name), lang, libs, aliases)
 	if err != nil {
 		utils.Fatalf("Failed to generate ABI binding: %v", err)
 	}
 	// Either flush it out to a file or display on the standard output
-	if !c.IsSet(outFlag.Name) {
+	if !c.GlobalIsSet(outFlag.Name) {
 		fmt.Printf("%s\n", code)
 		return nil
 	}
-	if err := os.WriteFile(c.String(outFlag.Name), []byte(code), 0600); err != nil {
+	if err := os.WriteFile(c.GlobalString(outFlag.Name), []byte(code), 0600); err != nil {
 		utils.Fatalf("Failed to write ABI binding: %v", err)
 	}
 	return nil

cmd/checkpoint-admin/common.go

@@ -28,12 +28,12 @@ import (
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rpc"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 // newClient creates a client with specified remote URL.
 func newClient(ctx *cli.Context) *ethclient.Client {
-	client, err := ethclient.Dial(ctx.String(nodeURLFlag.Name))
+	client, err := ethclient.Dial(ctx.GlobalString(nodeURLFlag.Name))
 	if err != nil {
 		utils.Fatalf("Failed to connect to Ethereum node: %v", err)
 	}
@@ -64,9 +64,9 @@ func getContractAddr(client *rpc.Client) common.Address {
 func getCheckpoint(ctx *cli.Context, client *rpc.Client) *params.TrustedCheckpoint {
 	var checkpoint *params.TrustedCheckpoint
 
-	if ctx.IsSet(indexFlag.Name) {
+	if ctx.GlobalIsSet(indexFlag.Name) {
 		var result [3]string
-		index := uint64(ctx.Int64(indexFlag.Name))
+		index := uint64(ctx.GlobalInt64(indexFlag.Name))
 		if err := client.Call(&result, "les_getCheckpoint", index); err != nil {
 			utils.Fatalf("Failed to get local checkpoint %v, please ensure the les API is exposed", err)
 		}

cmd/checkpoint-admin/exec.go

@@ -36,10 +36,10 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rpc"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
-var commandDeploy = &cli.Command{
+var commandDeploy = cli.Command{
 	Name:  "deploy",
 	Usage: "Deploy a new checkpoint oracle contract",
 	Flags: []cli.Flag{
@@ -49,10 +49,10 @@ var commandDeploy = &cli.Command{
 		signersFlag,
 		thresholdFlag,
 	},
-	Action: deploy,
+	Action: utils.MigrateFlags(deploy),
 }
 
-var commandSign = &cli.Command{
+var commandSign = cli.Command{
 	Name:  "sign",
 	Usage: "Sign the checkpoint with the specified key",
 	Flags: []cli.Flag{
@@ -63,10 +63,10 @@ var commandSign = &cli.Command{
 		hashFlag,
 		oracleFlag,
 	},
-	Action: sign,
+	Action: utils.MigrateFlags(sign),
 }
 
-var commandPublish = &cli.Command{
+var commandPublish = cli.Command{
 	Name:  "publish",
 	Usage: "Publish a checkpoint into the oracle",
 	Flags: []cli.Flag{
@@ -76,7 +76,7 @@ var commandPublish = &cli.Command{
 		indexFlag,
 		signaturesFlag,
 	},
-	Action: publish,
+	Action: utils.MigrateFlags(publish),
 }
 
 // deploy deploys the checkpoint registrar contract.
@@ -132,7 +132,7 @@ func sign(ctx *cli.Context) error {
 		node   *rpc.Client
 		oracle *checkpointoracle.CheckpointOracle
 	)
-	if !ctx.IsSet(nodeURLFlag.Name) {
+	if !ctx.GlobalIsSet(nodeURLFlag.Name) {
 		// Offline mode signing
 		offline = true
 		if !ctx.IsSet(hashFlag.Name) {
@@ -151,7 +151,7 @@ func sign(ctx *cli.Context) error {
 		address = common.HexToAddress(ctx.String(oracleFlag.Name))
 	} else {
 		// Interactive mode signing, retrieve the data from the remote node
-		node = newRPCClient(ctx.String(nodeURLFlag.Name))
+		node = newRPCClient(ctx.GlobalString(nodeURLFlag.Name))
 
 		checkpoint := getCheckpoint(ctx, node)
 		chash, cindex, address = checkpoint.Hash(), checkpoint.SectionIndex, getContractAddr(node)
@@ -265,7 +265,7 @@ func publish(ctx *cli.Context) error {
 	}
 	// Retrieve the checkpoint we want to sign to sort the signatures
 	var (
-		client       = newRPCClient(ctx.String(nodeURLFlag.Name))
+		client       = newRPCClient(ctx.GlobalString(nodeURLFlag.Name))
 		addr, oracle = newContract(client)
 		checkpoint   = getCheckpoint(ctx, client)
 		sighash      = sighash(checkpoint.SectionIndex, addr, checkpoint.Hash())

cmd/checkpoint-admin/main.go

@@ -25,20 +25,20 @@ import (
 	"github.com/ethereum/go-ethereum/common/fdlimit"
 	"github.com/ethereum/go-ethereum/internal/flags"
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
 	// Git SHA1 commit hash of the release (set via linker flags)
 	gitCommit = ""
 	gitDate   = ""
-
-	app *cli.App
 )
 
+var app *cli.App
+
 func init() {
 	app = flags.NewApp(gitCommit, gitDate, "ethereum checkpoint helper tool")
-	app.Commands = []*cli.Command{
+	app.Commands = []cli.Command{
 		commandStatus,
 		commandDeploy,
 		commandSign,
@@ -48,45 +48,46 @@ func init() {
 		oracleFlag,
 		nodeURLFlag,
 	}
+	cli.CommandHelpTemplate = flags.OriginCommandHelpTemplate
 }
 
 // Commonly used command line flags.
 var (
-	indexFlag = &cli.Int64Flag{
+	indexFlag = cli.Int64Flag{
 		Name:  "index",
 		Usage: "Checkpoint index (query latest from remote node if not specified)",
 	}
-	hashFlag = &cli.StringFlag{
+	hashFlag = cli.StringFlag{
 		Name:  "hash",
 		Usage: "Checkpoint hash (query latest from remote node if not specified)",
 	}
-	oracleFlag = &cli.StringFlag{
+	oracleFlag = cli.StringFlag{
 		Name:  "oracle",
 		Usage: "Checkpoint oracle address (query from remote node if not specified)",
 	}
-	thresholdFlag = &cli.Int64Flag{
+	thresholdFlag = cli.Int64Flag{
 		Name:  "threshold",
 		Usage: "Minimal number of signatures required to approve a checkpoint",
 	}
-	nodeURLFlag = &cli.StringFlag{
+	nodeURLFlag = cli.StringFlag{
 		Name:  "rpc",
 		Value: "http://localhost:8545",
 		Usage: "The rpc endpoint of a local or remote geth node",
 	}
-	clefURLFlag = &cli.StringFlag{
+	clefURLFlag = cli.StringFlag{
 		Name:  "clef",
 		Value: "http://localhost:8550",
 		Usage: "The rpc endpoint of clef",
 	}
-	signerFlag = &cli.StringFlag{
+	signerFlag = cli.StringFlag{
 		Name:  "signer",
 		Usage: "Signer address for clef signing",
 	}
-	signersFlag = &cli.StringFlag{
+	signersFlag = cli.StringFlag{
 		Name:  "signers",
 		Usage: "Comma separated accounts of trusted checkpoint signers",
 	}
-	signaturesFlag = &cli.StringFlag{
+	signaturesFlag = cli.StringFlag{
 		Name:  "signatures",
 		Usage: "Comma separated checkpoint signatures to submit",
 	}

cmd/checkpoint-admin/status.go

@@ -19,23 +19,24 @@ package main
 import (
 	"fmt"
 
+	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
-var commandStatus = &cli.Command{
+var commandStatus = cli.Command{
 	Name:  "status",
 	Usage: "Fetches the signers and checkpoint status of the oracle contract",
 	Flags: []cli.Flag{
 		nodeURLFlag,
 	},
-	Action: status,
+	Action: utils.MigrateFlags(status),
 }
 
 // status fetches the admin list of specified registrar contract.
 func status(ctx *cli.Context) error {
 	// Create a wrapper around the checkpoint oracle contract
-	addr, oracle := newContract(newRPCClient(ctx.String(nodeURLFlag.Name)))
+	addr, oracle := newContract(newRPCClient(ctx.GlobalString(nodeURLFlag.Name)))
 	fmt.Printf("Oracle => %s\n", addr.Hex())
 	fmt.Println()
 

cmd/clef/main.go

@@ -30,6 +30,7 @@ import (
 	"os/signal"
 	"path/filepath"
 	"runtime"
+	"sort"
 	"strings"
 	"time"
 
@@ -54,7 +55,7 @@ import (
 	"github.com/ethereum/go-ethereum/signer/storage"
 	"github.com/mattn/go-colorable"
 	"github.com/mattn/go-isatty"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 const legalWarning = `
@@ -72,70 +73,70 @@ PURPOSE. See the GNU General Public License for more details.
 `
 
 var (
-	logLevelFlag = &cli.IntFlag{
+	logLevelFlag = cli.IntFlag{
 		Name:  "loglevel",
 		Value: 4,
 		Usage: "log level to emit to the screen",
 	}
-	advancedMode = &cli.BoolFlag{
+	advancedMode = cli.BoolFlag{
 		Name:  "advanced",
 		Usage: "If enabled, issues warnings instead of rejections for suspicious requests. Default off",
 	}
-	acceptFlag = &cli.BoolFlag{
+	acceptFlag = cli.BoolFlag{
 		Name:  "suppress-bootwarn",
 		Usage: "If set, does not show the warning during boot",
 	}
-	keystoreFlag = &cli.StringFlag{
+	keystoreFlag = cli.StringFlag{
 		Name:  "keystore",
 		Value: filepath.Join(node.DefaultDataDir(), "keystore"),
 		Usage: "Directory for the keystore",
 	}
-	configdirFlag = &cli.StringFlag{
+	configdirFlag = cli.StringFlag{
 		Name:  "configdir",
 		Value: DefaultConfigDir(),
 		Usage: "Directory for Clef configuration",
 	}
-	chainIdFlag = &cli.Int64Flag{
+	chainIdFlag = cli.Int64Flag{
 		Name:  "chainid",
 		Value: params.MainnetChainConfig.ChainID.Int64(),
 		Usage: "Chain id to use for signing (1=mainnet, 3=Ropsten, 4=Rinkeby, 5=Goerli)",
 	}
-	rpcPortFlag = &cli.IntFlag{
-		Name:     "http.port",
-		Usage:    "HTTP-RPC server listening port",
-		Value:    node.DefaultHTTPPort + 5,
-		Category: flags.APICategory,
+	rpcPortFlag = cli.IntFlag{
+		Name:  "http.port",
+		Usage: "HTTP-RPC server listening port",
+		Value: node.DefaultHTTPPort + 5,
 	}
-	signerSecretFlag = &cli.StringFlag{
+	signerSecretFlag = cli.StringFlag{
 		Name:  "signersecret",
 		Usage: "A file containing the (encrypted) master seed to encrypt Clef data, e.g. keystore credentials and ruleset hash",
 	}
-	customDBFlag = &cli.StringFlag{
+	customDBFlag = cli.StringFlag{
 		Name:  "4bytedb-custom",
 		Usage: "File used for writing new 4byte-identifiers submitted via API",
 		Value: "./4byte-custom.json",
 	}
-	auditLogFlag = &cli.StringFlag{
+	auditLogFlag = cli.StringFlag{
 		Name:  "auditlog",
 		Usage: "File used to emit audit logs. Set to \"\" to disable",
 		Value: "audit.log",
 	}
-	ruleFlag = &cli.StringFlag{
+	ruleFlag = cli.StringFlag{
 		Name:  "rules",
 		Usage: "Path to the rule file to auto-authorize requests with",
 	}
-	stdiouiFlag = &cli.BoolFlag{
+	stdiouiFlag = cli.BoolFlag{
 		Name: "stdio-ui",
 		Usage: "Use STDIN/STDOUT as a channel for an external UI. " +
 			"This means that an STDIN/STDOUT is used for RPC-communication with a e.g. a graphical user " +
 			"interface, and can be used when Clef is started by an external process.",
 	}
-	testFlag = &cli.BoolFlag{
+	testFlag = cli.BoolFlag{
 		Name:  "stdio-ui-test",
 		Usage: "Mechanism to test interface between Clef and UI. Requires 'stdio-ui'.",
 	}
-	initCommand = &cli.Command{
-		Action:    initializeSecrets,
+	app         = cli.NewApp()
+	initCommand = cli.Command{
+		Action:    utils.MigrateFlags(initializeSecrets),
 		Name:      "init",
 		Usage:     "Initialize the signer, generate secret storage",
 		ArgsUsage: "",
@@ -147,8 +148,8 @@ var (
 The init command generates a master seed which Clef can use to store credentials and data needed for
 the rule-engine to work.`,
 	}
-	attestCommand = &cli.Command{
-		Action:    attestFile,
+	attestCommand = cli.Command{
+		Action:    utils.MigrateFlags(attestFile),
 		Name:      "attest",
 		Usage:     "Attest that a js-file is to be used",
 		ArgsUsage: "<sha256sum>",
@@ -164,8 +165,8 @@ incoming requests.
 Whenever you make an edit to the rule file, you need to use attestation to tell
 Clef that the file is 'safe' to execute.`,
 	}
-	setCredentialCommand = &cli.Command{
-		Action:    setCredential,
+	setCredentialCommand = cli.Command{
+		Action:    utils.MigrateFlags(setCredential),
 		Name:      "setpw",
 		Usage:     "Store a credential for a keystore file",
 		ArgsUsage: "<address>",
@@ -177,8 +178,8 @@ Clef that the file is 'safe' to execute.`,
 		Description: `
 The setpw command stores a password for a given address (keyfile).
 `}
-	delCredentialCommand = &cli.Command{
-		Action:    removeCredential,
+	delCredentialCommand = cli.Command{
+		Action:    utils.MigrateFlags(removeCredential),
 		Name:      "delpw",
 		Usage:     "Remove a credential for a keystore file",
 		ArgsUsage: "<address>",
@@ -190,8 +191,8 @@ The setpw command stores a password for a given address (keyfile).
 		Description: `
 The delpw command removes a password for a given address (keyfile).
 `}
-	newAccountCommand = &cli.Command{
-		Action:    newAccount,
+	newAccountCommand = cli.Command{
+		Action:    utils.MigrateFlags(newAccount),
 		Name:      "newaccount",
 		Usage:     "Create a new account",
 		ArgsUsage: "",
@@ -206,7 +207,7 @@ The newaccount command creates a new keystore-backed account. It is a convenienc
 which can be used in lieu of an external UI.`,
 	}
 
-	gendocCommand = &cli.Command{
+	gendocCommand = cli.Command{
 		Action: GenDoc,
 		Name:   "gendoc",
 		Usage:  "Generate documentation about json-rpc format",
@@ -215,16 +216,39 @@ The gendoc generates example structures of the json-rpc communication types.
 `}
 )
 
-var (
-	// Git SHA1 commit hash of the release (set via linker flags)
-	gitCommit = ""
-	gitDate   = ""
-
-	app = flags.NewApp(gitCommit, gitDate, "Manage Ethereum account operations")
-)
+// AppHelpFlagGroups is the application flags, grouped by functionality.
+var AppHelpFlagGroups = []flags.FlagGroup{
+	{
+		Name: "FLAGS",
+		Flags: []cli.Flag{
+			logLevelFlag,
+			keystoreFlag,
+			configdirFlag,
+			chainIdFlag,
+			utils.LightKDFFlag,
+			utils.NoUSBFlag,
+			utils.SmartCardDaemonPathFlag,
+			utils.HTTPListenAddrFlag,
+			utils.HTTPVirtualHostsFlag,
+			utils.IPCDisabledFlag,
+			utils.IPCPathFlag,
+			utils.HTTPEnabledFlag,
+			rpcPortFlag,
+			signerSecretFlag,
+			customDBFlag,
+			auditLogFlag,
+			ruleFlag,
+			stdiouiFlag,
+			testFlag,
+			advancedMode,
+			acceptFlag,
+		},
+	},
+}
 
 func init() {
 	app.Name = "Clef"
+	app.Usage = "Manage Ethereum account operations"
 	app.Flags = []cli.Flag{
 		logLevelFlag,
 		keystoreFlag,
@@ -249,12 +273,46 @@ func init() {
 		acceptFlag,
 	}
 	app.Action = signer
-	app.Commands = []*cli.Command{initCommand,
+	app.Commands = []cli.Command{initCommand,
 		attestCommand,
 		setCredentialCommand,
 		delCredentialCommand,
 		newAccountCommand,
-		gendocCommand,
+		gendocCommand}
+	cli.CommandHelpTemplate = flags.CommandHelpTemplate
+	// Override the default app help template
+	cli.AppHelpTemplate = flags.ClefAppHelpTemplate
+
+	// Override the default app help printer, but only for the global app help
+	originalHelpPrinter := cli.HelpPrinter
+	cli.HelpPrinter = func(w io.Writer, tmpl string, data interface{}) {
+		if tmpl == flags.ClefAppHelpTemplate {
+			// Render out custom usage screen
+			originalHelpPrinter(w, tmpl, flags.HelpData{App: data, FlagGroups: AppHelpFlagGroups})
+		} else if tmpl == flags.CommandHelpTemplate {
+			// Iterate over all command specific flags and categorize them
+			categorized := make(map[string][]cli.Flag)
+			for _, flag := range data.(cli.Command).Flags {
+				if _, ok := categorized[flag.String()]; !ok {
+					categorized[flags.FlagCategory(flag, AppHelpFlagGroups)] = append(categorized[flags.FlagCategory(flag, AppHelpFlagGroups)], flag)
+				}
+			}
+
+			// sort to get a stable ordering
+			sorted := make([]flags.FlagGroup, 0, len(categorized))
+			for cat, flgs := range categorized {
+				sorted = append(sorted, flags.FlagGroup{Name: cat, Flags: flgs})
+			}
+			sort.Sort(flags.ByCategory(sorted))
+
+			// add sorted array to data and render with default printer
+			originalHelpPrinter(w, tmpl, map[string]interface{}{
+				"cmd":              data,
+				"categorizedFlags": sorted,
+			})
+		} else {
+			originalHelpPrinter(w, tmpl, data)
+		}
 	}
 }
 
@@ -271,7 +329,7 @@ func initializeSecrets(c *cli.Context) error {
 		return err
 	}
 	// Ensure the master key does not yet exist, we're not willing to overwrite
-	configDir := c.String(configdirFlag.Name)
+	configDir := c.GlobalString(configdirFlag.Name)
 	if err := os.Mkdir(configDir, 0700); err != nil && !os.IsExist(err) {
 		return err
 	}
@@ -289,7 +347,7 @@ func initializeSecrets(c *cli.Context) error {
 		return fmt.Errorf("failed to read enough random")
 	}
 	n, p := keystore.StandardScryptN, keystore.StandardScryptP
-	if c.Bool(utils.LightKDFFlag.Name) {
+	if c.GlobalBool(utils.LightKDFFlag.Name) {
 		n, p = keystore.LightScryptN, keystore.LightScryptP
 	}
 	text := "The master seed of clef will be locked with a password.\nPlease specify a password. Do not forget this password!"
@@ -332,9 +390,8 @@ You should treat 'masterseed.json' with utmost secrecy and make a backup of it!
 `)
 	return nil
 }
-
 func attestFile(ctx *cli.Context) error {
-	if ctx.NArg() < 1 {
+	if len(ctx.Args()) < 1 {
 		utils.Fatalf("This command requires an argument.")
 	}
 	if err := initialize(ctx); err != nil {
@@ -345,7 +402,7 @@ func attestFile(ctx *cli.Context) error {
 	if err != nil {
 		utils.Fatalf(err.Error())
 	}
-	configDir := ctx.String(configdirFlag.Name)
+	configDir := ctx.GlobalString(configdirFlag.Name)
 	vaultLocation := filepath.Join(configDir, common.Bytes2Hex(crypto.Keccak256([]byte("vault"), stretchedKey)[:10]))
 	confKey := crypto.Keccak256([]byte("config"), stretchedKey)
 
@@ -358,7 +415,7 @@ func attestFile(ctx *cli.Context) error {
 }
 
 func setCredential(ctx *cli.Context) error {
-	if ctx.NArg() < 1 {
+	if len(ctx.Args()) < 1 {
 		utils.Fatalf("This command requires an address to be passed as an argument")
 	}
 	if err := initialize(ctx); err != nil {
@@ -376,7 +433,7 @@ func setCredential(ctx *cli.Context) error {
 	if err != nil {
 		utils.Fatalf(err.Error())
 	}
-	configDir := ctx.String(configdirFlag.Name)
+	configDir := ctx.GlobalString(configdirFlag.Name)
 	vaultLocation := filepath.Join(configDir, common.Bytes2Hex(crypto.Keccak256([]byte("vault"), stretchedKey)[:10]))
 	pwkey := crypto.Keccak256([]byte("credentials"), stretchedKey)
 
@@ -388,7 +445,7 @@ func setCredential(ctx *cli.Context) error {
 }
 
 func removeCredential(ctx *cli.Context) error {
-	if ctx.NArg() < 1 {
+	if len(ctx.Args()) < 1 {
 		utils.Fatalf("This command requires an address to be passed as an argument")
 	}
 	if err := initialize(ctx); err != nil {
@@ -404,7 +461,7 @@ func removeCredential(ctx *cli.Context) error {
 	if err != nil {
 		utils.Fatalf(err.Error())
 	}
-	configDir := ctx.String(configdirFlag.Name)
+	configDir := ctx.GlobalString(configdirFlag.Name)
 	vaultLocation := filepath.Join(configDir, common.Bytes2Hex(crypto.Keccak256([]byte("vault"), stretchedKey)[:10]))
 	pwkey := crypto.Keccak256([]byte("credentials"), stretchedKey)
 
@@ -424,8 +481,8 @@ func newAccount(c *cli.Context) error {
 	var (
 		ui                        = core.NewCommandlineUI()
 		pwStorage storage.Storage = &storage.NoStorage{}
-		ksLoc                     = c.String(keystoreFlag.Name)
-		lightKdf                  = c.Bool(utils.LightKDFFlag.Name)
+		ksLoc                     = c.GlobalString(keystoreFlag.Name)
+		lightKdf                  = c.GlobalBool(utils.LightKDFFlag.Name)
 	)
 	log.Info("Starting clef", "keystore", ksLoc, "light-kdf", lightKdf)
 	am := core.StartClefAccountManager(ksLoc, true, lightKdf, "")
@@ -443,13 +500,13 @@ func newAccount(c *cli.Context) error {
 func initialize(c *cli.Context) error {
 	// Set up the logger to print everything
 	logOutput := os.Stdout
-	if c.Bool(stdiouiFlag.Name) {
+	if c.GlobalBool(stdiouiFlag.Name) {
 		logOutput = os.Stderr
 		// If using the stdioui, we can't do the 'confirm'-flow
-		if !c.Bool(acceptFlag.Name) {
+		if !c.GlobalBool(acceptFlag.Name) {
 			fmt.Fprint(logOutput, legalWarning)
 		}
-	} else if !c.Bool(acceptFlag.Name) {
+	} else if !c.GlobalBool(acceptFlag.Name) {
 		if !confirm(legalWarning) {
 			return fmt.Errorf("aborted by user")
 		}
@@ -488,8 +545,8 @@ func ipcEndpoint(ipcPath, datadir string) string {
 
 func signer(c *cli.Context) error {
 	// If we have some unrecognized command, bail out
-	if c.NArg() > 0 {
-		return fmt.Errorf("invalid command: %q", c.Args().First())
+	if args := c.Args(); len(args) > 0 {
+		return fmt.Errorf("invalid command: %q", args[0])
 	}
 	if err := initialize(c); err != nil {
 		return err
@@ -497,7 +554,7 @@ func signer(c *cli.Context) error {
 	var (
 		ui core.UIClientAPI
 	)
-	if c.Bool(stdiouiFlag.Name) {
+	if c.GlobalBool(stdiouiFlag.Name) {
 		log.Info("Using stdin/stdout as UI-channel")
 		ui = core.NewStdIOUI()
 	} else {
@@ -505,7 +562,7 @@ func signer(c *cli.Context) error {
 		ui = core.NewCommandlineUI()
 	}
 	// 4bytedb data
-	fourByteLocal := c.String(customDBFlag.Name)
+	fourByteLocal := c.GlobalString(customDBFlag.Name)
 	db, err := fourbyte.NewWithFile(fourByteLocal)
 	if err != nil {
 		utils.Fatalf(err.Error())
@@ -517,7 +574,7 @@ func signer(c *cli.Context) error {
 		api       core.ExternalAPI
 		pwStorage storage.Storage = &storage.NoStorage{}
 	)
-	configDir := c.String(configdirFlag.Name)
+	configDir := c.GlobalString(configdirFlag.Name)
 	if stretchedKey, err := readMasterKey(c, ui); err != nil {
 		log.Warn("Failed to open master, rules disabled", "err", err)
 	} else {
@@ -534,7 +591,7 @@ func signer(c *cli.Context) error {
 		configStorage := storage.NewAESEncryptedStorage(filepath.Join(vaultLocation, "config.json"), confkey)
 
 		// Do we have a rule-file?
-		if ruleFile := c.String(ruleFlag.Name); ruleFile != "" {
+		if ruleFile := c.GlobalString(ruleFlag.Name); ruleFile != "" {
 			ruleJS, err := os.ReadFile(ruleFile)
 			if err != nil {
 				log.Warn("Could not load rules, disabling", "file", ruleFile, "err", err)
@@ -558,12 +615,12 @@ func signer(c *cli.Context) error {
 		}
 	}
 	var (
-		chainId  = c.Int64(chainIdFlag.Name)
-		ksLoc    = c.String(keystoreFlag.Name)
-		lightKdf = c.Bool(utils.LightKDFFlag.Name)
-		advanced = c.Bool(advancedMode.Name)
-		nousb    = c.Bool(utils.NoUSBFlag.Name)
-		scpath   = c.String(utils.SmartCardDaemonPathFlag.Name)
+		chainId  = c.GlobalInt64(chainIdFlag.Name)
+		ksLoc    = c.GlobalString(keystoreFlag.Name)
+		lightKdf = c.GlobalBool(utils.LightKDFFlag.Name)
+		advanced = c.GlobalBool(advancedMode.Name)
+		nousb    = c.GlobalBool(utils.NoUSBFlag.Name)
+		scpath   = c.GlobalString(utils.SmartCardDaemonPathFlag.Name)
 	)
 	log.Info("Starting signer", "chainid", chainId, "keystore", ksLoc,
 		"light-kdf", lightKdf, "advanced", advanced)
@@ -575,7 +632,7 @@ func signer(c *cli.Context) error {
 	ui.RegisterUIServer(core.NewUIServerAPI(apiImpl))
 	api = apiImpl
 	// Audit logging
-	if logfile := c.String(auditLogFlag.Name); logfile != "" {
+	if logfile := c.GlobalString(auditLogFlag.Name); logfile != "" {
 		api, err = core.NewAuditLogger(logfile, api)
 		if err != nil {
 			utils.Fatalf(err.Error())
@@ -590,15 +647,16 @@ func signer(c *cli.Context) error {
 	rpcAPI := []rpc.API{
 		{
 			Namespace: "account",
+			Public:    true,
 			Service:   api,
-		},
+			Version:   "1.0"},
 	}
-	if c.Bool(utils.HTTPEnabledFlag.Name) {
-		vhosts := utils.SplitAndTrim(c.String(utils.HTTPVirtualHostsFlag.Name))
-		cors := utils.SplitAndTrim(c.String(utils.HTTPCORSDomainFlag.Name))
+	if c.GlobalBool(utils.HTTPEnabledFlag.Name) {
+		vhosts := utils.SplitAndTrim(c.GlobalString(utils.HTTPVirtualHostsFlag.Name))
+		cors := utils.SplitAndTrim(c.GlobalString(utils.HTTPCORSDomainFlag.Name))
 
 		srv := rpc.NewServer()
-		err := node.RegisterApis(rpcAPI, []string{"account"}, srv)
+		err := node.RegisterApis(rpcAPI, []string{"account"}, srv, false)
 		if err != nil {
 			utils.Fatalf("Could not register API: %w", err)
 		}
@@ -608,7 +666,7 @@ func signer(c *cli.Context) error {
 		port := c.Int(rpcPortFlag.Name)
 
 		// start http server
-		httpEndpoint := fmt.Sprintf("%s:%d", c.String(utils.HTTPListenAddrFlag.Name), port)
+		httpEndpoint := fmt.Sprintf("%s:%d", c.GlobalString(utils.HTTPListenAddrFlag.Name), port)
 		httpServer, addr, err := node.StartHTTPEndpoint(httpEndpoint, rpc.DefaultHTTPTimeouts, handler)
 		if err != nil {
 			utils.Fatalf("Could not start RPC api: %v", err)
@@ -622,8 +680,8 @@ func signer(c *cli.Context) error {
 			log.Info("HTTP endpoint closed", "url", extapiURL)
 		}()
 	}
-	if !c.Bool(utils.IPCDisabledFlag.Name) {
-		givenPath := c.String(utils.IPCPathFlag.Name)
+	if !c.GlobalBool(utils.IPCDisabledFlag.Name) {
+		givenPath := c.GlobalString(utils.IPCPathFlag.Name)
 		ipcapiURL = ipcEndpoint(filepath.Join(givenPath, "clef.ipc"), configDir)
 		listener, _, err := rpc.StartIPCEndpoint(ipcapiURL, rpcAPI)
 		if err != nil {
@@ -636,7 +694,7 @@ func signer(c *cli.Context) error {
 		}()
 	}
 
-	if c.Bool(testFlag.Name) {
+	if c.GlobalBool(testFlag.Name) {
 		log.Info("Performing UI test")
 		go testExternalUI(apiImpl)
 	}
@@ -662,7 +720,7 @@ func signer(c *cli.Context) error {
 // persistence requirements.
 func DefaultConfigDir() string {
 	// Try to place the data folder in the user's home dir
-	home := flags.HomeDir()
+	home := utils.HomeDir()
 	if home != "" {
 		if runtime.GOOS == "darwin" {
 			return filepath.Join(home, "Library", "Signer")
@@ -682,10 +740,10 @@ func DefaultConfigDir() string {
 func readMasterKey(ctx *cli.Context, ui core.UIClientAPI) ([]byte, error) {
 	var (
 		file      string
-		configDir = ctx.String(configdirFlag.Name)
+		configDir = ctx.GlobalString(configdirFlag.Name)
 	)
-	if ctx.IsSet(signerSecretFlag.Name) {
-		file = ctx.String(signerSecretFlag.Name)
+	if ctx.GlobalIsSet(signerSecretFlag.Name) {
+		file = ctx.GlobalString(signerSecretFlag.Name)
 	} else {
 		file = filepath.Join(configDir, "masterseed.json")
 	}
@@ -759,6 +817,7 @@ func confirm(text string) bool {
 }
 
 func testExternalUI(api *core.SignerAPI) {
+
 	ctx := context.WithValue(context.Background(), "remote", "clef binary")
 	ctx = context.WithValue(ctx, "scheme", "in-proc")
 	ctx = context.WithValue(ctx, "local", "main")
@@ -858,6 +917,7 @@ func testExternalUI(api *core.SignerAPI) {
 		expectDeny("signdata - text", err)
 	}
 	{ // Sign transaction
+
 		api.UI.ShowInfo("Please reject next transaction")
 		time.Sleep(delay)
 		data := hexutil.Bytes([]byte{})
@@ -900,6 +960,7 @@ func testExternalUI(api *core.SignerAPI) {
 	}
 	result := fmt.Sprintf("Tests completed. %d errors:\n%s\n", len(errs), strings.Join(errs, "\n"))
 	api.UI.ShowInfo(result)
+
 }
 
 type encryptedSeedStorage struct {
@@ -935,7 +996,8 @@ func decryptSeed(keyjson []byte, auth string) ([]byte, error) {
 }
 
 // GenDoc outputs examples of all structures used in json-rpc communication
-func GenDoc(ctx *cli.Context) error {
+func GenDoc(ctx *cli.Context) {
+
 	var (
 		a    = common.HexToAddress("0xdeadbeef000000000000000000000000deadbeef")
 		b    = common.HexToAddress("0x1111111122222222222233333333334444444444")
@@ -1045,6 +1107,7 @@ func GenDoc(ctx *cli.Context) error {
 		var tx types.Transaction
 		tx.UnmarshalBinary(rlpdata)
 		add("OnApproved - SignTransactionResult", desc, &ethapi.SignTransactionResult{Raw: rlpdata, Tx: &tx})
+
 	}
 	{ // User input
 		add("UserInputRequest", "Sent when clef needs the user to provide data. If 'password' is true, the input field should be treated accordingly (echo-free)",
@@ -1083,5 +1146,4 @@ These data types are defined in the channel between clef and the UI`)
 	for _, elem := range output {
 		fmt.Println(elem)
 	}
-	return nil
 }

cmd/devp2p/discv4cmd.go

@@ -25,18 +25,17 @@ import (
 	"github.com/ethereum/go-ethereum/cmd/devp2p/internal/v4test"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/internal/flags"
 	"github.com/ethereum/go-ethereum/p2p/discover"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/params"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
-	discv4Command = &cli.Command{
+	discv4Command = cli.Command{
 		Name:  "discv4",
 		Usage: "Node Discovery v4 tools",
-		Subcommands: []*cli.Command{
+		Subcommands: []cli.Command{
 			discv4PingCommand,
 			discv4RequestRecordCommand,
 			discv4ResolveCommand,
@@ -45,41 +44,39 @@ var (
 			discv4TestCommand,
 		},
 	}
-	discv4PingCommand = &cli.Command{
+	discv4PingCommand = cli.Command{
 		Name:      "ping",
 		Usage:     "Sends ping to a node",
 		Action:    discv4Ping,
 		ArgsUsage: "<node>",
-		Flags:     v4NodeFlags,
 	}
-	discv4RequestRecordCommand = &cli.Command{
+	discv4RequestRecordCommand = cli.Command{
 		Name:      "requestenr",
 		Usage:     "Requests a node record using EIP-868 enrRequest",
 		Action:    discv4RequestRecord,
 		ArgsUsage: "<node>",
-		Flags:     v4NodeFlags,
 	}
-	discv4ResolveCommand = &cli.Command{
+	discv4ResolveCommand = cli.Command{
 		Name:      "resolve",
 		Usage:     "Finds a node in the DHT",
 		Action:    discv4Resolve,
 		ArgsUsage: "<node>",
-		Flags:     v4NodeFlags,
+		Flags:     []cli.Flag{bootnodesFlag},
 	}
-	discv4ResolveJSONCommand = &cli.Command{
+	discv4ResolveJSONCommand = cli.Command{
 		Name:      "resolve-json",
 		Usage:     "Re-resolves nodes in a nodes.json file",
 		Action:    discv4ResolveJSON,
-		Flags:     v4NodeFlags,
+		Flags:     []cli.Flag{bootnodesFlag},
 		ArgsUsage: "<nodes.json file>",
 	}
-	discv4CrawlCommand = &cli.Command{
+	discv4CrawlCommand = cli.Command{
 		Name:   "crawl",
 		Usage:  "Updates a nodes.json file with random nodes found in the DHT",
 		Action: discv4Crawl,
-		Flags:  flags.Merge(v4NodeFlags, []cli.Flag{crawlTimeoutFlag}),
+		Flags:  []cli.Flag{bootnodesFlag, crawlTimeoutFlag},
 	}
-	discv4TestCommand = &cli.Command{
+	discv4TestCommand = cli.Command{
 		Name:   "test",
 		Usage:  "Runs tests against a node",
 		Action: discv4Test,
@@ -94,41 +91,34 @@ var (
 )
 
 var (
-	bootnodesFlag = &cli.StringFlag{
+	bootnodesFlag = cli.StringFlag{
 		Name:  "bootnodes",
 		Usage: "Comma separated nodes used for bootstrapping",
 	}
-	nodekeyFlag = &cli.StringFlag{
+	nodekeyFlag = cli.StringFlag{
 		Name:  "nodekey",
 		Usage: "Hex-encoded node key",
 	}
-	nodedbFlag = &cli.StringFlag{
+	nodedbFlag = cli.StringFlag{
 		Name:  "nodedb",
 		Usage: "Nodes database location",
 	}
-	listenAddrFlag = &cli.StringFlag{
+	listenAddrFlag = cli.StringFlag{
 		Name:  "addr",
 		Usage: "Listening address",
 	}
-	crawlTimeoutFlag = &cli.DurationFlag{
+	crawlTimeoutFlag = cli.DurationFlag{
 		Name:  "timeout",
 		Usage: "Time limit for the crawl.",
 		Value: 30 * time.Minute,
 	}
-	remoteEnodeFlag = &cli.StringFlag{
-		Name:    "remote",
-		Usage:   "Enode of the remote node under test",
-		EnvVars: []string{"REMOTE_ENODE"},
+	remoteEnodeFlag = cli.StringFlag{
+		Name:   "remote",
+		Usage:  "Enode of the remote node under test",
+		EnvVar: "REMOTE_ENODE",
 	}
 )
 
-var v4NodeFlags = []cli.Flag{
-	bootnodesFlag,
-	nodekeyFlag,
-	nodedbFlag,
-	listenAddrFlag,
-}
-
 func discv4Ping(ctx *cli.Context) error {
 	n := getNodeArg(ctx)
 	disc := startV4(ctx)

cmd/devp2p/discv5cmd.go

@@ -1,4 +1,4 @@
-// Copyright 2020 The go-ethereum Authors
+// Copyright 2019 The go-ethereum Authors
 // This file is part of go-ethereum.
 //
 // go-ethereum is free software: you can redistribute it and/or modify
@@ -23,14 +23,14 @@ import (
 	"github.com/ethereum/go-ethereum/cmd/devp2p/internal/v5test"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/p2p/discover"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
-	discv5Command = &cli.Command{
+	discv5Command = cli.Command{
 		Name:  "discv5",
 		Usage: "Node Discovery v5 tools",
-		Subcommands: []*cli.Command{
+		Subcommands: []cli.Command{
 			discv5PingCommand,
 			discv5ResolveCommand,
 			discv5CrawlCommand,
@@ -38,24 +38,24 @@ var (
 			discv5ListenCommand,
 		},
 	}
-	discv5PingCommand = &cli.Command{
+	discv5PingCommand = cli.Command{
 		Name:   "ping",
 		Usage:  "Sends ping to a node",
 		Action: discv5Ping,
 	}
-	discv5ResolveCommand = &cli.Command{
+	discv5ResolveCommand = cli.Command{
 		Name:   "resolve",
 		Usage:  "Finds a node in the DHT",
 		Action: discv5Resolve,
 		Flags:  []cli.Flag{bootnodesFlag},
 	}
-	discv5CrawlCommand = &cli.Command{
+	discv5CrawlCommand = cli.Command{
 		Name:   "crawl",
 		Usage:  "Updates a nodes.json file with random nodes found in the DHT",
 		Action: discv5Crawl,
 		Flags:  []cli.Flag{bootnodesFlag, crawlTimeoutFlag},
 	}
-	discv5TestCommand = &cli.Command{
+	discv5TestCommand = cli.Command{
 		Name:   "test",
 		Usage:  "Runs protocol tests against a node",
 		Action: discv5Test,
@@ -66,7 +66,7 @@ var (
 			testListen2Flag,
 		},
 	}
-	discv5ListenCommand = &cli.Command{
+	discv5ListenCommand = cli.Command{
 		Name:   "listen",
 		Usage:  "Runs a node",
 		Action: discv5Listen,

cmd/devp2p/dns_cloudflare.go

@@ -24,16 +24,16 @@ import (
 	"github.com/cloudflare/cloudflare-go"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/p2p/dnsdisc"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
-	cloudflareTokenFlag = &cli.StringFlag{
-		Name:    "token",
-		Usage:   "CloudFlare API token",
-		EnvVars: []string{"CLOUDFLARE_API_TOKEN"},
+	cloudflareTokenFlag = cli.StringFlag{
+		Name:   "token",
+		Usage:  "CloudFlare API token",
+		EnvVar: "CLOUDFLARE_API_TOKEN",
 	}
-	cloudflareZoneIDFlag = &cli.StringFlag{
+	cloudflareZoneIDFlag = cli.StringFlag{
 		Name:  "zoneid",
 		Usage: "CloudFlare Zone ID (optional)",
 	}
@@ -134,6 +134,7 @@ func (c *cloudflareClient) uploadRecords(name string, records map[string]string)
 			ttl := rootTTL
 			if path != name {
 				ttl = treeNodeTTLCloudflare // Max TTL permitted by Cloudflare
+
 			}
 			record := cloudflare.DNSRecord{Type: "TXT", Name: path, Content: val, TTL: ttl}
 			_, err = c.CreateDNSRecord(context.Background(), c.zoneID, record)

cmd/devp2p/dns_route53.go

@@ -32,7 +32,7 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/route53/types"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/p2p/dnsdisc"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 const (
@@ -45,21 +45,21 @@ const (
 )
 
 var (
-	route53AccessKeyFlag = &cli.StringFlag{
-		Name:    "access-key-id",
-		Usage:   "AWS Access Key ID",
-		EnvVars: []string{"AWS_ACCESS_KEY_ID"},
+	route53AccessKeyFlag = cli.StringFlag{
+		Name:   "access-key-id",
+		Usage:  "AWS Access Key ID",
+		EnvVar: "AWS_ACCESS_KEY_ID",
 	}
-	route53AccessSecretFlag = &cli.StringFlag{
-		Name:    "access-key-secret",
-		Usage:   "AWS Access Key Secret",
-		EnvVars: []string{"AWS_SECRET_ACCESS_KEY"},
+	route53AccessSecretFlag = cli.StringFlag{
+		Name:   "access-key-secret",
+		Usage:  "AWS Access Key Secret",
+		EnvVar: "AWS_SECRET_ACCESS_KEY",
 	}
-	route53ZoneIDFlag = &cli.StringFlag{
+	route53ZoneIDFlag = cli.StringFlag{
 		Name:  "zone-id",
 		Usage: "Route53 Zone ID",
 	}
-	route53RegionFlag = &cli.StringFlag{
+	route53RegionFlag = cli.StringFlag{
 		Name:  "aws-region",
 		Usage: "AWS Region",
 		Value: "eu-central-1",

cmd/devp2p/dnscmd.go

@@ -1,4 +1,4 @@
-// Copyright 2019 The go-ethereum Authors
+// Copyright 2018 The go-ethereum Authors
 // This file is part of go-ethereum.
 //
 // go-ethereum is free software: you can redistribute it and/or modify
@@ -29,14 +29,14 @@ import (
 	"github.com/ethereum/go-ethereum/console/prompt"
 	"github.com/ethereum/go-ethereum/p2p/dnsdisc"
 	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
-	dnsCommand = &cli.Command{
+	dnsCommand = cli.Command{
 		Name:  "dns",
 		Usage: "DNS Discovery Commands",
-		Subcommands: []*cli.Command{
+		Subcommands: []cli.Command{
 			dnsSyncCommand,
 			dnsSignCommand,
 			dnsTXTCommand,
@@ -45,34 +45,34 @@ var (
 			dnsRoute53NukeCommand,
 		},
 	}
-	dnsSyncCommand = &cli.Command{
+	dnsSyncCommand = cli.Command{
 		Name:      "sync",
 		Usage:     "Download a DNS discovery tree",
 		ArgsUsage: "<url> [ <directory> ]",
 		Action:    dnsSync,
 		Flags:     []cli.Flag{dnsTimeoutFlag},
 	}
-	dnsSignCommand = &cli.Command{
+	dnsSignCommand = cli.Command{
 		Name:      "sign",
 		Usage:     "Sign a DNS discovery tree",
 		ArgsUsage: "<tree-directory> <key-file>",
 		Action:    dnsSign,
 		Flags:     []cli.Flag{dnsDomainFlag, dnsSeqFlag},
 	}
-	dnsTXTCommand = &cli.Command{
+	dnsTXTCommand = cli.Command{
 		Name:      "to-txt",
 		Usage:     "Create a DNS TXT records for a discovery tree",
 		ArgsUsage: "<tree-directory> <output-file>",
 		Action:    dnsToTXT,
 	}
-	dnsCloudflareCommand = &cli.Command{
+	dnsCloudflareCommand = cli.Command{
 		Name:      "to-cloudflare",
 		Usage:     "Deploy DNS TXT records to CloudFlare",
 		ArgsUsage: "<tree-directory>",
 		Action:    dnsToCloudflare,
 		Flags:     []cli.Flag{cloudflareTokenFlag, cloudflareZoneIDFlag},
 	}
-	dnsRoute53Command = &cli.Command{
+	dnsRoute53Command = cli.Command{
 		Name:      "to-route53",
 		Usage:     "Deploy DNS TXT records to Amazon Route53",
 		ArgsUsage: "<tree-directory>",
@@ -84,7 +84,7 @@ var (
 			route53RegionFlag,
 		},
 	}
-	dnsRoute53NukeCommand = &cli.Command{
+	dnsRoute53NukeCommand = cli.Command{
 		Name:      "nuke-route53",
 		Usage:     "Deletes DNS TXT records of a subdomain on Amazon Route53",
 		ArgsUsage: "<domain>",
@@ -99,15 +99,15 @@ var (
 )
 
 var (
-	dnsTimeoutFlag = &cli.DurationFlag{
+	dnsTimeoutFlag = cli.DurationFlag{
 		Name:  "timeout",
 		Usage: "Timeout for DNS lookups",
 	}
-	dnsDomainFlag = &cli.StringFlag{
+	dnsDomainFlag = cli.StringFlag{
 		Name:  "domain",
 		Usage: "Domain name of the tree",
 	}
-	dnsSeqFlag = &cli.UintFlag{
+	dnsSeqFlag = cli.UintFlag{
 		Name:  "seq",
 		Usage: "New sequence number of the tree",
 	}

cmd/devp2p/enrcmd.go

@@ -30,12 +30,12 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/p2p/enr"
 	"github.com/ethereum/go-ethereum/rlp"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
-var fileFlag = &cli.StringFlag{Name: "file"}
+var fileFlag = cli.StringFlag{Name: "file"}
 
-var enrdumpCommand = &cli.Command{
+var enrdumpCommand = cli.Command{
 	Name:   "enrdump",
 	Usage:  "Pretty-prints node records",
 	Action: enrdump,
@@ -62,7 +62,7 @@ func enrdump(ctx *cli.Context) error {
 		}
 		source = string(b)
 	} else if ctx.NArg() == 1 {
-		source = ctx.Args().First()
+		source = ctx.Args()[0]
 	} else {
 		return fmt.Errorf("need record as argument")
 	}

cmd/devp2p/internal/ethtest/chain.go

@@ -1,18 +1,18 @@
 // Copyright 2020 The go-ethereum Authors
-// This file is part of go-ethereum.
+// This file is part of the go-ethereum library.
 //
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// The 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.
 //
-// go-ethereum is distributed in the hope that it will be useful,
+// 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 General Public License for more details.
+// GNU Lesser General Public License for more details.
 //
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+// 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 ethtest
 
@@ -47,7 +47,7 @@ func (c *Chain) Len() int {
 // TD calculates the total difficulty of the chain at the
 // chain head.
 func (c *Chain) TD() *big.Int {
-	sum := new(big.Int)
+	sum := big.NewInt(0)
 	for _, block := range c.blocks[:c.Len()] {
 		sum.Add(sum, block.Difficulty())
 	}
@@ -57,7 +57,7 @@ func (c *Chain) TD() *big.Int {
 // TotalDifficultyAt calculates the total difficulty of the chain
 // at the given block height.
 func (c *Chain) TotalDifficultyAt(height int) *big.Int {
-	sum := new(big.Int)
+	sum := big.NewInt(0)
 	if height >= c.Len() {
 		return sum
 	}
@@ -96,12 +96,12 @@ func (c *Chain) Head() *types.Block {
 	return c.blocks[c.Len()-1]
 }
 
-func (c *Chain) GetHeaders(req *GetBlockHeaders) ([]*types.Header, error) {
+func (c *Chain) GetHeaders(req GetBlockHeaders) (BlockHeaders, error) {
 	if req.Amount < 1 {
 		return nil, fmt.Errorf("no block headers requested")
 	}
 
-	headers := make([]*types.Header, req.Amount)
+	headers := make(BlockHeaders, req.Amount)
 	var blockNumber uint64
 
 	// range over blocks to check if our chain has the requested header
@@ -119,6 +119,7 @@ func (c *Chain) GetHeaders(req *GetBlockHeaders) ([]*types.Header, error) {
 		for i := 1; i < int(req.Amount); i++ {
 			blockNumber -= (1 - req.Skip)
 			headers[i] = c.blocks[blockNumber].Header()
+
 		}
 
 		return headers, nil
@@ -139,7 +140,7 @@ func loadChain(chainfile string, genesis string) (*Chain, error) {
 	if err != nil {
 		return nil, err
 	}
-	gblock := gen.ToBlock()
+	gblock := gen.ToBlock(nil)
 
 	blocks, err := blocksFromFile(chainfile, gblock)
 	if err != nil {

cmd/devp2p/internal/ethtest/chain_test.go

@@ -1,18 +1,18 @@
 // Copyright 2020 The go-ethereum Authors
-// This file is part of go-ethereum.
+// This file is part of the go-ethereum library.
 //
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// The 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.
 //
-// go-ethereum is distributed in the hope that it will be useful,
+// 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 General Public License for more details.
+// GNU Lesser General Public License for more details.
 //
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+// 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 ethtest
 
@@ -21,7 +21,6 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/eth/protocols/eth"
 	"github.com/ethereum/go-ethereum/p2p"
 	"github.com/stretchr/testify/assert"
@@ -141,18 +140,18 @@ func TestChain_GetHeaders(t *testing.T) {
 
 	var tests = []struct {
 		req      GetBlockHeaders
-		expected []*types.Header
+		expected BlockHeaders
 	}{
 		{
 			req: GetBlockHeaders{
-				GetBlockHeadersPacket: &eth.GetBlockHeadersPacket{
-					Origin:  eth.HashOrNumber{Number: uint64(2)},
-					Amount:  uint64(5),
-					Skip:    1,
-					Reverse: false,
+				Origin: eth.HashOrNumber{
+					Number: uint64(2),
 				},
+				Amount:  uint64(5),
+				Skip:    1,
+				Reverse: false,
 			},
-			expected: []*types.Header{
+			expected: BlockHeaders{
 				chain.blocks[2].Header(),
 				chain.blocks[4].Header(),
 				chain.blocks[6].Header(),
@@ -162,14 +161,14 @@ func TestChain_GetHeaders(t *testing.T) {
 		},
 		{
 			req: GetBlockHeaders{
-				GetBlockHeadersPacket: &eth.GetBlockHeadersPacket{
-					Origin:  eth.HashOrNumber{Number: uint64(chain.Len() - 1)},
-					Amount:  uint64(3),
-					Skip:    0,
-					Reverse: true,
+				Origin: eth.HashOrNumber{
+					Number: uint64(chain.Len() - 1),
 				},
+				Amount:  uint64(3),
+				Skip:    0,
+				Reverse: true,
 			},
-			expected: []*types.Header{
+			expected: BlockHeaders{
 				chain.blocks[chain.Len()-1].Header(),
 				chain.blocks[chain.Len()-2].Header(),
 				chain.blocks[chain.Len()-3].Header(),
@@ -177,14 +176,14 @@ func TestChain_GetHeaders(t *testing.T) {
 		},
 		{
 			req: GetBlockHeaders{
-				GetBlockHeadersPacket: &eth.GetBlockHeadersPacket{
-					Origin:  eth.HashOrNumber{Hash: chain.Head().Hash()},
-					Amount:  uint64(1),
-					Skip:    0,
-					Reverse: false,
+				Origin: eth.HashOrNumber{
+					Hash: chain.Head().Hash(),
 				},
+				Amount:  uint64(1),
+				Skip:    0,
+				Reverse: false,
 			},
-			expected: []*types.Header{
+			expected: BlockHeaders{
 				chain.Head().Header(),
 			},
 		},
@@ -192,7 +191,7 @@ func TestChain_GetHeaders(t *testing.T) {
 
 	for i, tt := range tests {
 		t.Run(strconv.Itoa(i), func(t *testing.T) {
-			headers, err := chain.GetHeaders(&tt.req)
+			headers, err := chain.GetHeaders(tt.req)
 			if err != nil {
 				t.Fatal(err)
 			}

cmd/devp2p/internal/ethtest/helpers.go

@@ -1,18 +1,18 @@
-// Copyright 2021 The go-ethereum Authors
-// This file is part of go-ethereum.
+// Copyright 2020 The go-ethereum Authors
+// This file is part of the go-ethereum library.
 //
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// The 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.
 //
-// go-ethereum is distributed in the hope that it will be useful,
+// 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 General Public License for more details.
+// GNU Lesser General Public License for more details.
 //
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+// 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 ethtest
 
@@ -43,6 +43,21 @@ var (
 	timeout = 20 * time.Second
 )
 
+// Is_66 checks if the node supports the eth66 protocol version,
+// and if not, exists the test suite
+func (s *Suite) Is_66(t *utesting.T) {
+	conn, err := s.dial66()
+	if err != nil {
+		t.Fatalf("dial failed: %v", err)
+	}
+	if err := conn.handshake(); err != nil {
+		t.Fatalf("handshake failed: %v", err)
+	}
+	if conn.negotiatedProtoVersion < 66 {
+		t.Fail()
+	}
+}
+
 // dial attempts to dial the given node and perform a handshake,
 // returning the created Conn if successful.
 func (s *Suite) dial() (*Conn, error) {
@@ -61,19 +76,34 @@ func (s *Suite) dial() (*Conn, error) {
 	}
 	// set default p2p capabilities
 	conn.caps = []p2p.Cap{
-		{Name: "eth", Version: 66},
-		{Name: "eth", Version: 67},
+		{Name: "eth", Version: 64},
+		{Name: "eth", Version: 65},
 	}
-	conn.ourHighestProtoVersion = 67
+	conn.ourHighestProtoVersion = 65
 	return &conn, nil
 }
 
-// dialSnap creates a connection with snap/1 capability.
-func (s *Suite) dialSnap() (*Conn, error) {
+// dial66 attempts to dial the given node and perform a handshake,
+// returning the created Conn with additional eth66 capabilities if
+// successful
+func (s *Suite) dial66() (*Conn, error) {
 	conn, err := s.dial()
 	if err != nil {
 		return nil, fmt.Errorf("dial failed: %v", err)
 	}
+	conn.caps = append(conn.caps, p2p.Cap{Name: "eth", Version: 66})
+	conn.ourHighestProtoVersion = 66
+	return conn, nil
+}
+
+// dial66 attempts to dial the given node and perform a handshake,
+// returning the created Conn with additional snap/1 capabilities if
+// successful.
+func (s *Suite) dialSnap() (*Conn, error) {
+	conn, err := s.dial66()
+	if err != nil {
+		return nil, fmt.Errorf("dial failed: %v", err)
+	}
 	conn.caps = append(conn.caps, p2p.Cap{Name: "snap", Version: 1})
 	conn.ourHighestSnapProtoVersion = 1
 	return conn, nil
@@ -205,40 +235,60 @@ loop:
 
 // createSendAndRecvConns creates two connections, one for sending messages to the
 // node, and one for receiving messages from the node.
-func (s *Suite) createSendAndRecvConns() (*Conn, *Conn, error) {
-	sendConn, err := s.dial()
-	if err != nil {
-		return nil, nil, fmt.Errorf("dial failed: %v", err)
-	}
-	recvConn, err := s.dial()
-	if err != nil {
-		sendConn.Close()
-		return nil, nil, fmt.Errorf("dial failed: %v", err)
+func (s *Suite) createSendAndRecvConns(isEth66 bool) (*Conn, *Conn, error) {
+	var (
+		sendConn *Conn
+		recvConn *Conn
+		err      error
+	)
+	if isEth66 {
+		sendConn, err = s.dial66()
+		if err != nil {
+			return nil, nil, fmt.Errorf("dial failed: %v", err)
+		}
+		recvConn, err = s.dial66()
+		if err != nil {
+			sendConn.Close()
+			return nil, nil, fmt.Errorf("dial failed: %v", err)
+		}
+	} else {
+		sendConn, err = s.dial()
+		if err != nil {
+			return nil, nil, fmt.Errorf("dial failed: %v", err)
+		}
+		recvConn, err = s.dial()
+		if err != nil {
+			sendConn.Close()
+			return nil, nil, fmt.Errorf("dial failed: %v", err)
+		}
 	}
 	return sendConn, recvConn, nil
 }
 
+func (c *Conn) readAndServe(chain *Chain, timeout time.Duration) Message {
+	if c.negotiatedProtoVersion == 66 {
+		_, msg := c.readAndServe66(chain, timeout)
+		return msg
+	}
+	return c.readAndServe65(chain, timeout)
+}
+
 // readAndServe serves GetBlockHeaders requests while waiting
 // on another message from the node.
-func (c *Conn) readAndServe(chain *Chain, timeout time.Duration) Message {
+func (c *Conn) readAndServe65(chain *Chain, timeout time.Duration) Message {
 	start := time.Now()
 	for time.Since(start) < timeout {
-		c.SetReadDeadline(time.Now().Add(10 * time.Second))
-
-		msg := c.Read()
-		switch msg := msg.(type) {
+		c.SetReadDeadline(time.Now().Add(5 * time.Second))
+		switch msg := c.Read().(type) {
 		case *Ping:
 			c.Write(&Pong{})
 		case *GetBlockHeaders:
-			headers, err := chain.GetHeaders(msg)
+			req := *msg
+			headers, err := chain.GetHeaders(req)
 			if err != nil {
 				return errorf("could not get headers for inbound header request: %v", err)
 			}
-			resp := &BlockHeaders{
-				RequestId:          msg.ReqID(),
-				BlockHeadersPacket: eth.BlockHeadersPacket(headers),
-			}
-			if err := c.Write(resp); err != nil {
+			if err := c.Write(headers); err != nil {
 				return errorf("could not write to connection: %v", err)
 			}
 		default:
@@ -248,25 +298,54 @@ func (c *Conn) readAndServe(chain *Chain, timeout time.Duration) Message {
 	return errorf("no message received within %v", timeout)
 }
 
+// readAndServe66 serves eth66 GetBlockHeaders requests while waiting
+// on another message from the node.
+func (c *Conn) readAndServe66(chain *Chain, timeout time.Duration) (uint64, Message) {
+	start := time.Now()
+	for time.Since(start) < timeout {
+		c.SetReadDeadline(time.Now().Add(10 * time.Second))
+
+		reqID, msg := c.Read66()
+
+		switch msg := msg.(type) {
+		case *Ping:
+			c.Write(&Pong{})
+		case GetBlockHeaders:
+			headers, err := chain.GetHeaders(msg)
+			if err != nil {
+				return 0, errorf("could not get headers for inbound header request: %v", err)
+			}
+			resp := &eth.BlockHeadersPacket66{
+				RequestId:          reqID,
+				BlockHeadersPacket: eth.BlockHeadersPacket(headers),
+			}
+			if err := c.Write66(resp, BlockHeaders{}.Code()); err != nil {
+				return 0, errorf("could not write to connection: %v", err)
+			}
+		default:
+			return reqID, msg
+		}
+	}
+	return 0, errorf("no message received within %v", timeout)
+}
+
 // headersRequest executes the given `GetBlockHeaders` request.
-func (c *Conn) headersRequest(request *GetBlockHeaders, chain *Chain, reqID uint64) ([]*types.Header, error) {
+func (c *Conn) headersRequest(request *GetBlockHeaders, chain *Chain, isEth66 bool, reqID uint64) (BlockHeaders, error) {
 	defer c.SetReadDeadline(time.Time{})
 	c.SetReadDeadline(time.Now().Add(20 * time.Second))
-
-	// write request
-	request.RequestId = reqID
+	// if on eth66 connection, perform eth66 GetBlockHeaders request
+	if isEth66 {
+		return getBlockHeaders66(chain, c, request, reqID)
+	}
 	if err := c.Write(request); err != nil {
-		return nil, fmt.Errorf("could not write to connection: %v", err)
+		return nil, err
 	}
-
-	// wait for response
-	msg := c.waitForResponse(chain, timeout, request.RequestId)
-	resp, ok := msg.(*BlockHeaders)
-	if !ok {
-		return nil, fmt.Errorf("unexpected message received: %s", pretty.Sdump(msg))
+	switch msg := c.readAndServe(chain, timeout).(type) {
+	case *BlockHeaders:
+		return *msg, nil
+	default:
+		return nil, fmt.Errorf("invalid message: %s", pretty.Sdump(msg))
 	}
-	headers := []*types.Header(resp.BlockHeadersPacket)
-	return headers, nil
 }
 
 func (c *Conn) snapRequest(msg Message, id uint64, chain *Chain) (Message, error) {
@@ -278,8 +357,28 @@ func (c *Conn) snapRequest(msg Message, id uint64, chain *Chain) (Message, error
 	return c.ReadSnap(id)
 }
 
+// getBlockHeaders66 executes the given `GetBlockHeaders` request over the eth66 protocol.
+func getBlockHeaders66(chain *Chain, conn *Conn, request *GetBlockHeaders, id uint64) (BlockHeaders, error) {
+	// write request
+	packet := eth.GetBlockHeadersPacket(*request)
+	req := &eth.GetBlockHeadersPacket66{
+		RequestId:             id,
+		GetBlockHeadersPacket: &packet,
+	}
+	if err := conn.Write66(req, GetBlockHeaders{}.Code()); err != nil {
+		return nil, fmt.Errorf("could not write to connection: %v", err)
+	}
+	// wait for response
+	msg := conn.waitForResponse(chain, timeout, req.RequestId)
+	headers, ok := msg.(BlockHeaders)
+	if !ok {
+		return nil, fmt.Errorf("unexpected message received: %s", pretty.Sdump(msg))
+	}
+	return headers, nil
+}
+
 // headersMatch returns whether the received headers match the given request
-func headersMatch(expected []*types.Header, headers []*types.Header) bool {
+func headersMatch(expected BlockHeaders, headers BlockHeaders) bool {
 	return reflect.DeepEqual(expected, headers)
 }
 
@@ -287,8 +386,8 @@ func headersMatch(expected []*types.Header, headers []*types.Header) bool {
 // request ID is received.
 func (c *Conn) waitForResponse(chain *Chain, timeout time.Duration, requestID uint64) Message {
 	for {
-		msg := c.readAndServe(chain, timeout)
-		if msg.ReqID() == requestID {
+		id, msg := c.readAndServe66(chain, timeout)
+		if id == requestID {
 			return msg
 		}
 	}
@@ -296,9 +395,9 @@ func (c *Conn) waitForResponse(chain *Chain, timeout time.Duration, requestID ui
 
 // sendNextBlock broadcasts the next block in the chain and waits
 // for the node to propagate the block and import it into its chain.
-func (s *Suite) sendNextBlock() error {
+func (s *Suite) sendNextBlock(isEth66 bool) error {
 	// set up sending and receiving connections
-	sendConn, recvConn, err := s.createSendAndRecvConns()
+	sendConn, recvConn, err := s.createSendAndRecvConns(isEth66)
 	if err != nil {
 		return err
 	}
@@ -321,7 +420,7 @@ func (s *Suite) sendNextBlock() error {
 		return fmt.Errorf("failed to announce block: %v", err)
 	}
 	// wait for client to update its chain
-	if err = s.waitForBlockImport(recvConn, nextBlock); err != nil {
+	if err = s.waitForBlockImport(recvConn, nextBlock, isEth66); err != nil {
 		return fmt.Errorf("failed to receive confirmation of block import: %v", err)
 	}
 	// update test suite chain
@@ -366,22 +465,29 @@ func (s *Suite) waitAnnounce(conn *Conn, blockAnnouncement *NewBlock) error {
 	}
 }
 
-func (s *Suite) waitForBlockImport(conn *Conn, block *types.Block) error {
+func (s *Suite) waitForBlockImport(conn *Conn, block *types.Block, isEth66 bool) error {
 	defer conn.SetReadDeadline(time.Time{})
 	conn.SetReadDeadline(time.Now().Add(20 * time.Second))
 	// create request
 	req := &GetBlockHeaders{
-		GetBlockHeadersPacket: &eth.GetBlockHeadersPacket{
-			Origin: eth.HashOrNumber{Hash: block.Hash()},
-			Amount: 1,
+		Origin: eth.HashOrNumber{
+			Hash: block.Hash(),
 		},
+		Amount: 1,
 	}
-
 	// loop until BlockHeaders response contains desired block, confirming the
 	// node imported the block
 	for {
-		requestID := uint64(54)
-		headers, err := conn.headersRequest(req, s.chain, requestID)
+		var (
+			headers BlockHeaders
+			err     error
+		)
+		if isEth66 {
+			requestID := uint64(54)
+			headers, err = conn.headersRequest(req, s.chain, eth66, requestID)
+		} else {
+			headers, err = conn.headersRequest(req, s.chain, eth65, 0)
+		}
 		if err != nil {
 			return fmt.Errorf("GetBlockHeader request failed: %v", err)
 		}
@@ -397,8 +503,8 @@ func (s *Suite) waitForBlockImport(conn *Conn, block *types.Block) error {
 	}
 }
 
-func (s *Suite) oldAnnounce() error {
-	sendConn, receiveConn, err := s.createSendAndRecvConns()
+func (s *Suite) oldAnnounce(isEth66 bool) error {
+	sendConn, receiveConn, err := s.createSendAndRecvConns(isEth66)
 	if err != nil {
 		return err
 	}
@@ -444,13 +550,23 @@ func (s *Suite) oldAnnounce() error {
 	return nil
 }
 
-func (s *Suite) maliciousHandshakes(t *utesting.T) error {
-	conn, err := s.dial()
-	if err != nil {
-		return fmt.Errorf("dial failed: %v", err)
+func (s *Suite) maliciousHandshakes(t *utesting.T, isEth66 bool) error {
+	var (
+		conn *Conn
+		err  error
+	)
+	if isEth66 {
+		conn, err = s.dial66()
+		if err != nil {
+			return fmt.Errorf("dial failed: %v", err)
+		}
+	} else {
+		conn, err = s.dial()
+		if err != nil {
+			return fmt.Errorf("dial failed: %v", err)
+		}
 	}
 	defer conn.Close()
-
 	// write hello to client
 	pub0 := crypto.FromECDSAPub(&conn.ourKey.PublicKey)[1:]
 	handshakes := []*Hello{
@@ -511,9 +627,16 @@ func (s *Suite) maliciousHandshakes(t *utesting.T) error {
 			}
 		}
 		// dial for the next round
-		conn, err = s.dial()
-		if err != nil {
-			return fmt.Errorf("dial failed: %v", err)
+		if isEth66 {
+			conn, err = s.dial66()
+			if err != nil {
+				return fmt.Errorf("dial failed: %v", err)
+			}
+		} else {
+			conn, err = s.dial()
+			if err != nil {
+				return fmt.Errorf("dial failed: %v", err)
+			}
 		}
 	}
 	return nil
@@ -531,7 +654,6 @@ func (s *Suite) maliciousStatus(conn *Conn) error {
 		Genesis:         s.chain.blocks[0].Hash(),
 		ForkID:          s.chain.ForkID(),
 	}
-
 	// get status
 	msg, err := conn.statusExchange(s.chain, status)
 	if err != nil {
@@ -542,7 +664,6 @@ func (s *Suite) maliciousStatus(conn *Conn) error {
 	default:
 		return fmt.Errorf("expected status, got: %#v ", msg)
 	}
-
 	// wait for disconnect
 	switch msg := conn.readAndServe(s.chain, timeout).(type) {
 	case *Disconnect:
@@ -554,9 +675,9 @@ func (s *Suite) maliciousStatus(conn *Conn) error {
 	}
 }
 
-func (s *Suite) hashAnnounce() error {
+func (s *Suite) hashAnnounce(isEth66 bool) error {
 	// create connections
-	sendConn, recvConn, err := s.createSendAndRecvConns()
+	sendConn, recvConn, err := s.createSendAndRecvConns(isEth66)
 	if err != nil {
 		return fmt.Errorf("failed to create connections: %v", err)
 	}
@@ -568,7 +689,6 @@ func (s *Suite) hashAnnounce() error {
 	if err := recvConn.peer(s.chain, nil); err != nil {
 		return fmt.Errorf("peering failed: %v", err)
 	}
-
 	// create NewBlockHashes announcement
 	type anno struct {
 		Hash   common.Hash // Hash of one particular block being announced
@@ -580,29 +700,56 @@ func (s *Suite) hashAnnounce() error {
 	if err := sendConn.Write(newBlockHash); err != nil {
 		return fmt.Errorf("failed to write to connection: %v", err)
 	}
-
 	// Announcement sent, now wait for a header request
-	msg := sendConn.Read()
-	blockHeaderReq, ok := msg.(*GetBlockHeaders)
-	if !ok {
-		return fmt.Errorf("unexpected %s", pretty.Sdump(msg))
+	var (
+		id             uint64
+		msg            Message
+		blockHeaderReq GetBlockHeaders
+	)
+	if isEth66 {
+		id, msg = sendConn.Read66()
+		switch msg := msg.(type) {
+		case GetBlockHeaders:
+			blockHeaderReq = msg
+		default:
+			return fmt.Errorf("unexpected %s", pretty.Sdump(msg))
+		}
+		if blockHeaderReq.Amount != 1 {
+			return fmt.Errorf("unexpected number of block headers requested: %v", blockHeaderReq.Amount)
+		}
+		if blockHeaderReq.Origin.Hash != announcement.Hash {
+			return fmt.Errorf("unexpected block header requested. Announced:\n %v\n Remote request:\n%v",
+				pretty.Sdump(announcement),
+				pretty.Sdump(blockHeaderReq))
+		}
+		if err := sendConn.Write66(&eth.BlockHeadersPacket66{
+			RequestId: id,
+			BlockHeadersPacket: eth.BlockHeadersPacket{
+				nextBlock.Header(),
+			},
+		}, BlockHeaders{}.Code()); err != nil {
+			return fmt.Errorf("failed to write to connection: %v", err)
+		}
+	} else {
+		msg = sendConn.Read()
+		switch msg := msg.(type) {
+		case *GetBlockHeaders:
+			blockHeaderReq = *msg
+		default:
+			return fmt.Errorf("unexpected %s", pretty.Sdump(msg))
+		}
+		if blockHeaderReq.Amount != 1 {
+			return fmt.Errorf("unexpected number of block headers requested: %v", blockHeaderReq.Amount)
+		}
+		if blockHeaderReq.Origin.Hash != announcement.Hash {
+			return fmt.Errorf("unexpected block header requested. Announced:\n %v\n Remote request:\n%v",
+				pretty.Sdump(announcement),
+				pretty.Sdump(blockHeaderReq))
+		}
+		if err := sendConn.Write(&BlockHeaders{nextBlock.Header()}); err != nil {
+			return fmt.Errorf("failed to write to connection: %v", err)
+		}
 	}
-	if blockHeaderReq.Amount != 1 {
-		return fmt.Errorf("unexpected number of block headers requested: %v", blockHeaderReq.Amount)
-	}
-	if blockHeaderReq.Origin.Hash != announcement.Hash {
-		return fmt.Errorf("unexpected block header requested. Announced:\n %v\n Remote request:\n%v",
-			pretty.Sdump(announcement),
-			pretty.Sdump(blockHeaderReq))
-	}
-	err = sendConn.Write(&BlockHeaders{
-		RequestId:          blockHeaderReq.ReqID(),
-		BlockHeadersPacket: eth.BlockHeadersPacket{nextBlock.Header()},
-	})
-	if err != nil {
-		return fmt.Errorf("failed to write to connection: %v", err)
-	}
-
 	// wait for block announcement
 	msg = recvConn.readAndServe(s.chain, timeout)
 	switch msg := msg.(type) {
@@ -615,7 +762,6 @@ func (s *Suite) hashAnnounce() error {
 			return fmt.Errorf("unexpected block hash announcement, wanted %v, got %v", nextBlock.Hash(),
 				hashes[0].Hash)
 		}
-
 	case *NewBlock:
 		// node should only propagate NewBlock without having requested the body if the body is empty
 		nextBlockBody := nextBlock.Body()
@@ -634,7 +780,7 @@ func (s *Suite) hashAnnounce() error {
 		return fmt.Errorf("unexpected: %s", pretty.Sdump(msg))
 	}
 	// confirm node imported block
-	if err := s.waitForBlockImport(recvConn, nextBlock); err != nil {
+	if err := s.waitForBlockImport(recvConn, nextBlock, isEth66); err != nil {
 		return fmt.Errorf("error waiting for node to import new block: %v", err)
 	}
 	// update the chain

cmd/devp2p/internal/ethtest/large.go

@@ -1,18 +1,18 @@
 // Copyright 2020 The go-ethereum Authors
-// This file is part of go-ethereum.
+// This file is part of the go-ethereum library.
 //
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// The 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.
 //
-// go-ethereum is distributed in the hope that it will be useful,
+// 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 General Public License for more details.
+// GNU Lesser General Public License for more details.
 //
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+// 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 ethtest
 

cmd/devp2p/internal/ethtest/snap.go

@@ -1,18 +1,18 @@
-// Copyright 2022 The go-ethereum Authors
-// This file is part of go-ethereum.
+// Copyright 2014 The go-ethereum Authors
+// This file is part of the go-ethereum library.
 //
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// The 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.
 //
-// go-ethereum is distributed in the hope that it will be useful,
+// 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 General Public License for more details.
+// GNU Lesser General Public License for more details.
 //
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+// 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 ethtest
 
@@ -104,7 +104,6 @@ func (s *Suite) TestSnapGetAccountRange(t *utesting.T) {
 		// Max bytes: 0. Expect to deliver one account.
 		{0, root, zero, ffHash, 1, firstKey, firstKey},
 	} {
-		tc := tc
 		if err := s.snapGetAccountRange(t, &tc); err != nil {
 			t.Errorf("test %d \n root: %x\n range: %#x - %#x\n bytes: %d\nfailed: %v", i, tc.root, tc.origin, tc.limit, tc.nBytes, err)
 		}
@@ -195,7 +194,6 @@ func (s *Suite) TestSnapGetStorageRanges(t *utesting.T) {
 			expSlots: 2,
 		},
 	} {
-		tc := tc
 		if err := s.snapGetStorageRanges(t, &tc); err != nil {
 			t.Errorf("test %d \n root: %x\n range: %#x - %#x\n bytes: %d\n #accounts: %d\nfailed: %v",
 				i, tc.root, tc.origin, tc.limit, tc.nBytes, len(tc.accounts), err)
@@ -293,7 +291,6 @@ func (s *Suite) TestSnapGetByteCodes(t *utesting.T) {
 			expHashes: 4,
 		},
 	} {
-		tc := tc
 		if err := s.snapGetByteCodes(t, &tc); err != nil {
 			t.Errorf("test %d \n bytes: %d\n #hashes: %d\nfailed: %v", i, tc.nBytes, len(tc.hashes), err)
 		}
@@ -350,6 +347,7 @@ func hexToCompact(hex []byte) []byte {
 
 // TestSnapTrieNodes various forms of GetTrieNodes requests.
 func (s *Suite) TestSnapTrieNodes(t *utesting.T) {
+
 	key := common.FromHex("0x00bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a")
 	// helper function to iterate the key, and generate the compact-encoded
 	// trie paths along the way.
@@ -438,7 +436,6 @@ func (s *Suite) TestSnapTrieNodes(t *utesting.T) {
 			},
 		},
 	} {
-		tc := tc
 		if err := s.snapGetTrieNodes(t, &tc); err != nil {
 			t.Errorf("test %d \n #hashes %x\n root: %#x\n bytes: %d\nfailed: %v", i, len(tc.expHashes), tc.root, tc.nBytes, err)
 		}
@@ -495,10 +492,10 @@ func (s *Suite) snapGetAccountRange(t *utesting.T, tc *accRangeTest) error {
 	}
 	if len(hashes) > 0 {
 		if exp, got := tc.expFirst, res.Accounts[0].Hash; exp != got {
-			return fmt.Errorf("expected first account %#x, got %#x", exp, got)
+			return fmt.Errorf("expected first account 0x%x, got 0x%x", exp, got)
 		}
 		if exp, got := tc.expLast, res.Accounts[len(res.Accounts)-1].Hash; exp != got {
-			return fmt.Errorf("expected last account %#x, got %#x", exp, got)
+			return fmt.Errorf("expected last account 0x%x, got 0x%x", exp, got)
 		}
 	}
 	// Reconstruct a partial trie from the response and verify it

cmd/devp2p/internal/ethtest/snapTypes.go

@@ -1,19 +1,3 @@
-// Copyright 2022 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
 package ethtest
 
 import "github.com/ethereum/go-ethereum/eth/protocols/snap"
@@ -21,40 +5,32 @@ import "github.com/ethereum/go-ethereum/eth/protocols/snap"
 // GetAccountRange represents an account range query.
 type GetAccountRange snap.GetAccountRangePacket
 
-func (msg GetAccountRange) Code() int     { return 33 }
-func (msg GetAccountRange) ReqID() uint64 { return msg.ID }
+func (g GetAccountRange) Code() int { return 33 }
 
 type AccountRange snap.AccountRangePacket
 
-func (msg AccountRange) Code() int     { return 34 }
-func (msg AccountRange) ReqID() uint64 { return msg.ID }
+func (g AccountRange) Code() int { return 34 }
 
 type GetStorageRanges snap.GetStorageRangesPacket
 
-func (msg GetStorageRanges) Code() int     { return 35 }
-func (msg GetStorageRanges) ReqID() uint64 { return msg.ID }
+func (g GetStorageRanges) Code() int { return 35 }
 
 type StorageRanges snap.StorageRangesPacket
 
-func (msg StorageRanges) Code() int     { return 36 }
-func (msg StorageRanges) ReqID() uint64 { return msg.ID }
+func (g StorageRanges) Code() int { return 36 }
 
 type GetByteCodes snap.GetByteCodesPacket
 
-func (msg GetByteCodes) Code() int     { return 37 }
-func (msg GetByteCodes) ReqID() uint64 { return msg.ID }
+func (g GetByteCodes) Code() int { return 37 }
 
 type ByteCodes snap.ByteCodesPacket
 
-func (msg ByteCodes) Code() int     { return 38 }
-func (msg ByteCodes) ReqID() uint64 { return msg.ID }
+func (g ByteCodes) Code() int { return 38 }
 
 type GetTrieNodes snap.GetTrieNodesPacket
 
-func (msg GetTrieNodes) Code() int     { return 39 }
-func (msg GetTrieNodes) ReqID() uint64 { return msg.ID }
+func (g GetTrieNodes) Code() int { return 39 }
 
 type TrieNodes snap.TrieNodesPacket
 
-func (msg TrieNodes) Code() int     { return 40 }
-func (msg TrieNodes) ReqID() uint64 { return msg.ID }
+func (g TrieNodes) Code() int { return 40 }

cmd/devp2p/internal/ethtest/suite.go

@@ -1,18 +1,18 @@
 // Copyright 2020 The go-ethereum Authors
-// This file is part of go-ethereum.
+// This file is part of the go-ethereum library.
 //
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// The 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.
 //
-// go-ethereum is distributed in the hope that it will be useful,
+// 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 General Public License for more details.
+// GNU Lesser General Public License for more details.
 //
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+// 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 ethtest
 
@@ -49,30 +49,79 @@ func NewSuite(dest *enode.Node, chainfile string, genesisfile string) (*Suite, e
 	}, nil
 }
 
-func (s *Suite) EthTests() []utesting.Test {
+func (s *Suite) AllEthTests() []utesting.Test {
 	return []utesting.Test{
 		// status
-		{Name: "TestStatus", Fn: s.TestStatus},
+		{Name: "TestStatus65", Fn: s.TestStatus65},
+		{Name: "TestStatus66", Fn: s.TestStatus66},
 		// get block headers
-		{Name: "TestGetBlockHeaders", Fn: s.TestGetBlockHeaders},
-		{Name: "TestSimultaneousRequests", Fn: s.TestSimultaneousRequests},
-		{Name: "TestSameRequestID", Fn: s.TestSameRequestID},
-		{Name: "TestZeroRequestID", Fn: s.TestZeroRequestID},
+		{Name: "TestGetBlockHeaders65", Fn: s.TestGetBlockHeaders65},
+		{Name: "TestGetBlockHeaders66", Fn: s.TestGetBlockHeaders66},
+		{Name: "TestSimultaneousRequests66", Fn: s.TestSimultaneousRequests66},
+		{Name: "TestSameRequestID66", Fn: s.TestSameRequestID66},
+		{Name: "TestZeroRequestID66", Fn: s.TestZeroRequestID66},
 		// get block bodies
-		{Name: "TestGetBlockBodies", Fn: s.TestGetBlockBodies},
+		{Name: "TestGetBlockBodies65", Fn: s.TestGetBlockBodies65},
+		{Name: "TestGetBlockBodies66", Fn: s.TestGetBlockBodies66},
 		// broadcast
-		{Name: "TestBroadcast", Fn: s.TestBroadcast},
-		{Name: "TestLargeAnnounce", Fn: s.TestLargeAnnounce},
-		{Name: "TestOldAnnounce", Fn: s.TestOldAnnounce},
-		{Name: "TestBlockHashAnnounce", Fn: s.TestBlockHashAnnounce},
+		{Name: "TestBroadcast65", Fn: s.TestBroadcast65},
+		{Name: "TestBroadcast66", Fn: s.TestBroadcast66},
+		{Name: "TestLargeAnnounce65", Fn: s.TestLargeAnnounce65},
+		{Name: "TestLargeAnnounce66", Fn: s.TestLargeAnnounce66},
+		{Name: "TestOldAnnounce65", Fn: s.TestOldAnnounce65},
+		{Name: "TestOldAnnounce66", Fn: s.TestOldAnnounce66},
+		{Name: "TestBlockHashAnnounce65", Fn: s.TestBlockHashAnnounce65},
+		{Name: "TestBlockHashAnnounce66", Fn: s.TestBlockHashAnnounce66},
 		// malicious handshakes + status
-		{Name: "TestMaliciousHandshake", Fn: s.TestMaliciousHandshake},
-		{Name: "TestMaliciousStatus", Fn: s.TestMaliciousStatus},
+		{Name: "TestMaliciousHandshake65", Fn: s.TestMaliciousHandshake65},
+		{Name: "TestMaliciousStatus65", Fn: s.TestMaliciousStatus65},
+		{Name: "TestMaliciousHandshake66", Fn: s.TestMaliciousHandshake66},
+		{Name: "TestMaliciousStatus66", Fn: s.TestMaliciousStatus66},
 		// test transactions
-		{Name: "TestTransaction", Fn: s.TestTransaction},
-		{Name: "TestMaliciousTx", Fn: s.TestMaliciousTx},
-		{Name: "TestLargeTxRequest", Fn: s.TestLargeTxRequest},
-		{Name: "TestNewPooledTxs", Fn: s.TestNewPooledTxs},
+		{Name: "TestTransaction65", Fn: s.TestTransaction65},
+		{Name: "TestTransaction66", Fn: s.TestTransaction66},
+		{Name: "TestMaliciousTx65", Fn: s.TestMaliciousTx65},
+		{Name: "TestMaliciousTx66", Fn: s.TestMaliciousTx66},
+		{Name: "TestLargeTxRequest66", Fn: s.TestLargeTxRequest66},
+		{Name: "TestNewPooledTxs66", Fn: s.TestNewPooledTxs66},
+	}
+}
+
+func (s *Suite) EthTests() []utesting.Test {
+	return []utesting.Test{
+		{Name: "TestStatus65", Fn: s.TestStatus65},
+		{Name: "TestGetBlockHeaders65", Fn: s.TestGetBlockHeaders65},
+		{Name: "TestGetBlockBodies65", Fn: s.TestGetBlockBodies65},
+		{Name: "TestBroadcast65", Fn: s.TestBroadcast65},
+		{Name: "TestLargeAnnounce65", Fn: s.TestLargeAnnounce65},
+		{Name: "TestOldAnnounce65", Fn: s.TestOldAnnounce65},
+		{Name: "TestBlockHashAnnounce65", Fn: s.TestBlockHashAnnounce65},
+		{Name: "TestMaliciousHandshake65", Fn: s.TestMaliciousHandshake65},
+		{Name: "TestMaliciousStatus65", Fn: s.TestMaliciousStatus65},
+		{Name: "TestTransaction65", Fn: s.TestTransaction65},
+		{Name: "TestMaliciousTx65", Fn: s.TestMaliciousTx65},
+	}
+}
+
+func (s *Suite) Eth66Tests() []utesting.Test {
+	return []utesting.Test{
+		// only proceed with eth66 test suite if node supports eth 66 protocol
+		{Name: "TestStatus66", Fn: s.TestStatus66},
+		{Name: "TestGetBlockHeaders66", Fn: s.TestGetBlockHeaders66},
+		{Name: "TestSimultaneousRequests66", Fn: s.TestSimultaneousRequests66},
+		{Name: "TestSameRequestID66", Fn: s.TestSameRequestID66},
+		{Name: "TestZeroRequestID66", Fn: s.TestZeroRequestID66},
+		{Name: "TestGetBlockBodies66", Fn: s.TestGetBlockBodies66},
+		{Name: "TestBroadcast66", Fn: s.TestBroadcast66},
+		{Name: "TestLargeAnnounce66", Fn: s.TestLargeAnnounce66},
+		{Name: "TestOldAnnounce66", Fn: s.TestOldAnnounce66},
+		{Name: "TestBlockHashAnnounce66", Fn: s.TestBlockHashAnnounce66},
+		{Name: "TestMaliciousHandshake66", Fn: s.TestMaliciousHandshake66},
+		{Name: "TestMaliciousStatus66", Fn: s.TestMaliciousStatus66},
+		{Name: "TestTransaction66", Fn: s.TestTransaction66},
+		{Name: "TestMaliciousTx66", Fn: s.TestMaliciousTx66},
+		{Name: "TestLargeTxRequest66", Fn: s.TestLargeTxRequest66},
+		{Name: "TestNewPooledTxs66", Fn: s.TestNewPooledTxs66},
 	}
 }
 
@@ -86,9 +135,14 @@ func (s *Suite) SnapTests() []utesting.Test {
 	}
 }
 
-// TestStatus attempts to connect to the given node and exchange
-// a status message with it on the eth protocol.
-func (s *Suite) TestStatus(t *utesting.T) {
+var (
+	eth66 = true  // indicates whether suite should negotiate eth66 connection
+	eth65 = false // indicates whether suite should negotiate eth65 connection or below.
+)
+
+// TestStatus65 attempts to connect to the given node and exchange
+// a status message with it.
+func (s *Suite) TestStatus65(t *utesting.T) {
 	conn, err := s.dial()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
@@ -99,32 +153,79 @@ func (s *Suite) TestStatus(t *utesting.T) {
 	}
 }
 
-// TestGetBlockHeaders tests whether the given node can respond to
-// an eth `GetBlockHeaders` request and that the response is accurate.
-func (s *Suite) TestGetBlockHeaders(t *utesting.T) {
+// TestStatus66 attempts to connect to the given node and exchange
+// a status message with it on the eth66 protocol.
+func (s *Suite) TestStatus66(t *utesting.T) {
+	conn, err := s.dial66()
+	if err != nil {
+		t.Fatalf("dial failed: %v", err)
+	}
+	defer conn.Close()
+	if err := conn.peer(s.chain, nil); err != nil {
+		t.Fatalf("peering failed: %v", err)
+	}
+}
+
+// TestGetBlockHeaders65 tests whether the given node can respond to
+// a `GetBlockHeaders` request accurately.
+func (s *Suite) TestGetBlockHeaders65(t *utesting.T) {
 	conn, err := s.dial()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
 	}
 	defer conn.Close()
+	if err := conn.peer(s.chain, nil); err != nil {
+		t.Fatalf("handshake(s) failed: %v", err)
+	}
+	// write request
+	req := &GetBlockHeaders{
+		Origin: eth.HashOrNumber{
+			Hash: s.chain.blocks[1].Hash(),
+		},
+		Amount:  2,
+		Skip:    1,
+		Reverse: false,
+	}
+	headers, err := conn.headersRequest(req, s.chain, eth65, 0)
+	if err != nil {
+		t.Fatalf("GetBlockHeaders request failed: %v", err)
+	}
+	// check for correct headers
+	expected, err := s.chain.GetHeaders(*req)
+	if err != nil {
+		t.Fatalf("failed to get headers for given request: %v", err)
+	}
+	if !headersMatch(expected, headers) {
+		t.Fatalf("header mismatch: \nexpected %v \ngot %v", expected, headers)
+	}
+}
+
+// TestGetBlockHeaders66 tests whether the given node can respond to
+// an eth66 `GetBlockHeaders` request and that the response is accurate.
+func (s *Suite) TestGetBlockHeaders66(t *utesting.T) {
+	conn, err := s.dial66()
+	if err != nil {
+		t.Fatalf("dial failed: %v", err)
+	}
+	defer conn.Close()
 	if err = conn.peer(s.chain, nil); err != nil {
 		t.Fatalf("peering failed: %v", err)
 	}
 	// write request
 	req := &GetBlockHeaders{
-		GetBlockHeadersPacket: &eth.GetBlockHeadersPacket{
-			Origin:  eth.HashOrNumber{Hash: s.chain.blocks[1].Hash()},
-			Amount:  2,
-			Skip:    1,
-			Reverse: false,
+		Origin: eth.HashOrNumber{
+			Hash: s.chain.blocks[1].Hash(),
 		},
+		Amount:  2,
+		Skip:    1,
+		Reverse: false,
 	}
-	headers, err := conn.headersRequest(req, s.chain, 33)
+	headers, err := conn.headersRequest(req, s.chain, eth66, 33)
 	if err != nil {
 		t.Fatalf("could not get block headers: %v", err)
 	}
 	// check for correct headers
-	expected, err := s.chain.GetHeaders(req)
+	expected, err := s.chain.GetHeaders(*req)
 	if err != nil {
 		t.Fatalf("failed to get headers for given request: %v", err)
 	}
@@ -133,12 +234,12 @@ func (s *Suite) TestGetBlockHeaders(t *utesting.T) {
 	}
 }
 
-// TestSimultaneousRequests sends two simultaneous `GetBlockHeader` requests from
+// TestSimultaneousRequests66 sends two simultaneous `GetBlockHeader` requests from
 // the same connection with different request IDs and checks to make sure the node
 // responds with the correct headers per request.
-func (s *Suite) TestSimultaneousRequests(t *utesting.T) {
+func (s *Suite) TestSimultaneousRequests66(t *utesting.T) {
 	// create a connection
-	conn, err := s.dial()
+	conn, err := s.dial66()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
 	}
@@ -146,9 +247,8 @@ func (s *Suite) TestSimultaneousRequests(t *utesting.T) {
 	if err := conn.peer(s.chain, nil); err != nil {
 		t.Fatalf("peering failed: %v", err)
 	}
-
 	// create two requests
-	req1 := &GetBlockHeaders{
+	req1 := &eth.GetBlockHeadersPacket66{
 		RequestId: uint64(111),
 		GetBlockHeadersPacket: &eth.GetBlockHeadersPacket{
 			Origin: eth.HashOrNumber{
@@ -159,7 +259,7 @@ func (s *Suite) TestSimultaneousRequests(t *utesting.T) {
 			Reverse: false,
 		},
 	}
-	req2 := &GetBlockHeaders{
+	req2 := &eth.GetBlockHeadersPacket66{
 		RequestId: uint64(222),
 		GetBlockHeadersPacket: &eth.GetBlockHeadersPacket{
 			Origin: eth.HashOrNumber{
@@ -170,49 +270,46 @@ func (s *Suite) TestSimultaneousRequests(t *utesting.T) {
 			Reverse: false,
 		},
 	}
-
 	// write the first request
-	if err := conn.Write(req1); err != nil {
+	if err := conn.Write66(req1, GetBlockHeaders{}.Code()); err != nil {
 		t.Fatalf("failed to write to connection: %v", err)
 	}
 	// write the second request
-	if err := conn.Write(req2); err != nil {
+	if err := conn.Write66(req2, GetBlockHeaders{}.Code()); err != nil {
 		t.Fatalf("failed to write to connection: %v", err)
 	}
-
 	// wait for responses
 	msg := conn.waitForResponse(s.chain, timeout, req1.RequestId)
-	headers1, ok := msg.(*BlockHeaders)
+	headers1, ok := msg.(BlockHeaders)
 	if !ok {
 		t.Fatalf("unexpected %s", pretty.Sdump(msg))
 	}
 	msg = conn.waitForResponse(s.chain, timeout, req2.RequestId)
-	headers2, ok := msg.(*BlockHeaders)
+	headers2, ok := msg.(BlockHeaders)
 	if !ok {
 		t.Fatalf("unexpected %s", pretty.Sdump(msg))
 	}
-
 	// check received headers for accuracy
-	expected1, err := s.chain.GetHeaders(req1)
+	expected1, err := s.chain.GetHeaders(GetBlockHeaders(*req1.GetBlockHeadersPacket))
 	if err != nil {
 		t.Fatalf("failed to get expected headers for request 1: %v", err)
 	}
-	expected2, err := s.chain.GetHeaders(req2)
+	expected2, err := s.chain.GetHeaders(GetBlockHeaders(*req2.GetBlockHeadersPacket))
 	if err != nil {
 		t.Fatalf("failed to get expected headers for request 2: %v", err)
 	}
-	if !headersMatch(expected1, headers1.BlockHeadersPacket) {
+	if !headersMatch(expected1, headers1) {
 		t.Fatalf("header mismatch: \nexpected %v \ngot %v", expected1, headers1)
 	}
-	if !headersMatch(expected2, headers2.BlockHeadersPacket) {
+	if !headersMatch(expected2, headers2) {
 		t.Fatalf("header mismatch: \nexpected %v \ngot %v", expected2, headers2)
 	}
 }
 
-// TestSameRequestID sends two requests with the same request ID to a
+// TestSameRequestID66 sends two requests with the same request ID to a
 // single node.
-func (s *Suite) TestSameRequestID(t *utesting.T) {
-	conn, err := s.dial()
+func (s *Suite) TestSameRequestID66(t *utesting.T) {
+	conn, err := s.dial66()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
 	}
@@ -222,7 +319,7 @@ func (s *Suite) TestSameRequestID(t *utesting.T) {
 	}
 	// create requests
 	reqID := uint64(1234)
-	request1 := &GetBlockHeaders{
+	request1 := &eth.GetBlockHeadersPacket66{
 		RequestId: reqID,
 		GetBlockHeadersPacket: &eth.GetBlockHeadersPacket{
 			Origin: eth.HashOrNumber{
@@ -231,7 +328,7 @@ func (s *Suite) TestSameRequestID(t *utesting.T) {
 			Amount: 2,
 		},
 	}
-	request2 := &GetBlockHeaders{
+	request2 := &eth.GetBlockHeadersPacket66{
 		RequestId: reqID,
 		GetBlockHeadersPacket: &eth.GetBlockHeadersPacket{
 			Origin: eth.HashOrNumber{
@@ -240,48 +337,45 @@ func (s *Suite) TestSameRequestID(t *utesting.T) {
 			Amount: 2,
 		},
 	}
-
 	// write the requests
-	if err = conn.Write(request1); err != nil {
+	if err = conn.Write66(request1, GetBlockHeaders{}.Code()); err != nil {
 		t.Fatalf("failed to write to connection: %v", err)
 	}
-	if err = conn.Write(request2); err != nil {
+	if err = conn.Write66(request2, GetBlockHeaders{}.Code()); err != nil {
 		t.Fatalf("failed to write to connection: %v", err)
 	}
-
 	// wait for responses
 	msg := conn.waitForResponse(s.chain, timeout, reqID)
-	headers1, ok := msg.(*BlockHeaders)
+	headers1, ok := msg.(BlockHeaders)
 	if !ok {
 		t.Fatalf("unexpected %s", pretty.Sdump(msg))
 	}
 	msg = conn.waitForResponse(s.chain, timeout, reqID)
-	headers2, ok := msg.(*BlockHeaders)
+	headers2, ok := msg.(BlockHeaders)
 	if !ok {
 		t.Fatalf("unexpected %s", pretty.Sdump(msg))
 	}
-
 	// check if headers match
-	expected1, err := s.chain.GetHeaders(request1)
+	expected1, err := s.chain.GetHeaders(GetBlockHeaders(*request1.GetBlockHeadersPacket))
 	if err != nil {
 		t.Fatalf("failed to get expected block headers: %v", err)
 	}
-	expected2, err := s.chain.GetHeaders(request2)
+	expected2, err := s.chain.GetHeaders(GetBlockHeaders(*request2.GetBlockHeadersPacket))
 	if err != nil {
 		t.Fatalf("failed to get expected block headers: %v", err)
 	}
-	if !headersMatch(expected1, headers1.BlockHeadersPacket) {
+	if !headersMatch(expected1, headers1) {
 		t.Fatalf("header mismatch: \nexpected %v \ngot %v", expected1, headers1)
 	}
-	if !headersMatch(expected2, headers2.BlockHeadersPacket) {
+	if !headersMatch(expected2, headers2) {
 		t.Fatalf("header mismatch: \nexpected %v \ngot %v", expected2, headers2)
 	}
 }
 
-// TestZeroRequestID checks that a message with a request ID of zero is still handled
+// TestZeroRequestID_66 checks that a message with a request ID of zero is still handled
 // by the node.
-func (s *Suite) TestZeroRequestID(t *utesting.T) {
-	conn, err := s.dial()
+func (s *Suite) TestZeroRequestID66(t *utesting.T) {
+	conn, err := s.dial66()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
 	}
@@ -290,16 +384,16 @@ func (s *Suite) TestZeroRequestID(t *utesting.T) {
 		t.Fatalf("peering failed: %v", err)
 	}
 	req := &GetBlockHeaders{
-		GetBlockHeadersPacket: &eth.GetBlockHeadersPacket{
-			Origin: eth.HashOrNumber{Number: 0},
-			Amount: 2,
+		Origin: eth.HashOrNumber{
+			Number: 0,
 		},
+		Amount: 2,
 	}
-	headers, err := conn.headersRequest(req, s.chain, 0)
+	headers, err := conn.headersRequest(req, s.chain, eth66, 0)
 	if err != nil {
 		t.Fatalf("failed to get block headers: %v", err)
 	}
-	expected, err := s.chain.GetHeaders(req)
+	expected, err := s.chain.GetHeaders(*req)
 	if err != nil {
 		t.Fatalf("failed to get expected block headers: %v", err)
 	}
@@ -308,9 +402,9 @@ func (s *Suite) TestZeroRequestID(t *utesting.T) {
 	}
 }
 
-// TestGetBlockBodies tests whether the given node can respond to
+// TestGetBlockBodies65 tests whether the given node can respond to
 // a `GetBlockBodies` request and that the response is accurate.
-func (s *Suite) TestGetBlockBodies(t *utesting.T) {
+func (s *Suite) TestGetBlockBodies65(t *utesting.T) {
 	conn, err := s.dial()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
@@ -321,39 +415,126 @@ func (s *Suite) TestGetBlockBodies(t *utesting.T) {
 	}
 	// create block bodies request
 	req := &GetBlockBodies{
+		s.chain.blocks[54].Hash(),
+		s.chain.blocks[75].Hash(),
+	}
+	if err := conn.Write(req); err != nil {
+		t.Fatalf("could not write to connection: %v", err)
+	}
+	// wait for response
+	switch msg := conn.readAndServe(s.chain, timeout).(type) {
+	case *BlockBodies:
+		t.Logf("received %d block bodies", len(*msg))
+		if len(*msg) != len(*req) {
+			t.Fatalf("wrong bodies in response: expected %d bodies, "+
+				"got %d", len(*req), len(*msg))
+		}
+	default:
+		t.Fatalf("unexpected: %s", pretty.Sdump(msg))
+	}
+}
+
+// TestGetBlockBodies66 tests whether the given node can respond to
+// a `GetBlockBodies` request and that the response is accurate over
+// the eth66 protocol.
+func (s *Suite) TestGetBlockBodies66(t *utesting.T) {
+	conn, err := s.dial66()
+	if err != nil {
+		t.Fatalf("dial failed: %v", err)
+	}
+	defer conn.Close()
+	if err := conn.peer(s.chain, nil); err != nil {
+		t.Fatalf("peering failed: %v", err)
+	}
+	// create block bodies request
+	req := &eth.GetBlockBodiesPacket66{
 		RequestId: uint64(55),
 		GetBlockBodiesPacket: eth.GetBlockBodiesPacket{
 			s.chain.blocks[54].Hash(),
 			s.chain.blocks[75].Hash(),
 		},
 	}
-	if err := conn.Write(req); err != nil {
+	if err := conn.Write66(req, GetBlockBodies{}.Code()); err != nil {
 		t.Fatalf("could not write to connection: %v", err)
 	}
 	// wait for block bodies response
 	msg := conn.waitForResponse(s.chain, timeout, req.RequestId)
-	resp, ok := msg.(*BlockBodies)
+	blockBodies, ok := msg.(BlockBodies)
 	if !ok {
 		t.Fatalf("unexpected: %s", pretty.Sdump(msg))
 	}
-	bodies := resp.BlockBodiesPacket
-	t.Logf("received %d block bodies", len(bodies))
-	if len(bodies) != len(req.GetBlockBodiesPacket) {
+	t.Logf("received %d block bodies", len(blockBodies))
+	if len(blockBodies) != len(req.GetBlockBodiesPacket) {
 		t.Fatalf("wrong bodies in response: expected %d bodies, "+
-			"got %d", len(req.GetBlockBodiesPacket), len(bodies))
+			"got %d", len(req.GetBlockBodiesPacket), len(blockBodies))
 	}
 }
 
-// TestBroadcast tests whether a block announcement is correctly
-// propagated to the node's peers.
-func (s *Suite) TestBroadcast(t *utesting.T) {
-	if err := s.sendNextBlock(); err != nil {
+// TestBroadcast65 tests whether a block announcement is correctly
+// propagated to the given node's peer(s).
+func (s *Suite) TestBroadcast65(t *utesting.T) {
+	if err := s.sendNextBlock(eth65); err != nil {
 		t.Fatalf("block broadcast failed: %v", err)
 	}
 }
 
-// TestLargeAnnounce tests the announcement mechanism with a large block.
-func (s *Suite) TestLargeAnnounce(t *utesting.T) {
+// TestBroadcast66 tests whether a block announcement is correctly
+// propagated to the given node's peer(s) on the eth66 protocol.
+func (s *Suite) TestBroadcast66(t *utesting.T) {
+	if err := s.sendNextBlock(eth66); err != nil {
+		t.Fatalf("block broadcast failed: %v", err)
+	}
+}
+
+// TestLargeAnnounce65 tests the announcement mechanism with a large block.
+func (s *Suite) TestLargeAnnounce65(t *utesting.T) {
+	nextBlock := len(s.chain.blocks)
+	blocks := []*NewBlock{
+		{
+			Block: largeBlock(),
+			TD:    s.fullChain.TotalDifficultyAt(nextBlock),
+		},
+		{
+			Block: s.fullChain.blocks[nextBlock],
+			TD:    largeNumber(2),
+		},
+		{
+			Block: largeBlock(),
+			TD:    largeNumber(2),
+		},
+	}
+
+	for i, blockAnnouncement := range blocks {
+		t.Logf("Testing malicious announcement: %v\n", i)
+		conn, err := s.dial()
+		if err != nil {
+			t.Fatalf("dial failed: %v", err)
+		}
+		if err = conn.peer(s.chain, nil); err != nil {
+			t.Fatalf("peering failed: %v", err)
+		}
+		if err = conn.Write(blockAnnouncement); err != nil {
+			t.Fatalf("could not write to connection: %v", err)
+		}
+		// Invalid announcement, check that peer disconnected
+		switch msg := conn.readAndServe(s.chain, time.Second*8).(type) {
+		case *Disconnect:
+		case *Error:
+			break
+		default:
+			t.Fatalf("unexpected: %s wanted disconnect", pretty.Sdump(msg))
+		}
+		conn.Close()
+	}
+	// Test the last block as a valid block
+	if err := s.sendNextBlock(eth65); err != nil {
+		t.Fatalf("failed to broadcast next block: %v", err)
+	}
+}
+
+// TestLargeAnnounce66 tests the announcement mechanism with a large
+// block over the eth66 protocol.
+func (s *Suite) TestLargeAnnounce66(t *utesting.T) {
 	nextBlock := len(s.chain.blocks)
 	blocks := []*NewBlock{
 		{
@@ -372,7 +553,7 @@ func (s *Suite) TestLargeAnnounce(t *utesting.T) {
 
 	for i, blockAnnouncement := range blocks[0:3] {
 		t.Logf("Testing malicious announcement: %v\n", i)
-		conn, err := s.dial()
+		conn, err := s.dial66()
 		if err != nil {
 			t.Fatalf("dial failed: %v", err)
 		}
@@ -383,7 +564,7 @@ func (s *Suite) TestLargeAnnounce(t *utesting.T) {
 			t.Fatalf("could not write to connection: %v", err)
 		}
 		// Invalid announcement, check that peer disconnected
-		switch msg := conn.readAndServe(s.chain, 8*time.Second).(type) {
+		switch msg := conn.readAndServe(s.chain, time.Second*8).(type) {
 		case *Disconnect:
 		case *Error:
 			break
@@ -393,35 +574,58 @@ func (s *Suite) TestLargeAnnounce(t *utesting.T) {
 		conn.Close()
 	}
 	// Test the last block as a valid block
-	if err := s.sendNextBlock(); err != nil {
+	if err := s.sendNextBlock(eth66); err != nil {
 		t.Fatalf("failed to broadcast next block: %v", err)
 	}
 }
 
-// TestOldAnnounce tests the announcement mechanism with an old block.
-func (s *Suite) TestOldAnnounce(t *utesting.T) {
-	if err := s.oldAnnounce(); err != nil {
+// TestOldAnnounce65 tests the announcement mechanism with an old block.
+func (s *Suite) TestOldAnnounce65(t *utesting.T) {
+	if err := s.oldAnnounce(eth65); err != nil {
 		t.Fatal(err)
 	}
 }
 
-// TestBlockHashAnnounce sends a new block hash announcement and expects
+// TestOldAnnounce66 tests the announcement mechanism with an old block,
+// over the eth66 protocol.
+func (s *Suite) TestOldAnnounce66(t *utesting.T) {
+	if err := s.oldAnnounce(eth66); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// TestBlockHashAnnounce65 sends a new block hash announcement and expects
 // the node to perform a `GetBlockHeaders` request.
-func (s *Suite) TestBlockHashAnnounce(t *utesting.T) {
-	if err := s.hashAnnounce(); err != nil {
+func (s *Suite) TestBlockHashAnnounce65(t *utesting.T) {
+	if err := s.hashAnnounce(eth65); err != nil {
 		t.Fatalf("block hash announcement failed: %v", err)
 	}
 }
 
-// TestMaliciousHandshake tries to send malicious data during the handshake.
-func (s *Suite) TestMaliciousHandshake(t *utesting.T) {
-	if err := s.maliciousHandshakes(t); err != nil {
+// TestBlockHashAnnounce66 sends a new block hash announcement and expects
+// the node to perform a `GetBlockHeaders` request.
+func (s *Suite) TestBlockHashAnnounce66(t *utesting.T) {
+	if err := s.hashAnnounce(eth66); err != nil {
+		t.Fatalf("block hash announcement failed: %v", err)
+	}
+}
+
+// TestMaliciousHandshake65 tries to send malicious data during the handshake.
+func (s *Suite) TestMaliciousHandshake65(t *utesting.T) {
+	if err := s.maliciousHandshakes(t, eth65); err != nil {
 		t.Fatal(err)
 	}
 }
 
-// TestMaliciousStatus sends a status package with a large total difficulty.
-func (s *Suite) TestMaliciousStatus(t *utesting.T) {
+// TestMaliciousHandshake66 tries to send malicious data during the handshake.
+func (s *Suite) TestMaliciousHandshake66(t *utesting.T) {
+	if err := s.maliciousHandshakes(t, eth66); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// TestMaliciousStatus65 sends a status package with a large total difficulty.
+func (s *Suite) TestMaliciousStatus65(t *utesting.T) {
 	conn, err := s.dial()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
@@ -433,28 +637,58 @@ func (s *Suite) TestMaliciousStatus(t *utesting.T) {
 	}
 }
 
-// TestTransaction sends a valid transaction to the node and
+// TestMaliciousStatus66 sends a status package with a large total
+// difficulty over the eth66 protocol.
+func (s *Suite) TestMaliciousStatus66(t *utesting.T) {
+	conn, err := s.dial66()
+	if err != nil {
+		t.Fatalf("dial failed: %v", err)
+	}
+	defer conn.Close()
+
+	if err := s.maliciousStatus(conn); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// TestTransaction65 sends a valid transaction to the node and
 // checks if the transaction gets propagated.
-func (s *Suite) TestTransaction(t *utesting.T) {
-	if err := s.sendSuccessfulTxs(t); err != nil {
+func (s *Suite) TestTransaction65(t *utesting.T) {
+	if err := s.sendSuccessfulTxs(t, eth65); err != nil {
 		t.Fatal(err)
 	}
 }
 
-// TestMaliciousTx sends several invalid transactions and tests whether
+// TestTransaction66 sends a valid transaction to the node and
+// checks if the transaction gets propagated.
+func (s *Suite) TestTransaction66(t *utesting.T) {
+	if err := s.sendSuccessfulTxs(t, eth66); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// TestMaliciousTx65 sends several invalid transactions and tests whether
 // the node will propagate them.
-func (s *Suite) TestMaliciousTx(t *utesting.T) {
-	if err := s.sendMaliciousTxs(t); err != nil {
+func (s *Suite) TestMaliciousTx65(t *utesting.T) {
+	if err := s.sendMaliciousTxs(t, eth65); err != nil {
 		t.Fatal(err)
 	}
 }
 
-// TestLargeTxRequest tests whether a node can fulfill a large GetPooledTransactions
+// TestMaliciousTx66 sends several invalid transactions and tests whether
+// the node will propagate them.
+func (s *Suite) TestMaliciousTx66(t *utesting.T) {
+	if err := s.sendMaliciousTxs(t, eth66); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// TestLargeTxRequest66 tests whether a node can fulfill a large GetPooledTransactions
 // request.
-func (s *Suite) TestLargeTxRequest(t *utesting.T) {
+func (s *Suite) TestLargeTxRequest66(t *utesting.T) {
 	// send the next block to ensure the node is no longer syncing and
 	// is able to accept txs
-	if err := s.sendNextBlock(); err != nil {
+	if err := s.sendNextBlock(eth66); err != nil {
 		t.Fatalf("failed to send next block: %v", err)
 	}
 	// send 2000 transactions to the node
@@ -467,7 +701,7 @@ func (s *Suite) TestLargeTxRequest(t *utesting.T) {
 	}
 	// set up connection to receive to ensure node is peered with the receiving connection
 	// before tx request is sent
-	conn, err := s.dial()
+	conn, err := s.dial66()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
 	}
@@ -480,17 +714,17 @@ func (s *Suite) TestLargeTxRequest(t *utesting.T) {
 	for _, hash := range hashMap {
 		hashes = append(hashes, hash)
 	}
-	getTxReq := &GetPooledTransactions{
+	getTxReq := &eth.GetPooledTransactionsPacket66{
 		RequestId:                   1234,
 		GetPooledTransactionsPacket: hashes,
 	}
-	if err = conn.Write(getTxReq); err != nil {
+	if err = conn.Write66(getTxReq, GetPooledTransactions{}.Code()); err != nil {
 		t.Fatalf("could not write to conn: %v", err)
 	}
 	// check that all received transactions match those that were sent to node
 	switch msg := conn.waitForResponse(s.chain, timeout, getTxReq.RequestId).(type) {
-	case *PooledTransactions:
-		for _, gotTx := range msg.PooledTransactionsPacket {
+	case PooledTransactions:
+		for _, gotTx := range msg {
 			if _, exists := hashMap[gotTx.Hash()]; !exists {
 				t.Fatalf("unexpected tx received: %v", gotTx.Hash())
 			}
@@ -500,12 +734,12 @@ func (s *Suite) TestLargeTxRequest(t *utesting.T) {
 	}
 }
 
-// TestNewPooledTxs tests whether a node will do a GetPooledTransactions
+// TestNewPooledTxs_66 tests whether a node will do a GetPooledTransactions
 // request upon receiving a NewPooledTransactionHashes announcement.
-func (s *Suite) TestNewPooledTxs(t *utesting.T) {
+func (s *Suite) TestNewPooledTxs66(t *utesting.T) {
 	// send the next block to ensure the node is no longer syncing and
 	// is able to accept txs
-	if err := s.sendNextBlock(); err != nil {
+	if err := s.sendNextBlock(eth66); err != nil {
 		t.Fatalf("failed to send next block: %v", err)
 	}
 
@@ -523,7 +757,7 @@ func (s *Suite) TestNewPooledTxs(t *utesting.T) {
 	announce := NewPooledTransactionHashes(hashes)
 
 	// send announcement
-	conn, err := s.dial()
+	conn, err := s.dial66()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
 	}
@@ -537,11 +771,11 @@ func (s *Suite) TestNewPooledTxs(t *utesting.T) {
 
 	// wait for GetPooledTxs request
 	for {
-		msg := conn.readAndServe(s.chain, timeout)
+		_, msg := conn.readAndServe66(s.chain, timeout)
 		switch msg := msg.(type) {
-		case *GetPooledTransactions:
-			if len(msg.GetPooledTransactionsPacket) != len(hashes) {
-				t.Fatalf("unexpected number of txs requested: wanted %d, got %d", len(hashes), len(msg.GetPooledTransactionsPacket))
+		case GetPooledTransactions:
+			if len(msg) != len(hashes) {
+				t.Fatalf("unexpected number of txs requested: wanted %d, got %d", len(hashes), len(msg))
 			}
 			return
 		// ignore propagated txs from previous tests

cmd/devp2p/internal/ethtest/suite_test.go

@@ -1,18 +1,18 @@
-// Copyright 2021 The go-ethereum Authors
-// This file is part of go-ethereum.
+// Copyright 2020 The go-ethereum Authors
+// This file is part of the go-ethereum library.
 //
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// The 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.
 //
-// go-ethereum is distributed in the hope that it will be useful,
+// 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 General Public License for more details.
+// GNU Lesser General Public License for more details.
 //
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+// 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 ethtest
 
@@ -45,7 +45,7 @@ func TestEthSuite(t *testing.T) {
 	if err != nil {
 		t.Fatalf("could not create new test suite: %v", err)
 	}
-	for _, test := range suite.EthTests() {
+	for _, test := range suite.Eth66Tests() {
 		t.Run(test.Name, func(t *testing.T) {
 			result := utesting.RunTAP([]utesting.Test{{Name: test.Name, Fn: test.Fn}}, os.Stdout)
 			if result[0].Failed {

cmd/devp2p/internal/ethtest/transaction.go

@@ -1,18 +1,18 @@
 // Copyright 2020 The go-ethereum Authors
-// This file is part of go-ethereum.
+// This file is part of the go-ethereum library.
 //
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// The 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.
 //
-// go-ethereum is distributed in the hope that it will be useful,
+// 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 General Public License for more details.
+// GNU Lesser General Public License for more details.
 //
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+// 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 ethtest
 
@@ -32,7 +32,7 @@ import (
 //var faucetAddr = common.HexToAddress("0x71562b71999873DB5b286dF957af199Ec94617F7")
 var faucetKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 
-func (s *Suite) sendSuccessfulTxs(t *utesting.T) error {
+func (s *Suite) sendSuccessfulTxs(t *utesting.T, isEth66 bool) error {
 	tests := []*types.Transaction{
 		getNextTxFromChain(s),
 		unknownTx(s),
@@ -48,15 +48,15 @@ func (s *Suite) sendSuccessfulTxs(t *utesting.T) error {
 			prevTx = tests[i-1]
 		}
 		// write tx to connection
-		if err := sendSuccessfulTx(s, tx, prevTx); err != nil {
+		if err := sendSuccessfulTx(s, tx, prevTx, isEth66); err != nil {
 			return fmt.Errorf("send successful tx test failed: %v", err)
 		}
 	}
 	return nil
 }
 
-func sendSuccessfulTx(s *Suite, tx *types.Transaction, prevTx *types.Transaction) error {
-	sendConn, recvConn, err := s.createSendAndRecvConns()
+func sendSuccessfulTx(s *Suite, tx *types.Transaction, prevTx *types.Transaction, isEth66 bool) error {
+	sendConn, recvConn, err := s.createSendAndRecvConns(isEth66)
 	if err != nil {
 		return err
 	}
@@ -73,10 +73,8 @@ func sendSuccessfulTx(s *Suite, tx *types.Transaction, prevTx *types.Transaction
 	if err = recvConn.peer(s.chain, nil); err != nil {
 		return fmt.Errorf("peering failed: %v", err)
 	}
-
 	// update last nonce seen
 	nonce = tx.Nonce()
-
 	// Wait for the transaction announcement
 	for {
 		switch msg := recvConn.readAndServe(s.chain, timeout).(type) {
@@ -116,7 +114,7 @@ func sendSuccessfulTx(s *Suite, tx *types.Transaction, prevTx *types.Transaction
 	}
 }
 
-func (s *Suite) sendMaliciousTxs(t *utesting.T) error {
+func (s *Suite) sendMaliciousTxs(t *utesting.T, isEth66 bool) error {
 	badTxs := []*types.Transaction{
 		getOldTxFromChain(s),
 		invalidNonceTx(s),
@@ -124,9 +122,16 @@ func (s *Suite) sendMaliciousTxs(t *utesting.T) error {
 		hugeGasPrice(s),
 		hugeData(s),
 	}
-
 	// setup receiving connection before sending malicious txs
-	recvConn, err := s.dial()
+	var (
+		recvConn *Conn
+		err      error
+	)
+	if isEth66 {
+		recvConn, err = s.dial66()
+	} else {
+		recvConn, err = s.dial()
+	}
 	if err != nil {
 		return fmt.Errorf("dial failed: %v", err)
 	}
@@ -134,10 +139,9 @@ func (s *Suite) sendMaliciousTxs(t *utesting.T) error {
 	if err = recvConn.peer(s.chain, nil); err != nil {
 		return fmt.Errorf("peering failed: %v", err)
 	}
-
 	for i, tx := range badTxs {
 		t.Logf("Testing malicious tx propagation: %v\n", i)
-		if err = sendMaliciousTx(s, tx); err != nil {
+		if err = sendMaliciousTx(s, tx, isEth66); err != nil {
 			return fmt.Errorf("malicious tx test failed:\ntx: %v\nerror: %v", tx, err)
 		}
 	}
@@ -145,8 +149,17 @@ func (s *Suite) sendMaliciousTxs(t *utesting.T) error {
 	return checkMaliciousTxPropagation(s, badTxs, recvConn)
 }
 
-func sendMaliciousTx(s *Suite, tx *types.Transaction) error {
-	conn, err := s.dial()
+func sendMaliciousTx(s *Suite, tx *types.Transaction, isEth66 bool) error {
+	// setup connection
+	var (
+		conn *Conn
+		err  error
+	)
+	if isEth66 {
+		conn, err = s.dial66()
+	} else {
+		conn, err = s.dial()
+	}
 	if err != nil {
 		return fmt.Errorf("dial failed: %v", err)
 	}
@@ -154,7 +167,6 @@ func sendMaliciousTx(s *Suite, tx *types.Transaction) error {
 	if err = conn.peer(s.chain, nil); err != nil {
 		return fmt.Errorf("peering failed: %v", err)
 	}
-
 	// write malicious tx
 	if err = conn.Write(&Transactions{tx}); err != nil {
 		return fmt.Errorf("failed to write to connection: %v", err)
@@ -170,7 +182,7 @@ func sendMultipleSuccessfulTxs(t *utesting.T, s *Suite, txs []*types.Transaction
 	txMsg := Transactions(txs)
 	t.Logf("sending %d txs\n", len(txs))
 
-	sendConn, recvConn, err := s.createSendAndRecvConns()
+	sendConn, recvConn, err := s.createSendAndRecvConns(true)
 	if err != nil {
 		return err
 	}
@@ -182,19 +194,15 @@ func sendMultipleSuccessfulTxs(t *utesting.T, s *Suite, txs []*types.Transaction
 	if err = recvConn.peer(s.chain, nil); err != nil {
 		return fmt.Errorf("peering failed: %v", err)
 	}
-
 	// Send the transactions
 	if err = sendConn.Write(&txMsg); err != nil {
 		return fmt.Errorf("failed to write message to connection: %v", err)
 	}
-
 	// update nonce
 	nonce = txs[len(txs)-1].Nonce()
-
-	// Wait for the transaction announcement(s) and make sure all sent txs are being propagated.
-	// all txs should be announced within 3 announcements.
+	// Wait for the transaction announcement(s) and make sure all sent txs are being propagated
 	recvHashes := make([]common.Hash, 0)
-
+	// all txs should be announced within 3 announcements
 	for i := 0; i < 3; i++ {
 		switch msg := recvConn.readAndServe(s.chain, timeout).(type) {
 		case *Transactions:

cmd/devp2p/internal/ethtest/types.go

@@ -1,18 +1,18 @@
 // Copyright 2020 The go-ethereum Authors
-// This file is part of go-ethereum.
+// This file is part of the go-ethereum library.
 //
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// The 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.
 //
-// go-ethereum is distributed in the hope that it will be useful,
+// 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 General Public License for more details.
+// GNU Lesser General Public License for more details.
 //
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+// 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 ethtest
 
@@ -29,7 +29,6 @@ import (
 
 type Message interface {
 	Code() int
-	ReqID() uint64
 }
 
 type Error struct {
@@ -38,11 +37,9 @@ type Error struct {
 
 func (e *Error) Unwrap() error  { return e.err }
 func (e *Error) Error() string  { return e.err.Error() }
+func (e *Error) Code() int      { return -1 }
 func (e *Error) String() string { return e.Error() }
 
-func (e *Error) Code() int     { return -1 }
-func (e *Error) ReqID() uint64 { return 0 }
-
 func errorf(format string, args ...interface{}) *Error {
 	return &Error{fmt.Errorf(format, args...)}
 }
@@ -59,88 +56,73 @@ type Hello struct {
 	Rest []rlp.RawValue `rlp:"tail"`
 }
 
-func (msg Hello) Code() int     { return 0x00 }
-func (msg Hello) ReqID() uint64 { return 0 }
+func (h Hello) Code() int { return 0x00 }
 
 // Disconnect is the RLP structure for a disconnect message.
 type Disconnect struct {
 	Reason p2p.DiscReason
 }
 
-func (msg Disconnect) Code() int     { return 0x01 }
-func (msg Disconnect) ReqID() uint64 { return 0 }
+func (d Disconnect) Code() int { return 0x01 }
 
 type Ping struct{}
 
-func (msg Ping) Code() int     { return 0x02 }
-func (msg Ping) ReqID() uint64 { return 0 }
+func (p Ping) Code() int { return 0x02 }
 
 type Pong struct{}
 
-func (msg Pong) Code() int     { return 0x03 }
-func (msg Pong) ReqID() uint64 { return 0 }
+func (p Pong) Code() int { return 0x03 }
 
 // Status is the network packet for the status message for eth/64 and later.
 type Status eth.StatusPacket
 
-func (msg Status) Code() int     { return 16 }
-func (msg Status) ReqID() uint64 { return 0 }
+func (s Status) Code() int { return 16 }
 
 // NewBlockHashes is the network packet for the block announcements.
 type NewBlockHashes eth.NewBlockHashesPacket
 
-func (msg NewBlockHashes) Code() int     { return 17 }
-func (msg NewBlockHashes) ReqID() uint64 { return 0 }
+func (nbh NewBlockHashes) Code() int { return 17 }
 
 type Transactions eth.TransactionsPacket
 
-func (msg Transactions) Code() int     { return 18 }
-func (msg Transactions) ReqID() uint64 { return 18 }
+func (t Transactions) Code() int { return 18 }
 
 // GetBlockHeaders represents a block header query.
-type GetBlockHeaders eth.GetBlockHeadersPacket66
+type GetBlockHeaders eth.GetBlockHeadersPacket
 
-func (msg GetBlockHeaders) Code() int     { return 19 }
-func (msg GetBlockHeaders) ReqID() uint64 { return msg.RequestId }
+func (g GetBlockHeaders) Code() int { return 19 }
 
-type BlockHeaders eth.BlockHeadersPacket66
+type BlockHeaders eth.BlockHeadersPacket
 
-func (msg BlockHeaders) Code() int     { return 20 }
-func (msg BlockHeaders) ReqID() uint64 { return msg.RequestId }
+func (bh BlockHeaders) Code() int { return 20 }
 
 // GetBlockBodies represents a GetBlockBodies request
-type GetBlockBodies eth.GetBlockBodiesPacket66
+type GetBlockBodies eth.GetBlockBodiesPacket
 
-func (msg GetBlockBodies) Code() int     { return 21 }
-func (msg GetBlockBodies) ReqID() uint64 { return msg.RequestId }
+func (gbb GetBlockBodies) Code() int { return 21 }
 
 // BlockBodies is the network packet for block content distribution.
-type BlockBodies eth.BlockBodiesPacket66
+type BlockBodies eth.BlockBodiesPacket
 
-func (msg BlockBodies) Code() int     { return 22 }
-func (msg BlockBodies) ReqID() uint64 { return msg.RequestId }
+func (bb BlockBodies) Code() int { return 22 }
 
 // NewBlock is the network packet for the block propagation message.
 type NewBlock eth.NewBlockPacket
 
-func (msg NewBlock) Code() int     { return 23 }
-func (msg NewBlock) ReqID() uint64 { return 0 }
+func (nb NewBlock) Code() int { return 23 }
 
 // NewPooledTransactionHashes is the network packet for the tx hash propagation message.
 type NewPooledTransactionHashes eth.NewPooledTransactionHashesPacket
 
-func (msg NewPooledTransactionHashes) Code() int     { return 24 }
-func (msg NewPooledTransactionHashes) ReqID() uint64 { return 0 }
+func (nb NewPooledTransactionHashes) Code() int { return 24 }
 
-type GetPooledTransactions eth.GetPooledTransactionsPacket66
+type GetPooledTransactions eth.GetPooledTransactionsPacket
 
-func (msg GetPooledTransactions) Code() int     { return 25 }
-func (msg GetPooledTransactions) ReqID() uint64 { return msg.RequestId }
+func (gpt GetPooledTransactions) Code() int { return 25 }
 
-type PooledTransactions eth.PooledTransactionsPacket66
+type PooledTransactions eth.PooledTransactionsPacket
 
-func (msg PooledTransactions) Code() int     { return 26 }
-func (msg PooledTransactions) ReqID() uint64 { return msg.RequestId }
+func (pt PooledTransactions) Code() int { return 26 }
 
 // Conn represents an individual connection with a peer
 type Conn struct {
@@ -153,13 +135,62 @@ type Conn struct {
 	caps                       []p2p.Cap
 }
 
-// Read reads an eth66 packet from the connection.
+// Read reads an eth packet from the connection.
 func (c *Conn) Read() Message {
 	code, rawData, _, err := c.Conn.Read()
 	if err != nil {
 		return errorf("could not read from connection: %v", err)
 	}
 
+	var msg Message
+	switch int(code) {
+	case (Hello{}).Code():
+		msg = new(Hello)
+	case (Ping{}).Code():
+		msg = new(Ping)
+	case (Pong{}).Code():
+		msg = new(Pong)
+	case (Disconnect{}).Code():
+		msg = new(Disconnect)
+	case (Status{}).Code():
+		msg = new(Status)
+	case (GetBlockHeaders{}).Code():
+		msg = new(GetBlockHeaders)
+	case (BlockHeaders{}).Code():
+		msg = new(BlockHeaders)
+	case (GetBlockBodies{}).Code():
+		msg = new(GetBlockBodies)
+	case (BlockBodies{}).Code():
+		msg = new(BlockBodies)
+	case (NewBlock{}).Code():
+		msg = new(NewBlock)
+	case (NewBlockHashes{}).Code():
+		msg = new(NewBlockHashes)
+	case (Transactions{}).Code():
+		msg = new(Transactions)
+	case (NewPooledTransactionHashes{}).Code():
+		msg = new(NewPooledTransactionHashes)
+	case (GetPooledTransactions{}.Code()):
+		msg = new(GetPooledTransactions)
+	case (PooledTransactions{}.Code()):
+		msg = new(PooledTransactions)
+	default:
+		return errorf("invalid message code: %d", code)
+	}
+	// if message is devp2p, decode here
+	if err := rlp.DecodeBytes(rawData, msg); err != nil {
+		return errorf("could not rlp decode message: %v", err)
+	}
+	return msg
+}
+
+// Read66 reads an eth66 packet from the connection.
+func (c *Conn) Read66() (uint64, Message) {
+	code, rawData, _, err := c.Conn.Read()
+	if err != nil {
+		return 0, errorf("could not read from connection: %v", err)
+	}
+
 	var msg Message
 	switch int(code) {
 	case (Hello{}).Code():
@@ -175,27 +206,27 @@ func (c *Conn) Read() Message {
 	case (GetBlockHeaders{}).Code():
 		ethMsg := new(eth.GetBlockHeadersPacket66)
 		if err := rlp.DecodeBytes(rawData, ethMsg); err != nil {
-			return errorf("could not rlp decode message: %v", err)
+			return 0, errorf("could not rlp decode message: %v", err)
 		}
-		return (*GetBlockHeaders)(ethMsg)
+		return ethMsg.RequestId, GetBlockHeaders(*ethMsg.GetBlockHeadersPacket)
 	case (BlockHeaders{}).Code():
 		ethMsg := new(eth.BlockHeadersPacket66)
 		if err := rlp.DecodeBytes(rawData, ethMsg); err != nil {
-			return errorf("could not rlp decode message: %v", err)
+			return 0, errorf("could not rlp decode message: %v", err)
 		}
-		return (*BlockHeaders)(ethMsg)
+		return ethMsg.RequestId, BlockHeaders(ethMsg.BlockHeadersPacket)
 	case (GetBlockBodies{}).Code():
 		ethMsg := new(eth.GetBlockBodiesPacket66)
 		if err := rlp.DecodeBytes(rawData, ethMsg); err != nil {
-			return errorf("could not rlp decode message: %v", err)
+			return 0, errorf("could not rlp decode message: %v", err)
 		}
-		return (*GetBlockBodies)(ethMsg)
+		return ethMsg.RequestId, GetBlockBodies(ethMsg.GetBlockBodiesPacket)
 	case (BlockBodies{}).Code():
 		ethMsg := new(eth.BlockBodiesPacket66)
 		if err := rlp.DecodeBytes(rawData, ethMsg); err != nil {
-			return errorf("could not rlp decode message: %v", err)
+			return 0, errorf("could not rlp decode message: %v", err)
 		}
-		return (*BlockBodies)(ethMsg)
+		return ethMsg.RequestId, BlockBodies(ethMsg.BlockBodiesPacket)
 	case (NewBlock{}).Code():
 		msg = new(NewBlock)
 	case (NewBlockHashes{}).Code():
@@ -207,26 +238,26 @@ func (c *Conn) Read() Message {
 	case (GetPooledTransactions{}.Code()):
 		ethMsg := new(eth.GetPooledTransactionsPacket66)
 		if err := rlp.DecodeBytes(rawData, ethMsg); err != nil {
-			return errorf("could not rlp decode message: %v", err)
+			return 0, errorf("could not rlp decode message: %v", err)
 		}
-		return (*GetPooledTransactions)(ethMsg)
+		return ethMsg.RequestId, GetPooledTransactions(ethMsg.GetPooledTransactionsPacket)
 	case (PooledTransactions{}.Code()):
 		ethMsg := new(eth.PooledTransactionsPacket66)
 		if err := rlp.DecodeBytes(rawData, ethMsg); err != nil {
-			return errorf("could not rlp decode message: %v", err)
+			return 0, errorf("could not rlp decode message: %v", err)
 		}
-		return (*PooledTransactions)(ethMsg)
+		return ethMsg.RequestId, PooledTransactions(ethMsg.PooledTransactionsPacket)
 	default:
 		msg = errorf("invalid message code: %d", code)
 	}
 
 	if msg != nil {
 		if err := rlp.DecodeBytes(rawData, msg); err != nil {
-			return errorf("could not rlp decode message: %v", err)
+			return 0, errorf("could not rlp decode message: %v", err)
 		}
-		return msg
+		return 0, msg
 	}
-	return errorf("invalid message: %s", string(rawData))
+	return 0, errorf("invalid message: %s", string(rawData))
 }
 
 // Write writes a eth packet to the connection.
@@ -239,6 +270,16 @@ func (c *Conn) Write(msg Message) error {
 	return err
 }
 
+// Write66 writes an eth66 packet to the connection.
+func (c *Conn) Write66(req eth.Packet, code int) error {
+	payload, err := rlp.EncodeToBytes(req)
+	if err != nil {
+		return err
+	}
+	_, err = c.Conn.Write(uint64(code), payload)
+	return err
+}
+
 // ReadSnap reads a snap/1 response with the given id from the connection.
 func (c *Conn) ReadSnap(id uint64) (Message, error) {
 	respId := id + 1
@@ -274,6 +315,7 @@ func (c *Conn) ReadSnap(id uint64) (Message, error) {
 			return nil, fmt.Errorf("could not rlp decode message: %v", err)
 		}
 		return snpMsg.(Message), nil
+
 	}
 	return nil, fmt.Errorf("request timed out")
 }

cmd/devp2p/internal/v5test/framework.go

@@ -60,9 +60,11 @@ type conn struct {
 	remoteAddr *net.UDPAddr
 	listeners  []net.PacketConn
 
-	log       logger
-	codec     *v5wire.Codec
-	idCounter uint32
+	log           logger
+	codec         *v5wire.Codec
+	lastRequest   v5wire.Packet
+	lastChallenge *v5wire.Whoareyou
+	idCounter     uint32
 }
 
 type logger interface {

cmd/devp2p/keycmd.go

@@ -22,25 +22,25 @@ import (
 
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
-	keyCommand = &cli.Command{
+	keyCommand = cli.Command{
 		Name:  "key",
 		Usage: "Operations on node keys",
-		Subcommands: []*cli.Command{
+		Subcommands: []cli.Command{
 			keyGenerateCommand,
 			keyToNodeCommand,
 		},
 	}
-	keyGenerateCommand = &cli.Command{
+	keyGenerateCommand = cli.Command{
 		Name:      "generate",
 		Usage:     "Generates node key files",
 		ArgsUsage: "keyfile",
 		Action:    genkey,
 	}
-	keyToNodeCommand = &cli.Command{
+	keyToNodeCommand = cli.Command{
 		Name:      "to-enode",
 		Usage:     "Creates an enode URL from a node key file",
 		ArgsUsage: "keyfile",
@@ -50,17 +50,17 @@ var (
 )
 
 var (
-	hostFlag = &cli.StringFlag{
+	hostFlag = cli.StringFlag{
 		Name:  "ip",
 		Usage: "IP address of the node",
 		Value: "127.0.0.1",
 	}
-	tcpPortFlag = &cli.IntFlag{
+	tcpPortFlag = cli.IntFlag{
 		Name:  "tcp",
 		Usage: "TCP port of the node",
 		Value: 30303,
 	}
-	udpPortFlag = &cli.IntFlag{
+	udpPortFlag = cli.IntFlag{
 		Name:  "udp",
 		Usage: "UDP port of the node",
 		Value: 30303,

cmd/devp2p/main.go

@@ -20,12 +20,12 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"sort"
 
 	"github.com/ethereum/go-ethereum/internal/debug"
-	"github.com/ethereum/go-ethereum/internal/flags"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/params"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
@@ -45,7 +45,6 @@ func init() {
 	// Set up the CLI app.
 	app.Flags = append(app.Flags, debug.Flags...)
 	app.Before = func(ctx *cli.Context) error {
-		flags.MigrateGlobalFlags(ctx)
 		return debug.Setup(ctx)
 	}
 	app.After = func(ctx *cli.Context) error {
@@ -57,7 +56,7 @@ func init() {
 		os.Exit(1)
 	}
 	// Add subcommands.
-	app.Commands = []*cli.Command{
+	app.Commands = []cli.Command{
 		enrdumpCommand,
 		keyCommand,
 		discv4Command,
@@ -74,17 +73,10 @@ func main() {
 
 // commandHasFlag returns true if the current command supports the given flag.
 func commandHasFlag(ctx *cli.Context, flag cli.Flag) bool {
-	names := flag.Names()
-	set := make(map[string]struct{}, len(names))
-	for _, name := range names {
-		set[name] = struct{}{}
-	}
-	for _, fn := range ctx.FlagNames() {
-		if _, ok := set[fn]; ok {
-			return true
-		}
-	}
-	return false
+	flags := ctx.FlagNames()
+	sort.Strings(flags)
+	i := sort.SearchStrings(flags, flag.GetName())
+	return i != len(flags) && flags[i] == flag.GetName()
 }
 
 // getNodeArg handles the common case of a single node descriptor argument.
@@ -92,7 +84,7 @@ func getNodeArg(ctx *cli.Context) *enode.Node {
 	if ctx.NArg() < 1 {
 		exit("missing node as command-line argument")
 	}
-	n, err := parseNode(ctx.Args().First())
+	n, err := parseNode(ctx.Args()[0])
 	if err != nil {
 		exit(err)
 	}

cmd/devp2p/nodesetcmd.go

@@ -29,25 +29,25 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/enr"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rlp"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
-	nodesetCommand = &cli.Command{
+	nodesetCommand = cli.Command{
 		Name:  "nodeset",
 		Usage: "Node set tools",
-		Subcommands: []*cli.Command{
+		Subcommands: []cli.Command{
 			nodesetInfoCommand,
 			nodesetFilterCommand,
 		},
 	}
-	nodesetInfoCommand = &cli.Command{
+	nodesetInfoCommand = cli.Command{
 		Name:      "info",
 		Usage:     "Shows statistics about a node set",
 		Action:    nodesetInfo,
 		ArgsUsage: "<nodes.json>",
 	}
-	nodesetFilterCommand = &cli.Command{
+	nodesetFilterCommand = cli.Command{
 		Name:      "filter",
 		Usage:     "Filters a node set",
 		Action:    nodesetFilter,

cmd/devp2p/rlpxcmd.go

@@ -22,28 +22,29 @@ import (
 
 	"github.com/ethereum/go-ethereum/cmd/devp2p/internal/ethtest"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/internal/utesting"
 	"github.com/ethereum/go-ethereum/p2p"
 	"github.com/ethereum/go-ethereum/p2p/rlpx"
 	"github.com/ethereum/go-ethereum/rlp"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
-	rlpxCommand = &cli.Command{
+	rlpxCommand = cli.Command{
 		Name:  "rlpx",
 		Usage: "RLPx Commands",
-		Subcommands: []*cli.Command{
+		Subcommands: []cli.Command{
 			rlpxPingCommand,
 			rlpxEthTestCommand,
 			rlpxSnapTestCommand,
 		},
 	}
-	rlpxPingCommand = &cli.Command{
+	rlpxPingCommand = cli.Command{
 		Name:   "ping",
 		Usage:  "ping <node>",
 		Action: rlpxPing,
 	}
-	rlpxEthTestCommand = &cli.Command{
+	rlpxEthTestCommand = cli.Command{
 		Name:      "eth-test",
 		Usage:     "Runs tests against a node",
 		ArgsUsage: "<node> <chain.rlp> <genesis.json>",
@@ -53,7 +54,7 @@ var (
 			testTAPFlag,
 		},
 	}
-	rlpxSnapTestCommand = &cli.Command{
+	rlpxSnapTestCommand = cli.Command{
 		Name:      "snap-test",
 		Usage:     "Runs tests against a node",
 		ArgsUsage: "<node> <chain.rlp> <genesis.json>",
@@ -105,11 +106,16 @@ func rlpxEthTest(ctx *cli.Context) error {
 	if ctx.NArg() < 3 {
 		exit("missing path to chain.rlp as command-line argument")
 	}
-	suite, err := ethtest.NewSuite(getNodeArg(ctx), ctx.Args().Get(1), ctx.Args().Get(2))
+	suite, err := ethtest.NewSuite(getNodeArg(ctx), ctx.Args()[1], ctx.Args()[2])
 	if err != nil {
 		exit(err)
 	}
-	return runTests(ctx, suite.EthTests())
+	// check if given node supports eth66, and if so, run eth66 protocol tests as well
+	is66Failed, _ := utesting.Run(utesting.Test{Name: "Is_66", Fn: suite.Is_66})
+	if is66Failed {
+		return runTests(ctx, suite.EthTests())
+	}
+	return runTests(ctx, suite.AllEthTests())
 }
 
 // rlpxSnapTest runs the snap protocol test suite.
@@ -117,7 +123,7 @@ func rlpxSnapTest(ctx *cli.Context) error {
 	if ctx.NArg() < 3 {
 		exit("missing path to chain.rlp as command-line argument")
 	}
-	suite, err := ethtest.NewSuite(getNodeArg(ctx), ctx.Args().Get(1), ctx.Args().Get(2))
+	suite, err := ethtest.NewSuite(getNodeArg(ctx), ctx.Args()[1], ctx.Args()[2])
 	if err != nil {
 		exit(err)
 	}

cmd/devp2p/runtest.go

@@ -22,25 +22,25 @@ import (
 	"github.com/ethereum/go-ethereum/cmd/devp2p/internal/v4test"
 	"github.com/ethereum/go-ethereum/internal/utesting"
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
-	testPatternFlag = &cli.StringFlag{
+	testPatternFlag = cli.StringFlag{
 		Name:  "run",
 		Usage: "Pattern of test suite(s) to run",
 	}
-	testTAPFlag = &cli.BoolFlag{
+	testTAPFlag = cli.BoolFlag{
 		Name:  "tap",
 		Usage: "Output TAP",
 	}
 	// These two are specific to the discovery tests.
-	testListen1Flag = &cli.StringFlag{
+	testListen1Flag = cli.StringFlag{
 		Name:  "listen1",
 		Usage: "IP address of the first tester",
 		Value: v4test.Listen1,
 	}
-	testListen2Flag = &cli.StringFlag{
+	testListen2Flag = cli.StringFlag{
 		Name:  "listen2",
 		Usage: "IP address of the second tester",
 		Value: v4test.Listen2,
@@ -53,7 +53,7 @@ func runTests(ctx *cli.Context, tests []utesting.Test) error {
 		tests = utesting.MatchTests(tests, ctx.String(testPatternFlag.Name))
 	}
 	// Disable logging unless explicitly enabled.
-	if !ctx.IsSet("verbosity") && !ctx.IsSet("vmodule") {
+	if !ctx.GlobalIsSet("verbosity") && !ctx.GlobalIsSet("vmodule") {
 		log.Root().SetHandler(log.DiscardHandler())
 	}
 	// Run the tests.

cmd/ethkey/changepassword.go

@@ -23,15 +23,15 @@ import (
 
 	"github.com/ethereum/go-ethereum/accounts/keystore"
 	"github.com/ethereum/go-ethereum/cmd/utils"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
-var newPassphraseFlag = &cli.StringFlag{
+var newPassphraseFlag = cli.StringFlag{
 	Name:  "newpasswordfile",
 	Usage: "the file that contains the new password for the keyfile",
 }
 
-var commandChangePassphrase = &cli.Command{
+var commandChangePassphrase = cli.Command{
 	Name:      "changepassword",
 	Usage:     "change the password on a keyfile",
 	ArgsUsage: "<keyfile>",

cmd/ethkey/generate.go

@@ -26,7 +26,7 @@ import (
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/google/uuid"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 type outputGenerate struct {
@@ -35,17 +35,17 @@ type outputGenerate struct {
 }
 
 var (
-	privateKeyFlag = &cli.StringFlag{
+	privateKeyFlag = cli.StringFlag{
 		Name:  "privatekey",
 		Usage: "file containing a raw private key to encrypt",
 	}
-	lightKDFFlag = &cli.BoolFlag{
+	lightKDFFlag = cli.BoolFlag{
 		Name:  "lightkdf",
 		Usage: "use less secure scrypt parameters",
 	}
 )
 
-var commandGenerate = &cli.Command{
+var commandGenerate = cli.Command{
 	Name:      "generate",
 	Usage:     "generate new keyfile",
 	ArgsUsage: "[ <keyfile> ]",

cmd/ethkey/inspect.go

@@ -24,7 +24,7 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/keystore"
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 type outputInspect struct {
@@ -34,13 +34,13 @@ type outputInspect struct {
 }
 
 var (
-	privateFlag = &cli.BoolFlag{
+	privateFlag = cli.BoolFlag{
 		Name:  "private",
 		Usage: "include the private key in the output",
 	}
 )
 
-var commandInspect = &cli.Command{
+var commandInspect = cli.Command{
 	Name:      "inspect",
 	Usage:     "inspect a keyfile",
 	ArgsUsage: "<keyfile>",

cmd/ethkey/main.go

@@ -21,7 +21,7 @@ import (
 	"os"
 
 	"github.com/ethereum/go-ethereum/internal/flags"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 const (
@@ -36,22 +36,23 @@ var app *cli.App
 
 func init() {
 	app = flags.NewApp(gitCommit, gitDate, "an Ethereum key manager")
-	app.Commands = []*cli.Command{
+	app.Commands = []cli.Command{
 		commandGenerate,
 		commandInspect,
 		commandChangePassphrase,
 		commandSignMessage,
 		commandVerifyMessage,
 	}
+	cli.CommandHelpTemplate = flags.OriginCommandHelpTemplate
 }
 
 // Commonly used command line flags.
 var (
-	passphraseFlag = &cli.StringFlag{
+	passphraseFlag = cli.StringFlag{
 		Name:  "passwordfile",
 		Usage: "the file that contains the password for the keyfile",
 	}
-	jsonFlag = &cli.BoolFlag{
+	jsonFlag = cli.BoolFlag{
 		Name:  "json",
 		Usage: "output JSON instead of human-readable format",
 	}

cmd/ethkey/message.go

@@ -21,24 +21,23 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/accounts/keystore"
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 type outputSign struct {
 	Signature string
 }
 
-var msgfileFlag = &cli.StringFlag{
+var msgfileFlag = cli.StringFlag{
 	Name:  "msgfile",
 	Usage: "file containing the message to sign/verify",
 }
 
-var commandSignMessage = &cli.Command{
+var commandSignMessage = cli.Command{
 	Name:      "signmessage",
 	Usage:     "sign a message",
 	ArgsUsage: "<keyfile> <message>",
@@ -69,7 +68,7 @@ To sign a message contained in a file, use the --msgfile flag.
 			utils.Fatalf("Error decrypting key: %v", err)
 		}
 
-		signature, err := crypto.Sign(accounts.TextHash(message), key.PrivateKey)
+		signature, err := crypto.Sign(signHash(message), key.PrivateKey)
 		if err != nil {
 			utils.Fatalf("Failed to sign message: %v", err)
 		}
@@ -89,7 +88,7 @@ type outputVerify struct {
 	RecoveredPublicKey string
 }
 
-var commandVerifyMessage = &cli.Command{
+var commandVerifyMessage = cli.Command{
 	Name:      "verifymessage",
 	Usage:     "verify the signature of a signed message",
 	ArgsUsage: "<address> <signature> <message>",
@@ -114,7 +113,7 @@ It is possible to refer to a file containing the message.`,
 			utils.Fatalf("Signature encoding is not hexadecimal: %v", err)
 		}
 
-		recoveredPubkey, err := crypto.SigToPub(accounts.TextHash(message), signature)
+		recoveredPubkey, err := crypto.SigToPub(signHash(message), signature)
 		if err != nil || recoveredPubkey == nil {
 			utils.Fatalf("Signature verification failed: %v", err)
 		}
@@ -144,7 +143,7 @@ It is possible to refer to a file containing the message.`,
 
 func getMessage(ctx *cli.Context, msgarg int) []byte {
 	if file := ctx.String(msgfileFlag.Name); file != "" {
-		if ctx.NArg() > msgarg {
+		if len(ctx.Args()) > msgarg {
 			utils.Fatalf("Can't use --msgfile and message argument at the same time.")
 		}
 		msg, err := os.ReadFile(file)
@@ -152,9 +151,9 @@ func getMessage(ctx *cli.Context, msgarg int) []byte {
 			utils.Fatalf("Can't read message file: %v", err)
 		}
 		return msg
-	} else if ctx.NArg() == msgarg+1 {
+	} else if len(ctx.Args()) == msgarg+1 {
 		return []byte(ctx.Args().Get(msgarg))
 	}
-	utils.Fatalf("Invalid number of arguments: want %d, got %d", msgarg+1, ctx.NArg())
+	utils.Fatalf("Invalid number of arguments: want %d, got %d", msgarg+1, len(ctx.Args()))
 	return nil
 }

cmd/ethkey/utils.go

@@ -23,7 +23,8 @@ import (
 	"strings"
 
 	"github.com/ethereum/go-ethereum/cmd/utils"
-	"github.com/urfave/cli/v2"
+	"github.com/ethereum/go-ethereum/crypto"
+	"gopkg.in/urfave/cli.v1"
 )
 
 // getPassphrase obtains a passphrase given by the user.  It first checks the
@@ -45,6 +46,18 @@ func getPassphrase(ctx *cli.Context, confirmation bool) string {
 	return utils.GetPassPhrase("", confirmation)
 }
 
+// signHash is a helper function that calculates a hash for the given message
+// that can be safely used to calculate a signature from.
+//
+// The hash is calculated as
+//   keccak256("\x19Ethereum Signed Message:\n"${message length}${message}).
+//
+// This gives context to the signed message and prevents signing of transactions.
+func signHash(data []byte) []byte {
+	msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(data), data)
+	return crypto.Keccak256([]byte(msg))
+}
+
 // mustPrintJSON prints the JSON encoding of the given object and
 // exits the program with an error message when the marshaling fails.
 func mustPrintJSON(jsonObject interface{}) {

cmd/evm/compiler.go

@@ -23,10 +23,10 @@ import (
 
 	"github.com/ethereum/go-ethereum/cmd/evm/internal/compiler"
 
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
-var compileCommand = &cli.Command{
+var compileCommand = cli.Command{
 	Action:    compileCmd,
 	Name:      "compile",
 	Usage:     "compiles easm source to evm binary",
@@ -34,7 +34,7 @@ var compileCommand = &cli.Command{
 }
 
 func compileCmd(ctx *cli.Context) error {
-	debug := ctx.Bool(DebugFlag.Name)
+	debug := ctx.GlobalBool(DebugFlag.Name)
 
 	if len(ctx.Args().First()) == 0 {
 		return errors.New("filename required")

cmd/evm/disasm.go

@@ -23,10 +23,10 @@ import (
 	"strings"
 
 	"github.com/ethereum/go-ethereum/core/asm"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
-var disasmCommand = &cli.Command{
+var disasmCommand = cli.Command{
 	Action:    disasmCmd,
 	Name:      "disasm",
 	Usage:     "disassembles evm binary",
@@ -43,8 +43,8 @@ func disasmCmd(ctx *cli.Context) error {
 			return err
 		}
 		in = string(input)
-	case ctx.IsSet(InputFlag.Name):
-		in = ctx.String(InputFlag.Name)
+	case ctx.GlobalIsSet(InputFlag.Name):
+		in = ctx.GlobalString(InputFlag.Name)
 	default:
 		return errors.New("missing filename or --input value")
 	}

cmd/evm/internal/t8ntool/block.go

@@ -33,7 +33,7 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rlp"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 //go:generate go run github.com/fjl/gencodec -type header -field-override headerMarshaling -out gen_header.go

cmd/evm/internal/t8ntool/execution.go

@@ -1,18 +1,18 @@
 // Copyright 2020 The go-ethereum Authors
-// This file is part of go-ethereum.
+// This file is part of the go-ethereum library.
 //
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// The 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.
 //
-// go-ethereum is distributed in the hope that it will be useful,
+// 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 General Public License for more details.
+// GNU Lesser General Public License for more details.
 //
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+// 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 t8ntool
 
@@ -100,6 +100,7 @@ type rejectedTx struct {
 func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 	txs types.Transactions, miningReward int64,
 	getTracerFn func(txIndex int, txHash common.Hash) (tracer vm.EVMLogger, err error)) (*state.StateDB, *ExecutionResult, error) {
+
 	// Capture errors for BLOCKHASH operation, if we haven't been supplied the
 	// required blockhashes
 	var hashError error
@@ -240,7 +241,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 			minerReward.Add(minerReward, perOmmer)
 			// Add (8-delta)/8
 			reward := big.NewInt(8)
-			reward.Sub(reward, new(big.Int).SetUint64(ommer.Delta))
+			reward.Sub(reward, big.NewInt(0).SetUint64(ommer.Delta))
 			reward.Mul(reward, blockReward)
 			reward.Div(reward, big.NewInt(8))
 			statedb.AddBalance(ommer.Address, reward)
@@ -268,7 +269,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 }
 
 func MakePreState(db ethdb.Database, accounts core.GenesisAlloc) *state.StateDB {
-	sdb := state.NewDatabaseWithConfig(db, &trie.Config{Preimages: true})
+	sdb := state.NewDatabase(db)
 	statedb, _ := state.New(common.Hash{}, sdb, nil)
 	for addr, a := range accounts {
 		statedb.SetCode(addr, a.Code)

cmd/evm/internal/t8ntool/flags.go

@@ -1,18 +1,18 @@
 // Copyright 2020 The go-ethereum Authors
-// This file is part of go-ethereum.
+// This file is part of the go-ethereum library.
 //
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// The 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.
 //
-// go-ethereum is distributed in the hope that it will be useful,
+// 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 General Public License for more details.
+// GNU Lesser General Public License for more details.
 //
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+// 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 t8ntool
 
@@ -22,47 +22,45 @@ import (
 
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/tests"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
-	TraceFlag = &cli.BoolFlag{
+	TraceFlag = cli.BoolFlag{
 		Name:  "trace",
 		Usage: "Output full trace logs to files <txhash>.jsonl",
 	}
-	TraceDisableMemoryFlag = &cli.BoolFlag{
+	TraceDisableMemoryFlag = cli.BoolTFlag{
 		Name:  "trace.nomemory",
-		Value: true,
 		Usage: "Disable full memory dump in traces (deprecated)",
 	}
-	TraceEnableMemoryFlag = &cli.BoolFlag{
+	TraceEnableMemoryFlag = cli.BoolFlag{
 		Name:  "trace.memory",
 		Usage: "Enable full memory dump in traces",
 	}
-	TraceDisableStackFlag = &cli.BoolFlag{
+	TraceDisableStackFlag = cli.BoolFlag{
 		Name:  "trace.nostack",
 		Usage: "Disable stack output in traces",
 	}
-	TraceDisableReturnDataFlag = &cli.BoolFlag{
+	TraceDisableReturnDataFlag = cli.BoolTFlag{
 		Name:  "trace.noreturndata",
-		Value: true,
 		Usage: "Disable return data output in traces (deprecated)",
 	}
-	TraceEnableReturnDataFlag = &cli.BoolFlag{
+	TraceEnableReturnDataFlag = cli.BoolFlag{
 		Name:  "trace.returndata",
 		Usage: "Enable return data output in traces",
 	}
-	OutputBasedir = &cli.StringFlag{
+	OutputBasedir = cli.StringFlag{
 		Name:  "output.basedir",
 		Usage: "Specifies where output files are placed. Will be created if it does not exist.",
 		Value: "",
 	}
-	OutputBodyFlag = &cli.StringFlag{
+	OutputBodyFlag = cli.StringFlag{
 		Name:  "output.body",
 		Usage: "If set, the RLP of the transactions (block body) will be written to this file.",
 		Value: "",
 	}
-	OutputAllocFlag = &cli.StringFlag{
+	OutputAllocFlag = cli.StringFlag{
 		Name: "output.alloc",
 		Usage: "Determines where to put the `alloc` of the post-state.\n" +
 			"\t`stdout` - into the stdout output\n" +
@@ -70,7 +68,7 @@ var (
 			"\t<file> - into the file <file> ",
 		Value: "alloc.json",
 	}
-	OutputResultFlag = &cli.StringFlag{
+	OutputResultFlag = cli.StringFlag{
 		Name: "output.result",
 		Usage: "Determines where to put the `result` (stateroot, txroot etc) of the post-state.\n" +
 			"\t`stdout` - into the stdout output\n" +
@@ -78,7 +76,7 @@ var (
 			"\t<file> - into the file <file> ",
 		Value: "result.json",
 	}
-	OutputBlockFlag = &cli.StringFlag{
+	OutputBlockFlag = cli.StringFlag{
 		Name: "output.block",
 		Usage: "Determines where to put the `block` after building.\n" +
 			"\t`stdout` - into the stdout output\n" +
@@ -86,65 +84,65 @@ var (
 			"\t<file> - into the file <file> ",
 		Value: "block.json",
 	}
-	InputAllocFlag = &cli.StringFlag{
+	InputAllocFlag = cli.StringFlag{
 		Name:  "input.alloc",
 		Usage: "`stdin` or file name of where to find the prestate alloc to use.",
 		Value: "alloc.json",
 	}
-	InputEnvFlag = &cli.StringFlag{
+	InputEnvFlag = cli.StringFlag{
 		Name:  "input.env",
 		Usage: "`stdin` or file name of where to find the prestate env to use.",
 		Value: "env.json",
 	}
-	InputTxsFlag = &cli.StringFlag{
+	InputTxsFlag = cli.StringFlag{
 		Name: "input.txs",
 		Usage: "`stdin` or file name of where to find the transactions to apply. " +
 			"If the file extension is '.rlp', then the data is interpreted as an RLP list of signed transactions." +
 			"The '.rlp' format is identical to the output.body format.",
 		Value: "txs.json",
 	}
-	InputHeaderFlag = &cli.StringFlag{
+	InputHeaderFlag = cli.StringFlag{
 		Name:  "input.header",
 		Usage: "`stdin` or file name of where to find the block header to use.",
 		Value: "header.json",
 	}
-	InputOmmersFlag = &cli.StringFlag{
+	InputOmmersFlag = cli.StringFlag{
 		Name:  "input.ommers",
 		Usage: "`stdin` or file name of where to find the list of ommer header RLPs to use.",
 	}
-	InputTxsRlpFlag = &cli.StringFlag{
+	InputTxsRlpFlag = cli.StringFlag{
 		Name:  "input.txs",
 		Usage: "`stdin` or file name of where to find the transactions list in RLP form.",
 		Value: "txs.rlp",
 	}
-	SealCliqueFlag = &cli.StringFlag{
+	SealCliqueFlag = cli.StringFlag{
 		Name:  "seal.clique",
 		Usage: "Seal block with Clique. `stdin` or file name of where to find the Clique sealing data.",
 	}
-	SealEthashFlag = &cli.BoolFlag{
+	SealEthashFlag = cli.BoolFlag{
 		Name:  "seal.ethash",
 		Usage: "Seal block with ethash.",
 	}
-	SealEthashDirFlag = &cli.StringFlag{
+	SealEthashDirFlag = cli.StringFlag{
 		Name:  "seal.ethash.dir",
 		Usage: "Path to ethash DAG. If none exists, a new DAG will be generated.",
 	}
-	SealEthashModeFlag = &cli.StringFlag{
+	SealEthashModeFlag = cli.StringFlag{
 		Name:  "seal.ethash.mode",
 		Usage: "Defines the type and amount of PoW verification an ethash engine makes.",
 		Value: "normal",
 	}
-	RewardFlag = &cli.Int64Flag{
+	RewardFlag = cli.Int64Flag{
 		Name:  "state.reward",
 		Usage: "Mining reward. Set to -1 to disable",
 		Value: 0,
 	}
-	ChainIDFlag = &cli.Int64Flag{
+	ChainIDFlag = cli.Int64Flag{
 		Name:  "state.chainid",
 		Usage: "ChainID to use",
 		Value: 1,
 	}
-	ForknameFlag = &cli.StringFlag{
+	ForknameFlag = cli.StringFlag{
 		Name: "state.fork",
 		Usage: fmt.Sprintf("Name of ruleset to use."+
 			"\n\tAvailable forknames:"+
@@ -154,9 +152,9 @@ var (
 			"\n\tSyntax <forkname>(+ExtraEip)",
 			strings.Join(tests.AvailableForks(), "\n\t    "),
 			strings.Join(vm.ActivateableEips(), ", ")),
-		Value: "GrayGlacier",
+		Value: "ArrowGlacier",
 	}
-	VerbosityFlag = &cli.IntFlag{
+	VerbosityFlag = cli.IntFlag{
 		Name:  "verbosity",
 		Usage: "sets the verbosity level",
 		Value: 3,

cmd/evm/internal/t8ntool/transaction.go

@@ -32,7 +32,7 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/tests"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 type result struct {

cmd/evm/internal/t8ntool/transition.go

@@ -38,7 +38,7 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/tests"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 const (

cmd/evm/internal/t8ntool/utils.go

@@ -21,7 +21,7 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 // readFile reads the json-data in the provided path and marshals into dest.

cmd/evm/main.go

@@ -23,118 +23,115 @@ import (
 	"os"
 
 	"github.com/ethereum/go-ethereum/cmd/evm/internal/t8ntool"
+	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/internal/flags"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
-var (
-	gitCommit = "" // Git SHA1 commit hash of the release (set via linker flags)
-	gitDate   = ""
+var gitCommit = "" // Git SHA1 commit hash of the release (set via linker flags)
+var gitDate = ""
 
+var (
 	app = flags.NewApp(gitCommit, gitDate, "the evm command line interface")
-)
 
-var (
-	DebugFlag = &cli.BoolFlag{
+	DebugFlag = cli.BoolFlag{
 		Name:  "debug",
 		Usage: "output full trace logs",
 	}
-	MemProfileFlag = &cli.StringFlag{
+	MemProfileFlag = cli.StringFlag{
 		Name:  "memprofile",
 		Usage: "creates a memory profile at the given path",
 	}
-	CPUProfileFlag = &cli.StringFlag{
+	CPUProfileFlag = cli.StringFlag{
 		Name:  "cpuprofile",
 		Usage: "creates a CPU profile at the given path",
 	}
-	StatDumpFlag = &cli.BoolFlag{
+	StatDumpFlag = cli.BoolFlag{
 		Name:  "statdump",
 		Usage: "displays stack and heap memory information",
 	}
-	CodeFlag = &cli.StringFlag{
+	CodeFlag = cli.StringFlag{
 		Name:  "code",
 		Usage: "EVM code",
 	}
-	CodeFileFlag = &cli.StringFlag{
+	CodeFileFlag = cli.StringFlag{
 		Name:  "codefile",
 		Usage: "File containing EVM code. If '-' is specified, code is read from stdin ",
 	}
-	GasFlag = &cli.Uint64Flag{
+	GasFlag = cli.Uint64Flag{
 		Name:  "gas",
 		Usage: "gas limit for the evm",
 		Value: 10000000000,
 	}
-	PriceFlag = &flags.BigFlag{
+	PriceFlag = utils.BigFlag{
 		Name:  "price",
 		Usage: "price set for the evm",
 		Value: new(big.Int),
 	}
-	ValueFlag = &flags.BigFlag{
+	ValueFlag = utils.BigFlag{
 		Name:  "value",
 		Usage: "value set for the evm",
 		Value: new(big.Int),
 	}
-	DumpFlag = &cli.BoolFlag{
+	DumpFlag = cli.BoolFlag{
 		Name:  "dump",
 		Usage: "dumps the state after the run",
 	}
-	InputFlag = &cli.StringFlag{
+	InputFlag = cli.StringFlag{
 		Name:  "input",
 		Usage: "input for the EVM",
 	}
-	InputFileFlag = &cli.StringFlag{
+	InputFileFlag = cli.StringFlag{
 		Name:  "inputfile",
 		Usage: "file containing input for the EVM",
 	}
-	VerbosityFlag = &cli.IntFlag{
+	VerbosityFlag = cli.IntFlag{
 		Name:  "verbosity",
 		Usage: "sets the verbosity level",
 	}
-	BenchFlag = &cli.BoolFlag{
+	BenchFlag = cli.BoolFlag{
 		Name:  "bench",
 		Usage: "benchmark the execution",
 	}
-	CreateFlag = &cli.BoolFlag{
+	CreateFlag = cli.BoolFlag{
 		Name:  "create",
 		Usage: "indicates the action should be create rather than call",
 	}
-	GenesisFlag = &cli.StringFlag{
+	GenesisFlag = cli.StringFlag{
 		Name:  "prestate",
 		Usage: "JSON file with prestate (genesis) config",
 	}
-	MachineFlag = &cli.BoolFlag{
+	MachineFlag = cli.BoolFlag{
 		Name:  "json",
 		Usage: "output trace logs in machine readable format (json)",
 	}
-	SenderFlag = &cli.StringFlag{
+	SenderFlag = cli.StringFlag{
 		Name:  "sender",
 		Usage: "The transaction origin",
 	}
-	ReceiverFlag = &cli.StringFlag{
+	ReceiverFlag = cli.StringFlag{
 		Name:  "receiver",
 		Usage: "The transaction receiver (execution context)",
 	}
-	DisableMemoryFlag = &cli.BoolFlag{
+	DisableMemoryFlag = cli.BoolTFlag{
 		Name:  "nomemory",
-		Value: true,
 		Usage: "disable memory output",
 	}
-	DisableStackFlag = &cli.BoolFlag{
+	DisableStackFlag = cli.BoolFlag{
 		Name:  "nostack",
 		Usage: "disable stack output",
 	}
-	DisableStorageFlag = &cli.BoolFlag{
+	DisableStorageFlag = cli.BoolFlag{
 		Name:  "nostorage",
 		Usage: "disable storage output",
 	}
-	DisableReturnDataFlag = &cli.BoolFlag{
+	DisableReturnDataFlag = cli.BoolTFlag{
 		Name:  "noreturndata",
-		Value: true,
 		Usage: "enable return data output",
 	}
 )
 
-var stateTransitionCommand = &cli.Command{
+var stateTransitionCommand = cli.Command{
 	Name:    "transition",
 	Aliases: []string{"t8n"},
 	Usage:   "executes a full state transition",
@@ -159,8 +156,7 @@ var stateTransitionCommand = &cli.Command{
 		t8ntool.VerbosityFlag,
 	},
 }
-
-var transactionCommand = &cli.Command{
+var transactionCommand = cli.Command{
 	Name:    "transaction",
 	Aliases: []string{"t9n"},
 	Usage:   "performs transaction validation",
@@ -173,7 +169,7 @@ var transactionCommand = &cli.Command{
 	},
 }
 
-var blockBuilderCommand = &cli.Command{
+var blockBuilderCommand = cli.Command{
 	Name:    "block-builder",
 	Aliases: []string{"b11r"},
 	Usage:   "builds a block",
@@ -218,7 +214,7 @@ func init() {
 		DisableStorageFlag,
 		DisableReturnDataFlag,
 	}
-	app.Commands = []*cli.Command{
+	app.Commands = []cli.Command{
 		compileCommand,
 		disasmCommand,
 		runCommand,
@@ -227,6 +223,7 @@ func init() {
 		transactionCommand,
 		blockBuilderCommand,
 	}
+	cli.CommandHelpTemplate = flags.OriginCommandHelpTemplate
 }
 
 func main() {

cmd/evm/runner.go

@@ -37,13 +37,12 @@ import (
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/core/vm/runtime"
 	"github.com/ethereum/go-ethereum/eth/tracers/logger"
-	"github.com/ethereum/go-ethereum/internal/flags"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
-var runCommand = &cli.Command{
+var runCommand = cli.Command{
 	Action:      runCmd,
 	Name:        "run",
 	Usage:       "run arbitrary evm binary",
@@ -107,14 +106,14 @@ func timedExec(bench bool, execFunc func() ([]byte, uint64, error)) (output []by
 
 func runCmd(ctx *cli.Context) error {
 	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.TerminalFormat(false)))
-	glogger.Verbosity(log.Lvl(ctx.Int(VerbosityFlag.Name)))
+	glogger.Verbosity(log.Lvl(ctx.GlobalInt(VerbosityFlag.Name)))
 	log.Root().SetHandler(glogger)
 	logconfig := &logger.Config{
-		EnableMemory:     !ctx.Bool(DisableMemoryFlag.Name),
-		DisableStack:     ctx.Bool(DisableStackFlag.Name),
-		DisableStorage:   ctx.Bool(DisableStorageFlag.Name),
-		EnableReturnData: !ctx.Bool(DisableReturnDataFlag.Name),
-		Debug:            ctx.Bool(DebugFlag.Name),
+		EnableMemory:     !ctx.GlobalBool(DisableMemoryFlag.Name),
+		DisableStack:     ctx.GlobalBool(DisableStackFlag.Name),
+		DisableStorage:   ctx.GlobalBool(DisableStorageFlag.Name),
+		EnableReturnData: !ctx.GlobalBool(DisableReturnDataFlag.Name),
+		Debug:            ctx.GlobalBool(DebugFlag.Name),
 	}
 
 	var (
@@ -126,37 +125,37 @@ func runCmd(ctx *cli.Context) error {
 		receiver      = common.BytesToAddress([]byte("receiver"))
 		genesisConfig *core.Genesis
 	)
-	if ctx.Bool(MachineFlag.Name) {
+	if ctx.GlobalBool(MachineFlag.Name) {
 		tracer = logger.NewJSONLogger(logconfig, os.Stdout)
-	} else if ctx.Bool(DebugFlag.Name) {
+	} else if ctx.GlobalBool(DebugFlag.Name) {
 		debugLogger = logger.NewStructLogger(logconfig)
 		tracer = debugLogger
 	} else {
 		debugLogger = logger.NewStructLogger(logconfig)
 	}
-	if ctx.String(GenesisFlag.Name) != "" {
-		gen := readGenesis(ctx.String(GenesisFlag.Name))
+	if ctx.GlobalString(GenesisFlag.Name) != "" {
+		gen := readGenesis(ctx.GlobalString(GenesisFlag.Name))
 		genesisConfig = gen
 		db := rawdb.NewMemoryDatabase()
-		genesis := gen.MustCommit(db)
+		genesis := gen.ToBlock(db)
 		statedb, _ = state.New(genesis.Root(), state.NewDatabase(db), nil)
 		chainConfig = gen.Config
 	} else {
 		statedb, _ = state.New(common.Hash{}, state.NewDatabase(rawdb.NewMemoryDatabase()), nil)
 		genesisConfig = new(core.Genesis)
 	}
-	if ctx.String(SenderFlag.Name) != "" {
-		sender = common.HexToAddress(ctx.String(SenderFlag.Name))
+	if ctx.GlobalString(SenderFlag.Name) != "" {
+		sender = common.HexToAddress(ctx.GlobalString(SenderFlag.Name))
 	}
 	statedb.CreateAccount(sender)
 
-	if ctx.String(ReceiverFlag.Name) != "" {
-		receiver = common.HexToAddress(ctx.String(ReceiverFlag.Name))
+	if ctx.GlobalString(ReceiverFlag.Name) != "" {
+		receiver = common.HexToAddress(ctx.GlobalString(ReceiverFlag.Name))
 	}
 
 	var code []byte
-	codeFileFlag := ctx.String(CodeFileFlag.Name)
-	codeFlag := ctx.String(CodeFlag.Name)
+	codeFileFlag := ctx.GlobalString(CodeFileFlag.Name)
+	codeFlag := ctx.GlobalString(CodeFlag.Name)
 
 	// The '--code' or '--codefile' flag overrides code in state
 	if codeFileFlag != "" || codeFlag != "" {
@@ -198,7 +197,7 @@ func runCmd(ctx *cli.Context) error {
 		}
 		code = common.Hex2Bytes(bin)
 	}
-	initialGas := ctx.Uint64(GasFlag.Name)
+	initialGas := ctx.GlobalUint64(GasFlag.Name)
 	if genesisConfig.GasLimit != 0 {
 		initialGas = genesisConfig.GasLimit
 	}
@@ -206,19 +205,19 @@ func runCmd(ctx *cli.Context) error {
 		Origin:      sender,
 		State:       statedb,
 		GasLimit:    initialGas,
-		GasPrice:    flags.GlobalBig(ctx, PriceFlag.Name),
-		Value:       flags.GlobalBig(ctx, ValueFlag.Name),
+		GasPrice:    utils.GlobalBig(ctx, PriceFlag.Name),
+		Value:       utils.GlobalBig(ctx, ValueFlag.Name),
 		Difficulty:  genesisConfig.Difficulty,
 		Time:        new(big.Int).SetUint64(genesisConfig.Timestamp),
 		Coinbase:    genesisConfig.Coinbase,
 		BlockNumber: new(big.Int).SetUint64(genesisConfig.Number),
 		EVMConfig: vm.Config{
 			Tracer: tracer,
-			Debug:  ctx.Bool(DebugFlag.Name) || ctx.Bool(MachineFlag.Name),
+			Debug:  ctx.GlobalBool(DebugFlag.Name) || ctx.GlobalBool(MachineFlag.Name),
 		},
 	}
 
-	if cpuProfilePath := ctx.String(CPUProfileFlag.Name); cpuProfilePath != "" {
+	if cpuProfilePath := ctx.GlobalString(CPUProfileFlag.Name); cpuProfilePath != "" {
 		f, err := os.Create(cpuProfilePath)
 		if err != nil {
 			fmt.Println("could not create CPU profile: ", err)
@@ -238,14 +237,14 @@ func runCmd(ctx *cli.Context) error {
 	}
 
 	var hexInput []byte
-	if inputFileFlag := ctx.String(InputFileFlag.Name); inputFileFlag != "" {
+	if inputFileFlag := ctx.GlobalString(InputFileFlag.Name); inputFileFlag != "" {
 		var err error
 		if hexInput, err = os.ReadFile(inputFileFlag); err != nil {
 			fmt.Printf("could not load input from file: %v\n", err)
 			os.Exit(1)
 		}
 	} else {
-		hexInput = []byte(ctx.String(InputFlag.Name))
+		hexInput = []byte(ctx.GlobalString(InputFlag.Name))
 	}
 	hexInput = bytes.TrimSpace(hexInput)
 	if len(hexInput)%2 != 0 {
@@ -255,7 +254,7 @@ func runCmd(ctx *cli.Context) error {
 	input := common.FromHex(string(hexInput))
 
 	var execFunc func() ([]byte, uint64, error)
-	if ctx.Bool(CreateFlag.Name) {
+	if ctx.GlobalBool(CreateFlag.Name) {
 		input = append(code, input...)
 		execFunc = func() ([]byte, uint64, error) {
 			output, _, gasLeft, err := runtime.Create(input, &runtimeConfig)
@@ -270,16 +269,16 @@ func runCmd(ctx *cli.Context) error {
 		}
 	}
 
-	bench := ctx.Bool(BenchFlag.Name)
+	bench := ctx.GlobalBool(BenchFlag.Name)
 	output, leftOverGas, stats, err := timedExec(bench, execFunc)
 
-	if ctx.Bool(DumpFlag.Name) {
+	if ctx.GlobalBool(DumpFlag.Name) {
 		statedb.Commit(true)
 		statedb.IntermediateRoot(true)
 		fmt.Println(string(statedb.Dump(nil)))
 	}
 
-	if memProfilePath := ctx.String(MemProfileFlag.Name); memProfilePath != "" {
+	if memProfilePath := ctx.GlobalString(MemProfileFlag.Name); memProfilePath != "" {
 		f, err := os.Create(memProfilePath)
 		if err != nil {
 			fmt.Println("could not create memory profile: ", err)
@@ -292,7 +291,7 @@ func runCmd(ctx *cli.Context) error {
 		f.Close()
 	}
 
-	if ctx.Bool(DebugFlag.Name) {
+	if ctx.GlobalBool(DebugFlag.Name) {
 		if debugLogger != nil {
 			fmt.Fprintln(os.Stderr, "#### TRACE ####")
 			logger.WriteTrace(os.Stderr, debugLogger.StructLogs())
@@ -301,7 +300,7 @@ func runCmd(ctx *cli.Context) error {
 		logger.WriteLogs(os.Stderr, statedb.Logs())
 	}
 
-	if bench || ctx.Bool(StatDumpFlag.Name) {
+	if bench || ctx.GlobalBool(StatDumpFlag.Name) {
 		fmt.Fprintf(os.Stderr, `EVM gas used:    %d
 execution time:  %v
 allocations:     %d
@@ -309,7 +308,7 @@ allocated bytes: %d
 `, initialGas-leftOverGas, stats.time, stats.allocs, stats.bytesAllocated)
 	}
 	if tracer == nil {
-		fmt.Printf("%#x\n", output)
+		fmt.Printf("0x%x\n", output)
 		if err != nil {
 			fmt.Printf(" error: %v\n", err)
 		}

cmd/evm/staterunner.go

@@ -28,10 +28,10 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/tests"
 
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
-var stateTestCommand = &cli.Command{
+var stateTestCommand = cli.Command{
 	Action:    stateTestCmd,
 	Name:      "statetest",
 	Usage:     "executes the given state tests",
@@ -54,25 +54,25 @@ func stateTestCmd(ctx *cli.Context) error {
 	}
 	// Configure the go-ethereum logger
 	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.TerminalFormat(false)))
-	glogger.Verbosity(log.Lvl(ctx.Int(VerbosityFlag.Name)))
+	glogger.Verbosity(log.Lvl(ctx.GlobalInt(VerbosityFlag.Name)))
 	log.Root().SetHandler(glogger)
 
 	// Configure the EVM logger
 	config := &logger.Config{
-		EnableMemory:     !ctx.Bool(DisableMemoryFlag.Name),
-		DisableStack:     ctx.Bool(DisableStackFlag.Name),
-		DisableStorage:   ctx.Bool(DisableStorageFlag.Name),
-		EnableReturnData: !ctx.Bool(DisableReturnDataFlag.Name),
+		EnableMemory:     !ctx.GlobalBool(DisableMemoryFlag.Name),
+		DisableStack:     ctx.GlobalBool(DisableStackFlag.Name),
+		DisableStorage:   ctx.GlobalBool(DisableStorageFlag.Name),
+		EnableReturnData: !ctx.GlobalBool(DisableReturnDataFlag.Name),
 	}
 	var (
 		tracer   vm.EVMLogger
 		debugger *logger.StructLogger
 	)
 	switch {
-	case ctx.Bool(MachineFlag.Name):
+	case ctx.GlobalBool(MachineFlag.Name):
 		tracer = logger.NewJSONLogger(config, os.Stderr)
 
-	case ctx.Bool(DebugFlag.Name):
+	case ctx.GlobalBool(DebugFlag.Name):
 		debugger = logger.NewStructLogger(config)
 		tracer = debugger
 
@@ -91,7 +91,7 @@ func stateTestCmd(ctx *cli.Context) error {
 	// Iterate over all the tests, run them and aggregate the results
 	cfg := vm.Config{
 		Tracer: tracer,
-		Debug:  ctx.Bool(DebugFlag.Name) || ctx.Bool(MachineFlag.Name),
+		Debug:  ctx.GlobalBool(DebugFlag.Name) || ctx.GlobalBool(MachineFlag.Name),
 	}
 	results := make([]StatetestResult, 0, len(tests))
 	for key, test := range tests {
@@ -100,13 +100,13 @@ func stateTestCmd(ctx *cli.Context) error {
 			result := &StatetestResult{Name: key, Fork: st.Fork, Pass: true}
 			_, s, err := test.Run(st, cfg, false)
 			// print state root for evmlab tracing
-			if ctx.Bool(MachineFlag.Name) && s != nil {
+			if ctx.GlobalBool(MachineFlag.Name) && s != nil {
 				fmt.Fprintf(os.Stderr, "{\"stateRoot\": \"%x\"}\n", s.IntermediateRoot(false))
 			}
 			if err != nil {
 				// Test failed, mark as so and dump any state to aid debugging
 				result.Pass, result.Error = false, err.Error()
-				if ctx.Bool(DumpFlag.Name) && s != nil {
+				if ctx.GlobalBool(DumpFlag.Name) && s != nil {
 					dump := s.RawDump(nil)
 					result.State = &dump
 				}
@@ -115,7 +115,7 @@ func stateTestCmd(ctx *cli.Context) error {
 			results = append(results, *result)
 
 			// Print any structured logs collected
-			if ctx.Bool(DebugFlag.Name) {
+			if ctx.GlobalBool(DebugFlag.Name) {
 				if debugger != nil {
 					fmt.Fprintln(os.Stderr, "#### TRACE ####")
 					logger.WriteTrace(os.Stderr, debugger.StructLogs())

cmd/evm/t8n_test.go

@@ -1,19 +1,3 @@
-// Copyright 2021 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
 package main
 
 import (
@@ -211,14 +195,6 @@ func TestT8n(t *testing.T) {
 			output: t8nOutput{result: true},
 			expOut: "exp_arrowglacier.json",
 		},
-		{ // Difficulty calculation on gray glacier
-			base: "./testdata/19",
-			input: t8nInput{
-				"alloc.json", "txs.json", "env.json", "GrayGlacier", "",
-			},
-			output: t8nOutput{result: true},
-			expOut: "exp_grayglacier.json",
-		},
 		{ // Sign unprotected (pre-EIP155) transaction
 			base: "./testdata/23",
 			input: t8nInput{
@@ -244,6 +220,7 @@ func TestT8n(t *testing.T) {
 			expExitCode: 3,
 		},
 	} {
+
 		args := []string{"t8n"}
 		args = append(args, tc.output.get()...)
 		args = append(args, tc.input.get(tc.base)...)
@@ -354,6 +331,7 @@ func TestT9n(t *testing.T) {
 			expExitCode: t8ntool.ErrorIO,
 		},
 	} {
+
 		args := []string{"t9n"}
 		args = append(args, tc.input.get(tc.base)...)
 
@@ -473,6 +451,7 @@ func TestB11r(t *testing.T) {
 			expOut: "exp.json",
 		},
 	} {
+
 		args := []string{"b11r"}
 		args = append(args, tc.input.get(tc.base)...)
 

cmd/evm/testdata/19/exp_grayglacier.json

@@ -1,12 +0,0 @@
-{
-    "result": {
-      "stateRoot": "0x6f058887ca01549716789c380ede95aecc510e6d1fdc4dbf67d053c7c07f4bdc",
-      "txRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
-      "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
-      "logsHash": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
-      "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-      "receipts": [],
-      "currentDifficulty": "0x2000000004000",
-      "gasUsed": "0x0"
-    }
-}

cmd/evm/testdata/19/readme.md

@@ -1,9 +1,9 @@
 ## Difficulty calculation
 
 This test shows how the `evm t8n` can be used to calculate the (ethash) difficulty, if none is provided by the caller, 
-this time on `GrayGlacier` (Eip 5133).
+this time on `ArrowGlacier` (Eip 4345).
 
-Calculating it (with an empty set of txs) using `GrayGlacier` rules (and no provided unclehash for the parent block):
+Calculating it (with an empty set of txs) using `ArrowGlacier` rules (and no provided unclehash for the parent block):
 ```
-[user@work evm]$ ./evm t8n --input.alloc=./testdata/19/alloc.json --input.txs=./testdata/19/txs.json --input.env=./testdata/19/env.json --output.result=stdout --state.fork=GrayGlacier
+[user@work evm]$ ./evm t8n --input.alloc=./testdata/14/alloc.json --input.txs=./testdata/14/txs.json --input.env=./testdata/14/env.json --output.result=stdout --state.fork=ArrowGlacier
 ```

cmd/faucet/README.md

@@ -10,10 +10,9 @@ The `faucet` is a single binary app (everything included) with all configuration
 
 First thing's first, the `faucet` needs to connect to an Ethereum network, for which it needs the necessary genesis and network infos. Each of the following flags must be set:
 
-- `-genesis` is a path to a file containing the network `genesis.json`. or using:
+- `-genesis` is a path to a file containin the network `genesis.json`. or using:
   - `-goerli` with the faucet with Görli network config
   - `-rinkeby` with the faucet with Rinkeby network config
-  - `-sepolia` with the faucet with Sepolia network config
 - `-network` is the devp2p network id used during connection
 - `-bootnodes` is a list of `enode://` ids to join the network through
 

cmd/faucet/faucet.go

@@ -86,7 +86,6 @@ var (
 
 	goerliFlag  = flag.Bool("goerli", false, "Initializes the faucet with Görli network config")
 	rinkebyFlag = flag.Bool("rinkeby", false, "Initializes the faucet with Rinkeby network config")
-	sepoliaFlag = flag.Bool("sepolia", false, "Initializes the faucet with Sepolia network config")
 )
 
 var (
@@ -144,7 +143,7 @@ func main() {
 		log.Crit("Failed to render the faucet template", "err", err)
 	}
 	// Load and parse the genesis block requested by the user
-	genesis, err := getGenesis(*genesisFlag, *goerliFlag, *rinkebyFlag, *sepoliaFlag)
+	genesis, err := getGenesis(*genesisFlag, *goerliFlag, *rinkebyFlag)
 	if err != nil {
 		log.Crit("Failed to parse genesis config", "err", err)
 	}
@@ -248,7 +247,7 @@ func newFaucet(genesis *core.Genesis, port int, enodes []*enode.Node, network ui
 	cfg.SyncMode = downloader.LightSync
 	cfg.NetworkId = network
 	cfg.Genesis = genesis
-	utils.SetDNSDiscoveryDefaults(&cfg, genesis.ToBlock().Hash())
+	utils.SetDNSDiscoveryDefaults(&cfg, genesis.ToBlock(nil).Hash())
 
 	lesBackend, err := les.New(stack, &cfg)
 	if err != nil {
@@ -709,7 +708,7 @@ func authTwitter(url string, tokenV1, tokenV2 string) (string, string, string, c
 	case tokenV2 != "":
 		return authTwitterWithTokenV2(tweetID, tokenV2)
 	}
-	// Twitter API token isn't provided so we just load the public posts
+	// Twiter API token isn't provided so we just load the public posts
 	// and scrape it for the Ethereum address and profile URL. We need to load
 	// the mobile page though since the main page loads tweet contents via JS.
 	url = strings.Replace(url, "https://twitter.com/", "https://mobile.twitter.com/", 1)
@@ -861,7 +860,7 @@ func authFacebook(url string) (string, string, common.Address, error) {
 	address := common.HexToAddress(string(regexp.MustCompile("0x[0-9a-fA-F]{40}").Find(body)))
 	if address == (common.Address{}) {
 		//lint:ignore ST1005 This error is to be displayed in the browser
-		return "", "", common.Address{}, errors.New("No Ethereum address found to fund. Please check the post URL and verify that it can be viewed publicly.")
+		return "", "", common.Address{}, errors.New("No Ethereum address found to fund")
 	}
 	var avatar string
 	if parts = regexp.MustCompile(`src="([^"]+fbcdn\.net[^"]+)"`).FindStringSubmatch(string(body)); len(parts) == 2 {
@@ -883,7 +882,7 @@ func authNoAuth(url string) (string, string, common.Address, error) {
 }
 
 // getGenesis returns a genesis based on input args
-func getGenesis(genesisFlag string, goerliFlag bool, rinkebyFlag bool, sepoliaFlag bool) (*core.Genesis, error) {
+func getGenesis(genesisFlag string, goerliFlag bool, rinkebyFlag bool) (*core.Genesis, error) {
 	switch {
 	case genesisFlag != "":
 		var genesis core.Genesis
@@ -893,8 +892,6 @@ func getGenesis(genesisFlag string, goerliFlag bool, rinkebyFlag bool, sepoliaFl
 		return core.DefaultGoerliGenesisBlock(), nil
 	case rinkebyFlag:
 		return core.DefaultRinkebyGenesisBlock(), nil
-	case sepoliaFlag:
-		return core.DefaultSepoliaGenesisBlock(), nil
 	default:
 		return nil, fmt.Errorf("no genesis flag provided")
 	}

cmd/geth/accountcmd.go

@@ -25,27 +25,29 @@ import (
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
-	walletCommand = &cli.Command{
+	walletCommand = cli.Command{
 		Name:      "wallet",
 		Usage:     "Manage Ethereum presale wallets",
 		ArgsUsage: "",
+		Category:  "ACCOUNT COMMANDS",
 		Description: `
     geth wallet import /path/to/my/presale.wallet
 
 will prompt for your password and imports your ether presale account.
 It can be used non-interactively with the --password option taking a
 passwordfile as argument containing the wallet password in plaintext.`,
-		Subcommands: []*cli.Command{
+		Subcommands: []cli.Command{
 			{
 
 				Name:      "import",
 				Usage:     "Import Ethereum presale wallet",
 				ArgsUsage: "<keyFile>",
-				Action:    importWallet,
+				Action:    utils.MigrateFlags(importWallet),
+				Category:  "ACCOUNT COMMANDS",
 				Flags: []cli.Flag{
 					utils.DataDirFlag,
 					utils.KeyStoreDirFlag,
@@ -62,9 +64,10 @@ passwordfile as argument containing the wallet password in plaintext.`,
 		},
 	}
 
-	accountCommand = &cli.Command{
-		Name:  "account",
-		Usage: "Manage accounts",
+	accountCommand = cli.Command{
+		Name:     "account",
+		Usage:    "Manage accounts",
+		Category: "ACCOUNT COMMANDS",
 		Description: `
 
 Manage accounts, list all existing accounts, import a private key into a new
@@ -85,11 +88,11 @@ It is safe to transfer the entire directory or the individual keys therein
 between ethereum nodes by simply copying.
 
 Make sure you backup your keys regularly.`,
-		Subcommands: []*cli.Command{
+		Subcommands: []cli.Command{
 			{
 				Name:   "list",
 				Usage:  "Print summary of existing accounts",
-				Action: accountList,
+				Action: utils.MigrateFlags(accountList),
 				Flags: []cli.Flag{
 					utils.DataDirFlag,
 					utils.KeyStoreDirFlag,
@@ -100,7 +103,7 @@ Print a short summary of all accounts`,
 			{
 				Name:   "new",
 				Usage:  "Create a new account",
-				Action: accountCreate,
+				Action: utils.MigrateFlags(accountCreate),
 				Flags: []cli.Flag{
 					utils.DataDirFlag,
 					utils.KeyStoreDirFlag,
@@ -125,7 +128,7 @@ password to file or expose in any other way.
 			{
 				Name:      "update",
 				Usage:     "Update an existing account",
-				Action:    accountUpdate,
+				Action:    utils.MigrateFlags(accountUpdate),
 				ArgsUsage: "<address>",
 				Flags: []cli.Flag{
 					utils.DataDirFlag,
@@ -154,7 +157,7 @@ changing your password is only possible interactively.
 			{
 				Name:   "import",
 				Usage:  "Import a private key into a new account",
-				Action: accountImport,
+				Action: utils.MigrateFlags(accountImport),
 				Flags: []cli.Flag{
 					utils.DataDirFlag,
 					utils.KeyStoreDirFlag,
@@ -236,15 +239,14 @@ func ambiguousAddrRecovery(ks *keystore.KeyStore, err *keystore.AmbiguousAddrErr
 	}
 	fmt.Println("Testing your password against all of them...")
 	var match *accounts.Account
-	for i, a := range err.Matches {
-		if e := ks.Unlock(a, auth); e == nil {
-			match = &err.Matches[i]
+	for _, a := range err.Matches {
+		if err := ks.Unlock(a, auth); err == nil {
+			match = &a
 			break
 		}
 	}
 	if match == nil {
 		utils.Fatalf("None of the listed files could be unlocked.")
-		return accounts.Account{}
 	}
 	fmt.Printf("Your password unlocked %s\n", match.URL)
 	fmt.Println("In order to avoid this warning, you need to remove the following duplicate key files:")
@@ -260,7 +262,7 @@ func ambiguousAddrRecovery(ks *keystore.KeyStore, err *keystore.AmbiguousAddrErr
 func accountCreate(ctx *cli.Context) error {
 	cfg := gethConfig{Node: defaultNodeConfig()}
 	// Load config file.
-	if file := ctx.String(configFileFlag.Name); file != "" {
+	if file := ctx.GlobalString(configFileFlag.Name); file != "" {
 		if err := loadConfig(file, &cfg); err != nil {
 			utils.Fatalf("%v", err)
 		}
@@ -297,13 +299,13 @@ func accountCreate(ctx *cli.Context) error {
 // accountUpdate transitions an account from a previous format to the current
 // one, also providing the possibility to change the pass-phrase.
 func accountUpdate(ctx *cli.Context) error {
-	if ctx.Args().Len() == 0 {
+	if len(ctx.Args()) == 0 {
 		utils.Fatalf("No accounts specified to update")
 	}
 	stack, _ := makeConfigNode(ctx)
 	ks := stack.AccountManager().Backends(keystore.KeyStoreType)[0].(*keystore.KeyStore)
 
-	for _, addr := range ctx.Args().Slice() {
+	for _, addr := range ctx.Args() {
 		account, oldPassword := unlockAccount(ks, addr, 0, nil)
 		newPassword := utils.GetPassPhraseWithList("Please give a new password. Do not forget this password.", true, 0, nil)
 		if err := ks.Update(account, oldPassword, newPassword); err != nil {
@@ -314,10 +316,10 @@ func accountUpdate(ctx *cli.Context) error {
 }
 
 func importWallet(ctx *cli.Context) error {
-	if ctx.Args().Len() != 1 {
-		utils.Fatalf("keyfile must be given as the only argument")
-	}
 	keyfile := ctx.Args().First()
+	if len(keyfile) == 0 {
+		utils.Fatalf("keyfile must be given as argument")
+	}
 	keyJSON, err := os.ReadFile(keyfile)
 	if err != nil {
 		utils.Fatalf("Could not read wallet file: %v", err)
@@ -336,10 +338,10 @@ func importWallet(ctx *cli.Context) error {
 }
 
 func accountImport(ctx *cli.Context) error {
-	if ctx.Args().Len() != 1 {
-		utils.Fatalf("keyfile must be given as the only argument")
-	}
 	keyfile := ctx.Args().First()
+	if len(keyfile) == 0 {
+		utils.Fatalf("keyfile must be given as argument")
+	}
 	key, err := crypto.LoadECDSA(keyfile)
 	if err != nil {
 		utils.Fatalf("Failed to load the private key: %v", err)

cmd/geth/accountcmd_test.go

@@ -49,27 +49,20 @@ func TestAccountListEmpty(t *testing.T) {
 
 func TestAccountList(t *testing.T) {
 	datadir := tmpDatadirWithKeystore(t)
-	var want = `
-Account #0: {7ef5a6135f1fd6a02593eedc869c6d41d934aef8} keystore://{{.Datadir}}/keystore/UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8
-Account #1: {f466859ead1932d743d622cb74fc058882e8648a} keystore://{{.Datadir}}/keystore/aaa
-Account #2: {289d485d9771714cce91d3393d764e1311907acc} keystore://{{.Datadir}}/keystore/zzz
-`
+	geth := runGeth(t, "account", "list", "--datadir", datadir)
+	defer geth.ExpectExit()
 	if runtime.GOOS == "windows" {
-		want = `
+		geth.Expect(`
 Account #0: {7ef5a6135f1fd6a02593eedc869c6d41d934aef8} keystore://{{.Datadir}}\keystore\UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8
 Account #1: {f466859ead1932d743d622cb74fc058882e8648a} keystore://{{.Datadir}}\keystore\aaa
 Account #2: {289d485d9771714cce91d3393d764e1311907acc} keystore://{{.Datadir}}\keystore\zzz
-`
-	}
-	{
-		geth := runGeth(t, "account", "list", "--datadir", datadir)
-		geth.Expect(want)
-		geth.ExpectExit()
-	}
-	{
-		geth := runGeth(t, "--datadir", datadir, "account", "list")
-		geth.Expect(want)
-		geth.ExpectExit()
+`)
+	} else {
+		geth.Expect(`
+Account #0: {7ef5a6135f1fd6a02593eedc869c6d41d934aef8} keystore://{{.Datadir}}/keystore/UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8
+Account #1: {f466859ead1932d743d622cb74fc058882e8648a} keystore://{{.Datadir}}/keystore/aaa
+Account #2: {289d485d9771714cce91d3393d764e1311907acc} keystore://{{.Datadir}}/keystore/zzz
+`)
 	}
 }
 
@@ -117,20 +110,6 @@ func TestAccountImport(t *testing.T) {
 	}
 }
 
-func TestAccountHelp(t *testing.T) {
-	geth := runGeth(t, "account", "-h")
-	geth.WaitExit()
-	if have, want := geth.ExitStatus(), 0; have != want {
-		t.Errorf("exit error, have %d want %d", have, want)
-	}
-
-	geth = runGeth(t, "account", "import", "-h")
-	geth.WaitExit()
-	if have, want := geth.ExitStatus(), 0; have != want {
-		t.Errorf("exit error, have %d want %d", have, want)
-	}
-}
-
 func importAccountWithExpect(t *testing.T, key string, expected string) {
 	dir := t.TempDir()
 	keyfile := filepath.Join(dir, "key.prv")
@@ -141,7 +120,7 @@ func importAccountWithExpect(t *testing.T, key string, expected string) {
 	if err := os.WriteFile(passwordFile, []byte("foobar"), 0600); err != nil {
 		t.Error(err)
 	}
-	geth := runGeth(t, "--lightkdf", "account", "import", "-password", passwordFile, keyfile)
+	geth := runGeth(t, "--lightkdf", "account", "import", keyfile, "-password", passwordFile)
 	defer geth.ExpectExit()
 	geth.Expect(expected)
 }
@@ -201,12 +180,11 @@ Fatal: could not decrypt key with given password
 
 func TestUnlockFlag(t *testing.T) {
 	geth := runMinimalGeth(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
-		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "console", "--exec", "loadScript('testdata/empty.js')")
+		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "js", "testdata/empty.js")
 	geth.Expect(`
 Unlocking account f466859ead1932d743d622cb74fc058882e8648a | Attempt 1/3
 !! Unsupported terminal, password will be echoed.
 Password: {{.InputLine "foobar"}}
-undefined
 `)
 	geth.ExpectExit()
 
@@ -223,7 +201,7 @@ undefined
 
 func TestUnlockFlagWrongPassword(t *testing.T) {
 	geth := runMinimalGeth(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
-		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "console", "--exec", "loadScript('testdata/empty.js')")
+		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "js", "testdata/empty.js")
 
 	defer geth.ExpectExit()
 	geth.Expect(`
@@ -241,7 +219,7 @@ Fatal: Failed to unlock account f466859ead1932d743d622cb74fc058882e8648a (could
 // https://github.com/ethereum/go-ethereum/issues/1785
 func TestUnlockFlagMultiIndex(t *testing.T) {
 	geth := runMinimalGeth(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
-		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "--unlock", "0,2", "console", "--exec", "loadScript('testdata/empty.js')")
+		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "--unlock", "0,2", "js", "testdata/empty.js")
 
 	geth.Expect(`
 Unlocking account 0 | Attempt 1/3
@@ -249,7 +227,6 @@ Unlocking account 0 | Attempt 1/3
 Password: {{.InputLine "foobar"}}
 Unlocking account 2 | Attempt 1/3
 Password: {{.InputLine "foobar"}}
-undefined
 `)
 	geth.ExpectExit()
 
@@ -267,11 +244,8 @@ undefined
 
 func TestUnlockFlagPasswordFile(t *testing.T) {
 	geth := runMinimalGeth(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
-		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "--password", "testdata/passwords.txt", "--unlock", "0,2", "console", "--exec", "loadScript('testdata/empty.js')")
+		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "--password", "testdata/passwords.txt", "--unlock", "0,2", "js", "testdata/empty.js")
 
-	geth.Expect(`
-undefined
-`)
 	geth.ExpectExit()
 
 	wantMessages := []string{
@@ -301,7 +275,7 @@ func TestUnlockFlagAmbiguous(t *testing.T) {
 	geth := runMinimalGeth(t, "--port", "0", "--ipcdisable", "--datadir", tmpDatadirWithKeystore(t),
 		"--unlock", "f466859ead1932d743d622cb74fc058882e8648a", "--keystore",
 		store, "--unlock", "f466859ead1932d743d622cb74fc058882e8648a",
-		"console", "--exec", "loadScript('testdata/empty.js')")
+		"js", "testdata/empty.js")
 	defer geth.ExpectExit()
 
 	// Helper for the expect template, returns absolute keystore path.
@@ -320,7 +294,6 @@ Testing your password against all of them...
 Your password unlocked keystore://{{keypath "1"}}
 In order to avoid this warning, you need to remove the following duplicate key files:
    keystore://{{keypath "2"}}
-undefined
 `)
 	geth.ExpectExit()
 

cmd/geth/chaincmd.go

@@ -35,20 +35,20 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/internal/flags"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethereum/go-ethereum/node"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
-	initCommand = &cli.Command{
-		Action:    initGenesis,
+	initCommand = cli.Command{
+		Action:    utils.MigrateFlags(initGenesis),
 		Name:      "init",
 		Usage:     "Bootstrap and initialize a new genesis block",
 		ArgsUsage: "<genesisPath>",
 		Flags:     utils.DatabasePathFlags,
+		Category:  "BLOCKCHAIN COMMANDS",
 		Description: `
 The init command initializes a new genesis block and definition for the network.
 This is a destructive action and changes the network in which you will be
@@ -56,21 +56,22 @@ participating.
 
 It expects the genesis file as argument.`,
 	}
-	dumpGenesisCommand = &cli.Command{
-		Action:    dumpGenesis,
+	dumpGenesisCommand = cli.Command{
+		Action:    utils.MigrateFlags(dumpGenesis),
 		Name:      "dumpgenesis",
 		Usage:     "Dumps genesis block JSON configuration to stdout",
 		ArgsUsage: "",
 		Flags:     utils.NetworkFlags,
+		Category:  "BLOCKCHAIN COMMANDS",
 		Description: `
 The dumpgenesis command dumps the genesis block configuration in JSON format to stdout.`,
 	}
-	importCommand = &cli.Command{
-		Action:    importChain,
+	importCommand = cli.Command{
+		Action:    utils.MigrateFlags(importChain),
 		Name:      "import",
 		Usage:     "Import a blockchain file",
 		ArgsUsage: "<filename> (<filename 2> ... <filename N>) ",
-		Flags: flags.Merge([]cli.Flag{
+		Flags: append([]cli.Flag{
 			utils.CacheFlag,
 			utils.SyncModeFlag,
 			utils.GCModeFlag,
@@ -92,7 +93,8 @@ The dumpgenesis command dumps the genesis block configuration in JSON format to
 			utils.MetricsInfluxDBBucketFlag,
 			utils.MetricsInfluxDBOrganizationFlag,
 			utils.TxLookupLimitFlag,
-		}, utils.DatabasePathFlags),
+		}, utils.DatabasePathFlags...),
+		Category: "BLOCKCHAIN COMMANDS",
 		Description: `
 The import command imports blocks from an RLP-encoded form. The form can be one file
 with several RLP-encoded blocks, or several files can be used.
@@ -100,15 +102,16 @@ with several RLP-encoded blocks, or several files can be used.
 If only one file is used, import error will result in failure. If several files are used,
 processing will proceed even if an individual RLP-file import failure occurs.`,
 	}
-	exportCommand = &cli.Command{
-		Action:    exportChain,
+	exportCommand = cli.Command{
+		Action:    utils.MigrateFlags(exportChain),
 		Name:      "export",
 		Usage:     "Export blockchain into file",
 		ArgsUsage: "<filename> [<blockNumFirst> <blockNumLast>]",
-		Flags: flags.Merge([]cli.Flag{
+		Flags: append([]cli.Flag{
 			utils.CacheFlag,
 			utils.SyncModeFlag,
-		}, utils.DatabasePathFlags),
+		}, utils.DatabasePathFlags...),
+		Category: "BLOCKCHAIN COMMANDS",
 		Description: `
 Requires a first argument of the file to write to.
 Optional second and third arguments control the first and
@@ -116,40 +119,42 @@ last block to write. In this mode, the file will be appended
 if already existing. If the file ends with .gz, the output will
 be gzipped.`,
 	}
-	importPreimagesCommand = &cli.Command{
-		Action:    importPreimages,
+	importPreimagesCommand = cli.Command{
+		Action:    utils.MigrateFlags(importPreimages),
 		Name:      "import-preimages",
 		Usage:     "Import the preimage database from an RLP stream",
 		ArgsUsage: "<datafile>",
-		Flags: flags.Merge([]cli.Flag{
+		Flags: append([]cli.Flag{
 			utils.CacheFlag,
 			utils.SyncModeFlag,
-		}, utils.DatabasePathFlags),
+		}, utils.DatabasePathFlags...),
+		Category: "BLOCKCHAIN COMMANDS",
 		Description: `
 The import-preimages command imports hash preimages from an RLP encoded stream.
 It's deprecated, please use "geth db import" instead.
 `,
 	}
-	exportPreimagesCommand = &cli.Command{
-		Action:    exportPreimages,
+	exportPreimagesCommand = cli.Command{
+		Action:    utils.MigrateFlags(exportPreimages),
 		Name:      "export-preimages",
 		Usage:     "Export the preimage database into an RLP stream",
 		ArgsUsage: "<dumpfile>",
-		Flags: flags.Merge([]cli.Flag{
+		Flags: append([]cli.Flag{
 			utils.CacheFlag,
 			utils.SyncModeFlag,
-		}, utils.DatabasePathFlags),
+		}, utils.DatabasePathFlags...),
+		Category: "BLOCKCHAIN COMMANDS",
 		Description: `
 The export-preimages command exports hash preimages to an RLP encoded stream.
 It's deprecated, please use "geth db export" instead.
 `,
 	}
-	dumpCommand = &cli.Command{
-		Action:    dump,
+	dumpCommand = cli.Command{
+		Action:    utils.MigrateFlags(dump),
 		Name:      "dump",
 		Usage:     "Dump a specific block from storage",
 		ArgsUsage: "[? <blockHash> | <blockNum>]",
-		Flags: flags.Merge([]cli.Flag{
+		Flags: append([]cli.Flag{
 			utils.CacheFlag,
 			utils.IterativeOutputFlag,
 			utils.ExcludeCodeFlag,
@@ -157,7 +162,8 @@ It's deprecated, please use "geth db export" instead.
 			utils.IncludeIncompletesFlag,
 			utils.StartKeyFlag,
 			utils.DumpLimitFlag,
-		}, utils.DatabasePathFlags),
+		}, utils.DatabasePathFlags...),
+		Category: "BLOCKCHAIN COMMANDS",
 		Description: `
 This command dumps out the state for a given block (or latest, if none provided).
 `,
@@ -167,12 +173,10 @@ This command dumps out the state for a given block (or latest, if none provided)
 // initGenesis will initialise the given JSON format genesis file and writes it as
 // the zero'd block (i.e. genesis) or will fail hard if it can't succeed.
 func initGenesis(ctx *cli.Context) error {
-	if ctx.Args().Len() != 1 {
-		utils.Fatalf("need genesis.json file as the only argument")
-	}
+	// Make sure we have a valid genesis JSON
 	genesisPath := ctx.Args().First()
 	if len(genesisPath) == 0 {
-		utils.Fatalf("invalid path to genesis file")
+		utils.Fatalf("Must supply path to genesis JSON file")
 	}
 	file, err := os.Open(genesisPath)
 	if err != nil {
@@ -188,7 +192,7 @@ func initGenesis(ctx *cli.Context) error {
 	stack, _ := makeConfigNode(ctx)
 	defer stack.Close()
 	for _, name := range []string{"chaindata", "lightchaindata"} {
-		chaindb, err := stack.OpenDatabaseWithFreezer(name, 0, 0, ctx.String(utils.AncientFlag.Name), "", false)
+		chaindb, err := stack.OpenDatabaseWithFreezer(name, 0, 0, ctx.GlobalString(utils.AncientFlag.Name), "", false)
 		if err != nil {
 			utils.Fatalf("Failed to open database: %v", err)
 		}
@@ -215,7 +219,7 @@ func dumpGenesis(ctx *cli.Context) error {
 }
 
 func importChain(ctx *cli.Context) error {
-	if ctx.Args().Len() < 1 {
+	if len(ctx.Args()) < 1 {
 		utils.Fatalf("This command requires an argument.")
 	}
 	// Start metrics export if enabled
@@ -249,13 +253,13 @@ func importChain(ctx *cli.Context) error {
 
 	var importErr error
 
-	if ctx.Args().Len() == 1 {
+	if len(ctx.Args()) == 1 {
 		if err := utils.ImportChain(chain, ctx.Args().First()); err != nil {
 			importErr = err
 			log.Error("Import error", "err", err)
 		}
 	} else {
-		for _, arg := range ctx.Args().Slice() {
+		for _, arg := range ctx.Args() {
 			if err := utils.ImportChain(chain, arg); err != nil {
 				importErr = err
 				log.Error("Import error", "file", arg, "err", err)
@@ -277,7 +281,7 @@ func importChain(ctx *cli.Context) error {
 	fmt.Printf("Allocations:   %.3f million\n", float64(mem.Mallocs)/1000000)
 	fmt.Printf("GC pause:      %v\n\n", time.Duration(mem.PauseTotalNs))
 
-	if ctx.Bool(utils.NoCompactionFlag.Name) {
+	if ctx.GlobalBool(utils.NoCompactionFlag.Name) {
 		return nil
 	}
 
@@ -294,7 +298,7 @@ func importChain(ctx *cli.Context) error {
 }
 
 func exportChain(ctx *cli.Context) error {
-	if ctx.Args().Len() < 1 {
+	if len(ctx.Args()) < 1 {
 		utils.Fatalf("This command requires an argument.")
 	}
 
@@ -306,7 +310,7 @@ func exportChain(ctx *cli.Context) error {
 
 	var err error
 	fp := ctx.Args().First()
-	if ctx.Args().Len() < 3 {
+	if len(ctx.Args()) < 3 {
 		err = utils.ExportChain(chain, fp)
 	} else {
 		// This can be improved to allow for numbers larger than 9223372036854775807
@@ -333,7 +337,7 @@ func exportChain(ctx *cli.Context) error {
 
 // importPreimages imports preimage data from the specified file.
 func importPreimages(ctx *cli.Context) error {
-	if ctx.Args().Len() < 1 {
+	if len(ctx.Args()) < 1 {
 		utils.Fatalf("This command requires an argument.")
 	}
 
@@ -352,7 +356,7 @@ func importPreimages(ctx *cli.Context) error {
 
 // exportPreimages dumps the preimage data to specified json file in streaming way.
 func exportPreimages(ctx *cli.Context) error {
-	if ctx.Args().Len() < 1 {
+	if len(ctx.Args()) < 1 {
 		utils.Fatalf("This command requires an argument.")
 	}
 	stack, _ := makeConfigNode(ctx)
@@ -384,12 +388,12 @@ func parseDumpConfig(ctx *cli.Context, stack *node.Node) (*state.DumpConfig, eth
 				return nil, nil, common.Hash{}, fmt.Errorf("block %x not found", hash)
 			}
 		} else {
-			number, err := strconv.ParseUint(arg, 10, 64)
+			number, err := strconv.Atoi(arg)
 			if err != nil {
 				return nil, nil, common.Hash{}, err
 			}
-			if hash := rawdb.ReadCanonicalHash(db, number); hash != (common.Hash{}) {
-				header = rawdb.ReadHeader(db, hash, number)
+			if hash := rawdb.ReadCanonicalHash(db, uint64(number)); hash != (common.Hash{}) {
+				header = rawdb.ReadHeader(db, hash, uint64(number))
 			} else {
 				return nil, nil, common.Hash{}, fmt.Errorf("header for block %d not found", number)
 			}

cmd/geth/config.go

@@ -20,11 +20,12 @@ import (
 	"bufio"
 	"errors"
 	"fmt"
+	"math/big"
 	"os"
 	"reflect"
 	"unicode"
 
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 
 	"github.com/ethereum/go-ethereum/accounts/external"
 	"github.com/ethereum/go-ethereum/accounts/keystore"
@@ -34,7 +35,6 @@ import (
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/eth/ethconfig"
 	"github.com/ethereum/go-ethereum/internal/ethapi"
-	"github.com/ethereum/go-ethereum/internal/flags"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethereum/go-ethereum/node"
@@ -43,19 +43,19 @@ import (
 )
 
 var (
-	dumpConfigCommand = &cli.Command{
-		Action:      dumpConfig,
+	dumpConfigCommand = cli.Command{
+		Action:      utils.MigrateFlags(dumpConfig),
 		Name:        "dumpconfig",
 		Usage:       "Show configuration values",
 		ArgsUsage:   "",
-		Flags:       flags.Merge(nodeFlags, rpcFlags),
+		Flags:       utils.GroupFlags(nodeFlags, rpcFlags),
+		Category:    "MISCELLANEOUS COMMANDS",
 		Description: `The dumpconfig command shows configuration values.`,
 	}
 
-	configFileFlag = &cli.StringFlag{
-		Name:     "config",
-		Usage:    "TOML configuration file",
-		Category: flags.EthCategory,
+	configFileFlag = cli.StringFlag{
+		Name:  "config",
+		Usage: "TOML configuration file",
 	}
 )
 
@@ -127,7 +127,7 @@ func makeConfigNode(ctx *cli.Context) (*node.Node, gethConfig) {
 	}
 
 	// Load config file.
-	if file := ctx.String(configFileFlag.Name); file != "" {
+	if file := ctx.GlobalString(configFileFlag.Name); file != "" {
 		if err := loadConfig(file, &cfg); err != nil {
 			utils.Fatalf("%v", err)
 		}
@@ -145,8 +145,8 @@ func makeConfigNode(ctx *cli.Context) (*node.Node, gethConfig) {
 	}
 
 	utils.SetEthConfig(ctx, stack, &cfg.Eth)
-	if ctx.IsSet(utils.EthStatsURLFlag.Name) {
-		cfg.Ethstats.URL = ctx.String(utils.EthStatsURLFlag.Name)
+	if ctx.GlobalIsSet(utils.EthStatsURLFlag.Name) {
+		cfg.Ethstats.URL = ctx.GlobalString(utils.EthStatsURLFlag.Name)
 	}
 	applyMetricConfig(ctx, &cfg)
 
@@ -156,18 +156,15 @@ func makeConfigNode(ctx *cli.Context) (*node.Node, gethConfig) {
 // makeFullNode loads geth configuration and creates the Ethereum backend.
 func makeFullNode(ctx *cli.Context) (*node.Node, ethapi.Backend) {
 	stack, cfg := makeConfigNode(ctx)
-	if ctx.IsSet(utils.OverrideTerminalTotalDifficulty.Name) {
-		cfg.Eth.OverrideTerminalTotalDifficulty = flags.GlobalBig(ctx, utils.OverrideTerminalTotalDifficulty.Name)
+	if ctx.GlobalIsSet(utils.OverrideArrowGlacierFlag.Name) {
+		cfg.Eth.OverrideArrowGlacier = new(big.Int).SetUint64(ctx.GlobalUint64(utils.OverrideArrowGlacierFlag.Name))
 	}
-	if ctx.IsSet(utils.OverrideTerminalTotalDifficultyPassed.Name) {
-		override := ctx.Bool(utils.OverrideTerminalTotalDifficultyPassed.Name)
-		cfg.Eth.OverrideTerminalTotalDifficultyPassed = &override
+	if ctx.GlobalIsSet(utils.OverrideTerminalTotalDifficulty.Name) {
+		cfg.Eth.OverrideTerminalTotalDifficulty = utils.GlobalBig(ctx, utils.OverrideTerminalTotalDifficulty.Name)
 	}
-
 	backend, eth := utils.RegisterEthService(stack, &cfg.Eth)
-
 	// Warn users to migrate if they have a legacy freezer format.
-	if eth != nil && !ctx.IsSet(utils.IgnoreLegacyReceiptsFlag.Name) {
+	if eth != nil {
 		firstIdx := uint64(0)
 		// Hack to speed up check for mainnet because we know
 		// the first non-empty block.
@@ -179,19 +176,14 @@ func makeFullNode(ctx *cli.Context) (*node.Node, ethapi.Backend) {
 		if err != nil {
 			log.Error("Failed to check db for legacy receipts", "err", err)
 		} else if isLegacy {
-			stack.Close()
-			utils.Fatalf("Database has receipts with a legacy format. Please run `geth db freezer-migrate`.")
+			log.Warn("Database has receipts with a legacy format. Please run `geth db freezer-migrate`.")
 		}
 	}
 
-	// Configure log filter RPC API.
-	filterSystem := utils.RegisterFilterAPI(stack, backend, &cfg.Eth)
-
-	// Configure GraphQL if requested.
-	if ctx.IsSet(utils.GraphQLEnabledFlag.Name) {
-		utils.RegisterGraphQLService(stack, backend, filterSystem, &cfg.Node)
+	// Configure GraphQL if requested
+	if ctx.GlobalIsSet(utils.GraphQLEnabledFlag.Name) {
+		utils.RegisterGraphQLService(stack, backend, cfg.Node)
 	}
-
 	// Add the Ethereum Stats daemon if requested.
 	if cfg.Ethstats.URL != "" {
 		utils.RegisterEthStatsService(stack, backend, cfg.Ethstats.URL)
@@ -229,47 +221,47 @@ func dumpConfig(ctx *cli.Context) error {
 }
 
 func applyMetricConfig(ctx *cli.Context, cfg *gethConfig) {
-	if ctx.IsSet(utils.MetricsEnabledFlag.Name) {
-		cfg.Metrics.Enabled = ctx.Bool(utils.MetricsEnabledFlag.Name)
+	if ctx.GlobalIsSet(utils.MetricsEnabledFlag.Name) {
+		cfg.Metrics.Enabled = ctx.GlobalBool(utils.MetricsEnabledFlag.Name)
 	}
-	if ctx.IsSet(utils.MetricsEnabledExpensiveFlag.Name) {
-		cfg.Metrics.EnabledExpensive = ctx.Bool(utils.MetricsEnabledExpensiveFlag.Name)
+	if ctx.GlobalIsSet(utils.MetricsEnabledExpensiveFlag.Name) {
+		cfg.Metrics.EnabledExpensive = ctx.GlobalBool(utils.MetricsEnabledExpensiveFlag.Name)
 	}
-	if ctx.IsSet(utils.MetricsHTTPFlag.Name) {
-		cfg.Metrics.HTTP = ctx.String(utils.MetricsHTTPFlag.Name)
+	if ctx.GlobalIsSet(utils.MetricsHTTPFlag.Name) {
+		cfg.Metrics.HTTP = ctx.GlobalString(utils.MetricsHTTPFlag.Name)
 	}
-	if ctx.IsSet(utils.MetricsPortFlag.Name) {
-		cfg.Metrics.Port = ctx.Int(utils.MetricsPortFlag.Name)
+	if ctx.GlobalIsSet(utils.MetricsPortFlag.Name) {
+		cfg.Metrics.Port = ctx.GlobalInt(utils.MetricsPortFlag.Name)
 	}
-	if ctx.IsSet(utils.MetricsEnableInfluxDBFlag.Name) {
-		cfg.Metrics.EnableInfluxDB = ctx.Bool(utils.MetricsEnableInfluxDBFlag.Name)
+	if ctx.GlobalIsSet(utils.MetricsEnableInfluxDBFlag.Name) {
+		cfg.Metrics.EnableInfluxDB = ctx.GlobalBool(utils.MetricsEnableInfluxDBFlag.Name)
 	}
-	if ctx.IsSet(utils.MetricsInfluxDBEndpointFlag.Name) {
-		cfg.Metrics.InfluxDBEndpoint = ctx.String(utils.MetricsInfluxDBEndpointFlag.Name)
+	if ctx.GlobalIsSet(utils.MetricsInfluxDBEndpointFlag.Name) {
+		cfg.Metrics.InfluxDBEndpoint = ctx.GlobalString(utils.MetricsInfluxDBEndpointFlag.Name)
 	}
-	if ctx.IsSet(utils.MetricsInfluxDBDatabaseFlag.Name) {
-		cfg.Metrics.InfluxDBDatabase = ctx.String(utils.MetricsInfluxDBDatabaseFlag.Name)
+	if ctx.GlobalIsSet(utils.MetricsInfluxDBDatabaseFlag.Name) {
+		cfg.Metrics.InfluxDBDatabase = ctx.GlobalString(utils.MetricsInfluxDBDatabaseFlag.Name)
 	}
-	if ctx.IsSet(utils.MetricsInfluxDBUsernameFlag.Name) {
-		cfg.Metrics.InfluxDBUsername = ctx.String(utils.MetricsInfluxDBUsernameFlag.Name)
+	if ctx.GlobalIsSet(utils.MetricsInfluxDBUsernameFlag.Name) {
+		cfg.Metrics.InfluxDBUsername = ctx.GlobalString(utils.MetricsInfluxDBUsernameFlag.Name)
 	}
-	if ctx.IsSet(utils.MetricsInfluxDBPasswordFlag.Name) {
-		cfg.Metrics.InfluxDBPassword = ctx.String(utils.MetricsInfluxDBPasswordFlag.Name)
+	if ctx.GlobalIsSet(utils.MetricsInfluxDBPasswordFlag.Name) {
+		cfg.Metrics.InfluxDBPassword = ctx.GlobalString(utils.MetricsInfluxDBPasswordFlag.Name)
 	}
-	if ctx.IsSet(utils.MetricsInfluxDBTagsFlag.Name) {
-		cfg.Metrics.InfluxDBTags = ctx.String(utils.MetricsInfluxDBTagsFlag.Name)
+	if ctx.GlobalIsSet(utils.MetricsInfluxDBTagsFlag.Name) {
+		cfg.Metrics.InfluxDBTags = ctx.GlobalString(utils.MetricsInfluxDBTagsFlag.Name)
 	}
-	if ctx.IsSet(utils.MetricsEnableInfluxDBV2Flag.Name) {
-		cfg.Metrics.EnableInfluxDBV2 = ctx.Bool(utils.MetricsEnableInfluxDBV2Flag.Name)
+	if ctx.GlobalIsSet(utils.MetricsEnableInfluxDBV2Flag.Name) {
+		cfg.Metrics.EnableInfluxDBV2 = ctx.GlobalBool(utils.MetricsEnableInfluxDBV2Flag.Name)
 	}
-	if ctx.IsSet(utils.MetricsInfluxDBTokenFlag.Name) {
-		cfg.Metrics.InfluxDBToken = ctx.String(utils.MetricsInfluxDBTokenFlag.Name)
+	if ctx.GlobalIsSet(utils.MetricsInfluxDBTokenFlag.Name) {
+		cfg.Metrics.InfluxDBToken = ctx.GlobalString(utils.MetricsInfluxDBTokenFlag.Name)
 	}
-	if ctx.IsSet(utils.MetricsInfluxDBBucketFlag.Name) {
-		cfg.Metrics.InfluxDBBucket = ctx.String(utils.MetricsInfluxDBBucketFlag.Name)
+	if ctx.GlobalIsSet(utils.MetricsInfluxDBBucketFlag.Name) {
+		cfg.Metrics.InfluxDBBucket = ctx.GlobalString(utils.MetricsInfluxDBBucketFlag.Name)
 	}
-	if ctx.IsSet(utils.MetricsInfluxDBOrganizationFlag.Name) {
-		cfg.Metrics.InfluxDBOrganization = ctx.String(utils.MetricsInfluxDBOrganizationFlag.Name)
+	if ctx.GlobalIsSet(utils.MetricsInfluxDBOrganizationFlag.Name) {
+		cfg.Metrics.InfluxDBOrganization = ctx.GlobalString(utils.MetricsInfluxDBOrganizationFlag.Name)
 	}
 }
 

cmd/geth/consolecmd.go

@@ -18,36 +18,39 @@ package main
 
 import (
 	"fmt"
+	"path/filepath"
 	"strings"
 
 	"github.com/ethereum/go-ethereum/cmd/utils"
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/console"
-	"github.com/ethereum/go-ethereum/internal/flags"
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/rpc"
-	"github.com/urfave/cli/v2"
+	"gopkg.in/urfave/cli.v1"
 )
 
 var (
 	consoleFlags = []cli.Flag{utils.JSpathFlag, utils.ExecFlag, utils.PreloadJSFlag}
 
-	consoleCommand = &cli.Command{
-		Action: localConsole,
-		Name:   "console",
-		Usage:  "Start an interactive JavaScript environment",
-		Flags:  flags.Merge(nodeFlags, rpcFlags, consoleFlags),
+	consoleCommand = cli.Command{
+		Action:   utils.MigrateFlags(localConsole),
+		Name:     "console",
+		Usage:    "Start an interactive JavaScript environment",
+		Flags:    utils.GroupFlags(nodeFlags, rpcFlags, consoleFlags),
+		Category: "CONSOLE COMMANDS",
 		Description: `
 The Geth console is an interactive shell for the JavaScript runtime environment
 which exposes a node admin interface as well as the Ðapp JavaScript API.
 See https://geth.ethereum.org/docs/interface/javascript-console.`,
 	}
 
-	attachCommand = &cli.Command{
-		Action:    remoteConsole,
+	attachCommand = cli.Command{
+		Action:    utils.MigrateFlags(remoteConsole),
 		Name:      "attach",
 		Usage:     "Start an interactive JavaScript environment (connect to node)",
 		ArgsUsage: "[endpoint]",
-		Flags:     flags.Merge([]cli.Flag{utils.DataDirFlag}, consoleFlags),
+		Flags:     utils.GroupFlags([]cli.Flag{utils.DataDirFlag}, consoleFlags),
+		Category:  "CONSOLE COMMANDS",
 		Description: `
 The Geth console is an interactive shell for the JavaScript runtime environment
 which exposes a node admin interface as well as the Ðapp JavaScript API.
@@ -55,12 +58,13 @@ See https://geth.ethereum.org/docs/interface/javascript-console.
 This command allows to open a console on a running geth node.`,
 	}
 
-	javascriptCommand = &cli.Command{
-		Action:    ephemeralConsole,
+	javascriptCommand = cli.Command{
+		Action:    utils.MigrateFlags(ephemeralConsole),
 		Name:      "js",
-		Usage:     "(DEPRECATED) Execute the specified JavaScript files",
+		Usage:     "Execute the specified JavaScript files",
 		ArgsUsage: "<jsfile> [jsfile...]",
-		Flags:     flags.Merge(nodeFlags, consoleFlags),
+		Flags:     utils.GroupFlags(nodeFlags, consoleFlags),
+		Category:  "CONSOLE COMMANDS",
 		Description: `
 The JavaScript VM exposes a node admin interface as well as the Ðapp
 JavaScript API. See https://geth.ethereum.org/docs/interface/javascript-console`,
@@ -83,7 +87,7 @@ func localConsole(ctx *cli.Context) error {
 	}
 	config := console.Config{
 		DataDir: utils.MakeDataDir(ctx),
-		DocRoot: ctx.String(utils.JSpathFlag.Name),
+		DocRoot: ctx.GlobalString(utils.JSpathFlag.Name),
 		Client:  client,
 		Preload: utils.MakeConsolePreloads(ctx),
 	}
@@ -94,7 +98,7 @@ func localConsole(ctx *cli.Context) error {
 	defer console.Stop(false)
 
 	// If only a short execution was requested, evaluate and return.
-	if script := ctx.String(utils.ExecFlag.Name); script != "" {
+	if script := ctx.GlobalString(utils.ExecFlag.Name); script != "" {
 		console.Evaluate(script)
 		return nil
 	}
@@ -115,15 +119,33 @@ func localConsole(ctx *cli.Context) error {
 // remoteConsole will connect to a remote geth instance, attaching a JavaScript
 // console to it.
 func remoteConsole(ctx *cli.Context) error {
-	if ctx.Args().Len() > 1 {
-		utils.Fatalf("invalid command-line: too many arguments")
-	}
-
 	endpoint := ctx.Args().First()
 	if endpoint == "" {
-		cfg := defaultNodeConfig()
-		utils.SetDataDir(ctx, &cfg)
-		endpoint = cfg.IPCEndpoint()
+		path := node.DefaultDataDir()
+		if ctx.GlobalIsSet(utils.DataDirFlag.Name) {
+			path = ctx.GlobalString(utils.DataDirFlag.Name)
+		}
+		if path != "" {
+			if ctx.GlobalBool(utils.RopstenFlag.Name) {
+				// Maintain compatibility with older Geth configurations storing the
+				// Ropsten database in `testnet` instead of `ropsten`.
+				legacyPath := filepath.Join(path, "testnet")
+				if common.FileExist(legacyPath) {
+					path = legacyPath
+				} else {
+					path = filepath.Join(path, "ropsten")
+				}
+			} else if ctx.GlobalBool(utils.RinkebyFlag.Name) {
+				path = filepath.Join(path, "rinkeby")
+			} else if ctx.GlobalBool(utils.GoerliFlag.Name) {
+				path = filepath.Join(path, "goerli")
+			} else if ctx.GlobalBool(utils.SepoliaFlag.Name) {
+				path = filepath.Join(path, "sepolia")
+			} else if ctx.GlobalBool(utils.KilnFlag.Name) {
+				path = filepath.Join(path, "kiln")
+			}
+		}
+		endpoint = fmt.Sprintf("%s/geth.ipc", path)
 	}
 	client, err := dialRPC(endpoint)
 	if err != nil {
@@ -131,7 +153,7 @@ func remoteConsole(ctx *cli.Context) error {
 	}
 	config := console.Config{
 		DataDir: utils.MakeDataDir(ctx),
-		DocRoot: ctx.String(utils.JSpathFlag.Name),
+		DocRoot: ctx.GlobalString(utils.JSpathFlag.Name),
 		Client:  client,
 		Preload: utils.MakeConsolePreloads(ctx),
 	}
@@ -141,7 +163,7 @@ func remoteConsole(ctx *cli.Context) error {
 	}
 	defer console.Stop(false)
 
-	if script := ctx.String(utils.ExecFlag.Name); script != "" {
+	if script := ctx.GlobalString(utils.ExecFlag.Name); script != "" {
 		console.Evaluate(script)
 		return nil
 	}
@@ -152,19 +174,6 @@ func remoteConsole(ctx *cli.Context) error {
 	return nil
 }
 
-// ephemeralConsole starts a new geth node, attaches an ephemeral JavaScript
-// console to it, executes each of the files specified as arguments and tears
-// everything down.
-func ephemeralConsole(ctx *cli.Context) error {
-	var b strings.Builder
-	for _, file := range ctx.Args().Slice() {
-		b.Write([]byte(fmt.Sprintf("loadScript('%s');", file)))
-	}
-	utils.Fatalf(`The "js" command is deprecated. Please use the following instead:
-geth --exec "%s" console`, b.String())
-	return nil
-}
-
 // dialRPC returns a RPC client which connects to the given endpoint.
 // The check for empty endpoint implements the defaulting logic
 // for "geth attach" with no argument.
@@ -178,3 +187,48 @@ func dialRPC(endpoint string) (*rpc.Client, error) {
 	}
 	return rpc.Dial(endpoint)
 }
+
+// ephemeralConsole starts a new geth node, attaches an ephemeral JavaScript
+// console to it, executes each of the files specified as arguments and tears
+// everything down.
+func ephemeralConsole(ctx *cli.Context) error {
+	// Create and start the node based on the CLI flags
+	stack, backend := makeFullNode(ctx)
+	startNode(ctx, stack, backend, false)
+	defer stack.Close()
+
+	// Attach to the newly started node and start the JavaScript console
+	client, err := stack.Attach()
+	if err != nil {
+		return fmt.Errorf("Failed to attach to the inproc geth: %v", err)
+	}
+	config := console.Config{
+		DataDir: utils.MakeDataDir(ctx),
+		DocRoot: ctx.GlobalString(utils.JSpathFlag.Name),
+		Client:  client,
+		Preload: utils.MakeConsolePreloads(ctx),
+	}
+
+	console, err := console.New(config)
+	if err != nil {
+		return fmt.Errorf("Failed to start the JavaScript console: %v", err)
+	}
+	defer console.Stop(false)
+
+	// Interrupt the JS interpreter when node is stopped.
+	go func() {
+		stack.Wait()
+		console.Stop(false)
+	}()
+
+	// Evaluate each of the specified JavaScript files.
+	for _, file := range ctx.Args() {
+		if err = console.Execute(file); err != nil {
+			return fmt.Errorf("Failed to execute %s: %v", file, err)
+		}
+	}
+
+	// The main script is now done, but keep running timers/callbacks.
+	console.Stop(true)
+	return nil
+}