Genesis poa

cmd/blockchaincmd/create.go

@@ -45,8 +45,10 @@ type CreateFlags struct {
 	useLatestReleasedVMVersion    bool
 	useLatestPreReleasedVMVersion bool
 	useExternalGasToken           bool
+	addICMRegistryToGenesis       bool
 	proofOfStake                  bool
 	proofOfAuthority              bool
+	poaValidatorManagerOwner      string
 }
 
 var (
@@ -103,8 +105,10 @@ configuration, pass the -f flag.`,
 	cmd.Flags().BoolVar(&createFlags.useWarp, "warp", true, "generate a vm with warp support (needed for teleporter)")
 	cmd.Flags().BoolVar(&createFlags.useTeleporter, "teleporter", false, "interoperate with other blockchains using teleporter")
 	cmd.Flags().BoolVar(&createFlags.useExternalGasToken, "external-gas-token", false, "use a gas token from another blockchain")
+	cmd.Flags().BoolVar(&createFlags.addICMRegistryToGenesis, "icm-registry-at-genesis", false, "setup ICM registry smart contract on genesis [experimental]")
 	cmd.Flags().BoolVar(&createFlags.proofOfAuthority, "proof-of-authority", false, "use proof of authority for validator management")
 	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)")
 	return cmd
 }
 
@@ -202,7 +206,6 @@ func createBlockchainConfig(cmd *cobra.Command, args []string) error {
 
 	var (
 		genesisBytes        []byte
-		sc                  *models.Sidecar
 		useTeleporterFlag   *bool
 		deployTeleporter    bool
 		useExternalGasToken bool
@@ -220,7 +223,28 @@ func createBlockchainConfig(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
+	sc := &models.Sidecar{}
+
+	if err = promptValidatorManagementType(app, sc); err != nil {
+		return err
+	}
+
+	if sc.ValidatorManagement != models.ProofOfAuthority && createFlags.poaValidatorManagerOwner != "" {
+		return errors.New("--poa-manager-owner flag cannot be used when blockchain validator management type is not Proof of Authority")
+	}
+
 	if vmType == models.SubnetEvm {
+		if sc.ValidatorManagement == models.ProofOfAuthority {
+			if createFlags.poaValidatorManagerOwner == "" {
+				createFlags.poaValidatorManagerOwner, err = getValidatorContractManagerAddr()
+				if err != nil {
+					return err
+				}
+			}
+			sc.PoAValidatorManagerOwner = createFlags.poaValidatorManagerOwner
+			ux.Logger.GreenCheckmarkToUser("PoA Validator Manager Contract owner %s", createFlags.poaValidatorManagerOwner)
+		}
+
 		if genesisFile == "" {
 			// Default
 			defaultsKind, err = vm.PromptDefaults(app, defaultsKind)
@@ -270,6 +294,7 @@ func createBlockchainConfig(cmd *cobra.Command, args []string) error {
 			var params vm.SubnetEVMGenesisParams
 			params, tokenSymbol, err = vm.PromptSubnetEVMGenesisParams(
 				app,
+				sc,
 				vmVersion,
 				createFlags.chainID,
 				createFlags.tokenSymbol,
@@ -288,19 +313,20 @@ func createBlockchainConfig(cmd *cobra.Command, args []string) error {
 				blockchainName,
 				params,
 				teleporterInfo,
+				createFlags.addICMRegistryToGenesis,
 			)
 			if err != nil {
 				return err
 			}
 		}
-		sc, err = vm.CreateEvmSidecar(
+		if err := vm.FillEvmSidecar(
+			sc,
 			app,
 			blockchainName,
 			vmVersion,
 			tokenSymbol,
 			true,
-		)
-		if err != nil {
+		); err != nil {
 			return err
 		}
 	} else {
@@ -319,7 +345,8 @@ func createBlockchainConfig(cmd *cobra.Command, args []string) error {
 				return err
 			}
 		}
-		sc, err = vm.CreateCustomSidecar(
+		if err := vm.FillCustomSidecar(
+			sc,
 			app,
 			blockchainName,
 			useRepo,
@@ -328,8 +355,7 @@ func createBlockchainConfig(cmd *cobra.Command, args []string) error {
 			customVMBuildScript,
 			vmFile,
 			tokenSymbol,
-		)
-		if err != nil {
+		); err != nil {
 			return err
 		}
 	}
@@ -352,9 +378,6 @@ func createBlockchainConfig(cmd *cobra.Command, args []string) error {
 			}
 		}
 	}
-	if err = promptValidatorManagementType(app, sc); err != nil {
-		return err
-	}
 
 	if err = app.WriteGenesisFile(blockchainName, genesisBytes); err != nil {
 		return err

cmd/blockchaincmd/deploy.go

@@ -105,7 +105,8 @@ so you can take your locally tested Subnet and deploy it on Fuji or Mainnet.`,
 	cmd.Flags().BoolVar(&icmSpec.SkipICMDeploy, "skip-local-teleporter", false, "skip automatic teleporter deploy on local networks [to be deprecated]")
 	cmd.Flags().BoolVar(&icmSpec.SkipICMDeploy, "skip-teleporter-deploy", false, "skip automatic teleporter deploy")
 	cmd.Flags().BoolVar(&icmSpec.SkipRelayerDeploy, "skip-relayer", false, "skip relayer deploy")
-	cmd.Flags().StringVar(&icmSpec.Version, "teleporter-version", "latest", "teleporter version to deploy")
+	cmd.Flags().StringVar(&icmSpec.ICMVersion, "teleporter-version", "latest", "teleporter version to deploy")
+	cmd.Flags().StringVar(&icmSpec.RelayerVersion, "relayer-version", "latest", "relayer version to deploy")
 	cmd.Flags().StringVar(&icmSpec.MessengerContractAddressPath, "teleporter-messenger-contract-address-path", "", "path to an interchain messenger contract address file")
 	cmd.Flags().StringVar(&icmSpec.MessengerDeployerAddressPath, "teleporter-messenger-deployer-address-path", "", "path to an interchain messenger deployer address file")
 	cmd.Flags().StringVar(&icmSpec.MessengerDeployerTxPath, "teleporter-messenger-deployer-tx-path", "", "path to an interchain messenger deployer tx file")

cmd/blockchaincmd/describe.go

@@ -17,6 +17,7 @@ import (
 	"github.com/ava-labs/avalanche-cli/pkg/models"
 	"github.com/ava-labs/avalanche-cli/pkg/networkoptions"
 	"github.com/ava-labs/avalanche-cli/pkg/subnet"
+	icmgenesis "github.com/ava-labs/avalanche-cli/pkg/teleporter/genesis"
 	"github.com/ava-labs/avalanche-cli/pkg/txutils"
 	"github.com/ava-labs/avalanche-cli/pkg/utils"
 	"github.com/ava-labs/avalanche-cli/pkg/ux"
@@ -275,8 +276,14 @@ func printAllocations(sc models.Sidecar, genesis core.Genesis) error {
 		t.Style().Options.SeparateRows = true
 		t.SetTitle("Initial Token Allocation")
 		t.AppendHeader(table.Row{"Description", "Address and Private Key", "Amount (10^18)", "Amount (wei)"})
-		for address := range genesis.Alloc {
-			amount := genesis.Alloc[address].Balance
+		for address, allocation := range genesis.Alloc {
+			if len(allocation.Code) > 0 {
+				continue
+			}
+			if address == common.HexToAddress(icmgenesis.MessengerDeployerAddress) {
+				continue
+			}
+			amount := allocation.Balance
 			formattedAmount := new(big.Int).Div(amount, big.NewInt(params.Ether))
 			description := ""
 			privKey := ""

cmd/blockchaincmd/export_test.go

@@ -12,6 +12,7 @@ import (
 	"github.com/ava-labs/avalanche-cli/internal/mocks"
 	"github.com/ava-labs/avalanche-cli/pkg/application"
 	"github.com/ava-labs/avalanche-cli/pkg/constants"
+	"github.com/ava-labs/avalanche-cli/pkg/models"
 	"github.com/ava-labs/avalanche-cli/pkg/prompts"
 	"github.com/ava-labs/avalanche-cli/pkg/ux"
 	"github.com/ava-labs/avalanche-cli/pkg/vm"
@@ -40,7 +41,9 @@ func TestExportImportSubnet(t *testing.T) {
 		"../../"+utils.SubnetEvmGenesisPath,
 	)
 	require.NoError(err)
-	sc, err := vm.CreateEvmSidecar(
+	sc := &models.Sidecar{}
+	err = vm.FillEvmSidecar(
+		sc,
 		app,
 		testSubnet,
 		vmVersion,

cmd/blockchaincmd/prompt_genesis_input.go

@@ -18,6 +18,19 @@ import (
 	"github.com/ava-labs/avalanchego/vms/platformvm/signer"
 )
 
+func getValidatorContractManagerAddr() (string, error) {
+	return prompts.PromptAddress(
+		app.Prompt,
+		"enable as controller of ValidatorManager contract",
+		app.GetKeyDir(),
+		app.GetKey,
+		"",
+		models.UndefinedNetwork,
+		prompts.EVMFormat,
+		"Enter address",
+	)
+}
+
 func promptProofOfPossession() (string, string, error) {
 	ux.Logger.PrintToUser("Next, we need the public key and proof of possession of the node's BLS")
 	ux.Logger.PrintToUser("Check https://docs.avax.network/api-reference/info-api#infogetnodeid for instructions on calling info.getNodeID API")
@@ -49,6 +62,7 @@ func promptValidatorManagementType(
 		sidecar.ValidatorManagement = models.ProofOfAuthority
 		return nil
 	}
+
 	options := []string{models.ProofOfAuthority, models.ProofOfStake, explainOption}
 	for {
 		option, err := app.Prompt.CaptureList(

cmd/blockchaincmd/upgradecmd/generate.go

@@ -598,7 +598,7 @@ func promptAdminManagerAndEnabledAddresses(
 	sc *models.Sidecar,
 	action string,
 ) ([]common.Address, []common.Address, []common.Address, bool, error) {
-	allowList, cancelled, err := vm.GenerateAllowList(app, action, sc.VMVersion)
+	allowList, cancelled, err := vm.GenerateAllowList(app, vm.AllowList{}, action, sc.VMVersion)
 	if cancelled || err != nil {
 		return nil, nil, nil, cancelled, err
 	}

cmd/nodecmd/wiz.go

@@ -395,6 +395,7 @@ func wiz(cmd *cobra.Command, args []string) error {
 			},
 			DeployMessenger:              deployTeleporterMessenger,
 			DeployRegistry:               deployTeleporterRegistry,
+			ForceRegistryDeploy:          true,
 			Version:                      teleporterVersion,
 			MessengerContractAddressPath: teleporterMessengerContractAddressPath,
 			MessengerDeployerAddressPath: teleporterMessengerDeployerAddressPath,

cmd/teleportercmd/deploy.go

@@ -25,6 +25,7 @@ type DeployFlags struct {
 	GenesisKey                   bool
 	DeployMessenger              bool
 	DeployRegistry               bool
+	ForceRegistryDeploy          bool
 	RPCURL                       string
 	Version                      string
 	MessengerContractAddressPath string
@@ -62,6 +63,7 @@ func newDeployCmd() *cobra.Command {
 	deployFlags.ChainFlags.AddToCmd(cmd, "deploy ICM", true)
 	cmd.Flags().BoolVar(&deployFlags.DeployMessenger, "deploy-messenger", true, "deploy Teleporter Messenger")
 	cmd.Flags().BoolVar(&deployFlags.DeployRegistry, "deploy-registry", true, "deploy Teleporter Registry")
+	cmd.Flags().BoolVar(&deployFlags.ForceRegistryDeploy, "force-registry-deploy", false, "deploy Teleporter Registry even if Messenger has already been deployed")
 	cmd.Flags().StringVar(&deployFlags.RPCURL, "rpc-url", "", "use the given RPC URL to connect to the subnet")
 	cmd.Flags().StringVar(&deployFlags.Version, "version", "latest", "version to deploy")
 	cmd.Flags().StringVar(&deployFlags.MessengerContractAddressPath, "messenger-contract-address-path", "", "path to a messenger contract address file")
@@ -188,6 +190,7 @@ func CallDeploy(_ []string, flags DeployFlags) error {
 		privateKey,
 		flags.DeployMessenger,
 		flags.DeployRegistry,
+		flags.ForceRegistryDeploy,
 	)
 	if err != nil {
 		return err
@@ -224,6 +227,7 @@ func CallDeploy(_ []string, flags DeployFlags) error {
 			ewoq.PrivKeyHex(),
 			flags.DeployMessenger,
 			flags.DeployRegistry,
+			false,
 		)
 		if err != nil {
 			return err

pkg/contract/allocations.go

@@ -235,3 +235,39 @@ func GetEVMSubnetGenesisNativeMinterAdmin(
 	}
 	return getGenesisNativeMinterAdmin(app, network, genesisData)
 }
+
+func ContractAddressIsInBlockchainGenesis(
+	app *application.Avalanche,
+	network models.Network,
+	chainSpec ChainSpec,
+	contractAddress common.Address,
+) (bool, error) {
+	genesisData, err := GetBlockchainGenesis(
+		app,
+		network,
+		chainSpec,
+	)
+	if err != nil {
+		return false, err
+	}
+	if !utils.ByteSliceIsSubnetEvmGenesis(genesisData) {
+		return false, fmt.Errorf("only EVM based vms support genesis contract checks")
+	}
+	return ContractAddressIsInGenesisData(genesisData, contractAddress)
+}
+
+func ContractAddressIsInGenesisData(
+	genesisData []byte,
+	contractAddress common.Address,
+) (bool, error) {
+	genesis, err := utils.ByteSliceToSubnetEvmGenesis(genesisData)
+	if err != nil {
+		return false, err
+	}
+	for address, allocation := range genesis.Alloc {
+		if address == contractAddress {
+			return len(allocation.Code) > 0, nil
+		}
+	}
+	return false, nil
+}

pkg/models/sidecar.go

@@ -43,7 +43,8 @@ type Sidecar struct {
 	// SubnetEVM based VM's only
 	SubnetEVMMainnetChainID uint
 	// TODO: remove if not needed for subnet acp 77 create flow once avalnache go releases etna
-	ValidatorManagement ValidatorManagementType
+	ValidatorManagement      ValidatorManagementType
+	PoAValidatorManagerOwner string
 }
 
 func (sc Sidecar) GetVMID() (string, error) {