chore: use cobra helpers for cmd args (#717)

* chore: use cobra helpers for cmd args

* fix: use switch for nodekey

* fix: import

* docs: update CLAUDE.md

* fix: spacing

Author: minhd-vu

CLAUDE.md

@@ -147,6 +147,9 @@ The tool supports configuration via:
   f.IntVar(&count, "count", 0, "description")
   ```
 
+### Cobra Command Arguments
+- Prefer to use Cobra built-in validators (`cobra.NoArgs`, `cobra.ExactArgs(n)`, `cobra.MinimumNArgs(n)`, `cobra.MaximumNArgs(n)`, `cobra.ArbitraryArgs`) instead of custom `Args: func(cmd *cobra.Command, args []string) error` functions, and move argument parsing/validation logic to `PreRunE` hook
+
 ### Cobra Commands
 - Command `Short` descriptions: sentence case with ending period, e.g., `"Generate a node list to seed a node."`
 - Command `Long` descriptions: consider using embedded usage.md file via `//go:embed usage.md` pattern; when using inline strings, use sentence case with ending period for complete sentences

cmd/dbbench/dbbench.go

@@ -140,6 +140,18 @@ var DBBenchCmd = &cobra.Command{
 	Use:   "dbbench [flags]",
 	Short: "Perform a level/pebble db benchmark.",
 	Long:  usage,
+	Args:  cobra.NoArgs,
+	PreRunE: func(cmd *cobra.Command, args []string) error {
+		var err error
+		sizeDistribution, err = parseRawSizeDistribution(rawSizeDistribution)
+		if err != nil {
+			return err
+		}
+		if keySize > 64 {
+			return fmt.Errorf("max supported key size is 64 bytes. %d is too big", keySize)
+		}
+		return nil
+	},
 	RunE: func(cmd *cobra.Command, args []string) error {
 		log.Info().Msg("Starting db test")
 		var kvdb KeyValueDB
@@ -217,17 +229,6 @@ var DBBenchCmd = &cobra.Command{
 
 		return printSummary(trs)
 	},
-	Args: func(cmd *cobra.Command, args []string) error {
-		var err error
-		sizeDistribution, err = parseRawSizeDistribution(rawSizeDistribution)
-		if err != nil {
-			return err
-		}
-		if keySize > 64 {
-			return fmt.Errorf(" max supported key size is 64 bytes. %d is too big", keySize)
-		}
-		return nil
-	},
 }
 
 func printSummary(trs []*TestResult) error {

cmd/dumpblocks/dumpblocks.go

@@ -55,12 +55,13 @@ var DumpblocksCmd = &cobra.Command{
 	Use:   "dumpblocks start end",
 	Short: "Export a range of blocks from a JSON-RPC endpoint.",
 	Long:  usage,
+	Args:  cobra.MinimumNArgs(2),
 	PersistentPreRun: func(cmd *cobra.Command, args []string) {
 		rpcUrlFlagValue := flag_loader.GetRpcUrlFlagValue(cmd)
 		inputDumpblocks.RpcUrl = *rpcUrlFlagValue
 	},
 	PreRunE: func(cmd *cobra.Command, args []string) error {
-		return checkFlags()
+		return checkFlags(args)
 	},
 	RunE: func(cmd *cobra.Command, args []string) error {
 		ctx := cmd.Context()
@@ -136,50 +137,6 @@ var DumpblocksCmd = &cobra.Command{
 		wg.Wait()
 		log.Info().Msg("Done")
 
-		return nil
-	},
-	Args: func(cmd *cobra.Command, args []string) error {
-		if len(args) < 2 {
-			return fmt.Errorf("command needs at least two arguments. A start block and an end block")
-		}
-
-		start, err := strconv.ParseInt(args[0], 10, 64)
-		if err != nil {
-			return err
-		}
-		end, err := strconv.ParseInt(args[1], 10, 64)
-		if err != nil {
-			return err
-		}
-		if start < 0 || end < 0 {
-			return fmt.Errorf("the start and end parameters need to be positive")
-		}
-		if end < start {
-			start, end = end, start
-		}
-
-		inputDumpblocks.Start = uint64(start)
-		inputDumpblocks.End = uint64(end)
-
-		if inputDumpblocks.Threads == 0 {
-			inputDumpblocks.Threads = 1
-		}
-		if !slices.Contains([]string{"json", "proto"}, inputDumpblocks.Mode) {
-			return fmt.Errorf("output format must one of [json, proto]")
-		}
-
-		if err := json.Unmarshal([]byte(inputDumpblocks.FilterStr), &inputDumpblocks.filter); err != nil {
-			return fmt.Errorf("could not unmarshal filter string")
-		}
-
-		// Make sure the filters are all lowercase.
-		for i := 0; i < len(inputDumpblocks.filter.To); i++ {
-			inputDumpblocks.filter.To[i] = strings.ToLower(inputDumpblocks.filter.To[i])
-		}
-		for i := 0; i < len(inputDumpblocks.filter.From); i++ {
-			inputDumpblocks.filter.From[i] = strings.ToLower(inputDumpblocks.filter.From[i])
-		}
-
 		return nil
 	},
 }
@@ -196,12 +153,50 @@ func init() {
 	f.StringVarP(&inputDumpblocks.FilterStr, "filter", "F", "{}", "filter output based on tx to and from (not setting a filter means all are allowed)")
 }
 
-func checkFlags() error {
+func checkFlags(args []string) error {
 	// Check rpc url flag.
 	if err := util.ValidateUrl(inputDumpblocks.RpcUrl); err != nil {
 		return err
 	}
 
+	// Parse start and end blocks
+	start, err := strconv.ParseInt(args[0], 10, 64)
+	if err != nil {
+		return err
+	}
+	end, err := strconv.ParseInt(args[1], 10, 64)
+	if err != nil {
+		return err
+	}
+	if start < 0 || end < 0 {
+		return fmt.Errorf("the start and end parameters need to be positive")
+	}
+	if end < start {
+		start, end = end, start
+	}
+
+	inputDumpblocks.Start = uint64(start)
+	inputDumpblocks.End = uint64(end)
+
+	if inputDumpblocks.Threads == 0 {
+		inputDumpblocks.Threads = 1
+	}
+	if !slices.Contains([]string{"json", "proto"}, inputDumpblocks.Mode) {
+		return fmt.Errorf("output format must one of [json, proto]")
+	}
+
+	if err := json.Unmarshal([]byte(inputDumpblocks.FilterStr), &inputDumpblocks.filter); err != nil {
+		return fmt.Errorf("could not unmarshal filter string")
+	}
+
+	// Make sure the filters are all lowercase.
+	for i := 0; i < len(inputDumpblocks.filter.To); i++ {
+		inputDumpblocks.filter.To[i] = strings.ToLower(inputDumpblocks.filter.To[i])
+	}
+	for i := 0; i < len(inputDumpblocks.filter.From); i++ {
+		inputDumpblocks.filter.From[i] = strings.ToLower(inputDumpblocks.filter.From[i])
+	}
+
 	return nil
 }
 

cmd/foldtrace/foldtrace.go

@@ -37,6 +37,10 @@ var FoldTraceCmd = &cobra.Command{
 	Use:   "fold-trace",
 	Short: "Trace an execution trace and fold it for visualization.",
 	Long:  usage,
+	Args:  cobra.ArbitraryArgs,
+	PreRunE: func(cmd *cobra.Command, args []string) error {
+		return validateInputMetric()
+	},
 	RunE: func(cmd *cobra.Command, args []string) error {
 		data, err := getInputData(cmd, args)
 		if err != nil {
@@ -100,13 +104,6 @@ var FoldTraceCmd = &cobra.Command{
 
 		return nil
 	},
-	Args: func(cmd *cobra.Command, args []string) error {
-		err := validateInputMetric()
-		if err != nil {
-			return err
-		}
-		return nil
-	},
 }
 
 func getActualUsedGas(index int, td *TraceData) uint64 {

cmd/fork/fork.go

@@ -28,6 +28,12 @@ var ForkCmd = &cobra.Command{
 	Use:   "fork blockhash url",
 	Short: "Take a forked block and walk up the chain to do analysis.",
 	Long:  "",
+	Args:  cobra.ExactArgs(2),
+	PreRunE: func(cmd *cobra.Command, args []string) error {
+		blockHash = ethcommon.HexToHash(args[0])
+		rpcURL = args[1]
+		return nil
+	},
 	RunE: func(cmd *cobra.Command, args []string) error {
 		log.Info().Str("rpc", rpcURL).Str("blockHash", blockHash.String()).Msg("Starting Analysis")
 		c, err := ethclient.Dial(rpcURL)
@@ -37,14 +43,6 @@ var ForkCmd = &cobra.Command{
 		}
 		return walkTheBlocks(blockHash, c)
 	},
-	Args: func(cmd *cobra.Command, args []string) error {
-		if len(args) != 2 {
-			return fmt.Errorf("two arguments required a block hash and an RPC URL")
-		}
-		blockHash = ethcommon.HexToHash(args[0])
-		rpcURL = args[1]
-		return nil
-	},
 }
 
 func walkTheBlocks(inputBlockHash ethcommon.Hash, client *ethclient.Client) error {

cmd/nodekey/nodekey.go

@@ -22,7 +22,6 @@ import (
 	libp2ppeer "github.com/libp2p/go-libp2p/core/peer"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
-	"golang.org/x/exp/slices"
 )
 
 // libp2p (substrate/avail) - https://github.com/libp2p/specs/blob/master/peer-ids/peer-ids.md
@@ -66,10 +65,35 @@ var NodekeyCmd = &cobra.Command{
 	Use:   "nodekey",
 	Short: "Generate node keys for different blockchain clients and protocols.",
 	Long:  usage,
+	Args:  cobra.NoArgs,
 	PersistentPreRun: func(cmd *cobra.Command, args []string) {
 		privateKey := flag_loader.GetPrivateKeyFlagValue(cmd)
 		inputNodeKeyPrivateKey = *privateKey
 	},
+	PreRunE: func(cmd *cobra.Command, args []string) error {
+		switch inputNodeKeyProtocol {
+		case "devp2p":
+			invalidFlags := []string{"seed", "marshal-protobuf"}
+			return validateNodeKeyFlags(cmd, invalidFlags)
+		case "libp2p":
+			invalidFlags := []string{"file", "ip", "tcp", "udp", "sign", "seed"}
+			return validateNodeKeyFlags(cmd, invalidFlags)
+		case "seed-libp2p":
+			invalidFlags := []string{"file", "ip", "tcp", "udp", "sign"}
+			if err := validateNodeKeyFlags(cmd, invalidFlags); err != nil {
+				return err
+			}
+			if inputNodeKeyType == "rsa" {
+				return fmt.Errorf("the RSA key type doesn't support manual key seeding")
+			}
+			if inputNodeKeyType == "secp256k1" {
+				return fmt.Errorf("the secp256k1 key type doesn't support manual key seeding")
+			}
+			return nil
+		default:
+			return fmt.Errorf("the protocol %s is not implemented", inputNodeKeyProtocol)
+		}
+	},
 	RunE: func(cmd *cobra.Command, args []string) error {
 		var nko nodeKeyOut
 		var withSeed bool
@@ -115,46 +139,6 @@ var NodekeyCmd = &cobra.Command{
 
 		return nil
 	},
-	Args: func(cmd *cobra.Command, args []string) error {
-		if len(args) != 0 {
-			return fmt.Errorf("this command expects no arguments")
-		}
-
-		validProtocols := []string{"devp2p", "libp2p", "seed-libp2p"}
-		ok := slices.Contains(validProtocols, inputNodeKeyProtocol)
-		if !ok {
-			return fmt.Errorf("the protocol %s is not implemented", inputNodeKeyProtocol)
-		}
-
-		if inputNodeKeyProtocol == "devp2p" {
-			invalidFlags := []string{"seed", "marshal-protobuf"}
-			err := validateNodeKeyFlags(cmd, invalidFlags)
-			if err != nil {
-				return err
-			}
-		}
-		if inputNodeKeyProtocol == "libp2p" {
-			invalidFlags := []string{"file", "ip", "tcp", "udp", "sign", "seed"}
-			err := validateNodeKeyFlags(cmd, invalidFlags)
-			if err != nil {
-				return err
-			}
-		}
-		if inputNodeKeyProtocol == "seed-libp2p" {
-			invalidFlags := []string{"file", "ip", "tcp", "udp", "sign"}
-			err := validateNodeKeyFlags(cmd, invalidFlags)
-			if err != nil {
-				return err
-			}
-			if inputNodeKeyType == "rsa" {
-				return fmt.Errorf("the RSA key type doesn't support manual key seeding")
-			}
-			if inputNodeKeyType == "secp256k1" {
-				return fmt.Errorf("the secp256k1 key type doesn't support manual key seeding")
-			}
-		}
-		return nil
-	},
 }
 
 func validateNodeKeyFlags(cmd *cobra.Command, invalidFlags []string) error {

cmd/wallet/wallet.go

@@ -29,9 +29,17 @@ var (
 
 // WalletCmd represents the wallet command
 var WalletCmd = &cobra.Command{
-	Use:   "wallet [create|inspect]",
-	Short: "Create or inspect BIP39(ish) wallets.",
-	Long:  usage,
+	Use:       "wallet [create|inspect]",
+	Short:     "Create or inspect BIP39(ish) wallets.",
+	Long:      usage,
+	Args:      cobra.ExactArgs(1),
+	ValidArgs: []string{"create", "inspect"},
+	PreRunE: func(cmd *cobra.Command, args []string) error {
+		if args[0] != "create" && args[0] != "inspect" {
+			return fmt.Errorf("expected argument to be create or inspect. Got: %s", args[0])
+		}
+		return nil
+	},
 	RunE: func(cmd *cobra.Command, args []string) error {
 		mode := args[0]
 		var err error
@@ -91,15 +99,6 @@ var WalletCmd = &cobra.Command{
 		fmt.Println(string(out))
 		return nil
 	},
-	Args: func(cmd *cobra.Command, args []string) error {
-		if len(args) != 1 {
-			return fmt.Errorf("expected exactly one argument: create or inspect")
-		}
-		if args[0] != "create" && args[0] != "inspect" {
-			return fmt.Errorf("expected argument to be create or inspect. Got: %s", args[0])
-		}
-		return nil
-	},
 }
 
 func getFileOrFlag(filename string, flag string) (string, error) {

cmd/wrapcontract/wrapcontract.go

@@ -37,12 +37,7 @@ var WrapContractCmd = &cobra.Command{
 		fmt.Println(createBytecode)
 		return nil
 	},
-	Args: func(cmd *cobra.Command, args []string) error {
-		if len(args) > 1 {
-			return fmt.Errorf("expected at most one argument: bytecode")
-		}
-		return nil
-	},
+	Args: cobra.MaximumNArgs(1),
 }
 
 func init() {