Add Validator for remote L1 without importing blockchain

cmd/blockchaincmd/add_validator.go

@@ -8,6 +8,8 @@ import (
 	"strings"
 	"time"
 
+	"github.com/ava-labs/avalanchego/vms/platformvm"
+
 	"github.com/ava-labs/avalanche-cli/pkg/blockchain"
 	"github.com/ava-labs/avalanche-cli/pkg/cobrautils"
 	"github.com/ava-labs/avalanche-cli/pkg/constants"
@@ -64,8 +66,11 @@ var (
 	aggregatorExtraEndpoints            []string
 	aggregatorAllowPrivatePeers         bool
 	clusterNameFlagValue                string
+	createLocalValidator                bool
+)
 
-	createLocalValidator bool
+const (
+	validatorWeightFlag = "weight"
 )
 
 // avalanche blockchain addValidator
@@ -82,12 +87,11 @@ staking token. Both processes will issue a RegisterL1ValidatorTx on the P-Chain.
 This command currently only works on Blockchains deployed to either the Fuji
 Testnet or Mainnet.`,
 		RunE: addValidator,
-		Args: cobrautils.ExactArgs(1),
+		Args: cobrautils.MaximumNArgs(1),
 	}
 	networkoptions.AddNetworkFlagsToCmd(cmd, &globalNetworkFlags, true, networkoptions.DefaultSupportedNetworkOptions)
 
 	cmd.Flags().StringVarP(&keyName, "key", "k", "", "select the key to use [fuji/devnet only]")
-	cmd.Flags().Uint64Var(&weight, "weight", constants.NonBootstrapValidatorWeight, "set the staking weight of the validator to add")
 	cmd.Flags().Float64Var(
 		&balanceAVAX,
 		"balance",
@@ -119,31 +123,50 @@ Testnet or Mainnet.`,
 	cmd.Flags().StringVar(&outputTxPath, "output-tx-path", "", "(for Subnets, not L1s) file path of the add validator tx")
 	cmd.Flags().BoolVar(&waitForTxAcceptance, "wait-for-tx-acceptance", true, "(for Subnets, not L1s) just issue the add validator tx, without waiting for its acceptance")
 	cmd.Flags().Uint16Var(&delegationFee, "delegation-fee", 100, "(PoS only) delegation fee (in bips)")
+	cmd.Flags().StringVar(&subnetIDstr, "subnet-id", "", "subnet ID (only if blockchain name is not provided)")
+	cmd.Flags().StringVar(&validatorManagerOwnerAddress, "validator-manager-owner", "", "validator manager owner address (only if blockchain name is not provided)")
+	cmd.Flags().Uint64Var(&weight, validatorWeightFlag, uint64(constants.DefaultStakeWeight), "set the weight of the validator")
 
 	return cmd
 }
 
