Validate validator manager flag value (#2395)

* update validator manager flag value

* fix lint

cmd/blockchaincmd/create.go

@@ -12,6 +12,10 @@ import (
 	"strings"
 	"unicode"
 
+	"github.com/ava-labs/avalanche-cli/pkg/key"
+	"github.com/ava-labs/avalanchego/utils/formatting/address"
+	"github.com/ethereum/go-ethereum/common"
+
 	"github.com/ava-labs/avalanche-cli/cmd/flags"
 	"github.com/ava-labs/avalanche-cli/pkg/cobrautils"
 	"github.com/ava-labs/avalanche-cli/pkg/constants"
@@ -251,6 +255,12 @@ func createBlockchainConfig(cmd *cobra.Command, args []string) error {
 
 	if vmType == models.SubnetEvm {
 		if sovereign {
+			// if validatorManagerOwner flag is used, we get the C Chain address of the key used
+			if createFlags.validatorManagerOwner != "" {
+				if err = validateValidatorManagerOwnerFlag(createFlags.validatorManagerOwner); err != nil {
+					return err
+				}
+			}
 			if createFlags.validatorManagerOwner == "" {
 				createFlags.validatorManagerOwner, err = getValidatorContractManagerAddr()
 				if err != nil {
@@ -262,6 +272,9 @@ func createBlockchainConfig(cmd *cobra.Command, args []string) error {
 
 			// use the validator manager owner as the transparent proxy contract owner unless specified via cmd flag
 			if createFlags.proxyContractOwner != "" {
+				if err = validateValidatorManagerOwnerFlag(createFlags.proxyContractOwner); err != nil {
+					return err
+				}
 				sc.ProxyContractOwner = createFlags.proxyContractOwner
 			} else {
 				sc.ProxyContractOwner = sc.ValidatorManagerOwner
@@ -510,6 +523,24 @@ func sendMetrics(cmd *cobra.Command, repoName, blockchainName string) error {
 	return nil
 }
 
+func validateValidatorManagerOwnerFlag(input string) error {
+	// check that flag value is not P Chain or X Chain address
+	_, _, _, err := address.Parse(input)
+	if err == nil {
+		return fmt.Errorf("validator manager owner has to be EVM address (in 0x format)")
+	}
+	// if flag value is a key name, we get the C Chain address of the key and set it as the value of
+	// the validator manager address
+	if !common.IsHexAddress(input) {
+		k, err := key.LoadSoft(models.UndefinedNetwork.ID, app.GetKeyPath(input))
+		if err != nil {
+			return err
+		}
+		createFlags.validatorManagerOwner = k.C()
+	}
+	return nil
+}
+
 func checkInvalidSubnetNames(name string) error {
 	if name == "" {
 		return errEmptyBlockchainName

tests/e2e/testcases/subnet/sov/etna/suite.go

@@ -19,7 +19,6 @@ const (
 	CLIBinary         = "./bin/avalanche"
 	subnetName        = "e2eSubnetTest"
 	keyName           = "ewoq"
-	avalancheGoPath   = "--avalanchego-path"
 	ewoqEVMAddress    = "0x8db97C7cEcE249c2b98bDC0226Cc4C2A57BF52FC"
 	ewoqPChainAddress = "P-custom18jma8ppw3nhx5r4ap8clazz0dps7rv5u9xde7p"
 	testLocalNodeName = "e2eSubnetTest-local-node"
@@ -67,6 +66,125 @@ func createEtnaSubnetEvmConfig(poa, pos bool) {
 	gomega.Expect(exists).Should(gomega.BeTrue())
 }
 
+func createEtnaSubnetEvmConfigWithoutProxyOwner(poa, pos bool) {
+	// Check config does not already exist
+	exists, err := utils.SubnetConfigExists(subnetName)
+	gomega.Expect(err).Should(gomega.BeNil())
+	gomega.Expect(exists).Should(gomega.BeFalse())
+
+	cmdArgs := []string{
+		"blockchain",
+		"create",
+		subnetName,
+		"--evm",
+		"--validator-manager-owner",
+		ewoqEVMAddress,
+		"--production-defaults",
+		"--evm-chain-id=99999",
+		"--evm-token=TOK",
+		"--teleporter=false",
+		"--" + constants.SkipUpdateFlag,
+	}
+	if poa {
+		cmdArgs = append(cmdArgs, "--proof-of-authority")
+	} else if pos {
+		cmdArgs = append(cmdArgs, "--proof-of-stake")
+	}
+
+	cmd := exec.Command(CLIBinary, cmdArgs...)
+	output, err := cmd.CombinedOutput()
+	fmt.Println(string(output))
+	if err != nil {
+		fmt.Println(cmd.String())
+		utils.PrintStdErr(err)
+	}
+	gomega.Expect(err).Should(gomega.BeNil())
+
+	// Config should now exist
+	exists, err = utils.SubnetConfigExists(subnetName)
+	gomega.Expect(err).Should(gomega.BeNil())
+	gomega.Expect(exists).Should(gomega.BeTrue())
+}
+
+func createEtnaSubnetEvmConfigValidatorManagerFlagKeyname(poa, pos bool) {
+	// Check config does not already exist
+	exists, err := utils.SubnetConfigExists(subnetName)
+	gomega.Expect(err).Should(gomega.BeNil())
+	gomega.Expect(exists).Should(gomega.BeFalse())
+
+	cmdArgs := []string{
+		"blockchain",
+		"create",
+		subnetName,
+		"--evm",
+		"--validator-manager-owner",
+		"ewoq",
+		"--proxy-contract-owner",
+		"ewoq",
+		"--production-defaults",
+		"--evm-chain-id=99999",
+		"--evm-token=TOK",
+		"--teleporter=false",
+		"--" + constants.SkipUpdateFlag,
+	}
+	if poa {
+		cmdArgs = append(cmdArgs, "--proof-of-authority")
+	} else if pos {
+		cmdArgs = append(cmdArgs, "--proof-of-stake")
+	}
+
+	cmd := exec.Command(CLIBinary, cmdArgs...)
+	output, err := cmd.CombinedOutput()
+	fmt.Println(string(output))
+	if err != nil {
+		fmt.Println(cmd.String())
+		utils.PrintStdErr(err)
+	}
+	gomega.Expect(err).Should(gomega.BeNil())
+
+	// Config should now exist
+	exists, err = utils.SubnetConfigExists(subnetName)
+	gomega.Expect(err).Should(gomega.BeNil())
+	gomega.Expect(exists).Should(gomega.BeTrue())
+}
+
+func createEtnaSubnetEvmConfigValidatorManagerFlagPChain(poa, pos bool) {
+	// Check config does not already exist
+	exists, err := utils.SubnetConfigExists(subnetName)
+	gomega.Expect(err).Should(gomega.BeNil())
+	gomega.Expect(exists).Should(gomega.BeFalse())
+
+	cmdArgs := []string{
+		"blockchain",
+		"create",
+		subnetName,
+		"--evm",
+		"--validator-manager-owner",
+		"P-custom18jma8ppw3nhx5r4ap8clazz0dps7rv5u9xde7p",
+		"--proxy-contract-owner",
+		"P-custom18jma8ppw3nhx5r4ap8clazz0dps7rv5u9xde7p",
+		"--production-defaults",
+		"--evm-chain-id=99999",
+		"--evm-token=TOK",
+		"--teleporter=false",
+		"--" + constants.SkipUpdateFlag,
+	}
+	if poa {
+		cmdArgs = append(cmdArgs, "--proof-of-authority")
+	} else if pos {
+		cmdArgs = append(cmdArgs, "--proof-of-stake")
+	}
+
+	cmd := exec.Command(CLIBinary, cmdArgs...)
+	output, err := cmd.CombinedOutput()
+	fmt.Println(string(output))
+	if err != nil {
+		fmt.Println(cmd.String())
+		utils.PrintStdErr(err)
+	}
+	gomega.Expect(err).ShouldNot(gomega.BeNil())
+}
+
 func destroyLocalNode() {
 	_, err := os.Stat(testLocalNodeName)
 	if os.IsNotExist(err) {
@@ -242,6 +360,19 @@ var _ = ginkgo.Describe("[Etna Subnet SOV]", func() {
 		gomega.Expect(err).Should(gomega.BeNil())
 		commands.CleanNetwork()
 	})
+
+	ginkgo.It("Test Create Etna POA Subnet Config With Key Name for Validator Manager Flag", func() {
+		createEtnaSubnetEvmConfigValidatorManagerFlagKeyname(true, false)
+	})
+
+	ginkgo.It("Test Create Etna POA Subnet Config With P Chain Address for Validator Manager Flag", func() {
+		createEtnaSubnetEvmConfigValidatorManagerFlagPChain(true, false)
+	})
+
+	ginkgo.It("Test Create Etna POA Subnet Config Without Proxy Owner Flag", func() {
+		createEtnaSubnetEvmConfigWithoutProxyOwner(true, false)
+	})
+
 	ginkgo.It("Create Etna POA Subnet Config & Deploy the Subnet To Public Etna On Local Machine", func() {
 		createEtnaSubnetEvmConfig(true, false)
 		deployEtnaSubnetEtnaFlag()