Localclusters tmpnet

cmd/blockchaincmd/add_validator.go

@@ -14,9 +14,9 @@ import (
 	"github.com/ava-labs/avalanche-cli/pkg/contract"
 	"github.com/ava-labs/avalanche-cli/pkg/evm"
 	"github.com/ava-labs/avalanche-cli/pkg/keychain"
+	"github.com/ava-labs/avalanche-cli/pkg/localnet"
 	"github.com/ava-labs/avalanche-cli/pkg/models"
 	"github.com/ava-labs/avalanche-cli/pkg/networkoptions"
-	"github.com/ava-labs/avalanche-cli/pkg/node"
 	"github.com/ava-labs/avalanche-cli/pkg/prompts"
 	"github.com/ava-labs/avalanche-cli/pkg/subnet"
 	"github.com/ava-labs/avalanche-cli/pkg/txutils"
@@ -25,7 +25,6 @@ import (
 	"github.com/ava-labs/avalanche-cli/pkg/validatormanager"
 	sdkutils "github.com/ava-labs/avalanche-cli/sdk/utils"
 	"github.com/ava-labs/avalanche-cli/sdk/validator"
-	"github.com/ava-labs/avalanchego/config"
 	"github.com/ava-labs/avalanchego/ids"
 	avagoconstants "github.com/ava-labs/avalanchego/utils/constants"
 	"github.com/ava-labs/avalanchego/utils/formatting/address"
@@ -68,6 +67,8 @@ var (
 	createLocalValidator                bool
 	externalValidatorManagerOwner       bool
 	validatorManagerOwner               string
+	httpPort                            uint32
+	stakingPort                         uint32
 )
 
 const (
@@ -129,6 +130,8 @@ Testnet or Mainnet.`,
 	cmd.Flags().StringVar(&validatorManagerOwner, "validator-manager-owner", "", "force using this address to issue transactions to the validator manager")
 	cmd.Flags().BoolVar(&externalValidatorManagerOwner, "external-evm-signature", false, "set this value to true when signing validator manager tx outside of cli (for multisig or ledger)")
 	cmd.Flags().StringVar(&initiateTxHash, "initiate-tx-hash", "", "initiate tx is already issued, with the given hash")
+	cmd.Flags().Uint32Var(&httpPort, "http-port", 0, "http port for node")
+	cmd.Flags().Uint32Var(&stakingPort, "staking-port", 0, "staking port for node")
 
 	return cmd
 }
@@ -222,7 +225,7 @@ func addValidator(cmd *cobra.Command, args []string) error {
 	sovereign := sc.Sovereign
 
 	if nodeEndpoint != "" {
-		nodeIDStr, publicKey, pop, err = node.GetNodeData(nodeEndpoint)
+		nodeIDStr, publicKey, pop, err = utils.GetNodeID(nodeEndpoint)
 		if err != nil {
 			return err
 		}
@@ -264,54 +267,35 @@ func addValidator(cmd *cobra.Command, args []string) error {
 	subnetID := sc.Networks[network.Name()].SubnetID
 
 	// if user chose to upsize a local node to add another local validator
+	var localValidatorClusterName string
 	if createLocalValidator {
-		anrSettings := node.ANRSettings{}
-		nodeConfig := map[string]interface{}{}
-		ux.Logger.PrintToUser("Creating a new Avalanche node on local machine to add as a new validator to blockchain %s", blockchainName)
-		if app.AvagoNodeConfigExists(blockchainName) {
-			nodeConfig, err = utils.ReadJSON(app.GetAvagoNodeConfigPath(blockchainName))
-			if err != nil {
-				return err
-			}
-		}
-		if partialSync {
-			nodeConfig[config.PartialSyncPrimaryNetworkKey] = true
-		}
-		avalancheGoBinPath, err := node.GetLocalNodeAvalancheGoBinPath()
+		// TODO: make this to work even if there is no local cluster for the blockchain and network
+		targetClusters, err := localnet.GetFilteredLocalClusters(app, true, network, blockchainName)
 		if err != nil {
-			return fmt.Errorf("failed to get local node avalanche go bin path: %w", err)
-		}
-
-		nodeName := ""
-		blockchainID := sc.Networks[network.Name()].BlockchainID
-
-		if nodeName, err = node.UpsizeLocalNode(
-			app,
-			network,
-			blockchainName,
-			blockchainID,
-			subnetID,
-			avalancheGoBinPath,
-			nodeConfig,
-			anrSettings,
-		); err != nil {
 			return err
 		}
-		// get node data
-		nodeInfo, err := node.GetNodeInfo(nodeName)
+		if len(targetClusters) == 0 {
+			return fmt.Errorf("no local cluster is running for network %s and blockchain %s", network.Name(), blockchainName)
+		}
+		if len(targetClusters) != 1 {
+			return fmt.Errorf("too many local clusters running for network %s and blockchain %s", network.Name(), blockchainName)
+		}
+		localValidatorClusterName = targetClusters[0]
+		node, err := localnet.AddNodeToLocalCluster(app, ux.Logger.PrintToUser, localValidatorClusterName, httpPort, stakingPort)
 		if err != nil {
 			return err
 		}
-		nodeIDStr, publicKey, pop, err = node.GetNodeData(nodeInfo.Uri)
+		nodeIDStr, publicKey, pop, err = utils.GetNodeID(node.URI)
 		if err != nil {
 			return err
 		}
-		// update sidecar with new node
-		if err := node.AddNodeInfoToSidecar(&sc, nodeInfo, network); err != nil {
+		if err := app.AddDefaultBlockchainRPCsToSidecar(blockchainName, network, []string{node.URI}); err != nil {
 			return err
 		}
-		if err := app.UpdateSidecar(&sc); err != nil {
-			return err
+		// reload sc
+		sc, err = app.LoadSidecar(blockchainName)
+		if err != nil {
+			return fmt.Errorf("failed to load sidecar: %w", err)
 		}
 		// make sure extra validator endpoint added for the new node
 		aggregatorExtraEndpoints = append(aggregatorExtraEndpoints, constants.LocalAPIEndpoint)
@@ -346,7 +330,7 @@ func addValidator(cmd *cobra.Command, args []string) error {
 	if !sovereign {
 		return CallAddValidatorNonSOV(deployer, network, kc, useLedger, blockchainName, nodeIDStr, defaultValidatorParams, waitForTxAcceptance)
 	}
-	return CallAddValidator(
+	if err := CallAddValidator(
 		deployer,
 		network,
 		kc,
@@ -360,7 +344,15 @@ func addValidator(cmd *cobra.Command, args []string) error {
 		remainingBalanceOwnerAddr,
 		disableOwnerAddr,
 		sc,
-	)
+	); err != nil {
+		return err
+	}
+	if createLocalValidator {
+		if err := localnet.RefreshLocalClusterAliases(app, localValidatorClusterName); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
 func promptValidatorBalanceAVAX(availableBalance float64) (float64, error) {
@@ -623,6 +615,7 @@ func CallAddValidator(
 		ux.Logger.PrintToUser("  Weight: %d", weight)
 	}
 	ux.Logger.PrintToUser("  Balance: %.2f", balanceAVAX)
+
 	ux.Logger.GreenCheckmarkToUser("Validator successfully added to the L1")
 
 	return nil

cmd/blockchaincmd/change_weight.go

@@ -15,7 +15,6 @@ import (
 	"github.com/ava-labs/avalanche-cli/pkg/keychain"
 	"github.com/ava-labs/avalanche-cli/pkg/models"
 	"github.com/ava-labs/avalanche-cli/pkg/networkoptions"
-	"github.com/ava-labs/avalanche-cli/pkg/node"
 	"github.com/ava-labs/avalanche-cli/pkg/prompts"
 	"github.com/ava-labs/avalanche-cli/pkg/subnet"
 	"github.com/ava-labs/avalanche-cli/pkg/utils"
@@ -116,7 +115,7 @@ func setWeight(_ *cobra.Command, args []string) error {
 	}
 
 	if nodeEndpoint != "" {
-		nodeIDStr, publicKey, pop, err = node.GetNodeData(nodeEndpoint)
+		nodeIDStr, publicKey, pop, err = utils.GetNodeID(nodeEndpoint)
 		if err != nil {
 			return err
 		}

cmd/blockchaincmd/convert.go

@@ -82,6 +82,8 @@ Sovereign L1s require bootstrap validators. avalanche blockchain convert command
 		"set the AVAX balance of each bootstrap validator that will be used for continuous fee on P-Chain",
 	)
 	cmd.Flags().IntVar(&numLocalNodes, "num-local-nodes", 0, "number of nodes to be created on local machine")
+	cmd.Flags().UintSliceVar(&httpPorts, "http-port", []uint{}, "http port for node(s)")
+	cmd.Flags().UintSliceVar(&stakingPorts, "staking-port", []uint{}, "staking port for node(s)")
 	cmd.Flags().StringVar(&changeOwnerAddress, "change-owner-address", "", "address that will receive change if node is no longer L1 validator")
 
 	cmd.Flags().Uint64Var(&poSMinimumStakeAmount, "pos-minimum-stake-amount", 1, "minimum stake amount")
@@ -109,6 +111,8 @@ func StartLocalMachine(
 	blockchainName string,
 	deployBalance,
 	availableBalance uint64,
+	httpPorts []uint,
+	stakingPorts []uint,
 ) (bool, error) {
 	var err error
 	if network.Kind == models.Local {
@@ -118,15 +122,10 @@ func StartLocalMachine(
 	clusterName := fmt.Sprintf("%s-local-node-%s", blockchainName, networkNameComponent)
 	if clusterNameFlagValue != "" {
 		clusterName = clusterNameFlagValue
-		clusterConfig, err := app.GetClusterConfig(clusterName)
-		if err != nil {
-			return false, err
-		}
-		// check if cluster is local
-		if clusterConfig.Local {
+		if localnet.LocalClusterExists(app, clusterName) {
 			useLocalMachine = true
 			if len(bootstrapEndpoints) == 0 {
-				bootstrapEndpoints, err = getLocalBootstrapEndpoints()
+				bootstrapEndpoints, err = localnet.GetLocalClusterURIs(app, clusterName)
 				if err != nil {
 					return false, fmt.Errorf("error getting local host bootstrap endpoints: %w, "+
 						"please create your local node again and call blockchain deploy command again", err)
@@ -155,9 +154,7 @@ func StartLocalMachine(
 	}
 	// if no cluster provided - we create one with fmt.Sprintf("%s-local-node-%s", blockchainName, networkNameComponent) name
 	if useLocalMachine && clusterNameFlagValue == "" {
-		if clusterExists, err := node.CheckClusterIsLocal(app, clusterName); err != nil {
-			return false, err
-		} else if clusterExists {
+		if localnet.LocalClusterExists(app, clusterName) {
 			ux.Logger.PrintToUser("")
 			ux.Logger.PrintToUser(
 				logging.Red.Wrap("A local machine L1 deploy already exists for %s L1 and network %s"),
@@ -173,7 +170,8 @@ func StartLocalMachine(
 			if !yes {
 				return true, nil
 			}
-			_ = node.DestroyLocalNode(app, clusterName)
+			_ = localnet.LocalClusterRemove(app, clusterName)
+			ux.Logger.GreenCheckmarkToUser("Local node %s cleaned up.", clusterName)
 		}
 		requiredBalance := deployBalance * uint64(numLocalNodes)
 		if availableBalance < requiredBalance {
@@ -184,9 +182,6 @@ func StartLocalMachine(
 				availableBalance,
 			)
 		}
-		// stop local avalanchego process so that we can generate new local cluster
-		_ = node.StopLocalNode(app)
-		anrSettings := node.ANRSettings{}
 		avagoVersionSettings := node.AvalancheGoVersionSettings{}
 		// setup (install if needed) avalanchego binary
 		avagoVersion := userProvidedAvagoVersion
@@ -224,22 +219,35 @@ func StartLocalMachine(
 		if network.Kind == models.Mainnet {
 			globalNetworkFlags.UseMainnet = true
 		}
+		nodeSettingsLen := max(len(httpPorts), len(stakingPorts))
+		nodeSettings := make([]localnet.NodeSetting, nodeSettingsLen)
+		for i := range nodeSettingsLen {
+			nodeSetting := localnet.NodeSetting{}
+			if i < len(httpPorts) {
+				nodeSetting.HTTPPort = uint64(httpPorts[i])
+			}
+			if i < len(stakingPorts) {
+				nodeSetting.StakingPort = uint64(stakingPorts[i])
+			}
+			nodeSettings[i] = nodeSetting
+		}
 		// anrSettings, avagoVersionSettings, globalNetworkFlags are empty
 		if err = node.StartLocalNode(
 			app,
 			clusterName,
 			avagoBinaryPath,
 			uint32(numLocalNodes),
 			nodeConfig,
-			anrSettings,
+			localnet.ConnectionSettings{},
+			nodeSettings,
 			avagoVersionSettings,
 			network,
 		); err != nil {
 			return false, err
 		}
 		clusterNameFlagValue = clusterName
 		if len(bootstrapEndpoints) == 0 {
-			bootstrapEndpoints, err = getLocalBootstrapEndpoints()
+			bootstrapEndpoints, err = localnet.GetLocalClusterURIs(app, clusterName)
 			if err != nil {
 				return false, fmt.Errorf("error getting local host bootstrap endpoints: %w, "+
 					"please create your local node again and call blockchain deploy command again", err)
@@ -271,11 +279,11 @@ func InitializeValidatorManager(
 	clusterName := clusterNameFlagValue
 	switch {
 	case useLocalMachine:
-		if err := node.TrackSubnetWithLocalMachine(
+		if err := localnet.LocalClusterTrackSubnet(
 			app,
+			ux.Logger.PrintToUser,
 			clusterName,
 			blockchainName,
-			avagoBinaryPath,
 		); err != nil {
 			return false, err
 		}
@@ -648,7 +656,15 @@ func convertBlockchain(_ *cobra.Command, args []string) error {
 			}
 		}
 		if !generateNodeID {
-			if cancel, err := StartLocalMachine(network, sidecar, blockchainName, deployBalance, availableBalance); err != nil {
+			if cancel, err := StartLocalMachine(
+				network,
+				sidecar,
+				blockchainName,
+				deployBalance,
+				availableBalance,
+				httpPorts,
+				stakingPorts,
+			); err != nil {
 				return err
 			} else if cancel {
 				return nil

cmd/blockchaincmd/create.go

@@ -332,6 +332,7 @@ func createBlockchainConfig(cmd *cobra.Command, args []string) error {
 			deployICM = params.UseICM
 			useExternalGasToken = params.UseExternalGasToken
 			genesisBytes, err = vm.CreateEVMGenesis(
+				app,
 				params,
 				icmInfo,
 				createFlags.addICMRegistryToGenesis,