refactor!: remove gogo-proto

codec.go

@@ -4,13 +4,15 @@ import (
 	types "github.com/cosmos/cosmos-sdk/codec/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/msgservice"
+
+	examplev1 "github.com/cosmosregistry/example/api/v1"
 )
 
 // RegisterInterfaces registers the interfaces types with the interface registry.
 func RegisterInterfaces(registry types.InterfaceRegistry) {
 	registry.RegisterImplementations((*sdk.Msg)(nil),
-		&MsgUpdateParams{},
-		&MsgIncrementCounter{},
+		&examplev1.MsgUpdateParams{},
+		&examplev1.MsgIncrementCounter{},
 	)
-	msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)
+	msgservice.RegisterMsgServiceDesc(registry, &examplev1.Msg_ServiceDesc)
 }

genesis.go

@@ -1,14 +1,16 @@
 package example
 
+import examplev1 "github.com/cosmosregistry/example/api/v1"
+
 // NewGenesisState creates a new genesis state with default values.
-func NewGenesisState() *GenesisState {
-	return &GenesisState{
+func NewGenesisState() *examplev1.GenesisState {
+	return &examplev1.GenesisState{
 		Params: DefaultParams(),
 	}
 }
 
-// Validate performs basic genesis state validation returning an error upon any
-func (gs *GenesisState) Validate() error {
+// ValidateGenesis performs basic genesis state validation returning an error upon any
+func ValidateGenesis(gs *examplev1.GenesisState) error {
 	uniq := make(map[string]bool)
 	for _, counter := range gs.Counters {
 		if _, ok := uniq[counter.Address]; ok {
@@ -18,7 +20,7 @@ func (gs *GenesisState) Validate() error {
 		uniq[counter.Address] = true
 	}
 
-	if err := gs.Params.Validate(); err != nil {
+	if err := ValidateParams(gs.Params); err != nil {
 		return err
 	}
 

keeper/genesis.go

@@ -3,12 +3,12 @@ package keeper
 import (
 	"context"
 
-	"github.com/cosmosregistry/example"
+	examplev1 "github.com/cosmosregistry/example/api/v1"
 )
 
 // InitGenesis initializes the module state from a genesis state.
-func (k *Keeper) InitGenesis(ctx context.Context, data *example.GenesisState) error {
-	if err := k.Params.Set(ctx, data.Params); err != nil {
+func (k *Keeper) InitGenesis(ctx context.Context, data *examplev1.GenesisState) error {
+	if err := k.Params.Set(ctx, *data.Params); err != nil { // TODO: not good.
 		return err
 	}
 
@@ -22,15 +22,15 @@ func (k *Keeper) InitGenesis(ctx context.Context, data *example.GenesisState) er
 }
 
 // ExportGenesis exports the module state to a genesis state.
-func (k *Keeper) ExportGenesis(ctx context.Context) (*example.GenesisState, error) {
+func (k *Keeper) ExportGenesis(ctx context.Context) (*examplev1.GenesisState, error) {
 	params, err := k.Params.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	var counters []example.Counter
+	var counters []*examplev1.Counter
 	if err := k.Counter.Walk(ctx, nil, func(address string, count uint64) (bool, error) {
-		counters = append(counters, example.Counter{
+		counters = append(counters, &examplev1.Counter{
 			Address: address,
 			Count:   count,
 		})
@@ -40,8 +40,8 @@ func (k *Keeper) ExportGenesis(ctx context.Context) (*example.GenesisState, erro
 		return nil, err
 	}
 
-	return &example.GenesisState{
-		Params:   params,
+	return &examplev1.GenesisState{
+		Params:   &params,
 		Counters: counters,
 	}, nil
 }

keeper/genesis_test.go

@@ -4,14 +4,15 @@ import (
 	"testing"
 
 	"github.com/cosmosregistry/example"
+	examplev1 "github.com/cosmosregistry/example/api/v1"
 	"github.com/stretchr/testify/require"
 )
 
 func TestInitGenesis(t *testing.T) {
 	fixture := initFixture(t)
 
-	data := &example.GenesisState{
-		Counters: []example.Counter{
+	data := &examplev1.GenesisState{
+		Counters: []*examplev1.Counter{
 			{
 				Address: fixture.addrs[0].String(),
 				Count:   5,
@@ -35,7 +36,7 @@ func TestInitGenesis(t *testing.T) {
 func TestExportGenesis(t *testing.T) {
 	fixture := initFixture(t)
 
-	_, err := fixture.msgServer.IncrementCounter(fixture.ctx, &example.MsgIncrementCounter{
+	_, err := fixture.msgServer.IncrementCounter(fixture.ctx, &examplev1.MsgIncrementCounter{
 		Sender: fixture.addrs[0].String(),
 	})
 	require.NoError(t, err)

keeper/keeper.go

@@ -9,6 +9,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/codec"
 
 	"github.com/cosmosregistry/example"
+	examplev1 "github.com/cosmosregistry/example/api/v1"
 )
 
 type Keeper struct {
@@ -21,7 +22,7 @@ type Keeper struct {
 
 	// state management
 	Schema  collections.Schema
-	Params  collections.Item[example.Params]
+	Params  collections.Item[examplev1.Params]
 	Counter collections.Map[string, uint64]
 }
 
@@ -36,7 +37,7 @@ func NewKeeper(cdc codec.BinaryCodec, addressCodec address.Codec, storeService s
 		cdc:          cdc,
 		addressCodec: addressCodec,
 		authority:    authority,
-		Params:       collections.NewItem(sb, example.ParamsKey, "params", codec.CollValue[example.Params](cdc)),
+		Params:       collections.NewItem(sb, example.ParamsKey, "params", codec.CollValue[examplev1.Params](cdc)),
 		Counter:      collections.NewMap(sb, example.CounterKey, "counter", collections.StringKey, collections.Uint64Value),
 	}
 

keeper/keeper_test.go

@@ -12,14 +12,15 @@ import (
 	moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil"
 
 	"github.com/cosmosregistry/example"
+	examplev1 "github.com/cosmosregistry/example/api/v1"
 	"github.com/cosmosregistry/example/keeper"
 )
 
 type testFixture struct {
 	ctx         sdk.Context
 	k           keeper.Keeper
-	msgServer   example.MsgServer
-	queryServer example.QueryServer
+	msgServer   examplev1.MsgServer
+	queryServer examplev1.QueryServer
 
 	addrs []sdk.AccAddress
 }

keeper/msg_server.go

@@ -8,21 +8,24 @@ import (
 
 	"cosmossdk.io/collections"
 	"github.com/cosmosregistry/example"
+	examplev1 "github.com/cosmosregistry/example/api/v1"
 )
 
 type msgServer struct {
+	examplev1.UnimplementedMsgServer
+
 	k Keeper
 }
 
-var _ example.MsgServer = msgServer{}
+var _ examplev1.MsgServer = msgServer{}
 
 // NewMsgServerImpl returns an implementation of the module MsgServer interface.
-func NewMsgServerImpl(keeper Keeper) example.MsgServer {
+func NewMsgServerImpl(keeper Keeper) examplev1.MsgServer {
 	return &msgServer{k: keeper}
 }
 
 // IncrementCounter defines the handler for the MsgIncrementCounter message.
-func (ms msgServer) IncrementCounter(ctx context.Context, msg *example.MsgIncrementCounter) (*example.MsgIncrementCounterResponse, error) {
+func (ms msgServer) IncrementCounter(ctx context.Context, msg *examplev1.MsgIncrementCounter) (*examplev1.MsgIncrementCounterResponse, error) {
 	if _, err := ms.k.addressCodec.StringToBytes(msg.Sender); err != nil {
 		return nil, fmt.Errorf("invalid sender address: %w", err)
 	}
@@ -38,11 +41,11 @@ func (ms msgServer) IncrementCounter(ctx context.Context, msg *example.MsgIncrem
 		return nil, err
 	}
 
-	return &example.MsgIncrementCounterResponse{}, nil
+	return &examplev1.MsgIncrementCounterResponse{}, nil
 }
 
 // UpdateParams params is defining the handler for the MsgUpdateParams message.
-func (ms msgServer) UpdateParams(ctx context.Context, msg *example.MsgUpdateParams) (*example.MsgUpdateParamsResponse, error) {
+func (ms msgServer) UpdateParams(ctx context.Context, msg *examplev1.MsgUpdateParams) (*examplev1.MsgUpdateParamsResponse, error) {
 	if _, err := ms.k.addressCodec.StringToBytes(msg.Authority); err != nil {
 		return nil, fmt.Errorf("invalid authority address: %w", err)
 	}
@@ -51,13 +54,13 @@ func (ms msgServer) UpdateParams(ctx context.Context, msg *example.MsgUpdatePara
 		return nil, fmt.Errorf("unauthorized, authority does not match the module's authority: got %s, want %s", msg.Authority, authority)
 	}
 
-	if err := msg.Params.Validate(); err != nil {
+	if err := example.ValidateParams(msg.Params); err != nil {
 		return nil, err
 	}
 
-	if err := ms.k.Params.Set(ctx, msg.Params); err != nil {
+	if err := ms.k.Params.Set(ctx, *msg.Params); err != nil { // TODO: not good.
 		return nil, err
 	}
 
-	return &example.MsgUpdateParamsResponse{}, nil
+	return &examplev1.MsgUpdateParamsResponse{}, nil
 }

keeper/msg_server_test.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/cosmosregistry/example"
+	examplev1 "github.com/cosmosregistry/example/api/v1"
 	"github.com/stretchr/testify/require"
 )
 
@@ -14,28 +14,28 @@ func TestUpdateParams(t *testing.T) {
 
 	testCases := []struct {
 		name         string
-		request      *example.MsgUpdateParams
+		request      *examplev1.MsgUpdateParams
 		expectErrMsg string
 	}{
 		{
 			name: "set invalid authority (not an address)",
-			request: &example.MsgUpdateParams{
+			request: &examplev1.MsgUpdateParams{
 				Authority: "foo",
 			},
 			expectErrMsg: "invalid authority address",
 		},
 		{
 			name: "set invalid authority (not defined authority)",
-			request: &example.MsgUpdateParams{
+			request: &examplev1.MsgUpdateParams{
 				Authority: f.addrs[1].String(),
 			},
 			expectErrMsg: fmt.Sprintf("unauthorized, authority does not match the module's authority: got %s, want %s", f.addrs[1].String(), f.k.GetAuthority()),
 		},
 		{
 			name: "set valid params",
-			request: &example.MsgUpdateParams{
+			request: &examplev1.MsgUpdateParams{
 				Authority: f.k.GetAuthority(),
-				Params:    example.Params{},
+				Params:    &examplev1.Params{},
 			},
 			expectErrMsg: "",
 		},
@@ -61,20 +61,20 @@ func TestIncrementCounter(t *testing.T) {
 
 	testCases := []struct {
 		name            string
-		request         *example.MsgIncrementCounter
+		request         *examplev1.MsgIncrementCounter
 		expectErrMsg    string
 		expectedCounter uint64
 	}{
 		{
 			name: "set invalid sender (not an address)",
-			request: &example.MsgIncrementCounter{
+			request: &examplev1.MsgIncrementCounter{
 				Sender: "foo",
 			},
 			expectErrMsg: "invalid sender address",
 		},
 		{
 			name: "set valid sender",
-			request: &example.MsgIncrementCounter{
+			request: &examplev1.MsgIncrementCounter{
 				Sender: "cosmos139f7kncmglres2nf3h4hc4tade85ekfr8sulz5",
 			},
 			expectErrMsg:    "",