fix: genesis import/export for govshuttle module

proto/canto/govshuttle/v1/genesis.proto

@@ -10,5 +10,6 @@ option go_package = "github.com/Canto-Network/Canto/v7/x/govshuttle/types";
 // GenesisState defines the govshuttle module's genesis state.
 message GenesisState {
   Params params = 1 [ (gogoproto.nullable) = false ];
+  bytes port_address = 2;
   // this line is used by starport scaffolding # genesis/proto/state
 }

x/govshuttle/genesis.go

@@ -5,23 +5,32 @@ import (
 	"github.com/Canto-Network/Canto/v7/x/govshuttle/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
+	"github.com/ethereum/go-ethereum/common"
 )
 
 // InitGenesis initializes the capability module's state from a provided genesis
 // state.
 func InitGenesis(ctx sdk.Context, k keeper.Keeper, accountKeeper authkeeper.AccountKeeper, genState types.GenesisState) {
 	// this line is used by starport scaffolding # genesis/module/init
 	k.SetParams(ctx, genState.Params)
-
+	if genState.PortAddress != nil {
+		k.SetPort(ctx, common.BytesToAddress(genState.PortAddress))
+	}
 	if acc := accountKeeper.GetModuleAccount(ctx, types.ModuleName); acc == nil {
 		panic("the govshuttle module account has not been set")
 	}
+
 }
 
 // ExportGenesis returns the capability module's exported genesis.
 func ExportGenesis(ctx sdk.Context, k keeper.Keeper) *types.GenesisState {
-	genesis := types.DefaultGenesis()
-	genesis.Params = k.GetParams(ctx)
+	portAddress, found := k.GetPort(ctx)
+	var genesis *types.GenesisState
+	if found {
+		genesis = types.NewGenesisState(k.GetParams(ctx), portAddress.Bytes())
+	} else {
+		genesis = types.NewGenesisState(k.GetParams(ctx), nil)
+	}
 
 	// this line is used by starport scaffolding # genesis/module/export
 

x/govshuttle/keeper/genesis_test.go

@@ -0,0 +1,82 @@
+package keeper_test
+
+import (
+	"time"
+
+	"github.com/evmos/ethermint/tests"
+
+	"github.com/Canto-Network/Canto/v7/x/govshuttle"
+	"github.com/Canto-Network/Canto/v7/x/govshuttle/types"
+)
+
+func (suite *KeeperTestSuite) TestDefaultGenesis() {
+	genState := types.DefaultGenesis()
+
+	govshuttle.InitGenesis(suite.ctx, suite.app.GovshuttleKeeper, suite.app.AccountKeeper, *genState)
+	got := govshuttle.ExportGenesis(suite.ctx, suite.app.GovshuttleKeeper)
+	suite.Require().Equal(genState, got)
+}
+
+func (suite *KeeperTestSuite) TestImportExportGenesisEmpty() {
+	_, found := suite.app.GovshuttleKeeper.GetPort(suite.ctx)
+	suite.Require().False(found)
+	genState := govshuttle.ExportGenesis(suite.ctx, suite.app.GovshuttleKeeper)
+	suite.Require().Nil(genState.PortAddress)
+
+	// Copy genState to genState2 and init with it
+	var genState2 types.GenesisState
+	bz := suite.app.AppCodec().MustMarshalJSON(genState)
+	suite.app.AppCodec().MustUnmarshalJSON(bz, &genState2)
+	govshuttle.InitGenesis(suite.ctx, suite.app.GovshuttleKeeper, suite.app.AccountKeeper, genState2)
+
+	_, found = suite.app.GovshuttleKeeper.GetPort(suite.ctx)
+	suite.Require().False(found)
+
+	genState3 := govshuttle.ExportGenesis(suite.ctx, suite.app.GovshuttleKeeper)
+	suite.Equal(*genState, genState2)
+	suite.Equal(genState2, *genState3)
+	suite.Require().Nil(genState.PortAddress)
+}
+
+func (suite *KeeperTestSuite) TestInitExportGenesis() {
+	portAddress := tests.GenerateAddress()
+	expGenesis := types.NewGenesisState(types.DefaultParams(), portAddress.Bytes())
+
+	govshuttle.InitGenesis(suite.ctx, suite.app.GovshuttleKeeper, suite.app.AccountKeeper, *expGenesis)
+	genState := govshuttle.ExportGenesis(suite.ctx, suite.app.GovshuttleKeeper)
+	suite.Require().Equal(expGenesis, genState)
+
+	bz := suite.app.AppCodec().MustMarshalJSON(genState)
+
+	var genState2 types.GenesisState
+	suite.app.AppCodec().MustUnmarshalJSON(bz, &genState2)
+	govshuttle.InitGenesis(suite.ctx, suite.app.GovshuttleKeeper, suite.app.AccountKeeper, genState2)
+	genState3 := govshuttle.ExportGenesis(suite.ctx, suite.app.GovshuttleKeeper)
+
+	suite.Require().Equal(*genState, genState2)
+	suite.Require().Equal(genState2, *genState3)
+}
+
+func (suite *KeeperTestSuite) TestImportExportGenesis() {
+	t, _ := time.Parse(time.RFC3339, "2022-01-01T00:00:00Z")
+	suite.ctx = suite.ctx.WithBlockHeight(1).WithBlockTime(t)
+
+	portAddress := tests.GenerateAddress()
+	suite.app.GovshuttleKeeper.SetPort(suite.ctx, portAddress)
+
+	genState := govshuttle.ExportGenesis(suite.ctx, suite.app.GovshuttleKeeper)
+	bz := suite.app.AppCodec().MustMarshalJSON(genState)
+
+	// Copy genState to genState2 and init with it
+	var genState2 types.GenesisState
+	suite.app.AppCodec().MustUnmarshalJSON(bz, &genState2)
+	govshuttle.InitGenesis(suite.ctx, suite.app.GovshuttleKeeper, suite.app.AccountKeeper, genState2)
+	exported := govshuttle.ExportGenesis(suite.ctx, suite.app.GovshuttleKeeper)
+	suite.Equal(*genState, *exported)
+
+	suite.ctx = suite.ctx.WithBlockHeight(1).WithBlockTime(t)
+
+	p, found := suite.app.GovshuttleKeeper.GetPort(suite.ctx)
+	suite.True(found)
+	suite.Equal(portAddress, p)
+}

x/govshuttle/keeper/keeper.go

@@ -7,10 +7,11 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/tendermint/tendermint/libs/log"
 
-	"github.com/Canto-Network/Canto/v7/x/govshuttle/types"
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
+
+	"github.com/Canto-Network/Canto/v7/x/govshuttle/types"
 )
 
 type (

x/govshuttle/keeper/keeper_test.go

@@ -4,8 +4,14 @@ import (
 	"encoding/json"
 	"math/big"
 	"testing"
+	"time"
 
+	"github.com/evmos/ethermint/crypto/ethsecp256k1"
 	"github.com/stretchr/testify/suite"
+	"github.com/tendermint/tendermint/crypto/tmhash"
+	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+	tmversion "github.com/tendermint/tendermint/proto/tendermint/version"
+	"github.com/tendermint/tendermint/version"
 
 	"github.com/Canto-Network/Canto/v7/app"
 	"github.com/cosmos/cosmos-sdk/crypto/keyring"
@@ -53,6 +59,42 @@ func (suite *KeeperTestSuite) DoSetupTest(t require.TestingT) {
 
 	//init app
 	suite.app = app.Setup(checkTx, feemarketGenesis)
+
+	priv, err := ethsecp256k1.GenerateKey()
+	require.NoError(t, err)
+
+	suite.address = common.BytesToAddress(priv.PubKey().Address().Bytes())
+
+	// consensus key
+	privCons, err := ethsecp256k1.GenerateKey()
+	require.NoError(t, err)
+	consAddress := sdk.ConsAddress(privCons.PubKey().Address())
+
+	// setup context
+	suite.ctx = suite.app.BaseApp.NewContext(checkTx, tmproto.Header{
+		Height:          1,
+		ChainID:         "canto_9001-1",
+		Time:            time.Now().UTC(),
+		ProposerAddress: consAddress.Bytes(),
+
+		Version: tmversion.Consensus{
+			Block: version.BlockProtocol,
+		},
+		LastBlockId: tmproto.BlockID{
+			Hash: tmhash.Sum([]byte("block_id")),
+			PartSetHeader: tmproto.PartSetHeader{
+				Total: 11,
+				Hash:  tmhash.Sum([]byte("partset_header")),
+			},
+		},
+		AppHash:            tmhash.Sum([]byte("app")),
+		DataHash:           tmhash.Sum([]byte("data")),
+		EvidenceHash:       tmhash.Sum([]byte("evidence")),
+		ValidatorsHash:     tmhash.Sum([]byte("validators")),
+		NextValidatorsHash: tmhash.Sum([]byte("next_validators")),
+		ConsensusHash:      tmhash.Sum([]byte("consensus")),
+		LastResultsHash:    tmhash.Sum([]byte("last_result")),
+	})
 }
 
 func (suite *KeeperTestSuite) SetupTest() {

x/govshuttle/types/genesis.go

@@ -1,17 +1,18 @@
 package types
 
-import (
-// this line is used by starport scaffolding # genesis/types/import
-)
-
 // DefaultIndex is the default capability global index
 const DefaultIndex uint64 = 1
 
 // DefaultGenesis returns the default Capability genesis state
 func DefaultGenesis() *GenesisState {
+	return NewGenesisState(DefaultParams(), nil)
+}
+
+func NewGenesisState(params Params, portAddress []byte) *GenesisState {
 	return &GenesisState{
-		// this line is used by starport scaffolding # genesis/types/default
-		Params: DefaultParams(),
+		Params:      params,
+		PortAddress: portAddress,
+		// this line is used by starport scaffolding # genesis/types/init
 	}
 }