x/evidence genesis protobuf migration

proto/cosmos/evidence/evidence.proto

@@ -7,13 +7,14 @@ option (gogoproto.equal_all) = true;
 import "gogoproto/gogo.proto";
 import "google/protobuf/timestamp.proto";
 import "google/protobuf/any.proto";
+import "cosmos_proto/cosmos.proto";
 
 // MsgSubmitEvidence defines an sdk.Msg type that supports submitting arbitrary
 // Evidence.
 message MsgSubmitEvidence {
   option (gogoproto.goproto_getters)  = false;
   bytes submitter = 1 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"];
-  google.protobuf.Any evidence = 2;
+  google.protobuf.Any evidence = 2 [(cosmos_proto.accepts_interface) = "Evidence"];;
 }
 
 // Equivocation implements the Evidence interface and defines evidence of double

proto/cosmos/evidence/genesis.proto

@@ -0,0 +1,11 @@
+syntax = "proto3";
+package cosmos.evidence;
+
+option go_package = "github.com/cosmos/cosmos-sdk/x/evidence/types";
+
+import "google/protobuf/any.proto";
+
+// GenesisState defines the evidence module's genesis state.
+message GenesisState {
+  repeated google.protobuf.Any evidence = 1;
+}

x/evidence/genesis.go

@@ -3,9 +3,12 @@ package evidence
 import (
 	"fmt"
 
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/evidence/exported"
 	"github.com/cosmos/cosmos-sdk/x/evidence/keeper"
 	"github.com/cosmos/cosmos-sdk/x/evidence/types"
+	"github.com/gogo/protobuf/proto"
 )
 
 // InitGenesis initializes the evidence module's state from a provided genesis
@@ -16,17 +19,34 @@ func InitGenesis(ctx sdk.Context, k keeper.Keeper, gs types.GenesisState) {
 	}
 
 	for _, e := range gs.Evidence {
-		if _, ok := k.GetEvidence(ctx, e.Hash()); ok {
-			panic(fmt.Sprintf("evidence with hash %s already exists", e.Hash()))
+		evi, ok := e.GetCachedValue().(exported.Evidence)
+		if !ok {
+			panic("expected evidence")
+		}
+		if _, ok := k.GetEvidence(ctx, evi.Hash()); ok {
+			panic(fmt.Sprintf("evidence with hash %s already exists", evi.Hash()))
 		}
 
-		k.SetEvidence(ctx, e)
+		k.SetEvidence(ctx, evi)
 	}
 }
 
 // ExportGenesis returns the evidence module's exported genesis.
 func ExportGenesis(ctx sdk.Context, k keeper.Keeper) types.GenesisState {
+	e := k.GetAllEvidence(ctx)
+	evidence := make([]*codectypes.Any, len(e))
+	for i, evi := range e {
+		msg, ok := evi.(proto.Message)
+		if !ok {
+			panic(fmt.Errorf("cannot proto marshal %T", evi))
+		}
+		any, err := codectypes.NewAnyWithValue(msg)
+		if err != nil {
+			panic(err)
+		}
+		evidence[i] = any
+	}
 	return types.GenesisState{
-		Evidence: k.GetAllEvidence(ctx),
+		Evidence: evidence,
 	}
 }

x/evidence/genesis_test.go

@@ -1,6 +1,7 @@
 package evidence_test
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/suite"
@@ -31,46 +32,125 @@ func (suite *GenesisTestSuite) SetupTest() {
 	suite.keeper = app.EvidenceKeeper
 }
 
