acp 99

cmd/blockchaincmd/convert.go

@@ -395,7 +395,18 @@
 		ux.Logger.GreenCheckmarkToUser("Proof of Stake Validator Manager contract successfully initialized on blockchain %s", blockchainName)
 	} else {
 		ux.Logger.PrintToUser("Initializing Proof of Authority Validator Manager contract on blockchain %s ...", blockchainName)
-		if err := subnetSDK.InitializeProofOfAuthority(
+		//if err := subnetSDK.InitializeProofOfAuthority(
+		//	aggregatorCtx,
+		//	network,
+		//	genesisPrivateKey,
+		//	extraAggregatorPeers,
+		//	aggregatorAllowPrivatePeers,
+		//	aggregatorLogger,
+		//	validatorManagerAddrStr,
+		//); err != nil {
+		//	return tracked, err
+		//}
+		if err := subnetSDK.InitializeValidatorManager(
 			aggregatorCtx,
 			network,
 			genesisPrivateKey,

pkg/validatormanager/validatormanager.go

@@ -187,8 +187,16 @@
 	aggregatorLogger logging.Logger,
 	validatorManagerAddressStr string,
 ) error {
-	return subnet.InitializeProofOfAuthority(
-		ctx,
+	//return subnet.InitializeProofOfAuthority(
+	//	ctx,
+	//	network,
+	//	privateKey,
+	//	aggregatorExtraPeerEndpoints,
+	//	aggregatorAllowPrivatePeers,
+	//	aggregatorLogger,
+	//	validatorManagerAddressStr,
+	//)
+	return subnet.InitializeValidatorManager(ctx,
 		network,
 		privateKey,
 		aggregatorExtraPeerEndpoints,

sdk/blockchain/blockchain.go

@@ -424,6 +424,88 @@ func (c *Subnet) InitializeProofOfAuthority(
 	return nil
 }
 
+func (c *Subnet) InitializeValidatorManager(
+	ctx context.Context,
+	network models.Network,
+	privateKey string,
+	aggregatorExtraPeerEndpoints []info.Peer,
+	aggregatorAllowPrivatePeers bool,
+	aggregatorLogger logging.Logger,
+	validatorManagerAddressStr string,
+) error {
+	if c.SubnetID == ids.Empty {
+		return fmt.Errorf("unable to initialize Proof of Authority: %w", errMissingSubnetID)
+	}
+
+	if c.BlockchainID == ids.Empty {
+		return fmt.Errorf("unable to initialize Proof of Authority: %w", errMissingBlockchainID)
+	}
+
+	if c.RPC == "" {
+		return fmt.Errorf("unable to initialize Proof of Authority: %w", errMissingRPC)
+	}
+
+	if c.OwnerAddress == nil {
+		return fmt.Errorf("unable to initialize Proof of Authority: %w", errMissingOwnerAddress)
+	}
+
+	if len(c.BootstrapValidators) == 0 {
+		return fmt.Errorf("unable to initialize Proof of Authority: %w", errMissingBootstrapValidators)
+	}
+
+	if err := evm.SetupProposerVM(
+		c.RPC,
+		privateKey,
+	); err != nil {
+		ux.Logger.RedXToUser("failure setting proposer VM on L1: %s", err)
+	}
+	managerAddress := common.HexToAddress(validatorManagerAddressStr)
+	tx, _, err := validatormanager.InitializeValidatorManager(
+		c.RPC,
+		managerAddress,
+		privateKey,
+		c.SubnetID,
+		*c.OwnerAddress,
+	)
+	if err != nil {
+		if !errors.Is(err, validatormanager.ErrAlreadyInitialized) {
+			return evm.TransactionError(tx, err, "failure initializing poa validator manager")
+		}
+		ux.Logger.PrintToUser("Warning: the PoA contract is already initialized.")
+	}
+
+	subnetConversionSignedMessage, err := validatormanager.GetPChainSubnetConversionWarpMessage(
+		ctx,
+		network,
+		aggregatorLogger,
+		0,
+		aggregatorAllowPrivatePeers,
+		aggregatorExtraPeerEndpoints,
+		c.SubnetID,
+		c.BlockchainID,
+		managerAddress,
+		c.BootstrapValidators,
+	)
+	if err != nil {
+		return fmt.Errorf("failure signing subnet conversion warp message: %w", err)
+	}
+
+	tx, _, err = validatormanager.InitializeValidatorsSet(
+		c.RPC,
+		managerAddress,
+		privateKey,
+		c.SubnetID,
+		c.BlockchainID,
+		c.BootstrapValidators,
+		subnetConversionSignedMessage,
+	)
+	if err != nil {
+		return evm.TransactionError(tx, err, "failure initializing validators set on poa manager")
+	}
+
+	return nil
+}
+
 func (c *Subnet) InitializeProofOfStake(
 	ctx context.Context,
 	network models.Network,

sdk/validatormanager/root.go

@@ -29,6 +29,13 @@ type ValidatorManagerSettings struct {
 	MaximumChurnPercentage uint8
 }
 
+type ACP99ValidatorManagerSettings struct {
+	OwnerAddress           common.Address
+	SubnetID               [32]byte
+	ChurnPeriodSeconds     uint64
+	MaximumChurnPercentage uint8
+}
+
 type NativeTokenValidatorManagerSettings struct {
 	BaseSettings             ValidatorManagerSettings
 	MinimumStakeAmount       *big.Int
@@ -294,3 +301,32 @@ func InitializeValidatorsSet(
 		uint32(0),
 	)
 }
+
+func InitializeValidatorManager(
+	rpcURL string,
+	managerAddress common.Address,
+	privateKey string,
+	subnetID ids.ID,
+	ownerAddress common.Address,
+) (*types.Transaction, *types.Receipt, error) {
+	const (
+		defaultChurnPeriodSeconds     = uint64(0)
+		defaultMaximumChurnPercentage = uint8(20)
+	)
+	params := ACP99ValidatorManagerSettings{
+		OwnerAddress:           ownerAddress,
+		SubnetID:               subnetID,
+		ChurnPeriodSeconds:     defaultChurnPeriodSeconds,
+		MaximumChurnPercentage: defaultMaximumChurnPercentage,
+	}
+	return contract.TxToMethod(
+		rpcURL,
+		privateKey,
+		managerAddress,
+		nil,
+		"initialize validator manager",
+		ErrorSignatureToError,
+		"initialize((address,bytes32,uint64,uint8))",
+		params,
+	)
+}

tests/e2e/testcases/validatormanager/suite.go

@@ -215,7 +215,9 @@
 
 		ctx, cancel := utils.GetSignatureAggregatorContext()
 		defer cancel()
-		err = subnetSDK.InitializeProofOfAuthority(ctx, network, k.PrivKeyHex(), extraAggregatorPeers, true, logging.NoLog{}, ProxyContractAddress)
+		//err = subnetSDK.InitializeProofOfAuthority(ctx, network, k.PrivKeyHex(), extraAggregatorPeers, true, logging.NoLog{}, ProxyContractAddress)
+		//gomega.Expect(err).Should(gomega.BeNil())
+		err = subnetSDK.InitializeValidatorManager(ctx, network, k.PrivKeyHex(), extraAggregatorPeers, true, logging.NoLog{}, ProxyContractAddress)
 		gomega.Expect(err).Should(gomega.BeNil())
 	})
 })