chore: style flags (#711)

* chore: style flags

* chore: style flags more

* chore: reword flag usage strings

* docs: make gen-doc

* fix: loadtest mode string

* fix: multisentence flags

* docs: make gen-doc

* docs: make gen-doc

Regenerate documentation to reflect flag style guide changes.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

---------

Co-authored-by: Claude <[email protected]>

Author: minhd-vu

CLAUDE.md

@@ -123,4 +123,26 @@ The tool supports configuration via:
 - Use conventional commit messages
 
 ## Development Memories
-- Use `make build` to build polycli
+- Use `make build` to build polycli
+
+## Code Style
+
+### Cobra Flags
+- Flag names: lowercase with hyphens (kebab-case), e.g., `--output-file`
+- Usage strings: lowercase, no ending punctuation, e.g., `"path to output file"`
+- Remove unnecessary leading articles and filler words (e.g., "the", "a", "an") from usage strings
+- Use `PersistentFlags()` only when flags need to be inherited by subcommands; otherwise use `Flags()`
+- When defining multiple flags, use `f := cmd.Flags()` to avoid repetition
+- Prefer `Var()` flag methods (e.g., `StringVar`, `IntVar`, `BoolVar`) over non-Var methods (e.g., `String`, `Int`, `Bool`) to bind directly to variables:
+  ```go
+  f := cmd.Flags()
+  f.StringVar(&myVar, "name", "", "description")
+  f.IntVar(&count, "count", 0, "description")
+  ```
+- Flag variables should be non-pointer types unless there's a specific need for pointers (e.g., distinguishing unset from zero value):
+  ```go
+  var myVar string  // preferred
+  var count int     // preferred
+  f.StringVar(&myVar, "name", "", "description")
+  f.IntVar(&count, "count", 0, "description")
+  ```

cmd/abi/decode/decode.go

@@ -16,8 +16,8 @@ import (
 )
 
 var (
-	inputFileName *string
-	inputData     *string
+	inputFileName string
+	inputData     string
 )
 
 var ABIDecodeCmd = &cobra.Command{
@@ -39,8 +39,8 @@ var ABIDecodeCmd = &cobra.Command{
 		for _, meth := range abi.Methods {
 			fmt.Printf("Selector:%s\tSignature:%s%s\n", hex.EncodeToString(meth.ID), meth.Sig, getReturnSignature(meth.Outputs))
 		}
-		if *inputData != "" {
-			id, callData, err := parseContractInputData(*inputData)
+		if inputData != "" {
+			id, callData, err := parseContractInputData(inputData)
 			fmt.Printf("id: %x, %x\n", id, callData)
 			if err != nil {
 				return err
@@ -81,9 +81,9 @@ var ABIDecodeCmd = &cobra.Command{
 }
 
 func init() {
-	flagSet := ABIDecodeCmd.PersistentFlags()
-	inputFileName = flagSet.String("file", "", "Provide a filename to read and analyze")
-	inputData = flagSet.String("data", "", "Provide input data to be unpacked based on the ABI definition")
+	f := ABIDecodeCmd.Flags()
+	f.StringVar(&inputFileName, "file", "", "filename to read and analyze")
+	f.StringVar(&inputData, "data", "", "input data to be unpacked based on ABI definition")
 }
 
 func parseContractInputData(data string) ([]byte, []byte, error) {
@@ -107,8 +107,8 @@ func parseContractInputData(data string) ([]byte, []byte, error) {
 }
 
 func getInputData(cmd *cobra.Command, args []string) ([]byte, error) {
-	if inputFileName != nil && *inputFileName != "" {
-		return os.ReadFile(*inputFileName)
+	if inputFileName != "" {
+		return os.ReadFile(inputFileName)
 	}
 
 	if len(args) > 1 {

cmd/cdk/cdk.go

@@ -107,23 +107,26 @@ var CDKCmd = &cobra.Command{
 	Short: "Utilities for interacting with CDK networks",
 	Long:  "Basic utility commands for interacting with the cdk contracts",
 	PersistentPreRun: func(cmd *cobra.Command, args []string) {
-		cdkInputArgs.rpcURL = flag_loader.GetRpcUrlFlagValue(cmd)
+		rpcURL := flag_loader.GetRpcUrlFlagValue(cmd)
+		if rpcURL != nil {
+			cdkInputArgs.rpcURL = *rpcURL
+		}
 	},
 	Args: cobra.NoArgs,
 }
 
 type inputArgs struct {
-	rpcURL *string
+	rpcURL string
 
-	forkID *string
+	forkID string
 
-	rollupManagerAddress *string
+	rollupManagerAddress string
 
-	rollupID      *string
-	rollupChainID *string
-	rollupAddress *string
-	bridgeAddress *string
-	gerAddress    *string
+	rollupID      string
+	rollupChainID string
+	rollupAddress string
+	bridgeAddress string
+	gerAddress    string
 }
 
 type parsedCDKArgs struct {
@@ -156,14 +159,14 @@ func checkAddressArg(argFlagName, address string) error {
 func (inputArgs *inputArgs) parseCDKArgs(ctx context.Context) (parsedCDKArgs, error) {
 	args := parsedCDKArgs{}
 
-	args.rpcURL = *inputArgs.rpcURL
+	args.rpcURL = inputArgs.rpcURL
 
-	if inputArgs.forkID != nil && len(*inputArgs.forkID) > 0 {
-		_, found := knownForks[*inputArgs.forkID]
+	if len(inputArgs.forkID) > 0 {
+		_, found := knownForks[inputArgs.forkID]
 		if !found {
 			return parsedCDKArgs{}, invalidForkIDErr()
 		}
-		args.forkID = knownForks[*inputArgs.forkID]
+		args.forkID = knownForks[inputArgs.forkID]
 	}
 
 	return args, nil
@@ -172,14 +175,14 @@ func (inputArgs *inputArgs) parseCDKArgs(ctx context.Context) (parsedCDKArgs, er
 func (inputArgs *inputArgs) parseRollupManagerArgs(ctx context.Context, cdkArgs parsedCDKArgs) (*parsedRollupManagerArgs, error) {
 	args := &parsedRollupManagerArgs{}
 
-	if knownRollupManagerAddress, found := knownRollupManagerAddresses[*cdkInputArgs.rollupManagerAddress]; found {
+	if knownRollupManagerAddress, found := knownRollupManagerAddresses[cdkInputArgs.rollupManagerAddress]; found {
 		args.rollupManagerAddress = common.HexToAddress(knownRollupManagerAddress)
 	} else {
-		err := checkAddressArg(ArgRollupManagerAddress, *inputArgs.rollupManagerAddress)
+		err := checkAddressArg(ArgRollupManagerAddress, inputArgs.rollupManagerAddress)
 		if err != nil {
 			return nil, err
 		}
-		args.rollupManagerAddress = common.HexToAddress(*cdkInputArgs.rollupManagerAddress)
+		args.rollupManagerAddress = common.HexToAddress(cdkInputArgs.rollupManagerAddress)
 	}
 
 	return args, nil
@@ -189,29 +192,29 @@ func (inputArgs *inputArgs) parseRollupArgs(ctx context.Context, rollupManager r
 	args := &parsedRollupArgs{}
 
 	var rollupChainID uint64
-	if cdkInputArgs.rollupChainID != nil && len(*cdkInputArgs.rollupChainID) > 0 {
-		rollupChainIDN, err := strconv.ParseInt(*cdkInputArgs.rollupChainID, 10, 64)
+	if len(cdkInputArgs.rollupChainID) > 0 {
+		rollupChainIDN, err := strconv.ParseInt(cdkInputArgs.rollupChainID, 10, 64)
 		if err != nil || rollupChainIDN < 0 {
-			return nil, fmt.Errorf("invalid rollupChainID: %s, it must be a valid uint64", *cdkInputArgs.rollupID)
+			return nil, fmt.Errorf("invalid rollupChainID: %s, it must be a valid uint64", cdkInputArgs.rollupID)
 		}
 		rollupChainID = uint64(rollupChainIDN)
 	}
 	args.rollupChainID = rollupChainID
 
 	args.rollupAddress = common.Address{}
-	if inputArgs.rollupAddress != nil && len(*inputArgs.rollupAddress) > 0 {
-		err := checkAddressArg(ArgRollupAddress, *inputArgs.rollupAddress)
+	if len(inputArgs.rollupAddress) > 0 {
+		err := checkAddressArg(ArgRollupAddress, inputArgs.rollupAddress)
 		if err != nil {
 			return nil, err
 		}
-		args.rollupAddress = common.HexToAddress(*inputArgs.rollupAddress)
+		args.rollupAddress = common.HexToAddress(inputArgs.rollupAddress)
 	}
 
 	args.rollupID = 0
-	if cdkInputArgs.rollupID != nil && len(*cdkInputArgs.rollupID) > 0 {
-		rollupIDN, err := strconv.Atoi(*cdkInputArgs.rollupID)
+	if len(cdkInputArgs.rollupID) > 0 {
+		rollupIDN, err := strconv.Atoi(cdkInputArgs.rollupID)
 		if err != nil || rollupIDN < 0 {
-			return nil, fmt.Errorf("invalid rollupID: %s, it must be a valid uint32", *cdkInputArgs.rollupID)
+			return nil, fmt.Errorf("invalid rollupID: %s, it must be a valid uint32", cdkInputArgs.rollupID)
 		}
 		args.rollupID = uint32(rollupIDN)
 	} else {
@@ -632,22 +635,24 @@ func mustPrintLogs(logs []types.Log, contractInstance reflect.Value, contractABI
 
 func init() {
 	// cdk
-	cdkInputArgs.rpcURL = CDKCmd.PersistentFlags().String(ArgRpcURL, defaultRPCURL, "The RPC URL of the network containing the CDK contracts")
-	cdkInputArgs.forkID = CDKCmd.PersistentFlags().String(ArgForkID, defaultForkId, "The ForkID of the cdk networks")
-	cdkInputArgs.rollupManagerAddress = CDKCmd.PersistentFlags().String(ArgRollupManagerAddress, "", "The address of the rollup contract")
+	f := CDKCmd.PersistentFlags()
+	f.StringVar(&cdkInputArgs.rpcURL, ArgRpcURL, defaultRPCURL, "RPC URL of network containing CDK contracts")
+	f.StringVar(&cdkInputArgs.forkID, ArgForkID, defaultForkId, "fork ID of CDK networks")
+	f.StringVar(&cdkInputArgs.rollupManagerAddress, ArgRollupManagerAddress, "", "address of rollup contract")
 
 	// rollup manager
 
 	// rollup
-	cdkInputArgs.rollupID = rollupCmd.PersistentFlags().String(ArgRollupID, "", "The rollup ID")
-	cdkInputArgs.rollupChainID = rollupCmd.PersistentFlags().String(ArgRollupChainID, "", "The rollup chain ID")
-	cdkInputArgs.rollupAddress = rollupCmd.PersistentFlags().String(ArgRollupAddress, "", "The rollup Address")
+	fRollup := rollupCmd.PersistentFlags()
+	fRollup.StringVar(&cdkInputArgs.rollupID, ArgRollupID, "", "rollup ID")
+	fRollup.StringVar(&cdkInputArgs.rollupChainID, ArgRollupChainID, "", "rollup chain ID")
+	fRollup.StringVar(&cdkInputArgs.rollupAddress, ArgRollupAddress, "", "rollup address")
 
 	// bridge
-	cdkInputArgs.bridgeAddress = bridgeCmd.PersistentFlags().String(ArgBridgeAddress, "", "The address of the bridge contract")
+	bridgeCmd.PersistentFlags().StringVar(&cdkInputArgs.bridgeAddress, ArgBridgeAddress, "", "address of bridge contract")
 
 	// ger
-	cdkInputArgs.gerAddress = gerCmd.PersistentFlags().String(ArgGERAddress, "", "The address of the GER contract")
+	gerCmd.PersistentFlags().StringVar(&cdkInputArgs.gerAddress, ArgGERAddress, "", "address of GER contract")
 
 	CDKCmd.AddCommand(rollupManagerCmd)
 	CDKCmd.AddCommand(rollupCmd)

cmd/contract/cmd.go

@@ -28,8 +28,8 @@ var (
 )
 
 type contractInputArgs struct {
-	rpcURL  *string
-	address *string
+	rpcURL  string
+	address string
 }
 
 var inputArgs = contractInputArgs{}
@@ -46,7 +46,8 @@ var Cmd = &cobra.Command{
 	Short: "Interact with smart contracts and fetch contract information from the blockchain",
 	Long:  usage,
 	PersistentPreRun: func(cmd *cobra.Command, args []string) {
-		inputArgs.rpcURL = flag_loader.GetRpcUrlFlagValue(cmd)
+		rpcURL := flag_loader.GetRpcUrlFlagValue(cmd)
+		inputArgs.rpcURL = *rpcURL
 	},
 	RunE: func(cmd *cobra.Command, args []string) error {
 		return contract(cmd)
@@ -56,8 +57,8 @@ var Cmd = &cobra.Command{
 func contract(cmd *cobra.Command) error {
 	ctx := cmd.Context()
 
-	rpcURL := *inputArgs.rpcURL
-	address := *inputArgs.address
+	rpcURL := inputArgs.rpcURL
+	address := inputArgs.address
 
 	// connect to the blockchain node and fetch contract information
 	c, err := ethclient.Dial(rpcURL)
@@ -168,8 +169,9 @@ func fetchContractCreationTx(ctx context.Context, client *ethclient.Client, cont
 }
 
 func init() {
-	inputArgs.rpcURL = Cmd.PersistentFlags().String(ArgRpcURL, defaultRPCURL, "The RPC URL of the network containing the contract")
-	inputArgs.address = Cmd.PersistentFlags().String(ArgAddress, "", "The contract address")
+	f := Cmd.Flags()
+	f.StringVar(&inputArgs.rpcURL, ArgRpcURL, defaultRPCURL, "RPC URL of network containing contract")
+	f.StringVar(&inputArgs.address, ArgAddress, "", "contract address")
 
-	_ = Cmd.MarkPersistentFlagRequired(ArgAddress)
+	_ = Cmd.MarkFlagRequired(ArgAddress)
 }