-func preAddChecks() error {
+func preAddChecks(args []string) error {
 	if nodeEndpoint != "" && createLocalValidator {
 		return fmt.Errorf("cannot set both --node-endpoint and --create-local-validator")
 	}
 	if createLocalValidator && (nodeIDStr != "" || publicKey != "" || pop != "") {
 		return fmt.Errorf("cannot set --node-id, --bls-public-key or --bls-proof-of-possession if --create-local-validator used")
 	}
+	if len(args) == 0 && createLocalValidator {
+		return fmt.Errorf("use `avalanche addValidator <l1Name>`to use local machine as new validator")
+	}
 
 	return nil
 }
 
-func addValidator(_ *cobra.Command, args []string) error {
-	blockchainName := args[0]
-	_, err := ValidateSubnetNameAndGetChains([]string{blockchainName})
-	if err != nil {
-		return err
-	}
+func GetSubnet(subnetID ids.ID, network models.Network) (platformvm.GetSubnetClientResponse, error) {
+	api := network.Endpoint
+	pClient := platformvm.NewClient(api)
+	ctx, cancel := utils.GetAPIContext()
+	defer cancel()
+	return pClient.GetSubnet(ctx, subnetID)
+}
 
-	sc, err := app.LoadSidecar(blockchainName)
-	if err != nil {
-		return fmt.Errorf("failed to load sidecar: %w", err)
+func addValidator(cmd *cobra.Command, args []string) error {
+	var sc models.Sidecar
+	blockchainName := ""
+	networkOption := networkoptions.DefaultSupportedNetworkOptions
+	if len(args) == 1 {
+		blockchainName = args[0]
+		_, err := ValidateSubnetNameAndGetChains([]string{blockchainName})
+		if err != nil {
+			return err
+		}
+		sc, err = app.LoadSidecar(blockchainName)
+		if err != nil {
+			return fmt.Errorf("failed to load sidecar: %w", err)
+		}
+		networkOption = networkoptions.GetNetworkFromSidecar(sc, networkoptions.DefaultSupportedNetworkOptions)
 	}
 
 	network, err := networkoptions.GetNetworkFromCmdLineFlags(
@@ -152,7 +175,7 @@ func addValidator(_ *cobra.Command, args []string) error {
 		globalNetworkFlags,
 		true,
 		false,
-		networkoptions.GetNetworkFromSidecar(sc, networkoptions.DefaultSupportedNetworkOptions),
+		networkOption,
 		"",
 	)
 	if err != nil {
@@ -164,7 +187,36 @@ func addValidator(_ *cobra.Command, args []string) error {
 		network = models.ConvertClusterToNetwork(network)
 	}
 
-	if err := preAddChecks(); err != nil {
+	if len(args) == 0 {
+		if createLocalValidator {
+			return fmt.Errorf("use avalanche addValidator <subnetName> command to use local machine as new validator")
+		}
+		var subnetID ids.ID
+		if subnetIDstr == "" {
+			subnetID, err = app.Prompt.CaptureID("What is the Subnet ID?")
+			if err != nil {
+				return err
+			}
+		} else {
+			subnetID, err = ids.FromString(subnetIDstr)
+			if err != nil {
+				return err
+			}
+		}
+
+		if rpcURL == "" {
+			rpcURL, err = app.Prompt.CaptureURL("What is the RPC endpoint?", false)
+			if err != nil {
+				return err
+			}
+		}
+		sc, err = importL1(subnetID, rpcURL, network)
+		if err != nil {
+			return err
+		}
+	}
+
+	if err := preAddChecks(args); err != nil {
 		return err
 	}
 
@@ -197,19 +249,35 @@ func addValidator(_ *cobra.Command, args []string) error {
 		}
 	}
 
-	// if we don't have a nodeID or ProofOfPossession by this point, prompt user if we want to add a aditional local node
-	if (!sovereign && nodeIDStr == "") || (sovereign && !createLocalValidator && nodeIDStr == "" && publicKey == "" && pop == "") {
-		for {
-			local := "Use my local machine to spin up an additional validator"
-			existing := "I have an existing Avalanche node (we will require its NodeID and BLS info)"
-			if option, err := app.Prompt.CaptureList(
-				"How would you like to set up the new validator",
-				[]string{local, existing},
-			); err != nil {
+	if sovereign {
+		if !cmd.Flags().Changed(validatorWeightFlag) {
+			weight, err = app.Prompt.CaptureWeight(
+				"What weight would you like to assign to the validator?",
+				func(uint64) error { return nil },
+			)
+			if err != nil {
 				return err
-			} else {
-				createLocalValidator = option == local
-				break
+			}
+		}
+	}
+
+	// if we don't have a nodeID or ProofOfPossession by this point, prompt user if we want to add additional local node
+	if (!sovereign && nodeIDStr == "") || (sovereign && !createLocalValidator && nodeIDStr == "" && publicKey == "" && pop == "") {
+		if len(args) == 0 {
+			createLocalValidator = false
+		} else {
+			for {
+				local := "Use my local machine to spin up an additional validator"
+				existing := "I have an existing Avalanche node (we will require its NodeID and BLS info)"
+				if option, err := app.Prompt.CaptureList(
+					"How would you like to set up the new validator",
+					[]string{local, existing},
+				); err != nil {
+					return err
+				} else {
+					createLocalValidator = option == local
+					break
+				}
 			}
 		}
 	}
@@ -312,6 +380,7 @@ func addValidator(_ *cobra.Command, args []string) error {
 		balanceAVAX,
 		remainingBalanceOwnerAddr,
 		disableOwnerAddr,
+		sc,
 	)
 }
 
@@ -335,6 +404,7 @@ func CallAddValidator(
 	balanceAVAX float64,
 	remainingBalanceOwnerAddr string,
 	disableOwnerAddr string,
+	sc models.Sidecar,
 ) error {
 	nodeID, err := ids.NodeIDFromString(nodeIDStr)
 	if err != nil {
@@ -350,21 +420,16 @@ func CallAddValidator(
 		return fmt.Errorf("failed to get blockchain timestamp: %w", err)
 	}
 	expiry := uint64(blockchainTimestamp.Add(constants.DefaultValidationIDExpiryDuration).Unix())
-
 	chainSpec := contract.ChainSpec{
 		BlockchainName: blockchainName,
 	}
-
-	sc, err := app.LoadSidecar(chainSpec.BlockchainName)
-	if err != nil {
-		return fmt.Errorf("failed to load sidecar: %w", err)
+	if sc.Networks[network.Name()].BlockchainID.String() != "" {
+		chainSpec.BlockchainID = sc.Networks[network.Name()].BlockchainID.String()
 	}
-
 	if sc.Networks[network.Name()].ValidatorManagerAddress == "" {
 		return fmt.Errorf("unable to find Validator Manager address")
 	}
 	validatorManagerAddress = sc.Networks[network.Name()].ValidatorManagerAddress
-
 	ownerPrivateKeyFound, _, _, ownerPrivateKey, err := contract.SearchForManagedKey(
 		app,
 		network,

cmd/blockchaincmd/change_weight.go

@@ -257,5 +257,6 @@ func setWeight(_ *cobra.Command, args []string) error {
 		float64(balance)/float64(units.Avax),
 		remainingBalanceOwnerAddr,
 		disableOwnerAddr,
+		sc,
 	)
 }

cmd/blockchaincmd/convert.go

@@ -617,7 +617,7 @@ func convertBlockchain(_ *cobra.Command, args []string) error {
 			}
 
 		default:
-			bootstrapValidators, err = promptBootstrapValidators(
+			bootstrapValidators, _, err = promptBootstrapValidators(
 				network,
 				changeOwnerAddress,
 				numBootstrapValidators,

cmd/blockchaincmd/deploy.go

@@ -93,6 +93,7 @@ var (
 	poSWeightToValueFactor         uint64
 	deployBalanceAVAX              float64
 	validatorManagerAddress        string
+	validatorManagerOwnerAddress   string
 	errMutuallyExlusiveControlKeys = errors.New("--control-keys and --same-control-key are mutually exclusive")
 	ErrMutuallyExlusiveKeyLedger   = errors.New("key source flags --key, --ledger/--ledger-addrs are mutually exclusive")
 	ErrStoredKeyOnMainnet          = errors.New("key --key is not available for mainnet operations")
@@ -574,7 +575,8 @@ func deployBlockchain(cmd *cobra.Command, args []string) error {
 	}
 
 	deployBalance := uint64(deployBalanceAVAX * float64(units.Avax))
-
+	// whether user has created Avalanche Nodes when blockchain deploy command is called
+	var setUpNode bool
 	if sidecar.Sovereign {
 		if changeOwnerAddress == "" {
 			// use provided key as change owner unless already set
@@ -624,7 +626,7 @@ func deployBlockchain(cmd *cobra.Command, args []string) error {
 			}
 
 		default:
-			bootstrapValidators, err = promptBootstrapValidators(
+			bootstrapValidators, setUpNode, err = promptBootstrapValidators(
 				network,
 				changeOwnerAddress,
 				numBootstrapValidators,
@@ -793,12 +795,11 @@ func deployBlockchain(cmd *cobra.Command, args []string) error {
 			return nil
 		}
 
-		if convertOnly || generateNodeID || (!useLocalMachine && clusterNameFlagValue == "") {
+		if !setUpNode && (convertOnly || generateNodeID || (!useLocalMachine && clusterNameFlagValue == "")) {
 			ux.Logger.GreenCheckmarkToUser("Converted blockchain successfully generated")
 			ux.Logger.PrintToUser("To finish conversion to sovereign L1, create the corresponding Avalanche node(s) with the provided Node ID and BLS Info")
-			ux.Logger.PrintToUser("and setup them to track subnet ID %s with 'track-subnets' config setting", subnetID)
-			ux.Logger.PrintToUser(logging.Green.Wrap("Double check the nodes expose the P2P port and have a correct setting for 'public-ip' config value"))
 			ux.Logger.PrintToUser("Created Node ID and BLS Info can be found at %s", app.GetSidecarPath(blockchainName))
+			ux.Logger.PrintToUser("==================================================")
 			ux.Logger.PrintToUser("Once the Avalanche Node(s) are created and are tracking the blockchain, call `avalanche contract initValidatorManager %s` to finish conversion to sovereign L1", blockchainName)
 			return nil
 		}

cmd/blockchaincmd/import_public.go

@@ -3,9 +3,13 @@
 package blockchaincmd
 
 import (
+	"encoding/hex"
 	"encoding/json"
 	"fmt"
 
+	"github.com/ava-labs/avalanche-cli/pkg/validatormanager"
+	"github.com/ethereum/go-ethereum/common"
+
 	"github.com/ava-labs/avalanche-cli/pkg/application"
 	"github.com/ava-labs/avalanche-cli/pkg/cobrautils"
 	"github.com/ava-labs/avalanche-cli/pkg/constants"
@@ -22,7 +26,8 @@ import (
 )
 
 var (
-	blockchainIDstr string
+	blockchainIDStr string
+	subnetIDstr     string
 	nodeURL         string
 	useSubnetEvm    bool
 	useCustomVM     bool
@@ -55,7 +60,7 @@ flag.`,
 		"overwrite the existing configuration if one exists",
 	)
 	cmd.Flags().StringVar(
-		&blockchainIDstr,
+		&blockchainIDStr,
 		"blockchain-id",
 		"",
 		"the blockchain ID",
@@ -102,13 +107,13 @@ func importPublic(*cobra.Command, []string) error {
 	}
 
 	var blockchainID ids.ID
-	if blockchainIDstr == "" {
+	if blockchainIDStr == "" {
 		blockchainID, err = app.Prompt.CaptureID("What is the ID of the blockchain?")
 		if err != nil {
 			return err
 		}
 	} else {
-		blockchainID, err = ids.FromString(blockchainIDstr)
+		blockchainID, err = ids.FromString(blockchainIDStr)
 		if err != nil {
 			return err
 		}
@@ -211,3 +216,48 @@ func importPublic(*cobra.Command, []string) error {
 
 	return nil
 }
+
+func importL1(subnetID ids.ID, rpcURL string, network models.Network) (models.Sidecar, error) {
+	var sc models.Sidecar
+
+	subnetInfo, err := GetSubnet(subnetID, network)
+	if err != nil {
+		return models.Sidecar{}, err
+	}
+	if subnetInfo.IsPermissioned {
+		return models.Sidecar{}, fmt.Errorf("use avalanche addValidator <subnetName> command for non sovereign Subnets")
+	}
+	blockchainID := subnetInfo.ManagerChainID
+	validatorManagerAddress = "0x" + hex.EncodeToString(subnetInfo.ManagerAddress)
+
+	// add validator without blockchain arg is only for l1s
+	sc = models.Sidecar{
+		Sovereign: true,
+	}
+
+	isPoA := validatormanager.IsValidatorManagerPoA(rpcURL, common.HexToAddress(validatorManagerAddress))
+	if err != nil {
+		return models.Sidecar{}, err
+	}
+
+	if isPoA {
+		sc.ValidatorManagement = models.ProofOfAuthority
+		owner, err := validatormanager.GetValidatorManagerOwner(rpcURL, common.HexToAddress(validatorManagerAddress))
+		if err != nil {
+			return models.Sidecar{}, err
+		}
+		sc.ValidatorManagerOwner = owner.String()
+	} else {
+		sc.ValidatorManagement = models.ProofOfStake
+	}
+
+	sc.Networks = make(map[string]models.NetworkData)
+
+	sc.Networks[network.Name()] = models.NetworkData{
+		SubnetID:                subnetID,
+		BlockchainID:            blockchainID,
+		ValidatorManagerAddress: validatorManagerAddress,
+		RPCEndpoints:            []string{rpcURL},
+	}
+	return sc, err
+}