MX-15029: Accept multiple delegateVoting

cmd/node/config/enableEpochs.toml

@@ -64,6 +64,12 @@
     # GovernanceEnableEpoch represents the epoch when governance is enabled
     GovernanceEnableEpoch = 5
 
+    # GovernanceDisableProposeEnableEpoch represents the epoch when governance disable proposal is enabled
+    GovernanceDisableProposeEnableEpoch = 6
+
+    # GovernanceFixesEnableEpoch represents the epoch when governance fixes are enabled
+    GovernanceFixesEnableEpoch = 7
+
     # DelegationManagerEnableEpoch represents the epoch when the delegation manager is enabled
     # epoch should not be 0
     DelegationManagerEnableEpoch = 1

common/constants.go

@@ -913,6 +913,8 @@ const (
 	ESDTFlag                                           core.EnableEpochFlag = "ESDTFlag"
 	ESDTFlagInSpecificEpochOnly                        core.EnableEpochFlag = "ESDTFlagInSpecificEpochOnly"
 	GovernanceFlag                                     core.EnableEpochFlag = "GovernanceFlag"
+	GovernanceDisableProposeFlag                       core.EnableEpochFlag = "GovernanceDisableProposeFlag"
+	GovernanceFixesFlag                                core.EnableEpochFlag = "GovernanceFixesFlag"
 	GovernanceFlagInSpecificEpochOnly                  core.EnableEpochFlag = "GovernanceFlagInSpecificEpochOnly"
 	DelegationManagerFlag                              core.EnableEpochFlag = "DelegationManagerFlag"
 	DelegationSmartContractFlag                        core.EnableEpochFlag = "DelegationSmartContractFlag"

common/enablers/enableEpochsHandler.go

@@ -185,6 +185,18 @@ func (handler *enableEpochsHandler) createAllFlagsMap() {
 			},
 			activationEpoch: handler.enableEpochsConfig.GovernanceEnableEpoch,
 		},