-func (suite *GenesisTestSuite) TestInitGenesis_Valid() {
-	pk := ed25519.GenPrivKey()
-
-	testEvidence := make([]exported.Evidence, 100)
-	for i := 0; i < 100; i++ {
-		testEvidence[i] = &types.Equivocation{
-			Height:           int64(i + 1),
-			Power:            100,
-			Time:             time.Now().UTC(),
-			ConsensusAddress: pk.PubKey().Address().Bytes(),
-		}
+func (suite *GenesisTestSuite) TestInitGenesis() {
+	var (
+		genesisState types.GenesisState
+		testEvidence []exported.Evidence
+		pk           = ed25519.GenPrivKey()
+	)
+
+	testCases := []struct {
+		msg       string
+		malleate  func()
+		expPass   bool
+		posttests func()
+	}{
+		{
+			"valid",
+			func() {
+				testEvidence = make([]exported.Evidence, 100)
+				for i := 0; i < 100; i++ {
+					testEvidence[i] = &types.Equivocation{
+						Height:           int64(i + 1),
+						Power:            100,
+						Time:             time.Now().UTC(),
+						ConsensusAddress: pk.PubKey().Address().Bytes(),
+					}
+				}
+				genesisState = types.NewGenesisState(testEvidence)
+			},
+			true,
+			func() {
+				for _, e := range testEvidence {
+					_, ok := suite.keeper.GetEvidence(suite.ctx, e.Hash())
+					suite.True(ok)
+				}
+			},
+		},
+		{
+			"invalid",
+			func() {
+				testEvidence = make([]exported.Evidence, 100)
+				for i := 0; i < 100; i++ {
+					testEvidence[i] = &types.Equivocation{
+						Power:            100,
+						Time:             time.Now().UTC(),
+						ConsensusAddress: pk.PubKey().Address().Bytes(),
+					}
+				}
+				genesisState = types.NewGenesisState(testEvidence)
+			},
+			false,
+			func() {
+				suite.Empty(suite.keeper.GetAllEvidence(suite.ctx))
+			},
+		},
 	}
 
-	suite.NotPanics(func() {
-		evidence.InitGenesis(suite.ctx, suite.keeper, types.NewGenesisState(testEvidence))
-	})
+	for _, tc := range testCases {
+		suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
+			suite.SetupTest()
+
+			tc.malleate()
+
+			if tc.expPass {
+				suite.NotPanics(func() {
+					evidence.InitGenesis(suite.ctx, suite.keeper, genesisState)
+				})
+			} else {
+				suite.Panics(func() {
+					evidence.InitGenesis(suite.ctx, suite.keeper, genesisState)
+				})
+			}
 
-	for _, e := range testEvidence {
-		_, ok := suite.keeper.GetEvidence(suite.ctx, e.Hash())
-		suite.True(ok)
+			tc.posttests()
+		})
 	}
 }
 
-func (suite *GenesisTestSuite) TestInitGenesis_Invalid() {
+func (suite *GenesisTestSuite) TestExportGenesis() {
 	pk := ed25519.GenPrivKey()
 
-	testEvidence := make([]exported.Evidence, 100)
-	for i := 0; i < 100; i++ {
-		testEvidence[i] = &types.Equivocation{
-			Power:            100,
-			Time:             time.Now().UTC(),
-			ConsensusAddress: pk.PubKey().Address().Bytes(),
-		}
+	testCases := []struct {
+		msg       string
+		malleate  func()
+		expPass   bool
+		posttests func()
+	}{
+		{
+			"success",
+			func() {
+				suite.keeper.SetEvidence(suite.ctx, &types.Equivocation{
+					Height:           1,
+					Power:            100,
+					Time:             time.Now().UTC(),
+					ConsensusAddress: pk.PubKey().Address().Bytes(),
+				})
+			},
+			true,
+			func() {},
+		},
 	}
 
-	suite.Panics(func() {
-		evidence.InitGenesis(suite.ctx, suite.keeper, types.NewGenesisState(testEvidence))
-	})
+	for _, tc := range testCases {
+		suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
+			suite.SetupTest()
 
-	suite.Empty(suite.keeper.GetAllEvidence(suite.ctx))
+			tc.malleate()
+
+			if tc.expPass {
+				suite.NotPanics(func() {
+					evidence.ExportGenesis(suite.ctx, suite.keeper)
+				})
+			} else {
+				suite.Panics(func() {
+					evidence.ExportGenesis(suite.ctx, suite.keeper)
+				})
+			}
+
+			tc.posttests()
+		})
+	}
 }
 
 func TestGenesisTestSuite(t *testing.T) {

x/evidence/simulation/genesis.go

@@ -8,23 +8,23 @@ import (
 
 	"github.com/cosmos/cosmos-sdk/codec"
 
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	"github.com/cosmos/cosmos-sdk/types/module"
 	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
-	"github.com/cosmos/cosmos-sdk/x/evidence/exported"
 	"github.com/cosmos/cosmos-sdk/x/evidence/types"
 )
 
 // Simulation parameter constants
 const evidence = "evidence"
 
 // GenEvidences returns an empty slice of evidences.
-func GenEvidences(_ *rand.Rand, _ []simtypes.Account) []exported.Evidence {
-	return []exported.Evidence{}
+func GenEvidences(_ *rand.Rand, _ []simtypes.Account) []*codectypes.Any {
+	return []*codectypes.Any{}
 }
 
 // RandomizedGenState generates a random GenesisState for evidence
 func RandomizedGenState(simState *module.SimulationState) {
-	var ev []exported.Evidence
+	var ev []*codectypes.Any
 
 	simState.AppParams.GetOrGenerate(
 		simState.Cdc, evidence, &ev, simState.Rand,

x/evidence/simulation/genesis_test.go

@@ -18,9 +18,6 @@ import (
 // Abonormal scenarios are not tested here.
 func TestRandomizedGenState(t *testing.T) {
 	cdc := codec.New()
-	// Make sure to register cdc.
-	// Otherwise RandomizedGenState will panic!
-	types.RegisterCodec(cdc)
 
 	s := rand.NewSource(1)
 	r := rand.New(s)
@@ -42,25 +39,3 @@ func TestRandomizedGenState(t *testing.T) {
 
 	require.Len(t, evidenceGenesis.Evidence, 0)
 }
-
-// TestRandomizedGenState tests the execution of RandomizedGenState
-// without registering the evidence interfaces.
-// We expect the test to panic.
-func TestRandomizedGenState1(t *testing.T) {
-	cdc := codec.New()
-
-	s := rand.NewSource(1)
-	r := rand.New(s)
-
-	simState := module.SimulationState{
-		AppParams:    make(simtypes.AppParams),
-		Cdc:          cdc,
-		Rand:         r,
-		NumBonded:    3,
-		Accounts:     simtypes.RandomAccounts(r, 3),
-		InitialStake: 1000,
-		GenState:     make(map[string]json.RawMessage),
-	}
-
-	require.Panicsf(t, func() { simulation.RandomizedGenState(&simState) }, "failed to marshal JSON: Unregistered interface exported.Evidence")
-}