fix: add missing validations in x/rollapp/types/genesis.go (#1657)

update genesis validations

x/rollapp/types/genesis.go

@@ -2,6 +2,7 @@ package types
 
 import (
 	"errors"
+	fmt "fmt"
 )
 
 // DefaultIndex is the default capability global index
@@ -88,6 +89,63 @@ func (gs GenesisState) Validate() error {
 	// Check for duplicated index in obsolete DRS versions
 	obsoleteDRSVersionIndexMap := make(map[uint32]struct{})
 
+	// Check for duplicated index in livenessEvents
+	livenessEventsIndexMap := make(map[string]struct{})
+	for _, elem := range gs.LivenessEvents {
+		index := elem.RollappId
+		if _, ok := livenessEventsIndexMap[index]; ok {
+			return errors.New("duplicated index for LivenessEvents")
+		}
+		livenessEventsIndexMap[index] = struct{}{}
+	}
+
+	// Check for duplicated index in registerDenoms
+	registeredDenomsIndexMap := make(map[string]struct{})
+	for _, entry := range gs.RegisteredDenoms {
+		if entry.RollappId == "" {
+			return errors.New("invalid RegisteredDenoms: RollappId cannot be empty")
+		}
+
+		if _, ok := registeredDenomsIndexMap[entry.RollappId]; ok {
+			return fmt.Errorf("duplicate RegisteredDenoms entry for RollappId: %s", entry.RollappId)
+		}
+		registeredDenomsIndexMap[entry.RollappId] = struct{}{}
+
+		if len(entry.Denoms) == 0 {
+			return fmt.Errorf("invalid RegisteredDenoms for RollappId %s: Denoms list cannot be empty", entry.RollappId)
+		}
+
+		denomSet := make(map[string]struct{})
+		for _, denom := range entry.Denoms {
+			if denom == "" {
+				return fmt.Errorf("invalid RegisteredDenoms for RollappId %s: Denom cannot be empty", entry.RollappId)
+			}
+			if _, exists := denomSet[denom]; exists {
+				return fmt.Errorf("duplicate Denom '%s' found in RollappId: %s", denom, entry.RollappId)
+			}
+			denomSet[denom] = struct{}{}
+		}
+	}
+
+	// Check for duplicated index in SequencerHeightPairs
+	sequencerHeightPairsIndexMap := make(map[string]struct{})
+
+	for _, pair := range gs.SequencerHeightPairs {
+		if pair.Sequencer == "" {
+			return errors.New("invalid SequencerHeightPair: Sequencer cannot be empty")
+		}
+
+		if pair.Height == 0 {
+			return errors.New("invalid SequencerHeightPair: Height must be greater than 0")
+		}
+
+		index := fmt.Sprintf("%s-%d", pair.Sequencer, pair.Height)
+		if _, exists := sequencerHeightPairsIndexMap[index]; exists {
+			return fmt.Errorf("duplicated SequencerHeightPair: Sequencer '%s' with Height '%d'", pair.Sequencer, pair.Height)
+		}
+		sequencerHeightPairsIndexMap[index] = struct{}{}
+	}
+
 	for _, elem := range gs.ObsoleteDrsVersions {
 		if _, ok := obsoleteDRSVersionIndexMap[elem]; ok {
 			return errors.New("duplicated index for ObsoleteDrsVersions")

x/rollapp/types/genesis_test.go

@@ -154,6 +154,112 @@ func TestGenesisState_Validate(t *testing.T) {
 			},
 			valid: false,
 		},
+		{
+			desc: "duplicated livenessEvents",
+			genState: &types.GenesisState{
+				Params:                             types.DefaultParams(),
+				RollappList:                        []types.Rollapp{},
+				StateInfoList:                      []types.StateInfo{},
+				LatestStateInfoIndexList:           []types.StateInfoIndex{},
+				BlockHeightToFinalizationQueueList: []types.BlockHeightToFinalizationQueue{},
+				ObsoleteDrsVersions:                []uint32{},
+				LivenessEvents: []types.LivenessEvent{
+					{RollappId: "rollapp1"},
+					{RollappId: "rollapp1"},
+				},
+			},
+			valid: false,
+		},
+		{
+			desc: "empty RollappId in RegisteredDenoms",
+			genState: &types.GenesisState{
+				Params: types.DefaultParams(),
+				RegisteredDenoms: []types.RollappRegisteredDenoms{
+					{RollappId: "", Denoms: []string{"denom1"}},
+				},
+			},
+			valid: false,
+		},
+		{
+			desc: "duplicate RollappId in RegisteredDenoms",
+			genState: &types.GenesisState{
+				Params: types.DefaultParams(),
+				RegisteredDenoms: []types.RollappRegisteredDenoms{
+					{RollappId: "rollapp1", Denoms: []string{"denom1"}},
+					{RollappId: "rollapp1", Denoms: []string{"denom2"}},
+				},
+			},
+			valid: false,
+		},
+		{
+			desc: "empty Denoms list in RegisteredDenoms",
+			genState: &types.GenesisState{
+				Params: types.DefaultParams(),
+				RegisteredDenoms: []types.RollappRegisteredDenoms{
+					{RollappId: "rollapp1", Denoms: []string{}},
+				},
+			},
+			valid: false,
+		},
+		{
+			desc: "empty Denom value in RegisteredDenoms",
+			genState: &types.GenesisState{
+				Params: types.DefaultParams(),
+				RegisteredDenoms: []types.RollappRegisteredDenoms{
+					{RollappId: "rollapp1", Denoms: []string{"", "denom2"}},
+				},
+			},
+			valid: false,
+		},
+		{
+			desc: "duplicate Denoms in RegisteredDenoms for the same RollappId",
+			genState: &types.GenesisState{
+				Params: types.DefaultParams(),
+				RegisteredDenoms: []types.RollappRegisteredDenoms{
+					{RollappId: "rollapp1", Denoms: []string{"denom1", "denom1"}},
+				},
+			},
+			valid: false,
+		},
+		{
+			desc: "valid RegisteredDenoms entry",
+			genState: &types.GenesisState{
+				Params: types.DefaultParams(),
+				RegisteredDenoms: []types.RollappRegisteredDenoms{
+					{RollappId: "rollapp1", Denoms: []string{"denom1", "denom2"}},
+					{RollappId: "rollapp2", Denoms: []string{"denom3"}},
+				},
+			},
+			valid: true,
+		},
+		{
+			desc: "empty Sequencer field",
+			genState: &types.GenesisState{
+				SequencerHeightPairs: []types.SequencerHeightPair{
+					{Sequencer: "", Height: 10},
+				},
+			},
+			valid: false,
+		},
+		{
+			desc: "zero Height field",
+			genState: &types.GenesisState{
+				SequencerHeightPairs: []types.SequencerHeightPair{
+					{Sequencer: "sequencer1", Height: 0},
+				},
+			},
+			valid: false,
+		},
+		{
+			desc: "duplicate Sequencer-Height pair",
+			genState: &types.GenesisState{
+				SequencerHeightPairs: []types.SequencerHeightPair{
+					{Sequencer: "sequencer1", Height: 10},
+					{Sequencer: "sequencer1", Height: 10},
+				},
+			},
+			valid: false,
+		},
 	} {
 		t.Run(tc.desc, func(t *testing.T) {
 			err := tc.genState.Validate()