node local PoC

cmd/backendcmd/spawn_server.go

@@ -13,23 +13,35 @@ import (
 	"github.com/spf13/cobra"
 )
 
-var app *application.Avalanche
+var (
+	app          *application.Avalanche
+	serverPort   string
+	gatewayPort  string
+	snapshotsDir string
+)
 
 // backendCmd is the command to run the backend gRPC process
 func NewCmd(injectedApp *application.Avalanche) *cobra.Command {
 	app = injectedApp
-	return &cobra.Command{
+	cmd := &cobra.Command{
 		Use:    constants.BackendCmd,
 		Short:  "Run the backend server",
 		Long:   "This tool requires a backend process to run; this command starts it",
 		RunE:   startBackend,
 		Args:   cobrautils.ExactArgs(0),
 		Hidden: true,
 	}
+	cmd.Flags().StringVar(&serverPort, "server-port", binutils.LocalNetworkGRPCServerPort, "server port to use")
+	cmd.Flags().StringVar(&gatewayPort, "gateway-port", binutils.LocalNetworkGRPCGatewayPort, "gateway port to use")
+	cmd.Flags().StringVar(&snapshotsDir, "snapshots-dir", "", "snapshots dir to use")
+	return cmd
 }
 
 func startBackend(_ *cobra.Command, _ []string) error {
-	s, err := binutils.NewGRPCServer(app.GetSnapshotsDir())
+	if snapshotsDir == "" {
+		snapshotsDir = app.GetSnapshotsDir()
+	}
+	s, err := binutils.NewGRPCServer(serverPort, gatewayPort, snapshotsDir)
 	if err != nil {
 		return err
 	}

cmd/blockchaincmd/add_validator.go

@@ -145,7 +145,7 @@
 func CallAddValidator(
 	deployer *subnet.PublicDeployer,
 	network models.Network,
 	kc *keychain.Keychain,
 	useLedgerSetting bool,
 	blockchainName string,
 	nodeIDStrFormat string,
@@ -192,7 +192,7 @@
 	}
 
 	// TODO: implement getting validator manager controller address
 	//kcKeys, err := kc.PChainFormattedStrAddresses()
 	//if err != nil {
 	//	return err
 	//}
@@ -218,7 +218,7 @@
 	}
 
 	if changeAddr == "" {
-		changeAddr, err = getKeyForChangeOwner("", network)
+		changeAddr, err = getKeyForChangeOwner(nodeIDStrFormat, "", network)
 		if err != nil {
 			return err
 		}
@@ -261,7 +261,7 @@
 	return nil
 }
 
 func generateWarpMessageAddValidator(subnetID ids.ID, nodeID ids.NodeID, weight uint64, blsPublicKey string, expiry uint64) (warpPlatformVM.Message, error) {
 	return warpPlatformVM.Message{}, nil
 }
 

cmd/blockchaincmd/create.go

@@ -113,7 +113,7 @@ configuration, pass the -f flag.`,
 	cmd.Flags().BoolVar(&createFlags.proofOfStake, "proof-of-stake", false, "(coming soon) use proof of stake for validator management")
 	cmd.Flags().StringVar(&createFlags.poaValidatorManagerOwner, "poa-manager-owner", "", "EVM address that controls Validator Manager Owner (for Proof of Authority only)")
 	cmd.Flags().BoolVar(&sovereign, "sovereign", true, "set to false if creating non-sovereign blockchain")
-	cmd.Flags().BoolVar(&createFlags.enableDebugging, "debug", false, "enable blockchain debugging")
+	cmd.Flags().BoolVar(&createFlags.enableDebugging, "debug", true, "enable blockchain debugging")
 	return cmd
 }
 

cmd/blockchaincmd/deploy.go

@@ -3,6 +3,7 @@
 package blockchaincmd
 
 import (
+	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -10,7 +11,8 @@
 	"path/filepath"
 	"strings"
 	"time"
 
+	"github.com/ava-labs/avalanchego/api/info"
 	"github.com/ava-labs/avalanche-cli/pkg/node"
 
 	"github.com/ava-labs/avalanchego/vms/platformvm/warp/message"
@@ -74,6 +76,7 @@
 	generateNodeID                  bool
 	bootstrapValidatorsJSONFilePath string
 	privateKeyFlags                 contract.PrivateKeyFlags
+	bootstrapEndpoints              []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")
@@ -128,6 +131,7 @@
 	cmd.Flags().StringVar(&icmSpec.RegistryBydecodePath, "teleporter-registry-bytecode-path", "", "path to an interchain messenger registry bytecode file")
 	cmd.Flags().StringVar(&bootstrapValidatorsJSONFilePath, "bootstrap-filepath", "", "JSON file path that provides details about bootstrap validators, leave Node-ID and BLS values empty if using --generate-node-id=true")
 	cmd.Flags().BoolVar(&generateNodeID, "generate-node-id", false, "whether to create new node id for bootstrap validators (Node-ID and BLS values in bootstrap JSON file will be overridden if --bootstrap-filepath flag is used)")
+	cmd.Flags().StringSliceVar(&bootstrapEndpoints, "bootstrap-endpoints", nil, "take validator node info from the given endpoints")
 	return cmd
 }
 
@@ -394,13 +398,6 @@
 		}
 	}
 
-	if sidecar.Sovereign && bootstrapValidatorsJSONFilePath == "" {
-		bootstrapValidators, err = promptBootstrapValidators(network)
-		if err != nil {
-			return err
-		}
-	}
-
 	ux.Logger.PrintToUser("Deploying %s to %s", chains, network.Name())
 
 	if network.Kind == models.Local {
@@ -433,10 +430,20 @@
 		}
 
 		deployer := subnet.NewLocalDeployer(app, userProvidedAvagoVersion, avagoBinaryPath, vmBin)
-		deployInfo, err := deployer.DeployToLocalNetwork(chain, genesisPath, icmSpec, subnetIDStr)
+		deployInfo, err := deployer.DeployToLocalNetwork(
+			chain,
+			genesisPath,
+			icmSpec,
+			subnetIDStr,
+			constants.ServerRunFileLocalNetworkPrefix,
+		)
 		if err != nil {
 			if deployer.BackendStartedHere() {
-				if innerErr := binutils.KillgRPCServerProcess(app); innerErr != nil {
+				if innerErr := binutils.KillgRPCServerProcess(
+					app,
+					binutils.LocalNetworkGRPCServerEndpoint,
+					constants.ServerRunFileLocalNetworkPrefix,
+				); innerErr != nil {
 					app.Log.Warn("tried to kill the gRPC server process but it failed", zap.Error(innerErr))
 				}
 			}
@@ -452,13 +459,47 @@
 			deployInfo.BlockchainID,
 			deployInfo.ICMMessengerAddress,
 			deployInfo.ICMRegistryAddress,
-			bootstrapValidators,
+			nil,
 		); err != nil {
 			return err
 		}
 		return PrintSubnetInfo(blockchainName, true)
 	}
 
+	if len(bootstrapEndpoints) > 0 {
+		var changeAddr string
+		for _, endpoint := range bootstrapEndpoints {
+			infoClient := info.NewClient(endpoint)
+			ctx, cancel := utils.GetAPILargeContext()
+			defer cancel()
+			nodeID, proofOfPossession, err := infoClient.GetNodeID(ctx)
+			if err != nil {
+				return err
+			}
+			publicKey = "0x" + hex.EncodeToString(proofOfPossession.PublicKey[:])
+			pop = "0x" + hex.EncodeToString(proofOfPossession.ProofOfPossession[:])
+			changeAddr, err = getKeyForChangeOwner(nodeID.String(), changeAddr, network)
+			if err != nil {
+				return err
+			}
+			bootstrapValidators = append(bootstrapValidators, models.SubnetValidator{
+				NodeID:               nodeID.String(),
+				Weight:               constants.BootstrapValidatorWeight,
+				Balance:              constants.BootstrapValidatorBalance,
+				BLSPublicKey:         publicKey,
+				BLSProofOfPossession: pop,
+				ChangeOwnerAddr:      changeAddr,
+			})
+		}
+	}
+
+	if sidecar.Sovereign && len(bootstrapValidators) == 0 {
+		bootstrapValidators, err = promptBootstrapValidators(network)
+		if err != nil {
+			return err
+		}
+	}
+
 	// from here on we are assuming a public deploy
 	if subnetOnly && subnetIDStr != "" {
 		return errMutuallyExlusiveSubnetFlags
@@ -721,6 +762,10 @@
 			if err != nil {
 				return err
 			}
+			aggregatorExtraPeerEndpoints, err := GetAggregatorExtraPeerEndpoints(network)
+			if err != nil {
+				return err
+			}
 			if err := validatormanager.SetupPoA(
 				app,
 				network,
@@ -731,6 +776,7 @@
 				genesisPrivateKey,
 				common.HexToAddress(sidecar.PoAValidatorManagerOwner),
 				avaGoBootstrapValidators,
+				aggregatorExtraPeerEndpoints,
 			); err != nil {
 				return err
 			}
@@ -1003,3 +1049,34 @@
 	}
 	return subnetValidators, nil
 }
+
+func GetAggregatorExtraPeerEndpoints(network models.Network) ([]string, error) {
+	aggregatorExtraPeerEndpoints := []string{}
+	if network.ClusterName != "" {
+		clustersConfig, err := app.LoadClustersConfig()
+		if err != nil {
+			return nil, err
+		}
+		clusterConfig := clustersConfig.Clusters[network.ClusterName]
+		if clusterConfig.Local {
+			cli, err := binutils.NewGRPCClientWithEndpoint(
+				binutils.LocalClusterGRPCServerEndpoint,
+				binutils.WithAvoidRPCVersionCheck(true),
+				binutils.WithDialTimeout(constants.FastGRPCDialTimeout),
+			)
+			if err != nil {
+				return nil, err
+			}
+			ctx, cancel := utils.GetANRContext()
+			defer cancel()
+			status, err := cli.Status(ctx)
+			if err != nil {
+				return nil, err
+			}
+			for _, nodeInfo := range status.ClusterInfo.NodeInfos {
+				aggregatorExtraPeerEndpoints = append(aggregatorExtraPeerEndpoints, nodeInfo.Uri)
+			}
+		}
+	}
+	return aggregatorExtraPeerEndpoints, nil
+}

cmd/blockchaincmd/describe.go

@@ -119,7 +119,9 @@ func PrintSubnetInfo(blockchainName string, onlyLocalnetInfo bool) error {
 	for net, data := range sc.Networks {
 		network, err := networkoptions.GetNetworkFromSidecarNetworkName(app, net)
 		if err != nil {
-			return err
+			ux.Logger.RedXToUser("%s is supposed to be deployed to network %s: %s ", blockchainName, network.Name(), err)
+			ux.Logger.PrintToUser("")
+			continue
 		}
 		if network.Kind == models.Local && !locallyDeployed {
 			continue
@@ -191,7 +193,7 @@ func PrintSubnetInfo(blockchainName string, onlyLocalnetInfo bool) error {
 	for net, data := range sc.Networks {
 		network, err := networkoptions.GetNetworkFromSidecarNetworkName(app, net)
 		if err != nil {
-			return err
+			continue
 		}
 		if network.Kind == models.Local && !locallyDeployed {
 			continue

cmd/blockchaincmd/prompt_genesis_input.go

@@ -161,7 +161,7 @@ func promptBootstrapValidators(network models.Network) ([]models.SubnetValidator
 				return nil, err
 			}
 		}
-		changeAddr, err := getKeyForChangeOwner(previousAddr, network)
+		changeAddr, err := getKeyForChangeOwner(nodeIDStr, previousAddr, network)
 		if err != nil {
 			return nil, err
 		}

cmd/blockchaincmd/prompt_owners.go

@@ -290,8 +290,11 @@ func getThreshold(maxLen int) (uint32, error) {
 	return uint32(intTh), err
 }
 
-func getKeyForChangeOwner(previouslyUsedAddr string, network models.Network) (string, error) {
-	changeAddrPrompt := "Which key would you like to set as change owner for leftover AVAX if the node is removed from validator set?"
+func getKeyForChangeOwner(nodeID string, previouslyUsedAddr string, network models.Network) (string, error) {
+	changeAddrPrompt := fmt.Sprintf(
+		"Which key would you like to set as change owner for leftover AVAX if the node %s is removed from validator set?",
+		nodeID,
+	)
 
 	const (
 		getFromStored = "Get address from an existing stored key (created from avalanche key create or avalanche key import)"

cmd/contractcmd/init_poa_validator_manager.go

@@ -31,7 +31,8 @@ var (
 		networkoptions.Devnet,
 		networkoptions.Fuji,
 	}
-	initPOAManagerFlags InitPOAManagerFlags
+	initPOAManagerFlags        InitPOAManagerFlags
+	privateAggregatorEndpoints []string
 )
 
 // avalanche contract initpoamanager
@@ -46,6 +47,7 @@ func newInitPOAManagerCmd() *cobra.Command {
 	networkoptions.AddNetworkFlagsToCmd(cmd, &initPOAManagerFlags.Network, true, initPOAManagerSupportedNetworkOptions)
 	initPOAManagerFlags.PrivateKeyFlags.AddToCmd(cmd, "as contract deployer")
 	cmd.Flags().StringVar(&initPOAManagerFlags.rpcEndpoint, "rpc", "", "deploy the contract into the given rpc endpoint")
+	cmd.Flags().StringSliceVar(&privateAggregatorEndpoints, "private-aggregator-endpoints", nil, "endpoints for private nodes that are not available as network peers but are needed in signature aggregation")
 	return cmd
 }
 
@@ -116,6 +118,12 @@ func initPOAManager(_ *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
+	if len(privateAggregatorEndpoints) == 0 {
+		privateAggregatorEndpoints, err = blockchaincmd.GetAggregatorExtraPeerEndpoints(network)
+		if err != nil {
+			return err
+		}
+	}
 	if err := validatormanager.SetupPoA(
 		app,
 		network,
@@ -124,6 +132,7 @@ func initPOAManager(_ *cobra.Command, args []string) error {
 		privateKey,
 		common.HexToAddress(sc.PoAValidatorManagerOwner),
 		avaGoBootstrapValidators,
+		privateAggregatorEndpoints,
 	); err != nil {
 		return err
 	}

cmd/networkcmd/clean.go

@@ -51,7 +51,11 @@ func clean(*cobra.Command, []string) error {
 		app.Log.Warn("failed resetting default snapshot", zap.Error(err))
 	}
 
-	if err := binutils.KillgRPCServerProcess(app); err != nil {
+	if err := binutils.KillgRPCServerProcess(
+		app,
+		binutils.LocalNetworkGRPCServerEndpoint,
+		constants.ServerRunFileLocalNetworkPrefix,
+	); err != nil {
 		app.Log.Warn("failed killing server process", zap.Error(err))
 	} else {
 		ux.Logger.PrintToUser("Process terminated.")

cmd/networkcmd/start.go

@@ -3,7 +3,6 @@
 package networkcmd
 
 import (
-	"context"
 	"fmt"
 	"path/filepath"
 
@@ -18,7 +17,6 @@ import (
 	"github.com/ava-labs/avalanche-cli/pkg/ux"
 	"github.com/ava-labs/avalanche-cli/pkg/vm"
 	"github.com/ava-labs/avalanche-network-runner/client"
-	"github.com/ava-labs/avalanche-network-runner/server"
 	anrutils "github.com/ava-labs/avalanche-network-runner/utils"
 	"github.com/spf13/cobra"
 )
@@ -68,7 +66,13 @@ func StartNetwork(*cobra.Command, []string) error {
 	}
 	sd := subnet.NewLocalDeployer(app, avagoVersion, avagoBinaryPath, "")
 
-	if err := sd.StartServer(); err != nil {
+	if err := sd.StartServer(
+		constants.ServerRunFileLocalNetworkPrefix,
+		binutils.LocalNetworkGRPCServerPort,
+		binutils.LocalNetworkGRPCGatewayPort,
+		app.GetSnapshotsDir(),
+		"",
+	); err != nil {
 		return err
 	}
 
@@ -85,7 +89,7 @@ func StartNetwork(*cobra.Command, []string) error {
 	ctx, cancel := utils.GetANRContext()
 	defer cancel()
 
-	bootstrapped, err := checkNetworkIsAlreadyBootstrapped(ctx, cli)
+	bootstrapped, err := localnet.CheckNetworkIsAlreadyBootstrapped(ctx, cli)
 	if err != nil {
 		return err
 	}
@@ -242,14 +246,3 @@ func determineAvagoVersion(userProvidedAvagoVersion string) (string, error) {
 		constants.AvalancheGoCompatibilityURL,
 	)
 }
-
-func checkNetworkIsAlreadyBootstrapped(ctx context.Context, cli client.Client) (bool, error) {
-	_, err := cli.Status(ctx)
-	if err != nil {
-		if server.IsServerError(err, server.ErrNotBootstrapped) {
-			return false, nil
-		}
-		return false, fmt.Errorf("failed trying to get network status: %w", err)
-	}
-	return true, nil
-}

cmd/networkcmd/stop.go

@@ -51,7 +51,11 @@ func StopNetwork(*cobra.Command, []string) error {
 	}
 
 	var err error
-	if err = binutils.KillgRPCServerProcess(app); err != nil {
+	if err = binutils.KillgRPCServerProcess(
+		app,
+		binutils.LocalNetworkGRPCServerEndpoint,
+		constants.ServerRunFileLocalNetworkPrefix,
+	); err != nil {
 		app.Log.Warn("failed killing server process", zap.Error(err))
 		fmt.Println(err)
 	} else {