+		common.GovernanceDisableProposeFlag: {
+			isActiveInEpoch: func(epoch uint32) bool {
+				return epoch >= handler.enableEpochsConfig.GovernanceDisableProposeEnableEpoch
+			},
+			activationEpoch: handler.enableEpochsConfig.GovernanceDisableProposeEnableEpoch,
+		},
+		common.GovernanceFixesFlag: {
+			isActiveInEpoch: func(epoch uint32) bool {
+				return epoch >= handler.enableEpochsConfig.GovernanceFixesEnableEpoch
+			},
+			activationEpoch: handler.enableEpochsConfig.GovernanceFixesEnableEpoch,
+		},
 		common.DelegationManagerFlag: {
 			isActiveInEpoch: func(epoch uint32) bool {
 				return epoch >= handler.enableEpochsConfig.DelegationManagerEnableEpoch

common/enablers/enableEpochsHandler_test.go

@@ -37,6 +37,8 @@ func createEnableEpochsConfig() config.EnableEpochs {
 		DoubleKeyProtectionEnableEpoch:                           19,
 		ESDTEnableEpoch:                                          20,
 		GovernanceEnableEpoch:                                    21,
+		GovernanceDisableProposeEnableEpoch:                      22,
+		GovernanceFixesEnableEpoch:                               23,
 		DelegationManagerEnableEpoch:                             22,
 		DelegationSmartContractEnableEpoch:                       23,
 		CorrectLastUnjailedEnableEpoch:                           24,
@@ -213,6 +215,8 @@ func TestEnableEpochsHandler_IsFlagEnabled(t *testing.T) {
 	require.False(t, handler.IsFlagEnabled(common.ESDTFlagInSpecificEpochOnly)) // ==
 	require.True(t, handler.IsFlagEnabled(common.GovernanceFlag))
 	require.False(t, handler.IsFlagEnabled(common.GovernanceFlagInSpecificEpochOnly)) // ==
+	require.True(t, handler.IsFlagEnabled(common.GovernanceDisableProposeFlag))       // ==
+	require.True(t, handler.IsFlagEnabled(common.GovernanceFixesFlag))                // ==
 	require.True(t, handler.IsFlagEnabled(common.DelegationManagerFlag))
 	require.True(t, handler.IsFlagEnabled(common.DelegationSmartContractFlag))
 	require.False(t, handler.IsFlagEnabled(common.DelegationSmartContractFlagInSpecificEpochOnly)) // ==
@@ -326,6 +330,8 @@ func TestEnableEpochsHandler_GetActivationEpoch(t *testing.T) {
 	require.Equal(t, cfg.DoubleKeyProtectionEnableEpoch, handler.GetActivationEpoch(common.DoubleKeyProtectionFlag))
 	require.Equal(t, cfg.ESDTEnableEpoch, handler.GetActivationEpoch(common.ESDTFlag))
 	require.Equal(t, cfg.GovernanceEnableEpoch, handler.GetActivationEpoch(common.GovernanceFlag))
+	require.Equal(t, cfg.GovernanceDisableProposeEnableEpoch, handler.GetActivationEpoch(common.GovernanceDisableProposeFlag))
+	require.Equal(t, cfg.GovernanceFixesEnableEpoch, handler.GetActivationEpoch(common.GovernanceFixesFlag))
 	require.Equal(t, cfg.DelegationManagerEnableEpoch, handler.GetActivationEpoch(common.DelegationManagerFlag))
 	require.Equal(t, cfg.DelegationSmartContractEnableEpoch, handler.GetActivationEpoch(common.DelegationSmartContractFlag))
 	require.Equal(t, cfg.CorrectLastUnjailedEnableEpoch, handler.GetActivationEpoch(common.CorrectLastUnJailedFlag))

config/epochConfig.go

@@ -32,6 +32,8 @@ type EnableEpochs struct {
 	DoubleKeyProtectionEnableEpoch                           uint32
 	ESDTEnableEpoch                                          uint32
 	GovernanceEnableEpoch                                    uint32
+	GovernanceDisableProposeEnableEpoch                      uint32
+	GovernanceFixesEnableEpoch                               uint32
 	DelegationManagerEnableEpoch                             uint32
 	DelegationSmartContractEnableEpoch                       uint32
 	CorrectLastUnjailedEnableEpoch                           uint32

config/tomlConfig_test.go

@@ -619,6 +619,12 @@ func TestEnableEpochConfig(t *testing.T) {
     # GovernanceEnableEpoch represents the epoch when governance is enabled
     GovernanceEnableEpoch = 21
 
+    # GovernanceDisableProposeEnableEpoch represents the epoch when governance disable proposal is enabled
+    GovernanceDisableProposeEnableEpoch = 22
+
+    # GovernanceFixesEnableEpoch represents the epoch when governance fixes are enabled
+    GovernanceFixesEnableEpoch = 23
+
     # DelegationManagerEnableEpoch represents the epoch when the delegation manager is enabled
     # epoch should not be 0
     DelegationManagerEnableEpoch = 22
@@ -883,6 +889,8 @@ func TestEnableEpochConfig(t *testing.T) {
 			DoubleKeyProtectionEnableEpoch:                           19,
 			ESDTEnableEpoch:                                          20,
 			GovernanceEnableEpoch:                                    21,
+			GovernanceDisableProposeEnableEpoch:                      22,
+			GovernanceFixesEnableEpoch:                               23,
 			DelegationManagerEnableEpoch:                             22,
 			DelegationSmartContractEnableEpoch:                       23,
 			CorrectLastUnjailedEnableEpoch:                           24,

genesis/process/shardGenesisBlockCreator.go

@@ -88,6 +88,8 @@ func createGenesisConfig() config.EnableEpochs {
 		DoubleKeyProtectionEnableEpoch:                    0,
 		ESDTEnableEpoch:                                   unreachableEpoch,
 		GovernanceEnableEpoch:                             unreachableEpoch,
+		GovernanceDisableProposeEnableEpoch:               unreachableEpoch,
+		GovernanceFixesEnableEpoch:                        unreachableEpoch,
 		DelegationManagerEnableEpoch:                      unreachableEpoch,
 		DelegationSmartContractEnableEpoch:                unreachableEpoch,
 		CorrectLastUnjailedEnableEpoch:                    unreachableEpoch,

integrationTests/testProcessorNode.go

@@ -3172,6 +3172,8 @@ func CreateEnableEpochsConfig() config.EnableEpochs {
 		DoubleKeyProtectionEnableEpoch:                    0,
 		ESDTEnableEpoch:                                   UnreachableEpoch,
 		GovernanceEnableEpoch:                             UnreachableEpoch,
+		GovernanceDisableProposeEnableEpoch:               UnreachableEpoch,
+		GovernanceFixesEnableEpoch:                        UnreachableEpoch,
 		DelegationManagerEnableEpoch:                      UnreachableEpoch,
 		DelegationSmartContractEnableEpoch:                UnreachableEpoch,
 		CorrectLastUnjailedEnableEpoch:                    UnreachableEpoch,

node/nodeRunner.go

@@ -158,6 +158,8 @@ func printEnableEpochs(configs *config.Configs) {
 	log.Debug(readEpochFor("double key protection"), "epoch", enableEpochs.DoubleKeyProtectionEnableEpoch)
 	log.Debug(readEpochFor("esdt"), "epoch", enableEpochs.ESDTEnableEpoch)
 	log.Debug(readEpochFor("governance"), "epoch", enableEpochs.GovernanceEnableEpoch)
+	log.Debug(readEpochFor("governance disable proposal"), "epoch", enableEpochs.GovernanceDisableProposeEnableEpoch)
+	log.Debug(readEpochFor("governance fixes"), "epoch", enableEpochs.GovernanceFixesEnableEpoch)
 	log.Debug(readEpochFor("delegation manager"), "epoch", enableEpochs.DelegationManagerEnableEpoch)
 	log.Debug(readEpochFor("delegation smart contract"), "epoch", enableEpochs.DelegationSmartContractEnableEpoch)
 	log.Debug(readEpochFor("correct last unjailed"), "epoch", enableEpochs.CorrectLastUnjailedEnableEpoch)

vm/systemSmartContracts/governance.go

@@ -1,4 +1,4 @@
-//go:generate protoc -I=. -I=$GOPATH/src -I=$GOPATH/src/github.com/gogo/protobuf/protobuf  --gogoslick_out=. governance.proto
+//go:generate protoc -I=. -I=$GOPATH/src -I=$GOPATH/src/github.com/gogo/protobuf/protobuf --gogoslick_out=. governance.proto
 package systemSmartContracts
 
 import (
@@ -155,8 +155,6 @@ func (g *governanceContract) Execute(args *vmcommon.ContractCallInput) vmcommon.
 		return g.viewVotingPower(args)
 	case "viewConfig":
 		return g.viewConfig(args)
-	case "viewUserVoteHistory":
-		return g.viewUserVoteHistory(args)
 	case "viewDelegatedVoteInfo":
 		return g.viewDelegatedVoteInfo(args)
 	case "viewProposal":
@@ -284,6 +282,10 @@ func (g *governanceContract) changeConfig(args *vmcommon.ContractCallInput) vmco
 
 // proposal creates a new proposal from passed arguments
 func (g *governanceContract) proposal(args *vmcommon.ContractCallInput) vmcommon.ReturnCode {
+	if g.enableEpochsHandler.IsFlagEnabled(common.GovernanceDisableProposeFlag) && !g.enableEpochsHandler.IsFlagEnabled(common.GovernanceFixesFlag) {
+		g.eei.AddReturnMessage("proposing is disabled")
+		return vmcommon.UserError
+	}
 	err := g.eei.UseGas(g.gasCost.MetaChainSystemSCsCost.Proposal)
 	if err != nil {
 		g.eei.AddReturnMessage("not enough gas")
@@ -398,7 +400,8 @@ func (g *governanceContract) vote(args *vmcommon.ContractCallInput) vmcommon.Ret
 		string(args.Arguments[1]),
 		totalVotingPower,
 		totalStake,
-		true)
+		true,
+		nil)
 	if err != nil {
 		g.eei.AddReturnMessage(err.Error())
 		return vmcommon.UserError
@@ -465,7 +468,8 @@ func (g *governanceContract) delegateVote(args *vmcommon.ContractCallInput) vmco
 		string(args.Arguments[1]),
 		votePower,
 		userStake,
-		false)
+		false,
+		args.CallerAddr)
 	if err != nil {
 		g.eei.AddReturnMessage(err.Error())
 		return vmcommon.UserError
@@ -524,9 +528,11 @@ func (g *governanceContract) addUserVote(
 	totalVotingPower *big.Int,
 	totalStake *big.Int,
 	direct bool,
+	scAddress []byte,
 ) error {
 	nonce := big.NewInt(0).SetBytes(nonceAsBytes)
-	err := g.updateUserVoteList(address, nonce.Uint64(), direct)
+	//TODO: remove extra struct & methods for V2 if no V1 proposal exists
+	err := g.updateUserVoteListV2(address, nonce.Uint64(), direct, scAddress)
 	if err != nil {
 		return err
 	}
@@ -545,25 +551,57 @@ func (g *governanceContract) addUserVote(
 	return g.saveGeneralProposal(proposal.CommitHash, proposal)
 }
 
-func (g *governanceContract) updateUserVoteList(address []byte, nonce uint64, direct bool) error {
-	userVoteList, err := g.getUserVotes(address)
+func (g *governanceContract) updateUserVoteListV1(address []byte, nonce uint64, direct bool) error {
+	userVoteList, err := g.getUserVotesV1(address)
 	if err != nil {
 		return err
 	}
 
+	err = g.updateUserVotesV1(userVoteList, nonce, direct)
+	if err != nil {
+		return err
+	}
+
+	return g.saveUserVotesV1(address, userVoteList)
+}
+
+func (g *governanceContract) updateUserVoteListV2(address []byte, nonce uint64, direct bool, scAddress []byte) error {
+	if !g.enableEpochsHandler.IsFlagEnabled(common.GovernanceFixesFlag) {
+		return g.updateUserVoteListV1(address, nonce, direct)
+	}
+	userVoteList, err := g.getUserVotesV2(address)
+	if err != nil {
+		return err
+	}
+
+	err = g.updateUserVotesV2(userVoteList, nonce, direct, scAddress)
+	if err != nil {
+		return err
+	}
+
+	return g.saveUserVotesV2(address, userVoteList)
+}
+
+func (g *governanceContract) updateUserVotesV1(userVoteList *OngoingVotedList, nonce uint64, direct bool) error {
+	var err error
 	if direct {
 		userVoteList.Direct, err = addNewNonce(userVoteList.Direct, nonce)
-		if err != nil {
-			return err
-		}
-	} else {
-		userVoteList.Delegated, err = addNewNonce(userVoteList.Delegated, nonce)
-		if err != nil {
-			return err
-		}
+		return err
+	}
+
+	userVoteList.Delegated, err = addNewNonce(userVoteList.Delegated, nonce)
+	return err
+}
+
+func (g *governanceContract) updateUserVotesV2(userVoteList *OngoingVotedListV2, nonce uint64, direct bool, scAddress []byte) error {
+	var err error
+	if direct {
+		userVoteList.Direct, err = addNewNonce(userVoteList.Direct, nonce)
+		return err
 	}
 
-	return g.saveUserVotes(address, userVoteList)
+	userVoteList.DelegatedWithAddress, err = addNewNonceV2(userVoteList.DelegatedWithAddress, scAddress, nonce)
+	return err
 }
 
 func addNewNonce(nonceList []uint64, newNonce uint64) ([]uint64, error) {
@@ -577,6 +615,20 @@ func addNewNonce(nonceList []uint64, newNonce uint64) ([]uint64, error) {
 	return nonceList, nil
 }
 
+func addNewNonceV2(nonceList []*DelegatedWithAddress, newDelegatedAddress []byte, newNonce uint64) ([]*DelegatedWithAddress, error) {
+	for _, delegatedStruct := range nonceList {
+		if newNonce == delegatedStruct.Nonce && bytes.Equal(delegatedStruct.DelegatedAddress, newDelegatedAddress) {
+			return nil, vm.ErrDoubleVote
+		}
+	}
+
+	nonceList = append(nonceList, &DelegatedWithAddress{
+		Nonce:            newNonce,
+		DelegatedAddress: newDelegatedAddress,
+	})
+	return nonceList, nil
+}
+
 func (g *governanceContract) getMinValueToVote() (*big.Int, error) {
 	delegationManagement, err := getDelegationManagement(g.eei, g.marshalizer, g.delegationMgrSCAddress)
 	if err != nil {
@@ -756,41 +808,6 @@ func (g *governanceContract) viewConfig(args *vmcommon.ContractCallInput) vmcomm
 	return vmcommon.Ok
 }
 
-func (g *governanceContract) viewUserVoteHistory(args *vmcommon.ContractCallInput) vmcommon.ReturnCode {
-	err := g.checkViewFuncArguments(args, 1)
-	if err != nil {
-		g.eei.AddReturnMessage(err.Error())
-		return vmcommon.UserError
-	}
-
-	userVotes, err := g.getUserVotes(args.Arguments[0])
-	if err != nil {
-		g.eei.AddReturnMessage(err.Error())
-		return vmcommon.UserError
-	}
-
-	g.finishWithIntValue(len(userVotes.Delegated)) // first we send the number of delegated nonces and afterward the nonces
-	for _, val := range userVotes.Delegated {
-		g.finishWithIntValue(int(val))
-	}
-
-	g.finishWithIntValue(len(userVotes.Direct)) // then we send the number of direct nonces and afterward the nonces
-	for _, val := range userVotes.Direct {
-		g.finishWithIntValue(int(val))
-	}
-
-	return vmcommon.Ok
-}
-
-func (g *governanceContract) finishWithIntValue(value int) {
-	if value == 0 {
-		g.eei.Finish([]byte{0})
-		return
-	}
-
-	g.eei.Finish(big.NewInt(int64(value)).Bytes())
-}
-
 func (g *governanceContract) viewProposal(args *vmcommon.ContractCallInput) vmcommon.ReturnCode {
 	err := g.checkViewFuncArguments(args, 1)
 	if err != nil {
@@ -1010,7 +1027,17 @@ func (g *governanceContract) getTotalStake(validatorAddress []byte) (*big.Int, e
 	return validatorData.TotalStakeValue, nil
 }
 
-func (g *governanceContract) saveUserVotes(address []byte, votedList *OngoingVotedList) error {
+func (g *governanceContract) saveUserVotesV1(address []byte, votedList *OngoingVotedList) error {
+	marshaledData, err := g.marshalizer.Marshal(votedList)
+	if err != nil {
+		return err
+	}
+	g.eei.SetStorage(address, marshaledData)
+
+	return nil
+}
+
+func (g *governanceContract) saveUserVotesV2(address []byte, votedList *OngoingVotedListV2) error {
 	marshaledData, err := g.marshalizer.Marshal(votedList)
 	if err != nil {
 		return err
@@ -1020,7 +1047,7 @@ func (g *governanceContract) saveUserVotes(address []byte, votedList *OngoingVot
 	return nil
 }
 
-func (g *governanceContract) getUserVotes(address []byte) (*OngoingVotedList, error) {
+func (g *governanceContract) getUserVotesV1(address []byte) (*OngoingVotedList, error) {
 	onGoingList := &OngoingVotedList{
 		Direct:    make([]uint64, 0),
 		Delegated: make([]uint64, 0),
@@ -1038,6 +1065,25 @@ func (g *governanceContract) getUserVotes(address []byte) (*OngoingVotedList, er
 	return onGoingList, nil
 }
 
+// getUserVotesV2 returns the ongoing voted list for a user
+// if the user has v1 ongoing list, it will be converted to v2, dropping Delegate field
+func (g *governanceContract) getUserVotesV2(address []byte) (*OngoingVotedListV2, error) {
+	onGoingListV2 := &OngoingVotedListV2{
+		Direct:               make([]uint64, 0),
+		DelegatedWithAddress: make([]*DelegatedWithAddress, 0),
+	}
+	marshaledData := g.eei.GetStorage(address)
+	if len(marshaledData) == 0 {
+		return onGoingListV2, nil
+	}
+
+	err := g.marshalizer.Unmarshal(onGoingListV2, marshaledData)
+	if err != nil {
+		return nil, err
+	}
+	return onGoingListV2, nil
+}
+
 func (g *governanceContract) getDelegatedContractInfo(scAddress []byte, reference []byte) (*DelegatedSCVoteInfo, error) {
 	scVoteInfo := &DelegatedSCVoteInfo{
 		TotalPower: big.NewInt(0),