cmd: migrate to urfave/cli/v2 (#24751)

This change updates our urfave/cli dependency to the v2 branch of the library.
There are some Go API changes in cli v2:

- Flag values can now be accessed using the methods ctx.Bool,
  ctx.Int, ctx.String, ... regardless of whether the flag is 'local' or
  'global'.

- v2 has built-in support for flag categories. Our home-grown category
  system is removed and the categories of flags are assigned as part of
  the flag definition.

For users, there is only one observable difference with cli v2: flags must now
strictly appear before regular arguments. For example, the following command is
now invalid:

   geth account import mykey.json --password file.txt

Instead, the command must be invoked as follows:

   geth account import --password file.txt mykey.json

cmd/evm/compiler.go

@@ -23,10 +23,10 @@ import (
 
 	"github.com/ethereum/go-ethereum/cmd/evm/internal/compiler"
 
-	"gopkg.in/urfave/cli.v1"
+	"github.com/urfave/cli/v2"
 )
 
-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.GlobalBool(DebugFlag.Name)
+	debug := ctx.Bool(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"
-	"gopkg.in/urfave/cli.v1"
+	"github.com/urfave/cli/v2"
 )
 
-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.GlobalIsSet(InputFlag.Name):
-		in = ctx.GlobalString(InputFlag.Name)
+	case ctx.IsSet(InputFlag.Name):
+		in = ctx.String(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"
-	"gopkg.in/urfave/cli.v1"
+	"github.com/urfave/cli/v2"
 )
 
 //go:generate go run github.com/fjl/gencodec -type header -field-override headerMarshaling -out gen_header.go

cmd/evm/internal/t8ntool/flags.go

@@ -22,45 +22,47 @@ import (
 
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/tests"
-	"gopkg.in/urfave/cli.v1"
+	"github.com/urfave/cli/v2"
 )
 
 var (
-	TraceFlag = cli.BoolFlag{
+	TraceFlag = &cli.BoolFlag{
 		Name:  "trace",
 		Usage: "Output full trace logs to files <txhash>.jsonl",
 	}
-	TraceDisableMemoryFlag = cli.BoolTFlag{
+	TraceDisableMemoryFlag = &cli.BoolFlag{
 		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.BoolTFlag{
+	TraceDisableReturnDataFlag = &cli.BoolFlag{
 		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" +
@@ -68,7 +70,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" +
@@ -76,7 +78,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" +
@@ -84,65 +86,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,7 +156,7 @@ var (
 			strings.Join(vm.ActivateableEips(), ", ")),
 		Value: "GrayGlacier",
 	}
-	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"
-	"gopkg.in/urfave/cli.v1"
+	"github.com/urfave/cli/v2"
 )
 
 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"
-	"gopkg.in/urfave/cli.v1"
+	"github.com/urfave/cli/v2"
 )
 
 const (

cmd/evm/internal/t8ntool/utils.go

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

cmd/evm/main.go

@@ -23,115 +23,118 @@ 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"
-	"gopkg.in/urfave/cli.v1"
+	"github.com/urfave/cli/v2"
 )
 
-var gitCommit = "" // Git SHA1 commit hash of the release (set via linker flags)
-var gitDate = ""
+var (
+	gitCommit = "" // Git SHA1 commit hash of the release (set via linker flags)
+	gitDate   = ""
+
+	app = flags.NewApp(gitCommit, gitDate, "the evm command line interface")
+)
 
 var (
-	app = flags.NewApp(gitCommit, gitDate, "the evm command line interface")
-
-	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 = utils.BigFlag{
+	PriceFlag = &flags.BigFlag{
 		Name:  "price",
 		Usage: "price set for the evm",
 		Value: new(big.Int),
 	}
-	ValueFlag = utils.BigFlag{
+	ValueFlag = &flags.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.BoolTFlag{
+	DisableMemoryFlag = &cli.BoolFlag{
 		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.BoolTFlag{
+	DisableReturnDataFlag = &cli.BoolFlag{
 		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",
@@ -156,7 +159,8 @@ var stateTransitionCommand = cli.Command{
 		t8ntool.VerbosityFlag,
 	},
 }
-var transactionCommand = cli.Command{
+
+var transactionCommand = &cli.Command{
 	Name:    "transaction",
 	Aliases: []string{"t9n"},
 	Usage:   "performs transaction validation",
@@ -169,7 +173,7 @@ var transactionCommand = cli.Command{
 	},
 }
 
-var blockBuilderCommand = cli.Command{
+var blockBuilderCommand = &cli.Command{
 	Name:    "block-builder",
 	Aliases: []string{"b11r"},
 	Usage:   "builds a block",
@@ -214,7 +218,7 @@ func init() {
 		DisableStorageFlag,
 		DisableReturnDataFlag,
 	}
-	app.Commands = []cli.Command{
+	app.Commands = []*cli.Command{
 		compileCommand,
 		disasmCommand,
 		runCommand,
@@ -223,7 +227,6 @@ func init() {
 		transactionCommand,
 		blockBuilderCommand,
 	}
-	cli.CommandHelpTemplate = flags.OriginCommandHelpTemplate
 }
 
 func main() {

cmd/evm/runner.go

@@ -37,12 +37,13 @@ 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"
-	"gopkg.in/urfave/cli.v1"
+	"github.com/urfave/cli/v2"
 )
 
-var runCommand = cli.Command{
+var runCommand = &cli.Command{
 	Action:      runCmd,
 	Name:        "run",
 	Usage:       "run arbitrary evm binary",
@@ -106,14 +107,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.GlobalInt(VerbosityFlag.Name)))
+	glogger.Verbosity(log.Lvl(ctx.Int(VerbosityFlag.Name)))
 	log.Root().SetHandler(glogger)
 	logconfig := &logger.Config{
-		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),
+		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),
 	}
 
 	var (
@@ -125,16 +126,16 @@ func runCmd(ctx *cli.Context) error {
 		receiver      = common.BytesToAddress([]byte("receiver"))
 		genesisConfig *core.Genesis
 	)
-	if ctx.GlobalBool(MachineFlag.Name) {
+	if ctx.Bool(MachineFlag.Name) {
 		tracer = logger.NewJSONLogger(logconfig, os.Stdout)
-	} else if ctx.GlobalBool(DebugFlag.Name) {
+	} else if ctx.Bool(DebugFlag.Name) {
 		debugLogger = logger.NewStructLogger(logconfig)
 		tracer = debugLogger
 	} else {
 		debugLogger = logger.NewStructLogger(logconfig)
 	}
-	if ctx.GlobalString(GenesisFlag.Name) != "" {
-		gen := readGenesis(ctx.GlobalString(GenesisFlag.Name))
+	if ctx.String(GenesisFlag.Name) != "" {
+		gen := readGenesis(ctx.String(GenesisFlag.Name))
 		genesisConfig = gen
 		db := rawdb.NewMemoryDatabase()
 		genesis := gen.ToBlock(db)
@@ -144,18 +145,18 @@ func runCmd(ctx *cli.Context) error {
 		statedb, _ = state.New(common.Hash{}, state.NewDatabase(rawdb.NewMemoryDatabase()), nil)
 		genesisConfig = new(core.Genesis)
 	}
-	if ctx.GlobalString(SenderFlag.Name) != "" {
-		sender = common.HexToAddress(ctx.GlobalString(SenderFlag.Name))
+	if ctx.String(SenderFlag.Name) != "" {
+		sender = common.HexToAddress(ctx.String(SenderFlag.Name))
 	}
 	statedb.CreateAccount(sender)
 
-	if ctx.GlobalString(ReceiverFlag.Name) != "" {
-		receiver = common.HexToAddress(ctx.GlobalString(ReceiverFlag.Name))
+	if ctx.String(ReceiverFlag.Name) != "" {
+		receiver = common.HexToAddress(ctx.String(ReceiverFlag.Name))
 	}
 
 	var code []byte
-	codeFileFlag := ctx.GlobalString(CodeFileFlag.Name)
-	codeFlag := ctx.GlobalString(CodeFlag.Name)
+	codeFileFlag := ctx.String(CodeFileFlag.Name)
+	codeFlag := ctx.String(CodeFlag.Name)
 
 	// The '--code' or '--codefile' flag overrides code in state
 	if codeFileFlag != "" || codeFlag != "" {
@@ -197,7 +198,7 @@ func runCmd(ctx *cli.Context) error {
 		}
 		code = common.Hex2Bytes(bin)
 	}
-	initialGas := ctx.GlobalUint64(GasFlag.Name)
+	initialGas := ctx.Uint64(GasFlag.Name)
 	if genesisConfig.GasLimit != 0 {
 		initialGas = genesisConfig.GasLimit
 	}
@@ -205,19 +206,19 @@ func runCmd(ctx *cli.Context) error {
 		Origin:      sender,
 		State:       statedb,
 		GasLimit:    initialGas,
-		GasPrice:    utils.GlobalBig(ctx, PriceFlag.Name),
-		Value:       utils.GlobalBig(ctx, ValueFlag.Name),
+		GasPrice:    flags.GlobalBig(ctx, PriceFlag.Name),
+		Value:       flags.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.GlobalBool(DebugFlag.Name) || ctx.GlobalBool(MachineFlag.Name),
+			Debug:  ctx.Bool(DebugFlag.Name) || ctx.Bool(MachineFlag.Name),
 		},
 	}
 
-	if cpuProfilePath := ctx.GlobalString(CPUProfileFlag.Name); cpuProfilePath != "" {
+	if cpuProfilePath := ctx.String(CPUProfileFlag.Name); cpuProfilePath != "" {
 		f, err := os.Create(cpuProfilePath)
 		if err != nil {
 			fmt.Println("could not create CPU profile: ", err)
@@ -237,14 +238,14 @@ func runCmd(ctx *cli.Context) error {
 	}
 
 	var hexInput []byte
-	if inputFileFlag := ctx.GlobalString(InputFileFlag.Name); inputFileFlag != "" {
+	if inputFileFlag := ctx.String(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.GlobalString(InputFlag.Name))
+		hexInput = []byte(ctx.String(InputFlag.Name))
 	}
 	hexInput = bytes.TrimSpace(hexInput)
 	if len(hexInput)%2 != 0 {
@@ -254,7 +255,7 @@ func runCmd(ctx *cli.Context) error {
 	input := common.FromHex(string(hexInput))
 
 	var execFunc func() ([]byte, uint64, error)
-	if ctx.GlobalBool(CreateFlag.Name) {
+	if ctx.Bool(CreateFlag.Name) {
 		input = append(code, input...)
 		execFunc = func() ([]byte, uint64, error) {
 			output, _, gasLeft, err := runtime.Create(input, &runtimeConfig)
@@ -269,16 +270,16 @@ func runCmd(ctx *cli.Context) error {
 		}
 	}
 
-	bench := ctx.GlobalBool(BenchFlag.Name)
+	bench := ctx.Bool(BenchFlag.Name)
 	output, leftOverGas, stats, err := timedExec(bench, execFunc)
 
-	if ctx.GlobalBool(DumpFlag.Name) {
+	if ctx.Bool(DumpFlag.Name) {
 		statedb.Commit(true)
 		statedb.IntermediateRoot(true)
 		fmt.Println(string(statedb.Dump(nil)))
 	}
 
-	if memProfilePath := ctx.GlobalString(MemProfileFlag.Name); memProfilePath != "" {
+	if memProfilePath := ctx.String(MemProfileFlag.Name); memProfilePath != "" {
 		f, err := os.Create(memProfilePath)
 		if err != nil {
 			fmt.Println("could not create memory profile: ", err)
@@ -291,7 +292,7 @@ func runCmd(ctx *cli.Context) error {
 		f.Close()
 	}
 
-	if ctx.GlobalBool(DebugFlag.Name) {
+	if ctx.Bool(DebugFlag.Name) {
 		if debugLogger != nil {
 			fmt.Fprintln(os.Stderr, "#### TRACE ####")
 			logger.WriteTrace(os.Stderr, debugLogger.StructLogs())
@@ -300,7 +301,7 @@ func runCmd(ctx *cli.Context) error {
 		logger.WriteLogs(os.Stderr, statedb.Logs())
 	}
 
-	if bench || ctx.GlobalBool(StatDumpFlag.Name) {
+	if bench || ctx.Bool(StatDumpFlag.Name) {
 		fmt.Fprintf(os.Stderr, `EVM gas used:    %d
 execution time:  %v
 allocations:     %d

cmd/evm/staterunner.go

@@ -28,10 +28,10 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/tests"
 
-	"gopkg.in/urfave/cli.v1"
+	"github.com/urfave/cli/v2"
 )
 
-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.GlobalInt(VerbosityFlag.Name)))
+	glogger.Verbosity(log.Lvl(ctx.Int(VerbosityFlag.Name)))
 	log.Root().SetHandler(glogger)
 
 	// Configure the EVM logger
 	config := &logger.Config{
-		EnableMemory:     !ctx.GlobalBool(DisableMemoryFlag.Name),
-		DisableStack:     ctx.GlobalBool(DisableStackFlag.Name),
-		DisableStorage:   ctx.GlobalBool(DisableStorageFlag.Name),
-		EnableReturnData: !ctx.GlobalBool(DisableReturnDataFlag.Name),
+		EnableMemory:     !ctx.Bool(DisableMemoryFlag.Name),
+		DisableStack:     ctx.Bool(DisableStackFlag.Name),
+		DisableStorage:   ctx.Bool(DisableStorageFlag.Name),
+		EnableReturnData: !ctx.Bool(DisableReturnDataFlag.Name),
 	}
 	var (
 		tracer   vm.EVMLogger
 		debugger *logger.StructLogger
 	)
 	switch {
-	case ctx.GlobalBool(MachineFlag.Name):
+	case ctx.Bool(MachineFlag.Name):
 		tracer = logger.NewJSONLogger(config, os.Stderr)
 
-	case ctx.GlobalBool(DebugFlag.Name):
+	case ctx.Bool(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.GlobalBool(DebugFlag.Name) || ctx.GlobalBool(MachineFlag.Name),
+		Debug:  ctx.Bool(DebugFlag.Name) || ctx.Bool(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.GlobalBool(MachineFlag.Name) && s != nil {
+			if ctx.Bool(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.GlobalBool(DumpFlag.Name) && s != nil {
+				if ctx.Bool(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.GlobalBool(DebugFlag.Name) {
+			if ctx.Bool(DebugFlag.Name) {
 				if debugger != nil {
 					fmt.Fprintln(os.Stderr, "#### TRACE ####")
 					logger.WriteTrace(os.Stderr, debugger.StructLogs())