Fix createValidator logic

Author: matejmode

driver/executor/executor.go

@@ -193,12 +193,19 @@ func scheduleNodeEvents(node *parser.Node, queue *eventQueue, net driver.Network
 		name := fmt.Sprintf("%s-%d", node.Name, i)
 		var instance = new(driver.Node)
 		queue.add(toSingleEvent(startTime, fmt.Sprintf("starting node %s", name), func() error {
-			newNode, err := net.CreateNode(&driver.NodeConfig{
-				Name:      name,
-				Validator: node.IsValidator(),
-			})
-			*instance = newNode
-			return err
+			if node.IsValidator() {
+				newNode, err := net.CreateValidatorNode(&driver.NodeConfig{
+					Name: name,
+				})
+				*instance = newNode
+				return err
+			} else {
+				newNode, err := net.CreateNode(&driver.NodeConfig{
+					Name: name,
+				})
+				*instance = newNode
+				return err
+			}
 		}))
 
 		if &node.Genesis != nil {

driver/network.go

@@ -34,6 +34,8 @@ type Network interface {
 	// nodes to the network as needed.
 	CreateNode(config *NodeConfig) (Node, error)
 
+	CreateValidatorNode(config *NodeConfig) (Node, error)
+
 	// RemoveNode removes node from the network
 	RemoveNode(Node) error
 
@@ -87,8 +89,7 @@ type NetworkListener interface {
 }
 
 type NodeConfig struct {
-	Name      string
-	Validator bool
+	Name string
 	// TODO: add other parameters as needed
 	//  - features to include on the node
 	//  - state DB configuration

driver/network/local/local.go

@@ -55,6 +55,7 @@ type LocalNetwork struct {
 	// validators lists the validator nodes in the network. Validators
 	// are created during network startup and run for the full duration
 	// of the network.
+	// TODO dynamically created validators are not added to this list. Can't be added without old epoch is sealed, because method randomValidatorRPC could return a non validator node.
 	validators []*node.OperaNode
 
 	// nodes provide a register for all nodes in the network, including
@@ -180,58 +181,65 @@ func (n *LocalNetwork) createNode(nodeConfig *node.OperaNodeConfig) (*node.Opera
 
 // CreateNode creates nodes in the network during run.
 func (n *LocalNetwork) CreateNode(config *driver.NodeConfig) (driver.Node, error) {
+	return n.createNode(&node.OperaNodeConfig{
+		Label:            config.Name,
+		NetworkConfig:    &n.config,
+		VmImplementation: n.config.VmImplementation,
+	})
+}
+
+// CreateValidatorNode creates validator non genesis validator node in the network during run.
+func (n *LocalNetwork) CreateValidatorNode(config *driver.NodeConfig) (driver.Node, error) {
 	newValId := 0
-	if config.Validator {
-		log.Printf("Creating validator node %s", config.Name)
-		rpcClient, err := n.DialRandomRpc()
-		if err != nil {
-			return nil, err
-		}
-		defer rpcClient.Close()
+	//
+	rpcClient, err := n.dialRandomGenesisValidatorRpc()
+	if err != nil {
+		return nil, err
+	}
+	defer rpcClient.Close()
 
-		// get a representation of the deployed contract
-		SFCContract, err := contract.NewSFC(common.HexToAddress("0xFC00FACE00000000000000000000000000000000"), rpcClient)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get SFC contract representation; %v", err)
-		}
+	// get a representation of the deployed contract
+	SFCContract, err := contract.NewSFC(common.HexToAddress("0xFC00FACE00000000000000000000000000000000"), rpcClient)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get SFC contract representation; %v", err)
+	}
 
-		var lastValId *big.Int
-		lastValId, err = SFCContract.LastValidatorID(nil)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get validator count; %v", err)
-		}
+	var lastValId *big.Int
+	lastValId, err = SFCContract.LastValidatorID(nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get validator count; %v", err)
+	}
 
-		newValId = int(lastValId.Int64()) + 1
-		fmt.Println("newValId", newValId)
+	newValId = int(lastValId.Int64()) + 1
+	log.Printf("Creating validator node %s; %d", config.Name, newValId)
 
-		privateKeyECDSA := evmcore.FakeKey(uint32(newValId))
-		validatorPubKey := validatorpk.PubKey{
-			Raw:  crypto.FromECDSAPub(&privateKeyECDSA.PublicKey),
-			Type: validatorpk.Types.Secp256k1,
-		}
+	privateKeyECDSA := evmcore.FakeKey(uint32(newValId))
+	validatorPubKey := validatorpk.PubKey{
+		Raw:  crypto.FromECDSAPub(&privateKeyECDSA.PublicKey),
+		Type: validatorpk.Types.Secp256k1,
+	}
 
-		validatorPrivateKeykHex := strings.TrimPrefix(hexutil.Encode(crypto.FromECDSA(privateKeyECDSA)), "0x")
-		validatorAccount, err := app.NewAccount(newValId, validatorPrivateKeykHex, validatorPubKey.Raw, 0xfa3)
-		if err != nil {
-			return nil, fmt.Errorf("failed to create validator account: %v", err)
-		}
+	validatorPrivateKeykHex := strings.TrimPrefix(hexutil.Encode(crypto.FromECDSA(privateKeyECDSA)), "0x")
+	validatorAccount, err := app.NewAccount(newValId, validatorPrivateKeykHex, validatorPubKey.Bytes(), 0xfa3)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create validator account: %v", err)
+	}
 
-		_, err = validatorAccount.CreateValidator(SFCContract, rpcClient)
-		if err != nil {
-			return nil, err
-		}
-		err = app.WaitUntilAccountNonceIs(crypto.PubkeyToAddress(privateKeyECDSA.PublicKey), 1, rpcClient)
-		if err != nil {
-			return nil, fmt.Errorf("createValidator; failed to wait for nonce; %v", err)
-		}
+	_, err = validatorAccount.CreateValidator(SFCContract, rpcClient)
+	if err != nil {
+		return nil, err
+	}
+	err = app.WaitUntilAccountNonceIs(crypto.PubkeyToAddress(privateKeyECDSA.PublicKey), 1, rpcClient)
+	if err != nil {
+		return nil, fmt.Errorf("createValidator; failed to wait for nonce; %v", err)
+	}
 
-		lastValId, err = SFCContract.LastValidatorID(nil)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get validator count; %v", err)
-		}
-		if newValId != int(lastValId.Int64()) {
-			return nil, fmt.Errorf("failed to create validator %d", newValId)
-		}
+	lastValId, err = SFCContract.LastValidatorID(nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get validator count; %v", err)
+	}
+	if newValId != int(lastValId.Int64()) {
+		return nil, fmt.Errorf("failed to create validator %d", newValId)
 	}
 
 	return n.createNode(&node.OperaNodeConfig{
@@ -276,7 +284,11 @@ func (n *LocalNetwork) DialRandomRpc() (rpc2.RpcClient, error) {
 	return nodes[rand.Intn(len(nodes))].DialRpc()
 }
 
-func (n *LocalNetwork) dialRandomValidatorRpc() (rpc2.RpcClient, error) {
+// dialRandomGenesisValidatorRpc dials a random genesis validator node.
+// When network starts and still doesn't have any traffic, then first transaction must come from validator node.
+// Caused by: the regular nodes even when connected won't send transactions from their txpool,
+// because they don't know whether they are on head or not if blockchain is empty.
+func (n *LocalNetwork) dialRandomGenesisValidatorRpc() (rpc2.RpcClient, error) {
 	return n.validators[rand.Intn(len(n.validators))].DialRpc()
 }
 
@@ -336,16 +348,8 @@ func (a *localApplication) GetReceivedTransactions() (uint64, error) {
 	return a.controller.GetReceivedTransactions()
 }
 
-//func (n *LocalNetwork) CreateValidator(config *driver.NodeConfig) (driver.Node, error) {
-//	return n.createNode(&node.OperaNodeConfig{
-//		Label:            config.Name,
-//		NetworkConfig:    &n.config,
-//		VmImplementation: n.config.VmImplementation,
-//	})
-//}
-
 func (n *LocalNetwork) CreateApplication(config *driver.ApplicationConfig) (driver.Application, error) {
-	rpcClient, err := n.dialRandomValidatorRpc()
+	rpcClient, err := n.dialRandomGenesisValidatorRpc()
 	if err != nil {
 		return nil, fmt.Errorf("failed to connect to RPC to initialize the application; %v", err)
 	}

driver/network_mock.go

@@ -40,9 +40,11 @@ func (s *Scenario) Check() error {
 	if s.Duration <= 0 {
 		errs = append(errs, fmt.Errorf("scenario duration must be > 0"))
 	}
-	if s.NumValidators != nil && *s.NumValidators <= 0 {
-		errs = append(errs, fmt.Errorf("invalid number of validators: %d <= 0", *s.NumValidators))
+
+	if err := s.checkValidatorConstrains(); err != nil {
+		errs = append(errs, err)
 	}
+
 	names := map[string]bool{}
 	for _, node := range s.Nodes {
 		if err := node.Check(s); err != nil {
@@ -295,3 +297,35 @@ func checkTimeInterval(start, end *float32, duration float32) error {
 	}
 	return errors.Join(errs...)
 }
+
+// checkValidatorConstrains makes sure that there is correct number of validators
+// if during whole run there are just genesis validators, then one validator is enough
+// if there is creation of new validators trough sfc, then at all times there has to be at least two validators validating at every time
+// note during run validator won't be immediately registered for epoch, because it only happens during epoch seal,
+// therefore this check is not sufficient on its own
+func (s *Scenario) checkValidatorConstrains() error {
+	// check genesis validators
+	if s.NumValidators != nil && *s.NumValidators <= 0 {
+		return fmt.Errorf("invalid number of validators: %d <= 0", *s.NumValidators)
+	}
+
+	dynamicVals := make([]Node, 0)
+	// check dynamically created validators
+	for _, node := range s.Nodes {
+		if node.IsValidator() {
+			dynamicVals = append(dynamicVals, node)
+		}
+	}
+
+	if len(dynamicVals) == 0 {
+		return nil
+	}
+
+	if *s.NumValidators < 2 {
+		return fmt.Errorf("invalid number of genesis validators for sfc createValidator scenario: %d < 2", *s.NumValidators)
+	}
+
+	// TODO add check for dynamic validators to have always at least two running at any time
+	// needs to be implemented before enabling to shut down genesis validators
+	return nil
+}

driver/parser/check.go

@@ -13,6 +13,7 @@ require (
 	github.com/tyler-smith/go-bip32 v1.0.0
 	github.com/tyler-smith/go-bip39 v1.1.0
 	github.com/urfave/cli/v2 v2.25.7
+	go.uber.org/mock v0.2.0
 	golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa
 	gopkg.in/yaml.v3 v3.0.1
 )

go.mod

@@ -475,6 +475,8 @@ go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
 go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
 go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
+go.uber.org/mock v0.2.0 h1:TaP3xedm7JaAgScZO7tlvlKrqT0p7I6OsdGB5YNSMDU=
+go.uber.org/mock v0.2.0/go.mod h1:J0y0rp9L3xiff1+ZBfKxlC1fz2+aO16tw0tsDOixfuM=
 go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
 go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
 golang.org/x/crypto v0.0.0-20170613210332-850760c427c5/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=