diff --git a/Makefile b/Makefile
index 929fa2c5..eab94f8d 100644
--- a/Makefile
+++ b/Makefile
@@ -63,7 +63,10 @@ endif
 ldflags += $(LDFLAGS)
 ldflags := $(strip $(ldflags))
 
+testing_ldflags = -X github.com/tendermint/farming/x/farming/keeper.enableAdvanceEpoch=true
+
 BUILD_FLAGS := -tags "$(build_tags)" -ldflags '$(ldflags)'
+TESTING_BUILD_FLAGS := -tags "$(build_tags)" -ldflags '$(ldflags) $(testing_ldflags)'
 
 all: tools install lint
 
@@ -87,6 +90,9 @@ build-linux: go.sum
 install: go.sum
 	go install $(BUILD_FLAGS) ./cmd/farmingd
 
+install-testing: go.sum
+	go install $(TESTING_BUILD_FLAGS) ./cmd/farmingd
+
 build-reproducible: go.sum
 	$(DOCKER) rm latest-build || true
 	$(DOCKER) run --volume=$(CURDIR):/sources:ro \
diff --git a/proto/tendermint/farming/v1beta1/farming.proto b/proto/tendermint/farming/v1beta1/farming.proto
index 81d861c0..8c893d9e 100644
--- a/proto/tendermint/farming/v1beta1/farming.proto
+++ b/proto/tendermint/farming/v1beta1/farming.proto
@@ -149,7 +149,7 @@ message QueuedStaking {
   string amount = 1 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", (gogoproto.nullable) = false];
 }
 
-message TotalStaking {
+message TotalStakings {
   option (gogoproto.goproto_getters) = false;
 
   string amount = 1 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", (gogoproto.nullable) = false];
diff --git a/proto/tendermint/farming/v1beta1/query.proto b/proto/tendermint/farming/v1beta1/query.proto
index ba749fc3..868a46e5 100644
--- a/proto/tendermint/farming/v1beta1/query.proto
+++ b/proto/tendermint/farming/v1beta1/query.proto
@@ -8,6 +8,7 @@ import "gogoproto/gogo.proto";
 import "google/protobuf/any.proto";
 import "google/api/annotations.proto";
 import "cosmos_proto/cosmos.proto";
+import "cosmos/base/v1beta1/coin.proto";
 
 option go_package = "github.com/tendermint/farming/x/farming/types";
 
@@ -27,6 +28,18 @@ service Query {
   rpc Plan(QueryPlanRequest) returns (QueryPlanResponse) {
     option (google.api.http).get = "/cosmos/farming/v1beta1/plans/{plan_id}";
   }
+
+  rpc Stakings(QueryStakingsRequest) returns (QueryStakingsResponse) {
+    option (google.api.http).get = "/cosmos/farming/v1beta1/stakings/{farmer}";
+  }
+
+  rpc TotalStakings(QueryTotalStakingsRequest) returns (QueryTotalStakingsResponse) {
+    option (google.api.http).get = "/cosmos/farming/v1beta1/total_stakings/{staking_coin_denom}";
+  }
+
+  rpc Rewards(QueryRewardsRequest) returns (QueryRewardsResponse) {
+    option (google.api.http).get = "/cosmos/farming/v1beta1/rewards/{farmer}";
+  }
 }
 
 // QueryParamsRequest is the request type for the Query/Params RPC method.
@@ -62,3 +75,33 @@ message QueryPlanRequest {
 message QueryPlanResponse {
   google.protobuf.Any plan = 1 [(cosmos_proto.accepts_interface) = "PlanI"];
 }
+
+message QueryStakingsRequest {
+  string farmer             = 1;
+  string staking_coin_denom = 2;
+}
+
+message QueryStakingsResponse {
+  repeated cosmos.base.v1beta1.Coin staked_coins = 1
+      [(gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins", (gogoproto.nullable) = false];
+  repeated cosmos.base.v1beta1.Coin queued_coins = 2
+      [(gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins", (gogoproto.nullable) = false];
+}
+
+message QueryTotalStakingsRequest {
+  string staking_coin_denom = 1;
+}
+
+message QueryTotalStakingsResponse {
+  string amount = 1 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", (gogoproto.nullable) = false];
+}
+
+message QueryRewardsRequest {
+  string farmer             = 1;
+  string staking_coin_denom = 2;
+}
+
+message QueryRewardsResponse {
+  repeated cosmos.base.v1beta1.Coin rewards = 1
+      [(gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins", (gogoproto.nullable) = false];
+}
diff --git a/proto/tendermint/farming/v1beta1/tx.proto b/proto/tendermint/farming/v1beta1/tx.proto
index 4918cb94..4e17f6f1 100644
--- a/proto/tendermint/farming/v1beta1/tx.proto
+++ b/proto/tendermint/farming/v1beta1/tx.proto
@@ -24,8 +24,12 @@ service Msg {
   // Unstake defines a method for unstaking coins from the farming plan
   rpc Unstake(MsgUnstake) returns (MsgUnstakeResponse);
 
-  // harvest defines a method for claiming farming rewards
+  // Harvest defines a method for claiming farming rewards
   rpc Harvest(MsgHarvest) returns (MsgHarvestResponse);
+
+  // AdvanceEpoch defines a method for advancing epoch by one, just for testing purpose
+  // and shouldn't be used in real world
+  rpc AdvanceEpoch(MsgAdvanceEpoch) returns (MsgAdvanceEpochResponse);
 }
 
 // MsgCreateFixedAmountPlan defines a SDK message for creating a new fixed
@@ -156,3 +160,14 @@ message MsgHarvest {
 
 // MsgHarvestResponse defines the Msg/MsgHarvestResponse response type.
 message MsgHarvestResponse {}
+
+// MsgAdvanceEpoch defines a message to advance epoch by one.
+message MsgAdvanceEpoch {
+  option (gogoproto.goproto_getters) = false;
+
+  // requester defines the bech32-encoded address of the requester
+  string requester = 1;
+}
+
+// MsgAdvanceEpochResponse defines the Msg/AdvanceEpoch response type.
+message MsgAdvanceEpochResponse {}
\ No newline at end of file
diff --git a/x/farming/client/cli/flags.go b/x/farming/client/cli/flags.go
index 209c71ef..5ce509d7 100644
--- a/x/farming/client/cli/flags.go
+++ b/x/farming/client/cli/flags.go
@@ -26,6 +26,22 @@ func flagSetPlans() *flag.FlagSet {
 	return fs
 }
 
+func flagSetStakings() *flag.FlagSet {
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+
+	fs.String(FlagStakingCoinDenom, "", "The staking coin denom")
+
+	return fs
+}
+
+func flagSetRewards() *flag.FlagSet {
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+
+	fs.String(FlagStakingCoinDenom, "", "The staking coin denom")
+
+	return fs
+}
+
 func flagSetHarvest() *flag.FlagSet {
 	fs := flag.NewFlagSet("", flag.ContinueOnError)
 
diff --git a/x/farming/client/cli/query.go b/x/farming/client/cli/query.go
index 890f96ec..4d92a224 100644
--- a/x/farming/client/cli/query.go
+++ b/x/farming/client/cli/query.go
@@ -34,6 +34,9 @@ func GetQueryCmd() *cobra.Command {
 		GetCmdQueryParams(),
 		GetCmdQueryPlans(),
 		GetCmdQueryPlan(),
+		GetCmdQueryStakings(),
+		GetCmdQueryTotalStakings(),
+		GetCmdQueryRewards(),
 	)
 
 	return farmingQueryCmd
@@ -188,3 +191,149 @@ $ %s query %s plan
 
 	return cmd
 }
+
+func GetCmdQueryStakings() *cobra.Command {
+	bech32PrefixAccAddr := sdk.GetConfig().GetBech32AccountAddrPrefix()
+
+	cmd := &cobra.Command{
+		Use:   "stakings [farmer]",
+		Args:  cobra.ExactArgs(1),
+		Short: "Query stakings by a farmer",
+		Long: strings.TrimSpace(
+			fmt.Sprintf(`Query all stakings by a farmer.
+
+Optionally restrict coins for a staking coin denom.
+
+Example:
+$ %s query %s stakings %s1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj
+$ %s query %s stakings %s1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj --staking-coin-denom poolD35A0CC16EE598F90B044CE296A405BA9C381E38837599D96F2F70C2F02A23A4
+`,
+				version.AppName, types.ModuleName, bech32PrefixAccAddr,
+				version.AppName, types.ModuleName, bech32PrefixAccAddr,
+			),
+		),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+			queryClient := types.NewQueryClient(clientCtx)
+
+			farmerAcc, err := sdk.AccAddressFromBech32(args[0])
+			if err != nil {
+				return err
+			}
+
+			stakingCoinDenom, _ := cmd.Flags().GetString(FlagStakingCoinDenom)
+
+			resp, err := queryClient.Stakings(cmd.Context(), &types.QueryStakingsRequest{
+				Farmer:           farmerAcc.String(),
+				StakingCoinDenom: stakingCoinDenom,
+			})
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(resp)
+		},
+	}
+
+	cmd.Flags().AddFlagSet(flagSetStakings())
+	flags.AddQueryFlagsToCmd(cmd)
+
+	return cmd
+}
+
+func GetCmdQueryTotalStakings() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "total-stakings [staking-coin-denom]",
+		Args:  cobra.ExactArgs(1),
+		Short: "Query total staking amount for a staking coin denom",
+		Long: strings.TrimSpace(
+			fmt.Sprintf(`Query total staking amount for a staking coin denom.
+
+Example:
+$ %s query %s total-stakings poolD35A0CC16EE598F90B044CE296A405BA9C381E38837599D96F2F70C2F02A23A4
+`,
+				version.AppName, types.ModuleName,
+			),
+		),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+			queryClient := types.NewQueryClient(clientCtx)
+
+			stakingCoinDenom := args[0]
+			if err := sdk.ValidateDenom(stakingCoinDenom); err != nil {
+				return err
+			}
+
+			resp, err := queryClient.TotalStakings(cmd.Context(), &types.QueryTotalStakingsRequest{
+				StakingCoinDenom: stakingCoinDenom,
+			})
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(resp)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+
+	return cmd
+}
+
+func GetCmdQueryRewards() *cobra.Command {
+	bech32PrefixAccAddr := sdk.GetConfig().GetBech32AccountAddrPrefix()
+
+	cmd := &cobra.Command{
+		Use:   "rewards [farmer]",
+		Args:  cobra.ExactArgs(1),
+		Short: "Query rewards for a farmer",
+		Long: strings.TrimSpace(
+			fmt.Sprintf(`Query all rewards for a farmer.
+
+Optionally restrict rewards for a staking coin denom.
+
+Example:
+$ %s query %s rewards %s1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj
+$ %s query %s rewards %s1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj --staking-coin-denom poolD35A0CC16EE598F90B044CE296A405BA9C381E38837599D96F2F70C2F02A23A4
+`,
+				version.AppName, types.ModuleName, bech32PrefixAccAddr,
+				version.AppName, types.ModuleName, bech32PrefixAccAddr,
+			),
+		),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+			queryClient := types.NewQueryClient(clientCtx)
+
+			farmerAcc, err := sdk.AccAddressFromBech32(args[0])
+			if err != nil {
+				return err
+			}
+
+			stakingCoinDenom, _ := cmd.Flags().GetString(FlagStakingCoinDenom)
+
+			resp, err := queryClient.Rewards(cmd.Context(), &types.QueryRewardsRequest{
+				Farmer:           farmerAcc.String(),
+				StakingCoinDenom: stakingCoinDenom,
+			})
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(resp)
+		},
+	}
+
+	cmd.Flags().AddFlagSet(flagSetRewards())
+	flags.AddQueryFlagsToCmd(cmd)
+
+	return cmd
+}
diff --git a/x/farming/client/cli/tx.go b/x/farming/client/cli/tx.go
index 5c2fa2fa..a101f52d 100644
--- a/x/farming/client/cli/tx.go
+++ b/x/farming/client/cli/tx.go
@@ -18,6 +18,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/gov/client/cli"
 	gov "github.com/cosmos/cosmos-sdk/x/gov/types"
 
+	"github.com/tendermint/farming/x/farming/keeper"
 	"github.com/tendermint/farming/x/farming/types"
 )
 
@@ -38,6 +39,9 @@ func GetTxCmd() *cobra.Command {
 		NewUnstakeCmd(),
 		NewHarvestCmd(),
 	)
+	if keeper.EnableAdvanceEpoch {
+		farmingTxCmd.AddCommand(NewAdvanceEpochCmd())
+	}
 
 	return farmingTxCmd
 }
@@ -302,6 +306,30 @@ $ %s tx %s harvest --staking-coin-denoms="poolD35A0CC16EE598F90B044CE296A405BA9C
 	return cmd
 }
 
+func NewAdvanceEpochCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "advance-epoch",
+		Args:  cobra.NoArgs,
+		Short: "advance epoch by one to simulate reward distribution",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			requesterAcc := clientCtx.GetFromAddress()
+
+			msg := types.NewMsgAdvanceEpoch(requesterAcc)
+
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+
+	return cmd
+}
+
 // GetCmdSubmitPublicPlanProposal implements a command handler for submitting a public farming plan transaction to create, update, and delete plan.
 func GetCmdSubmitPublicPlanProposal() *cobra.Command {
 	cmd := &cobra.Command{
diff --git a/x/farming/client/testutil/cli_helpers.go b/x/farming/client/testutil/cli_helpers.go
index 8d4db580..9a371fb8 100644
--- a/x/farming/client/testutil/cli_helpers.go
+++ b/x/farming/client/testutil/cli_helpers.go
@@ -3,6 +3,8 @@ package testutil
 import (
 	"fmt"
 
+	dbm "github.com/tendermint/tm-db"
+
 	"github.com/cosmos/cosmos-sdk/baseapp"
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/flags"
@@ -17,7 +19,6 @@ import (
 
 	farmingapp "github.com/tendermint/farming/app"
 	farmingcli "github.com/tendermint/farming/x/farming/client/cli"
-	dbm "github.com/tendermint/tm-db"
 )
 
 // NewConfig returns config that defines the necessary testing requirements
diff --git a/x/farming/keeper/grpc_query.go b/x/farming/keeper/grpc_query.go
index 2ff053d0..f8fbd880 100644
--- a/x/farming/keeper/grpc_query.go
+++ b/x/farming/keeper/grpc_query.go
@@ -33,7 +33,7 @@ func (k Querier) Params(c context.Context, _ *types.QueryParamsRequest) (*types.
 // Plans queries all plans.
 func (k Querier) Plans(c context.Context, req *types.QueryPlansRequest) (*types.QueryPlansResponse, error) {
 	if req == nil {
-		return nil, status.Error(codes.InvalidArgument, "invalid request")
+		return nil, status.Error(codes.InvalidArgument, "empty request")
 	}
 
 	if req.Type != "" && !(req.Type == types.PlanTypePublic.String() || req.Type == types.PlanTypePrivate.String()) {
@@ -129,7 +129,7 @@ func (k Querier) Plans(c context.Context, req *types.QueryPlansRequest) (*types.
 // Plan queries a specific plan.
 func (k Querier) Plan(c context.Context, req *types.QueryPlanRequest) (*types.QueryPlanResponse, error) {
 	if req == nil {
-		return nil, status.Error(codes.InvalidArgument, "invalid request")
+		return nil, status.Error(codes.InvalidArgument, "empty request")
 	}
 
 	ctx := sdk.UnwrapSDKContext(c)
@@ -145,3 +145,110 @@ func (k Querier) Plan(c context.Context, req *types.QueryPlanRequest) (*types.Qu
 
 	return &types.QueryPlanResponse{Plan: any}, nil
 }
+
+func (k Querier) Stakings(c context.Context, req *types.QueryStakingsRequest) (*types.QueryStakingsResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "empty request")
+	}
+
+	farmerAcc, err := sdk.AccAddressFromBech32(req.Farmer)
+	if err != nil {
+		return nil, err
+	}
+
+	if req.StakingCoinDenom != "" {
+		if err := sdk.ValidateDenom(req.StakingCoinDenom); err != nil {
+			return nil, err
+		}
+	}
+
+	ctx := sdk.UnwrapSDKContext(c)
+
+	resp := &types.QueryStakingsResponse{
+		StakedCoins: sdk.NewCoins(),
+		QueuedCoins: sdk.NewCoins(),
+	}
+	if req.StakingCoinDenom == "" {
+		k.IterateStakingsByFarmer(ctx, farmerAcc, func(stakingCoinDenom string, staking types.Staking) (stop bool) {
+			resp.StakedCoins = resp.StakedCoins.Add(sdk.NewCoin(stakingCoinDenom, staking.Amount))
+			return false
+		})
+		k.IterateQueuedStakingsByFarmer(ctx, farmerAcc, func(stakingCoinDenom string, queuedStaking types.QueuedStaking) (stop bool) {
+			resp.QueuedCoins = resp.QueuedCoins.Add(sdk.NewCoin(stakingCoinDenom, queuedStaking.Amount))
+			return false
+		})
+	} else {
+		staking, found := k.GetStaking(ctx, req.StakingCoinDenom, farmerAcc)
+		if found {
+			resp.StakedCoins = resp.StakedCoins.Add(sdk.NewCoin(req.StakingCoinDenom, staking.Amount))
+		}
+		queuedStaking, found := k.GetQueuedStaking(ctx, req.StakingCoinDenom, farmerAcc)
+		if found {
+			resp.QueuedCoins = resp.QueuedCoins.Add(sdk.NewCoin(req.StakingCoinDenom, queuedStaking.Amount))
+		}
+	}
+
+	return resp, nil
+}
+
+func (k Querier) TotalStakings(c context.Context, req *types.QueryTotalStakingsRequest) (*types.QueryTotalStakingsResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "empty request")
+	}
+
+	if err := sdk.ValidateDenom(req.StakingCoinDenom); err != nil {
+		return nil, err
+	}
+
+	ctx := sdk.UnwrapSDKContext(c)
+
+	totalStakings, found := k.GetTotalStakings(ctx, req.StakingCoinDenom)
+	if !found {
+		totalStakings.Amount = sdk.ZeroInt()
+	}
+
+	return &types.QueryTotalStakingsResponse{
+		Amount: totalStakings.Amount,
+	}, nil
+}
+
+func (k Querier) Rewards(c context.Context, req *types.QueryRewardsRequest) (*types.QueryRewardsResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "empty request")
+	}
+
+	farmerAcc, err := sdk.AccAddressFromBech32(req.Farmer)
+	if err != nil {
+		return nil, err
+	}
+
+	if req.StakingCoinDenom != "" {
+		if err := sdk.ValidateDenom(req.StakingCoinDenom); err != nil {
+			return nil, err
+		}
+	}
+
+	ctx := sdk.UnwrapSDKContext(c)
+
+	resp := &types.QueryRewardsResponse{
+		Rewards: sdk.NewCoins(),
+	}
+
+	var rewards sdk.Coins
+	if req.StakingCoinDenom == "" {
+		var err error
+		rewards, err = k.WithdrawAllRewards(ctx, farmerAcc)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		var err error
+		rewards, err = k.WithdrawRewards(ctx, farmerAcc, req.StakingCoinDenom)
+		if err != nil {
+			return nil, err
+		}
+	}
+	resp.Rewards = rewards
+
+	return resp, nil
+}
diff --git a/x/farming/keeper/grpc_query_test.go b/x/farming/keeper/grpc_query_test.go
index b3fe8a1e..571e6bf5 100644
--- a/x/farming/keeper/grpc_query_test.go
+++ b/x/farming/keeper/grpc_query_test.go
@@ -3,6 +3,7 @@ package keeper_test
 import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
+	"github.com/tendermint/farming/x/farming"
 	"github.com/tendermint/farming/x/farming/types"
 )
 
@@ -217,132 +218,216 @@ func (suite *KeeperTestSuite) TestGRPCPlan() {
 	}
 }
 
-//func (suite *KeeperTestSuite) TestGRPCStakings() {
-//	suite.Stake(suite.addrs[0], sdk.NewCoins(sdk.NewInt64Coin(denom1, 1000), sdk.NewInt64Coin(denom2, 1500)))
-//	suite.Stake(suite.addrs[1], sdk.NewCoins(sdk.NewInt64Coin(denom1, 500)))
-//	suite.Stake(suite.addrs[2], sdk.NewCoins(sdk.NewInt64Coin(denom2, 800)))
-//	suite.keeper.ProcessQueuedCoins(suite.ctx)
-//
-//	for _, tc := range []struct {
-//		name      string
-//		req       *types.QueryStakingsRequest
-//		expectErr bool
-//		postRun   func(response *types.QueryStakingsResponse)
-//	}{
-//		{
-//			"nil request",
-//			nil,
-//			true,
-//			nil,
-//		},
-//		{
-//			"query all",
-//			&types.QueryStakingsRequest{},
-//			false,
-//			func(resp *types.QueryStakingsResponse) {
-//				suite.Require().Len(resp.Stakings, 3)
-//			},
-//		},
-//		{
-//			"query by farmer addr",
-//			&types.QueryStakingsRequest{Farmer: suite.addrs[0].String()},
-//			false,
-//			func(resp *types.QueryStakingsResponse) {
-//				suite.Require().Len(resp.Stakings, 1)
-//				suite.Require().Equal(suite.addrs[0], resp.Stakings[0].GetFarmer())
-//			},
-//		},
-//		{
-//			"invalid farmer addr",
-//			&types.QueryStakingsRequest{Farmer: "invalid"},
-//			true,
-//			nil,
-//		},
-//		{
-//			"query by staking coin denom",
-//			&types.QueryStakingsRequest{StakingCoinDenom: denom1},
-//			false,
-//			func(resp *types.QueryStakingsResponse) {
-//				suite.Require().Len(resp.Stakings, 2)
-//				for _, staking := range resp.Stakings {
-//					suite.Require().True(staking.StakedCoins.Add(staking.QueuedCoins...).AmountOf(denom1).IsPositive())
-//				}
-//			},
-//		},
-//		{
-//			"invalid staking coin denom",
-//			&types.QueryStakingsRequest{Farmer: "!!!"},
-//			true,
-//			nil,
-//		},
-//		{
-//			"query by farmer addr and staking coin denom",
-//			&types.QueryStakingsRequest{
-//				Farmer:           suite.addrs[0].String(),
-//				StakingCoinDenom: denom1,
-//			},
-//			false,
-//			func(resp *types.QueryStakingsResponse) {
-//				suite.Require().Len(resp.Stakings, 1)
-//				suite.Require().Equal(suite.addrs[0], resp.Stakings[0].GetFarmer())
-//				suite.Require().True(
-//					resp.Stakings[0].StakedCoins.Add(resp.Stakings[0].QueuedCoins...).AmountOf(denom1).IsPositive())
-//			},
-//		},
-//	} {
-//		suite.Run(tc.name, func() {
-//			resp, err := suite.querier.Stakings(sdk.WrapSDKContext(suite.ctx), tc.req)
-//			if tc.expectErr {
-//				suite.Require().Error(err)
-//			} else {
-//				suite.Require().NoError(err)
-//				tc.postRun(resp)
-//			}
-//		})
-//	}
-//}
-//
-//func (suite *KeeperTestSuite) TestGRPCStaking() {
-//	suite.Stake(suite.addrs[0], sdk.NewCoins(sdk.NewInt64Coin(denom1, 1000), sdk.NewInt64Coin(denom2, 1500)))
-//	suite.Stake(suite.addrs[1], sdk.NewCoins(sdk.NewInt64Coin(denom1, 500)))
-//	suite.Stake(suite.addrs[2], sdk.NewCoins(sdk.NewInt64Coin(denom2, 800)))
-//	suite.keeper.ProcessQueuedCoins(suite.ctx)
-//
-//	for _, tc := range []struct {
-//		name      string
-//		req       *types.QueryStakingRequest
-//		expectErr bool
-//		postRun   func(*types.QueryStakingResponse)
-//	}{
-//		{
-//			"nil request",
-//			nil,
-//			true,
-//			nil,
-//		},
-//		{
-//			"query by id",
-//			&types.QueryStakingRequest{StakingId: 1},
-//			false,
-//			func(resp *types.QueryStakingResponse) {
-//				suite.Require().Equal(uint64(1), resp.Staking.Id)
-//			},
-//		},
-//		{
-//			"id not found",
-//			&types.QueryStakingRequest{StakingId: 10},
-//			true,
-//			nil,
-//		},
-//	} {
-//		suite.Run(tc.name, func() {
-//			resp, err := suite.querier.Staking(sdk.WrapSDKContext(suite.ctx), tc.req)
-//			if tc.expectErr {
-//				suite.Require().Error(err)
-//			} else {
-//				suite.Require().NoError(err)
-//				tc.postRun(resp)
-//			}
-//		})
-//	}
-//}
+func (suite *KeeperTestSuite) TestGRPCStakings() {
+	suite.Stake(suite.addrs[0], sdk.NewCoins(sdk.NewInt64Coin(denom1, 1000), sdk.NewInt64Coin(denom2, 1500)))
+	suite.Stake(suite.addrs[1], sdk.NewCoins(sdk.NewInt64Coin(denom1, 500), sdk.NewInt64Coin(denom2, 2000)))
+	suite.keeper.ProcessQueuedCoins(suite.ctx)
+	suite.Stake(suite.addrs[0], sdk.NewCoins(sdk.NewInt64Coin(denom1, 1000), sdk.NewInt64Coin(denom2, 1500)))
+	suite.Stake(suite.addrs[1], sdk.NewCoins(sdk.NewInt64Coin(denom1, 500), sdk.NewInt64Coin(denom2, 2000)))
+
+	for _, tc := range []struct {
+		name      string
+		req       *types.QueryStakingsRequest
+		expectErr bool
+		postRun   func(*types.QueryStakingsResponse)
+	}{
+		{
+			"nil request",
+			nil,
+			true,
+			nil,
+		},
+		{
+			"query by farmer addr",
+			&types.QueryStakingsRequest{Farmer: suite.addrs[0].String()},
+			false,
+			func(resp *types.QueryStakingsResponse) {
+				suite.Require().True(coinsEq(
+					sdk.NewCoins(sdk.NewInt64Coin(denom1, 1000), sdk.NewInt64Coin(denom2, 1500)),
+					resp.StakedCoins))
+				suite.Require().True(coinsEq(
+					sdk.NewCoins(sdk.NewInt64Coin(denom1, 1000), sdk.NewInt64Coin(denom2, 1500)),
+					resp.QueuedCoins))
+			},
+		},
+		{
+			"invalid farmer addr",
+			&types.QueryStakingsRequest{Farmer: "invalid"},
+			true,
+			nil,
+		},
+		{
+			"query with staking coin denom",
+			&types.QueryStakingsRequest{Farmer: suite.addrs[1].String(), StakingCoinDenom: denom2},
+			false,
+			func(resp *types.QueryStakingsResponse) {
+				suite.Require().True(coinsEq(
+					sdk.NewCoins(sdk.NewInt64Coin(denom2, 2000)),
+					resp.StakedCoins))
+				suite.Require().True(coinsEq(
+					sdk.NewCoins(sdk.NewInt64Coin(denom2, 2000)),
+					resp.QueuedCoins))
+			},
+		},
+		{
+			"invalid staking coin denom",
+			&types.QueryStakingsRequest{StakingCoinDenom: "!"},
+			true,
+			nil,
+		},
+		{
+			"query with staking coin denom, without farmer addr",
+			&types.QueryStakingsRequest{StakingCoinDenom: denom1},
+			true,
+			nil,
+		},
+	} {
+		suite.Run(tc.name, func() {
+			resp, err := suite.querier.Stakings(sdk.WrapSDKContext(suite.ctx), tc.req)
+			if tc.expectErr {
+				suite.Require().Error(err)
+			} else {
+				suite.Require().NoError(err)
+				tc.postRun(resp)
+			}
+		})
+	}
+}
+
+func (suite *KeeperTestSuite) TestGRPCTotalStakings() {
+	suite.Stake(suite.addrs[0], sdk.NewCoins(sdk.NewInt64Coin(denom1, 1000), sdk.NewInt64Coin(denom2, 1500)))
+	suite.Stake(suite.addrs[1], sdk.NewCoins(sdk.NewInt64Coin(denom1, 500), sdk.NewInt64Coin(denom2, 2000)))
+	suite.keeper.ProcessQueuedCoins(suite.ctx)
+	suite.Stake(suite.addrs[0], sdk.NewCoins(sdk.NewInt64Coin(denom1, 1000), sdk.NewInt64Coin(denom2, 1500)))
+	suite.Stake(suite.addrs[1], sdk.NewCoins(sdk.NewInt64Coin(denom1, 500), sdk.NewInt64Coin(denom2, 2000)))
+
+	for _, tc := range []struct {
+		name      string
+		req       *types.QueryTotalStakingsRequest
+		expectErr bool
+		postRun   func(*types.QueryTotalStakingsResponse)
+	}{
+		{
+			"nil request",
+			nil,
+			true,
+			nil,
+		},
+		{
+			"empty request",
+			&types.QueryTotalStakingsRequest{},
+			true,
+			nil,
+		},
+		{
+			"query by staking coin denom #1",
+			&types.QueryTotalStakingsRequest{StakingCoinDenom: denom1},
+			false,
+			func(resp *types.QueryTotalStakingsResponse) {
+				suite.Require().True(intEq(sdk.NewInt(1500), resp.Amount))
+			},
+		},
+		{
+			"query by staking coin denom #1",
+			&types.QueryTotalStakingsRequest{StakingCoinDenom: denom2},
+			false,
+			func(resp *types.QueryTotalStakingsResponse) {
+				suite.Require().True(intEq(sdk.NewInt(3500), resp.Amount))
+			},
+		},
+		{
+			"invalid staking coin denom",
+			&types.QueryTotalStakingsRequest{StakingCoinDenom: "!"},
+			true,
+			nil,
+		},
+	} {
+		resp, err := suite.querier.TotalStakings(sdk.WrapSDKContext(suite.ctx), tc.req)
+		if tc.expectErr {
+			suite.Require().Error(err)
+		} else {
+			suite.Require().NoError(err)
+			tc.postRun(resp)
+		}
+	}
+}
+
+func (suite *KeeperTestSuite) TestGRPCRewards() {
+	for _, plan := range suite.sampleFixedAmtPlans {
+		suite.keeper.SetPlan(suite.ctx, plan)
+	}
+
+	suite.Stake(suite.addrs[0], sdk.NewCoins(sdk.NewInt64Coin(denom1, 1000), sdk.NewInt64Coin(denom2, 1500)))
+	suite.Stake(suite.addrs[1], sdk.NewCoins(sdk.NewInt64Coin(denom1, 1000)))
+
+	suite.ctx = suite.ctx.WithBlockTime(mustParseRFC3339("2021-08-06T00:00:00Z"))
+	farming.EndBlocker(suite.ctx, suite.keeper)
+	suite.ctx = suite.ctx.WithBlockTime(mustParseRFC3339("2021-08-07T00:00:00Z"))
+	farming.EndBlocker(suite.ctx, suite.keeper)
+	suite.ctx = suite.ctx.WithBlockTime(mustParseRFC3339("2021-08-08T00:00:00Z"))
+	farming.EndBlocker(suite.ctx, suite.keeper)
+
+	for _, tc := range []struct {
+		name      string
+		req       *types.QueryRewardsRequest
+		expectErr bool
+		postRun   func(*types.QueryRewardsResponse)
+	}{
+		{
+			"nil request",
+			nil,
+			true,
+			nil,
+		},
+		{
+			"empty request",
+			&types.QueryRewardsRequest{},
+			true,
+			nil,
+		},
+		{
+			"query by farmer addr",
+			&types.QueryRewardsRequest{Farmer: suite.addrs[0].String()},
+			false,
+			func(resp *types.QueryRewardsResponse) {
+				// 0.3 * 1000000 * 1/2
+				// + 0.7 * 1000000 * 1/1
+				// + 1.0 * 2000000 * 1/2
+				// ~= 1850000
+				suite.Require().True(coinsEq(sdk.NewCoins(sdk.NewInt64Coin(denom3, 1849999)), resp.Rewards))
+			},
+		},
+		{
+			"invalid farmer addr",
+			&types.QueryRewardsRequest{Farmer: "invalid"},
+			true,
+			nil,
+		},
+		{
+			"query with staking coin denom",
+			&types.QueryRewardsRequest{Farmer: suite.addrs[1].String(), StakingCoinDenom: denom1},
+			false,
+			func(resp *types.QueryRewardsResponse) {
+				// 0.3 * 1000000 * 1/2
+				// + 1.0 * 2000000 * 1/2
+				// ~= 1150000
+				suite.Require().True(coinsEq(sdk.NewCoins(sdk.NewInt64Coin(denom3, 1150000)), resp.Rewards))
+			},
+		},
+		{
+			"query with staking coin denom, without farmer addr",
+			&types.QueryRewardsRequest{StakingCoinDenom: denom2},
+			true,
+			nil,
+		},
+	} {
+		cacheCtx, _ := suite.ctx.CacheContext() // TODO: can we omit the 'cached' context?
+		resp, err := suite.querier.Rewards(sdk.WrapSDKContext(cacheCtx), tc.req)
+		if tc.expectErr {
+			suite.Require().Error(err)
+		} else {
+			suite.Require().NoError(err)
+			tc.postRun(resp)
+		}
+	}
+}
diff --git a/x/farming/keeper/keeper.go b/x/farming/keeper/keeper.go
index 078ae0a0..9482d39b 100644
--- a/x/farming/keeper/keeper.go
+++ b/x/farming/keeper/keeper.go
@@ -2,6 +2,7 @@ package keeper
 
 import (
 	"fmt"
+	"strconv"
 
 	"github.com/tendermint/tendermint/libs/log"
 
@@ -12,6 +13,19 @@ import (
 	"github.com/tendermint/farming/x/farming/types"
 )
 
+var (
+	enableAdvanceEpoch = "false" // set it to "true" using build flags to enable AdvanceEpoch msg handling.
+	EnableAdvanceEpoch = false
+)
+
+func init() {
+	var err error
+	EnableAdvanceEpoch, err = strconv.ParseBool(enableAdvanceEpoch)
+	if err != nil {
+		panic(err)
+	}
+}
+
 // Keeper of the farming store
 type Keeper struct {
 	storeKey   sdk.StoreKey
diff --git a/x/farming/keeper/msg_server.go b/x/farming/keeper/msg_server.go
index 61a1fd2e..8e41410e 100644
--- a/x/farming/keeper/msg_server.go
+++ b/x/farming/keeper/msg_server.go
@@ -7,6 +7,7 @@ package keeper
 
 import (
 	"context"
+	"fmt"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
@@ -101,3 +102,19 @@ func (k msgServer) Harvest(goCtx context.Context, msg *types.MsgHarvest) (*types
 
 	return &types.MsgHarvestResponse{}, nil
 }
+
+// AdvanceEpoch defines a method for advancing epoch by one, just for testing purpose
+// and shouldn't be used in real world.
+func (k msgServer) AdvanceEpoch(goCtx context.Context, msg *types.MsgAdvanceEpoch) (*types.MsgAdvanceEpochResponse, error) {
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	if EnableAdvanceEpoch {
+		if err := k.Keeper.AdvanceEpoch(ctx); err != nil {
+			return nil, err
+		}
+	} else {
+		return nil, fmt.Errorf("AdvanceEpoch is disabled")
+	}
+
+	return &types.MsgAdvanceEpochResponse{}, nil
+}
diff --git a/x/farming/keeper/reward.go b/x/farming/keeper/reward.go
index ef037823..0420ce33 100644
--- a/x/farming/keeper/reward.go
+++ b/x/farming/keeper/reward.go
@@ -228,11 +228,11 @@ func (k Keeper) AllocateRewards(ctx sdk.Context) error {
 
 		totalAllocCoins := sdk.NewDecCoins()
 		for _, weight := range allocInfo.Plan.GetStakingCoinWeights() {
-			totalStaking, found := k.GetTotalStaking(ctx, weight.Denom)
+			totalStakings, found := k.GetTotalStakings(ctx, weight.Denom)
 			if !found {
 				continue
 			}
-			if !totalStaking.Amount.IsPositive() {
+			if !totalStakings.Amount.IsPositive() {
 				continue
 			}
 
@@ -242,7 +242,7 @@ func (k Keeper) AllocateRewards(ctx sdk.Context) error {
 			currentEpoch := k.GetCurrentEpoch(ctx, weight.Denom)
 			historical := k.GetHistoricalRewards(ctx, weight.Denom, currentEpoch-1)
 			k.SetHistoricalRewards(ctx, weight.Denom, currentEpoch, types.HistoricalRewards{
-				CumulativeUnitRewards: historical.CumulativeUnitRewards.Add(allocCoins.QuoDecTruncate(totalStaking.Amount.ToDec())...),
+				CumulativeUnitRewards: historical.CumulativeUnitRewards.Add(allocCoins.QuoDecTruncate(totalStakings.Amount.ToDec())...),
 			})
 			k.SetCurrentEpoch(ctx, weight.Denom, currentEpoch+1)
 
diff --git a/x/farming/keeper/staking.go b/x/farming/keeper/staking.go
index 8d097af2..2a4421b3 100644
--- a/x/farming/keeper/staking.go
+++ b/x/farming/keeper/staking.go
@@ -129,21 +129,21 @@ func (k Keeper) IterateQueuedStakingsByFarmer(ctx sdk.Context, farmerAcc sdk.Acc
 	}
 }
 
-func (k Keeper) GetTotalStaking(ctx sdk.Context, stakingCoinDenom string) (totalStaking types.TotalStaking, found bool) {
+func (k Keeper) GetTotalStakings(ctx sdk.Context, stakingCoinDenom string) (totalStakings types.TotalStakings, found bool) {
 	store := ctx.KVStore(k.storeKey)
-	bz := store.Get(types.GetTotalStakingKey(stakingCoinDenom))
+	bz := store.Get(types.GetTotalStakingsKey(stakingCoinDenom))
 	if bz == nil {
 		return
 	}
-	k.cdc.MustUnmarshal(bz, &totalStaking)
+	k.cdc.MustUnmarshal(bz, &totalStakings)
 	found = true
 	return
 }
 
-func (k Keeper) SetTotalStaking(ctx sdk.Context, stakingCoinDenom string, totalStaking types.TotalStaking) {
+func (k Keeper) SetTotalStakings(ctx sdk.Context, stakingCoinDenom string, totalStakings types.TotalStakings) {
 	store := ctx.KVStore(k.storeKey)
-	bz := k.cdc.MustMarshal(&totalStaking)
-	store.Set(types.GetTotalStakingKey(stakingCoinDenom), bz)
+	bz := k.cdc.MustMarshal(&totalStakings)
+	store.Set(types.GetTotalStakingsKey(stakingCoinDenom), bz)
 }
 
 // ReserveStakingCoins sends staking coins to the staking reserve account.
@@ -237,12 +237,12 @@ func (k Keeper) Unstake(ctx sdk.Context, farmerAcc sdk.AccAddress, amount sdk.Co
 			k.DeleteQueuedStaking(ctx, coin.Denom, farmerAcc)
 		}
 
-		totalStaking, found := k.GetTotalStaking(ctx, coin.Denom)
+		totalStakings, found := k.GetTotalStakings(ctx, coin.Denom)
 		if !found {
-			totalStaking.Amount = sdk.ZeroInt()
+			totalStakings.Amount = sdk.ZeroInt()
 		}
-		totalStaking.Amount = totalStaking.Amount.Sub(removedFromStaking)
-		k.SetTotalStaking(ctx, coin.Denom, totalStaking)
+		totalStakings.Amount = totalStakings.Amount.Sub(removedFromStaking)
+		k.SetTotalStakings(ctx, coin.Denom, totalStakings)
 	}
 
 	if err := k.ReleaseStakingCoins(ctx, farmerAcc, amount); err != nil {
@@ -278,12 +278,12 @@ func (k Keeper) ProcessQueuedCoins(ctx sdk.Context) {
 			StartingEpoch: k.GetCurrentEpoch(ctx, stakingCoinDenom),
 		})
 
-		totalStaking, found := k.GetTotalStaking(ctx, stakingCoinDenom)
+		totalStakings, found := k.GetTotalStakings(ctx, stakingCoinDenom)
 		if !found {
-			totalStaking.Amount = sdk.ZeroInt()
+			totalStakings.Amount = sdk.ZeroInt()
 		}
-		k.SetTotalStaking(ctx, stakingCoinDenom, types.TotalStaking{
-			Amount: totalStaking.Amount.Add(queuedStaking.Amount),
+		k.SetTotalStakings(ctx, stakingCoinDenom, types.TotalStakings{
+			Amount: totalStakings.Amount.Add(queuedStaking.Amount),
 		})
 
 		return false
diff --git a/x/farming/types/farming.pb.go b/x/farming/types/farming.pb.go
index 573f9f39..3d230bd9 100644
--- a/x/farming/types/farming.pb.go
+++ b/x/farming/types/farming.pb.go
@@ -326,22 +326,22 @@ func (m *QueuedStaking) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_QueuedStaking proto.InternalMessageInfo
 
-type TotalStaking struct {
+type TotalStakings struct {
 	Amount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount"`
 }
 
-func (m *TotalStaking) Reset()         { *m = TotalStaking{} }
-func (m *TotalStaking) String() string { return proto.CompactTextString(m) }
-func (*TotalStaking) ProtoMessage()    {}
-func (*TotalStaking) Descriptor() ([]byte, []int) {
+func (m *TotalStakings) Reset()         { *m = TotalStakings{} }
+func (m *TotalStakings) String() string { return proto.CompactTextString(m) }
+func (*TotalStakings) ProtoMessage()    {}
+func (*TotalStakings) Descriptor() ([]byte, []int) {
 	return fileDescriptor_5b657e0809d9de86, []int{6}
 }
-func (m *TotalStaking) XXX_Unmarshal(b []byte) error {
+func (m *TotalStakings) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *TotalStaking) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *TotalStakings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_TotalStaking.Marshal(b, m, deterministic)
+		return xxx_messageInfo_TotalStakings.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -351,17 +351,17 @@ func (m *TotalStaking) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return b[:n], nil
 	}
 }
-func (m *TotalStaking) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TotalStaking.Merge(m, src)
+func (m *TotalStakings) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TotalStakings.Merge(m, src)
 }
-func (m *TotalStaking) XXX_Size() int {
+func (m *TotalStakings) XXX_Size() int {
 	return m.Size()
 }
-func (m *TotalStaking) XXX_DiscardUnknown() {
-	xxx_messageInfo_TotalStaking.DiscardUnknown(m)
+func (m *TotalStakings) XXX_DiscardUnknown() {
+	xxx_messageInfo_TotalStakings.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_TotalStaking proto.InternalMessageInfo
+var xxx_messageInfo_TotalStakings proto.InternalMessageInfo
 
 type HistoricalRewards struct {
 	CumulativeUnitRewards github_com_cosmos_cosmos_sdk_types.DecCoins `protobuf:"bytes,1,rep,name=cumulative_unit_rewards,json=cumulativeUnitRewards,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.DecCoins" json:"cumulative_unit_rewards" yaml:"cumulative_unit_rewards"`
@@ -408,7 +408,7 @@ func init() {
 	proto.RegisterType((*RatioPlan)(nil), "cosmos.farming.v1beta1.RatioPlan")
 	proto.RegisterType((*Staking)(nil), "cosmos.farming.v1beta1.Staking")
 	proto.RegisterType((*QueuedStaking)(nil), "cosmos.farming.v1beta1.QueuedStaking")
-	proto.RegisterType((*TotalStaking)(nil), "cosmos.farming.v1beta1.TotalStaking")
+	proto.RegisterType((*TotalStakings)(nil), "cosmos.farming.v1beta1.TotalStakings")
 	proto.RegisterType((*HistoricalRewards)(nil), "cosmos.farming.v1beta1.HistoricalRewards")
 }
 
@@ -417,77 +417,77 @@ func init() {
 }
 
 var fileDescriptor_5b657e0809d9de86 = []byte{
-	// 1114 bytes of a gzipped FileDescriptorProto
+	// 1113 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x4f, 0x6f, 0x1b, 0x45,
-	0x14, 0xf7, 0xb8, 0x6e, 0x62, 0x8f, 0x9b, 0xc4, 0x9e, 0xfc, 0x61, 0xe3, 0xb6, 0xde, 0xd5, 0x4a,
-	0x20, 0x2b, 0x28, 0xb6, 0x1a, 0x7a, 0xca, 0x89, 0x38, 0x7f, 0x8a, 0xa5, 0x28, 0xb8, 0x5b, 0x87,
-	0x02, 0x02, 0xad, 0xc6, 0xde, 0x89, 0xb3, 0xea, 0x7a, 0xc7, 0xda, 0x19, 0x27, 0xcd, 0x07, 0x40,
-	0xaa, 0x72, 0xaa, 0x10, 0x07, 0x2e, 0x41, 0x15, 0xdc, 0xca, 0x95, 0xef, 0x40, 0x25, 0x2e, 0x11,
+	0x14, 0xf7, 0xb8, 0x6e, 0x62, 0x8f, 0x49, 0x62, 0x4f, 0xfe, 0xb0, 0x71, 0x5b, 0xef, 0x6a, 0x25,
+	0x90, 0x15, 0x14, 0x5b, 0x0d, 0x3d, 0xe5, 0x44, 0x9c, 0x3f, 0xc5, 0x52, 0x14, 0xdc, 0xad, 0x43,
+	0x01, 0x09, 0xad, 0xc6, 0xde, 0x89, 0xb3, 0xea, 0x7a, 0xc7, 0xda, 0x19, 0x27, 0xcd, 0x07, 0x40,
+	0x8a, 0x72, 0xaa, 0x10, 0x07, 0x2e, 0x41, 0x15, 0xdc, 0xca, 0x95, 0xef, 0x40, 0x25, 0x2e, 0x11,
 	0x12, 0x12, 0xe2, 0xb0, 0x45, 0xc9, 0x37, 0xf0, 0x99, 0x03, 0xda, 0x99, 0x59, 0x67, 0x11, 0x0e,
-	0x69, 0x24, 0x7a, 0xf2, 0xce, 0x9b, 0xf7, 0x7e, 0xef, 0xf7, 0xde, 0xbe, 0xdf, 0xf3, 0xc2, 0x0a,
-	0x27, 0xbe, 0x43, 0x82, 0x9e, 0xeb, 0xf3, 0xda, 0x1e, 0x8e, 0x7e, 0xbb, 0xb5, 0x83, 0x7b, 0x6d,
-	0xc2, 0xf1, 0xbd, 0xf8, 0x5c, 0xed, 0x07, 0x94, 0x53, 0xb4, 0xd0, 0xa1, 0xac, 0x47, 0x59, 0x35,
+	0x69, 0xa4, 0x72, 0xf2, 0xce, 0x9b, 0xf7, 0x7e, 0xef, 0xf7, 0xde, 0xbe, 0xdf, 0xf3, 0xc2, 0x0a,
+	0x27, 0xbe, 0x43, 0x82, 0x9e, 0xeb, 0xf3, 0xda, 0x1e, 0x8e, 0x7e, 0xbb, 0xb5, 0x83, 0xfb, 0x6d,
+	0xc2, 0xf1, 0xfd, 0xf8, 0x5c, 0xed, 0x07, 0x94, 0x53, 0xb4, 0xd0, 0xa1, 0xac, 0x47, 0x59, 0x35,
 	0xb6, 0x2a, 0xaf, 0xd2, 0x5c, 0x97, 0x76, 0xa9, 0x70, 0xa9, 0x45, 0x4f, 0xd2, 0xbb, 0xb4, 0x28,
 	0xbd, 0x6d, 0x79, 0xa1, 0x42, 0xe5, 0x55, 0x59, 0x9e, 0x6a, 0x6d, 0xcc, 0xc8, 0x28, 0x57, 0x87,
 	0xba, 0xbe, 0xba, 0xd7, 0xbb, 0x94, 0x76, 0x3d, 0x52, 0x13, 0xa7, 0xf6, 0x60, 0xaf, 0xc6, 0xdd,
 	0x1e, 0x61, 0x1c, 0xf7, 0xfa, 0xd2, 0xc1, 0xfc, 0x25, 0x0d, 0x27, 0x9a, 0x38, 0xc0, 0x3d, 0x86,
 	0x5e, 0x02, 0xb8, 0xd8, 0x0f, 0xdc, 0x03, 0xcc, 0x89, 0xdd, 0xf7, 0xb0, 0x6f, 0x77, 0x02, 0x82,
-	0xb9, 0x4b, 0x7d, 0x7b, 0x8f, 0x10, 0x0d, 0x18, 0x37, 0x2a, 0xf9, 0x95, 0xc5, 0xaa, 0x4a, 0x1f,
+	0xb9, 0x4b, 0x7d, 0x7b, 0x8f, 0x10, 0x0d, 0x18, 0xb7, 0x2a, 0xf9, 0x95, 0xc5, 0xaa, 0x4a, 0x1f,
 	0x25, 0x8c, 0x69, 0x57, 0xd7, 0xa9, 0xeb, 0xd7, 0x5b, 0xaf, 0x42, 0x3d, 0x35, 0x0c, 0x75, 0xe3,
-	0x08, 0xf7, 0xbc, 0x55, 0xf3, 0x52, 0x24, 0xf3, 0xe5, 0x6b, 0xbd, 0xd2, 0x75, 0xf9, 0xfe, 0xa0,
-	0x5d, 0xed, 0xd0, 0x9e, 0xaa, 0x47, 0xfd, 0x2c, 0x33, 0xe7, 0x49, 0x8d, 0x1f, 0xf5, 0x09, 0x13,
-	0xa0, 0xcc, 0x5a, 0x50, 0x38, 0x4d, 0x0f, 0xfb, 0xeb, 0x0a, 0x65, 0x8b, 0x10, 0x74, 0x1f, 0x42,
+	0x08, 0xf7, 0xbc, 0x55, 0xf3, 0x4a, 0x24, 0xf3, 0xe5, 0x6b, 0xbd, 0xd2, 0x75, 0xf9, 0xfe, 0xa0,
+	0x5d, 0xed, 0xd0, 0x9e, 0xaa, 0x47, 0xfd, 0x2c, 0x33, 0xe7, 0x69, 0x8d, 0x1f, 0xf5, 0x09, 0x13,
+	0xa0, 0xcc, 0x5a, 0x50, 0x38, 0x4d, 0x0f, 0xfb, 0xeb, 0x0a, 0x65, 0x8b, 0x10, 0xf4, 0x00, 0x42,
 	0xd2, 0xa7, 0x9d, 0x7d, 0xdb, 0xc1, 0x47, 0x4c, 0x4b, 0x1b, 0xa0, 0x32, 0x55, 0x9f, 0x1f, 0x86,
-	0x7a, 0x51, 0x66, 0xbf, 0xb8, 0x33, 0xad, 0x9c, 0x38, 0x6c, 0xe0, 0x23, 0x86, 0x5a, 0x70, 0x5e,
-	0xb5, 0x3c, 0x62, 0x62, 0x77, 0xa8, 0xe7, 0x91, 0x0e, 0xa7, 0x81, 0x76, 0xc3, 0x00, 0x95, 0x5c,
-	0xdd, 0x18, 0x86, 0xfa, 0x1d, 0x09, 0x30, 0xd6, 0xcd, 0xb4, 0x66, 0x95, 0x7d, 0x8b, 0x90, 0xf5,
-	0xd8, 0xba, 0x9a, 0x7d, 0xf6, 0x42, 0x4f, 0x7d, 0xfb, 0x42, 0x4f, 0x99, 0xdf, 0x4d, 0xc2, 0x6c,
-	0x1d, 0x33, 0xc1, 0x16, 0x4d, 0xc3, 0xb4, 0xeb, 0x68, 0xc0, 0x00, 0x95, 0x8c, 0x95, 0x76, 0x1d,
-	0x84, 0x60, 0xc6, 0xc7, 0x3d, 0x22, 0xc8, 0xe6, 0x2c, 0xf1, 0x8c, 0xee, 0xc3, 0x4c, 0x54, 0xad,
-	0xc8, 0x3f, 0xbd, 0x62, 0x54, 0xc7, 0xcf, 0x45, 0x35, 0xc2, 0x6b, 0x1d, 0xf5, 0x89, 0x25, 0xbc,
-	0xd1, 0x43, 0x38, 0x17, 0xf3, 0xeb, 0x53, 0xea, 0xd9, 0xd8, 0x71, 0x02, 0xc2, 0x98, 0x96, 0x11,
-	0x55, 0xe8, 0xc3, 0x50, 0xbf, 0xfd, 0xcf, 0x2a, 0x92, 0x5e, 0xa6, 0x85, 0x94, 0xb9, 0x49, 0xa9,
-	0xb7, 0x26, 0x8d, 0xe8, 0x63, 0x38, 0xcb, 0xc5, 0xe8, 0xca, 0xf7, 0x14, 0x23, 0xde, 0x14, 0x88,
-	0xe5, 0x61, 0xa8, 0x97, 0x24, 0xe2, 0x18, 0x27, 0xd3, 0x42, 0x09, 0x6b, 0x0c, 0xf8, 0x3d, 0x80,
-	0x73, 0x8c, 0xe3, 0x27, 0x51, 0xfa, 0x68, 0x20, 0xed, 0x43, 0xe2, 0x76, 0xf7, 0x39, 0xd3, 0x26,
-	0xc4, 0x20, 0xdd, 0x19, 0x3b, 0x48, 0x1b, 0xa4, 0x23, 0x66, 0xc9, 0x52, 0xb3, 0xa4, 0xca, 0x18,
-	0x87, 0x13, 0x8d, 0xd1, 0xfb, 0x6f, 0x30, 0x46, 0x0a, 0x92, 0x59, 0x48, 0xa1, 0x44, 0xa7, 0xc7,
-	0x12, 0x03, 0x7d, 0x0a, 0x21, 0xe3, 0x38, 0xe0, 0x76, 0x24, 0x0b, 0x6d, 0xd2, 0x00, 0x95, 0xfc,
-	0x4a, 0xa9, 0x2a, 0x35, 0x53, 0x8d, 0x35, 0x53, 0x6d, 0xc5, 0x9a, 0xa9, 0xdf, 0x55, 0xbc, 0x8a,
-	0x23, 0x5e, 0x2a, 0xd6, 0x7c, 0xfe, 0x5a, 0x07, 0x56, 0x4e, 0x18, 0x22, 0x77, 0x64, 0xc1, 0x2c,
-	0xf1, 0x1d, 0x89, 0x9b, 0xbd, 0x12, 0xf7, 0xb6, 0xc2, 0x9d, 0x51, 0xd3, 0xab, 0x22, 0x25, 0xea,
-	0x24, 0xf1, 0x1d, 0x81, 0x59, 0x86, 0x30, 0x6e, 0x34, 0x71, 0xb4, 0x9c, 0x01, 0x2a, 0x59, 0x2b,
-	0x61, 0x41, 0x87, 0x70, 0xc1, 0xc3, 0x8c, 0xdb, 0x8e, 0xcb, 0x78, 0xe0, 0xb6, 0x07, 0xe2, 0x25,
-	0x09, 0x06, 0xf0, 0x4a, 0x06, 0xef, 0x0e, 0x43, 0xfd, 0xae, 0xcc, 0x3e, 0x1e, 0x43, 0x72, 0x99,
-	0x8b, 0x2e, 0x37, 0x12, 0x77, 0x82, 0xd8, 0x37, 0x00, 0x16, 0x47, 0x01, 0xc4, 0x11, 0xef, 0x89,
-	0x69, 0xf9, 0xab, 0x36, 0xc6, 0xb6, 0xaa, 0x5a, 0x93, 0x79, 0xff, 0x85, 0x70, 0xbd, 0x4d, 0x51,
-	0x48, 0xc4, 0x0b, 0xcb, 0x6a, 0x31, 0xd6, 0xe5, 0xaf, 0x3f, 0x2d, 0xdf, 0x8c, 0x24, 0xd4, 0x30,
-	0xff, 0x02, 0x70, 0x66, 0xcb, 0x7d, 0x4a, 0x9c, 0xb5, 0x1e, 0x1d, 0xf8, 0x5c, 0xe8, 0xf4, 0x31,
-	0xcc, 0x45, 0xdc, 0xc4, 0xa6, 0x12, 0x72, 0xcd, 0x5f, 0x2e, 0xc4, 0x58, 0xdc, 0x75, 0xed, 0x34,
-	0xd4, 0xc1, 0x30, 0xd4, 0x0b, 0x92, 0xfb, 0x08, 0xc0, 0xb4, 0xb2, 0xed, 0x78, 0x01, 0x7c, 0x05,
-	0xe0, 0x2d, 0xb9, 0x88, 0xb0, 0xc8, 0xa6, 0xa5, 0xaf, 0xea, 0xc8, 0x03, 0xd5, 0x91, 0xd9, 0xe4,
-	0x16, 0x93, 0xc1, 0xd7, 0x6b, 0x46, 0x5e, 0x84, 0xca, 0x22, 0x13, 0xfb, 0xe9, 0x37, 0x00, 0x73,
-	0x56, 0x24, 0xd3, 0xb7, 0x5b, 0x38, 0x81, 0x32, 0xbf, 0x1d, 0x44, 0xb9, 0xe4, 0xc2, 0xab, 0x6f,
-	0x44, 0xb5, 0xfd, 0x11, 0xea, 0xef, 0xbd, 0x99, 0x68, 0x87, 0xa1, 0x8e, 0x92, 0x5d, 0x10, 0x50,
-	0xa6, 0x25, 0xb7, 0xbe, 0xa8, 0x21, 0x51, 0xd7, 0x09, 0x80, 0x93, 0x8f, 0xa4, 0xbc, 0xd1, 0x16,
-	0x9c, 0x50, 0xed, 0x06, 0x22, 0x6f, 0xf5, 0x1a, 0x79, 0x1b, 0x3e, 0xb7, 0x54, 0x34, 0xfa, 0x10,
-	0x4e, 0x0b, 0x39, 0x47, 0x8b, 0x47, 0x24, 0x15, 0x75, 0x64, 0xea, 0x8b, 0xc3, 0x50, 0x9f, 0x4f,
-	0xe8, 0x7f, 0x74, 0x6f, 0x5a, 0x53, 0xb1, 0x61, 0x33, 0x3a, 0x27, 0xf8, 0x7d, 0x09, 0xa7, 0x1e,
-	0x0e, 0xc8, 0x80, 0x38, 0xff, 0x33, 0xc9, 0xd5, 0x4c, 0x94, 0xc2, 0xfc, 0x02, 0xde, 0x6a, 0x51,
-	0x8e, 0xbd, 0xb7, 0x83, 0xfe, 0x33, 0x80, 0xc5, 0x8f, 0x5c, 0xc6, 0x69, 0xe0, 0x76, 0xb0, 0x67,
-	0x91, 0x43, 0x1c, 0x38, 0x0c, 0xfd, 0x08, 0xe0, 0x3b, 0x9d, 0x41, 0x6f, 0xe0, 0x61, 0xee, 0x1e,
-	0x10, 0x7b, 0xe0, 0xbb, 0xdc, 0x0e, 0xe4, 0x9d, 0xfa, 0x56, 0xf8, 0xef, 0x15, 0xbf, 0xab, 0x46,
-	0xbd, 0x2c, 0x5b, 0x79, 0x09, 0xd4, 0xb5, 0xb7, 0xfc, 0xfc, 0x05, 0xd0, 0xae, 0xef, 0x72, 0xc5,
-	0x56, 0x56, 0xb2, 0xf4, 0x35, 0x80, 0xd9, 0xf8, 0xaf, 0x14, 0x2d, 0xc1, 0xf9, 0xe6, 0xf6, 0xda,
-	0x8e, 0xdd, 0xfa, 0xac, 0xb9, 0x69, 0xef, 0xee, 0x3c, 0x6a, 0x6e, 0xae, 0x37, 0xb6, 0x1a, 0x9b,
-	0x1b, 0x85, 0x54, 0x69, 0xe6, 0xf8, 0xc4, 0xc8, 0xc7, 0x8e, 0x3b, 0xae, 0x87, 0x2a, 0xb0, 0x70,
-	0xe1, 0xdb, 0xdc, 0xad, 0x6f, 0x37, 0xd6, 0x0b, 0xa0, 0x84, 0x8e, 0x4f, 0x8c, 0xe9, 0xd8, 0xad,
-	0x39, 0x68, 0x7b, 0x6e, 0x07, 0x2d, 0xc1, 0x62, 0xc2, 0xd3, 0x6a, 0x7c, 0xb2, 0xd6, 0xda, 0x2c,
-	0xa4, 0x4b, 0xb3, 0xc7, 0x27, 0xc6, 0xcc, 0xc8, 0x55, 0x7e, 0xd2, 0x94, 0x32, 0xcf, 0x7e, 0x28,
-	0xa7, 0xea, 0x0f, 0x5e, 0x9d, 0x95, 0xc1, 0xe9, 0x59, 0x19, 0xfc, 0x79, 0x56, 0x06, 0xcf, 0xcf,
-	0xcb, 0xa9, 0xd3, 0xf3, 0x72, 0xea, 0xf7, 0xf3, 0x72, 0xea, 0xf3, 0xe5, 0x44, 0xe1, 0x63, 0x3e,
-	0x2d, 0x9f, 0x8e, 0x9e, 0x44, 0x0f, 0xda, 0x13, 0x62, 0xad, 0x7f, 0xf0, 0x77, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0xf2, 0x14, 0x99, 0x82, 0x87, 0x0a, 0x00, 0x00,
+	0x7a, 0x51, 0x66, 0xbf, 0xbc, 0x33, 0xad, 0x9c, 0x38, 0x6c, 0xe0, 0x23, 0x86, 0x5a, 0x70, 0x5e,
+	0xb5, 0x3c, 0x62, 0x62, 0x77, 0xa8, 0xe7, 0x91, 0x0e, 0xa7, 0x81, 0x76, 0xcb, 0x00, 0x95, 0x5c,
+	0xdd, 0x18, 0x86, 0xfa, 0x5d, 0x09, 0x30, 0xd6, 0xcd, 0xb4, 0x66, 0x95, 0x7d, 0x8b, 0x90, 0xf5,
+	0xd8, 0xba, 0x9a, 0x3d, 0x7e, 0xa1, 0xa7, 0xbe, 0x7d, 0xa1, 0xa7, 0xcc, 0xef, 0x26, 0x61, 0xb6,
+	0x8e, 0x99, 0x60, 0x8b, 0xa6, 0x61, 0xda, 0x75, 0x34, 0x60, 0x80, 0x4a, 0xc6, 0x4a, 0xbb, 0x0e,
+	0x42, 0x30, 0xe3, 0xe3, 0x1e, 0x11, 0x64, 0x73, 0x96, 0x78, 0x46, 0x0f, 0x60, 0x26, 0xaa, 0x56,
+	0xe4, 0x9f, 0x5e, 0x31, 0xaa, 0xe3, 0xe7, 0xa2, 0x1a, 0xe1, 0xb5, 0x8e, 0xfa, 0xc4, 0x12, 0xde,
+	0xe8, 0x11, 0x9c, 0x8b, 0xf9, 0xf5, 0x29, 0xf5, 0x6c, 0xec, 0x38, 0x01, 0x61, 0x4c, 0xcb, 0x88,
+	0x2a, 0xf4, 0x61, 0xa8, 0xdf, 0xf9, 0x67, 0x15, 0x49, 0x2f, 0xd3, 0x42, 0xca, 0xdc, 0xa4, 0xd4,
+	0x5b, 0x93, 0x46, 0xf4, 0x09, 0x9c, 0xe5, 0x62, 0x74, 0xe5, 0x7b, 0x8a, 0x11, 0x6f, 0x0b, 0xc4,
+	0xf2, 0x30, 0xd4, 0x4b, 0x12, 0x71, 0x8c, 0x93, 0x69, 0xa1, 0x84, 0x35, 0x06, 0xfc, 0x1e, 0xc0,
+	0x39, 0xc6, 0xf1, 0xd3, 0x28, 0x7d, 0x34, 0x90, 0xf6, 0x21, 0x71, 0xbb, 0xfb, 0x9c, 0x69, 0x13,
+	0x62, 0x90, 0xee, 0x8e, 0x1d, 0xa4, 0x0d, 0xd2, 0x11, 0xb3, 0x64, 0xa9, 0x59, 0x52, 0x65, 0x8c,
+	0xc3, 0x89, 0xc6, 0xe8, 0x83, 0x37, 0x18, 0x23, 0x05, 0xc9, 0x2c, 0xa4, 0x50, 0xa2, 0xd3, 0x13,
+	0x89, 0x81, 0x3e, 0x83, 0x90, 0x71, 0x1c, 0x70, 0x3b, 0x92, 0x85, 0x36, 0x69, 0x80, 0x4a, 0x7e,
+	0xa5, 0x54, 0x95, 0x9a, 0xa9, 0xc6, 0x9a, 0xa9, 0xb6, 0x62, 0xcd, 0xd4, 0xef, 0x29, 0x5e, 0xc5,
+	0x11, 0x2f, 0x15, 0x6b, 0x3e, 0x7f, 0xad, 0x03, 0x2b, 0x27, 0x0c, 0x91, 0x3b, 0xb2, 0x60, 0x96,
+	0xf8, 0x8e, 0xc4, 0xcd, 0x5e, 0x8b, 0x7b, 0x47, 0xe1, 0xce, 0xa8, 0xe9, 0x55, 0x91, 0x12, 0x75,
+	0x92, 0xf8, 0x8e, 0xc0, 0x2c, 0x43, 0x18, 0x37, 0x9a, 0x38, 0x5a, 0xce, 0x00, 0x95, 0xac, 0x95,
+	0xb0, 0xa0, 0x43, 0xb8, 0xe0, 0x61, 0xc6, 0x6d, 0xc7, 0x65, 0x3c, 0x70, 0xdb, 0x03, 0xf1, 0x92,
+	0x04, 0x03, 0x78, 0x2d, 0x83, 0xf7, 0x86, 0xa1, 0x7e, 0x4f, 0x66, 0x1f, 0x8f, 0x21, 0xb9, 0xcc,
+	0x45, 0x97, 0x1b, 0x89, 0x3b, 0x41, 0xec, 0x1b, 0x00, 0x8b, 0xa3, 0x00, 0xe2, 0x88, 0xf7, 0xc4,
+	0xb4, 0xfc, 0x75, 0x1b, 0x63, 0x5b, 0x55, 0xad, 0xc9, 0xbc, 0xff, 0x42, 0xb8, 0xd9, 0xa6, 0x28,
+	0x24, 0xe2, 0x85, 0x65, 0xb5, 0x18, 0xeb, 0xf2, 0xd7, 0x9f, 0x96, 0x6f, 0x47, 0x12, 0x6a, 0x98,
+	0x7f, 0x01, 0x38, 0xb3, 0xe5, 0x3e, 0x23, 0xce, 0x5a, 0x8f, 0x0e, 0x7c, 0x2e, 0x74, 0xfa, 0x04,
+	0xe6, 0x22, 0x6e, 0x62, 0x53, 0x09, 0xb9, 0xe6, 0xaf, 0x16, 0x62, 0x2c, 0xee, 0xba, 0x76, 0x16,
+	0xea, 0x60, 0x18, 0xea, 0x05, 0xc9, 0x7d, 0x04, 0x60, 0x5a, 0xd9, 0x76, 0xbc, 0x00, 0xbe, 0x02,
+	0xf0, 0x1d, 0xb9, 0x88, 0xb0, 0xc8, 0xa6, 0xa5, 0xaf, 0xeb, 0xc8, 0x43, 0xd5, 0x91, 0xd9, 0xe4,
+	0x16, 0x93, 0xc1, 0x37, 0x6b, 0x46, 0x5e, 0x84, 0xca, 0x22, 0x13, 0xfb, 0xe9, 0x37, 0x00, 0x73,
+	0x56, 0x24, 0xd3, 0xff, 0xb7, 0x70, 0x02, 0x65, 0x7e, 0x3b, 0x88, 0x72, 0xc9, 0x85, 0x57, 0xdf,
+	0x88, 0x6a, 0xfb, 0x23, 0xd4, 0xdf, 0x7f, 0x33, 0xd1, 0x0e, 0x43, 0x1d, 0x25, 0xbb, 0x20, 0xa0,
+	0x4c, 0x4b, 0x6e, 0x7d, 0x51, 0x43, 0xa2, 0xae, 0x53, 0x00, 0x27, 0x1f, 0x4b, 0x79, 0xa3, 0x2d,
+	0x38, 0xa1, 0xda, 0x0d, 0x44, 0xde, 0xea, 0x0d, 0xf2, 0x36, 0x7c, 0x6e, 0xa9, 0x68, 0xf4, 0x11,
+	0x9c, 0x16, 0x72, 0x8e, 0x16, 0x8f, 0x48, 0x2a, 0xea, 0xc8, 0xd4, 0x17, 0x87, 0xa1, 0x3e, 0x9f,
+	0xd0, 0xff, 0xe8, 0xde, 0xb4, 0xa6, 0x62, 0xc3, 0x66, 0x74, 0x4e, 0xf0, 0xfb, 0x12, 0x4e, 0x3d,
+	0x1a, 0x90, 0x01, 0x71, 0xde, 0x32, 0xc9, 0xd5, 0xcc, 0xb1, 0x82, 0x6f, 0x51, 0x8e, 0x3d, 0x85,
+	0xce, 0xde, 0x32, 0xfc, 0xcf, 0x00, 0x16, 0x3f, 0x76, 0x19, 0xa7, 0x81, 0xdb, 0xc1, 0x9e, 0x45,
+	0x0e, 0x71, 0xe0, 0x30, 0xf4, 0x23, 0x80, 0xef, 0x76, 0x06, 0xbd, 0x81, 0x87, 0xb9, 0x7b, 0x40,
+	0xec, 0x81, 0xef, 0x72, 0x3b, 0x90, 0x77, 0xea, 0x63, 0xe1, 0xbf, 0x77, 0xfc, 0xae, 0x9a, 0xf5,
+	0xb2, 0xec, 0xe5, 0x15, 0x50, 0x37, 0x5e, 0xf3, 0xf3, 0x97, 0x40, 0xbb, 0xbe, 0xcb, 0x15, 0x5b,
+	0x59, 0xc9, 0xd2, 0xd7, 0x00, 0x66, 0xe3, 0xff, 0x52, 0xb4, 0x04, 0xe7, 0x9b, 0xdb, 0x6b, 0x3b,
+	0x76, 0xeb, 0xf3, 0xe6, 0xa6, 0xbd, 0xbb, 0xf3, 0xb8, 0xb9, 0xb9, 0xde, 0xd8, 0x6a, 0x6c, 0x6e,
+	0x14, 0x52, 0xa5, 0x99, 0x93, 0x53, 0x23, 0x1f, 0x3b, 0xee, 0xb8, 0x1e, 0xaa, 0xc0, 0xc2, 0xa5,
+	0x6f, 0x73, 0xb7, 0xbe, 0xdd, 0x58, 0x2f, 0x80, 0x12, 0x3a, 0x39, 0x35, 0xa6, 0x63, 0xb7, 0xe6,
+	0xa0, 0xed, 0xb9, 0x1d, 0xb4, 0x04, 0x8b, 0x09, 0x4f, 0xab, 0xf1, 0xe9, 0x5a, 0x6b, 0xb3, 0x90,
+	0x2e, 0xcd, 0x9e, 0x9c, 0x1a, 0x33, 0x23, 0x57, 0xf9, 0x4d, 0x53, 0xca, 0x1c, 0xff, 0x50, 0x4e,
+	0xd5, 0x1f, 0xbe, 0x3a, 0x2f, 0x83, 0xb3, 0xf3, 0x32, 0xf8, 0xf3, 0xbc, 0x0c, 0x9e, 0x5f, 0x94,
+	0x53, 0x67, 0x17, 0xe5, 0xd4, 0xef, 0x17, 0xe5, 0xd4, 0x17, 0xcb, 0x89, 0xc2, 0xc7, 0x7c, 0x5b,
+	0x3e, 0x1b, 0x3d, 0x89, 0x1e, 0xb4, 0x27, 0xc4, 0x5e, 0xff, 0xf0, 0xef, 0x00, 0x00, 0x00, 0xff,
+	0xff, 0xfd, 0xe1, 0xe0, 0x82, 0x88, 0x0a, 0x00, 0x00,
 }
 
 func (m *Params) Marshal() (dAtA []byte, err error) {
@@ -822,7 +822,7 @@ func (m *QueuedStaking) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *TotalStaking) Marshal() (dAtA []byte, err error) {
+func (m *TotalStakings) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -832,12 +832,12 @@ func (m *TotalStaking) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *TotalStaking) MarshalTo(dAtA []byte) (int, error) {
+func (m *TotalStakings) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *TotalStaking) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *TotalStakings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -1034,7 +1034,7 @@ func (m *QueuedStaking) Size() (n int) {
 	return n
 }
 
-func (m *TotalStaking) Size() (n int) {
+func (m *TotalStakings) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -2002,7 +2002,7 @@ func (m *QueuedStaking) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *TotalStaking) Unmarshal(dAtA []byte) error {
+func (m *TotalStakings) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -2025,10 +2025,10 @@ func (m *TotalStaking) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: TotalStaking: wiretype end group for non-group")
+			return fmt.Errorf("proto: TotalStakings: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: TotalStaking: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: TotalStakings: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
diff --git a/x/farming/types/keys.go b/x/farming/types/keys.go
index c2a75794..5dd362a5 100644
--- a/x/farming/types/keys.go
+++ b/x/farming/types/keys.go
@@ -67,7 +67,7 @@ func GetQueuedStakingByFarmerPrefix(farmerAcc sdk.AccAddress) []byte {
 	return append(QueuedStakingIndexKeyPrefix, address.MustLengthPrefix(farmerAcc)...)
 }
 
-func GetTotalStakingKey(stakingCoinDenom string) []byte {
+func GetTotalStakingsKey(stakingCoinDenom string) []byte {
 	return append(TotalStakingKeyPrefix, []byte(stakingCoinDenom)...)
 }
 
diff --git a/x/farming/types/msgs.go b/x/farming/types/msgs.go
index 105d9d35..87e43161 100644
--- a/x/farming/types/msgs.go
+++ b/x/farming/types/msgs.go
@@ -14,6 +14,7 @@ var (
 	_ sdk.Msg = (*MsgStake)(nil)
 	_ sdk.Msg = (*MsgUnstake)(nil)
 	_ sdk.Msg = (*MsgHarvest)(nil)
+	_ sdk.Msg = (*MsgAdvanceEpoch)(nil)
 )
 
 // Message types for the farming module
@@ -23,6 +24,7 @@ const (
 	TypeMsgStake                 = "stake"
 	TypeMsgUnstake               = "unstake"
 	TypeMsgHarvest               = "harvest"
+	TypeMsgAdvanceEpoch          = "advance_epoch"
 )
 
 // NewMsgCreateFixedAmountPlan creates a new MsgCreateFixedAmountPlan.
@@ -306,3 +308,33 @@ func (msg MsgHarvest) GetFarmer() sdk.AccAddress {
 	}
 	return addr
 }
+
+// NewMsgAdvanceEpoch creates a new MsgAdvanceEpoch.
+func NewMsgAdvanceEpoch(requesterAcc sdk.AccAddress) *MsgAdvanceEpoch {
+	return &MsgAdvanceEpoch{
+		Requester: requesterAcc.String(),
+	}
+}
+
+func (msg MsgAdvanceEpoch) Route() string { return RouterKey }
+
+func (msg MsgAdvanceEpoch) Type() string { return TypeMsgAdvanceEpoch }
+
+func (msg MsgAdvanceEpoch) ValidateBasic() error {
+	if _, err := sdk.AccAddressFromBech32(msg.Requester); err != nil {
+		return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid requester address %q: %v", msg.Requester, err)
+	}
+	return nil
+}
+
+func (msg MsgAdvanceEpoch) GetSignBytes() []byte {
+	return sdk.MustSortJSON(legacy.Cdc.MustMarshalJSON(&msg))
+}
+
+func (msg MsgAdvanceEpoch) GetSigners() []sdk.AccAddress {
+	addr, err := sdk.AccAddressFromBech32(msg.Requester)
+	if err != nil {
+		panic(err)
+	}
+	return []sdk.AccAddress{addr}
+}
diff --git a/x/farming/types/query.pb.go b/x/farming/types/query.pb.go
index 043ffd3d..7d33dc3c 100644
--- a/x/farming/types/query.pb.go
+++ b/x/farming/types/query.pb.go
@@ -7,6 +7,8 @@ import (
 	context "context"
 	fmt "fmt"
 	types "github.com/cosmos/cosmos-sdk/codec/types"
+	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
+	types1 "github.com/cosmos/cosmos-sdk/types"
 	query "github.com/cosmos/cosmos-sdk/types/query"
 	_ "github.com/gogo/protobuf/gogoproto"
 	grpc1 "github.com/gogo/protobuf/grpc"
@@ -342,6 +344,287 @@ func (m *QueryPlanResponse) GetPlan() *types.Any {
 	return nil
 }
 
+type QueryStakingsRequest struct {
+	Farmer           string `protobuf:"bytes,1,opt,name=farmer,proto3" json:"farmer,omitempty"`
+	StakingCoinDenom string `protobuf:"bytes,2,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty"`
+}
+
+func (m *QueryStakingsRequest) Reset()         { *m = QueryStakingsRequest{} }
+func (m *QueryStakingsRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryStakingsRequest) ProtoMessage()    {}
+func (*QueryStakingsRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_00c8db58c274b111, []int{6}
+}
+func (m *QueryStakingsRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryStakingsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryStakingsRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryStakingsRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryStakingsRequest.Merge(m, src)
+}
+func (m *QueryStakingsRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryStakingsRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryStakingsRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryStakingsRequest proto.InternalMessageInfo
+
+func (m *QueryStakingsRequest) GetFarmer() string {
+	if m != nil {
+		return m.Farmer
+	}
+	return ""
+}
+
+func (m *QueryStakingsRequest) GetStakingCoinDenom() string {
+	if m != nil {
+		return m.StakingCoinDenom
+	}
+	return ""
+}
+
+type QueryStakingsResponse struct {
+	StakedCoins github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,1,rep,name=staked_coins,json=stakedCoins,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"staked_coins"`
+	QueuedCoins github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=queued_coins,json=queuedCoins,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"queued_coins"`
+}
+
+func (m *QueryStakingsResponse) Reset()         { *m = QueryStakingsResponse{} }
+func (m *QueryStakingsResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryStakingsResponse) ProtoMessage()    {}
+func (*QueryStakingsResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_00c8db58c274b111, []int{7}
+}
+func (m *QueryStakingsResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryStakingsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryStakingsResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryStakingsResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryStakingsResponse.Merge(m, src)
+}
+func (m *QueryStakingsResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryStakingsResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryStakingsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryStakingsResponse proto.InternalMessageInfo
+
+func (m *QueryStakingsResponse) GetStakedCoins() github_com_cosmos_cosmos_sdk_types.Coins {
+	if m != nil {
+		return m.StakedCoins
+	}
+	return nil
+}
+
+func (m *QueryStakingsResponse) GetQueuedCoins() github_com_cosmos_cosmos_sdk_types.Coins {
+	if m != nil {
+		return m.QueuedCoins
+	}
+	return nil
+}
+
+type QueryTotalStakingsRequest struct {
+	StakingCoinDenom string `protobuf:"bytes,1,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty"`
+}
+
+func (m *QueryTotalStakingsRequest) Reset()         { *m = QueryTotalStakingsRequest{} }
+func (m *QueryTotalStakingsRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryTotalStakingsRequest) ProtoMessage()    {}
+func (*QueryTotalStakingsRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_00c8db58c274b111, []int{8}
+}
+func (m *QueryTotalStakingsRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryTotalStakingsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryTotalStakingsRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryTotalStakingsRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryTotalStakingsRequest.Merge(m, src)
+}
+func (m *QueryTotalStakingsRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryTotalStakingsRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryTotalStakingsRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryTotalStakingsRequest proto.InternalMessageInfo
+
+func (m *QueryTotalStakingsRequest) GetStakingCoinDenom() string {
+	if m != nil {
+		return m.StakingCoinDenom
+	}
+	return ""
+}
+
+type QueryTotalStakingsResponse struct {
+	Amount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount"`
+}
+
+func (m *QueryTotalStakingsResponse) Reset()         { *m = QueryTotalStakingsResponse{} }
+func (m *QueryTotalStakingsResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryTotalStakingsResponse) ProtoMessage()    {}
+func (*QueryTotalStakingsResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_00c8db58c274b111, []int{9}
+}
+func (m *QueryTotalStakingsResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryTotalStakingsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryTotalStakingsResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryTotalStakingsResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryTotalStakingsResponse.Merge(m, src)
+}
+func (m *QueryTotalStakingsResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryTotalStakingsResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryTotalStakingsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryTotalStakingsResponse proto.InternalMessageInfo
+
+type QueryRewardsRequest struct {
+	Farmer           string `protobuf:"bytes,1,opt,name=farmer,proto3" json:"farmer,omitempty"`
+	StakingCoinDenom string `protobuf:"bytes,2,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty"`
+}
+
+func (m *QueryRewardsRequest) Reset()         { *m = QueryRewardsRequest{} }
+func (m *QueryRewardsRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryRewardsRequest) ProtoMessage()    {}
+func (*QueryRewardsRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_00c8db58c274b111, []int{10}
+}
+func (m *QueryRewardsRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryRewardsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryRewardsRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryRewardsRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryRewardsRequest.Merge(m, src)
+}
+func (m *QueryRewardsRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryRewardsRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryRewardsRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryRewardsRequest proto.InternalMessageInfo
+
+func (m *QueryRewardsRequest) GetFarmer() string {
+	if m != nil {
+		return m.Farmer
+	}
+	return ""
+}
+
+func (m *QueryRewardsRequest) GetStakingCoinDenom() string {
+	if m != nil {
+		return m.StakingCoinDenom
+	}
+	return ""
+}
+
+type QueryRewardsResponse struct {
+	Rewards github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,1,rep,name=rewards,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"rewards"`
+}
+
+func (m *QueryRewardsResponse) Reset()         { *m = QueryRewardsResponse{} }
+func (m *QueryRewardsResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryRewardsResponse) ProtoMessage()    {}
+func (*QueryRewardsResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_00c8db58c274b111, []int{11}
+}
+func (m *QueryRewardsResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryRewardsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryRewardsResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryRewardsResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryRewardsResponse.Merge(m, src)
+}
+func (m *QueryRewardsResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryRewardsResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryRewardsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryRewardsResponse proto.InternalMessageInfo
+
+func (m *QueryRewardsResponse) GetRewards() github_com_cosmos_cosmos_sdk_types.Coins {
+	if m != nil {
+		return m.Rewards
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*QueryParamsRequest)(nil), "cosmos.farming.v1beta1.QueryParamsRequest")
 	proto.RegisterType((*QueryParamsResponse)(nil), "cosmos.farming.v1beta1.QueryParamsResponse")
@@ -349,6 +632,12 @@ func init() {
 	proto.RegisterType((*QueryPlansResponse)(nil), "cosmos.farming.v1beta1.QueryPlansResponse")
 	proto.RegisterType((*QueryPlanRequest)(nil), "cosmos.farming.v1beta1.QueryPlanRequest")
 	proto.RegisterType((*QueryPlanResponse)(nil), "cosmos.farming.v1beta1.QueryPlanResponse")
+	proto.RegisterType((*QueryStakingsRequest)(nil), "cosmos.farming.v1beta1.QueryStakingsRequest")
+	proto.RegisterType((*QueryStakingsResponse)(nil), "cosmos.farming.v1beta1.QueryStakingsResponse")
+	proto.RegisterType((*QueryTotalStakingsRequest)(nil), "cosmos.farming.v1beta1.QueryTotalStakingsRequest")
+	proto.RegisterType((*QueryTotalStakingsResponse)(nil), "cosmos.farming.v1beta1.QueryTotalStakingsResponse")
+	proto.RegisterType((*QueryRewardsRequest)(nil), "cosmos.farming.v1beta1.QueryRewardsRequest")
+	proto.RegisterType((*QueryRewardsResponse)(nil), "cosmos.farming.v1beta1.QueryRewardsResponse")
 }
 
 func init() {
@@ -356,46 +645,65 @@ func init() {
 }
 
 var fileDescriptor_00c8db58c274b111 = []byte{
-	// 623 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0x41, 0x6f, 0x12, 0x41,
-	0x14, 0x66, 0xe9, 0x82, 0xe9, 0xf4, 0x52, 0xa7, 0x44, 0x57, 0xa2, 0xdb, 0x66, 0x13, 0x5b, 0xa0,
-	0x76, 0xc7, 0xd2, 0x78, 0xf3, 0x52, 0x34, 0xd6, 0xde, 0xea, 0x7a, 0xf3, 0x42, 0x06, 0x76, 0xba,
-	0x6e, 0x84, 0x99, 0x2d, 0xb3, 0x18, 0x89, 0xf1, 0x62, 0xe2, 0xc1, 0xc4, 0x83, 0x89, 0xfe, 0x00,
-	0xcf, 0x9e, 0xfd, 0x11, 0x8d, 0xa7, 0x26, 0x5e, 0x3c, 0x19, 0x03, 0xfe, 0x10, 0x33, 0x6f, 0x66,
-	0x29, 0xa4, 0x2d, 0x70, 0x62, 0xf6, 0xbd, 0xef, 0x7d, 0xef, 0x9b, 0xf7, 0xbe, 0x01, 0x6d, 0xa6,
-	0x8c, 0x87, 0xac, 0xd7, 0x8d, 0x79, 0x4a, 0x8e, 0xa9, 0xfa, 0x8d, 0xc8, 0xeb, 0xdd, 0x16, 0x4b,
-	0xe9, 0x2e, 0x39, 0xe9, 0xb3, 0xde, 0xc0, 0x4f, 0x7a, 0x22, 0x15, 0xf8, 0x46, 0x5b, 0xc8, 0xae,
-	0x90, 0xbe, 0xc1, 0xf8, 0x06, 0x53, 0xae, 0xcc, 0xa8, 0xcf, 0xb0, 0xc0, 0x50, 0xae, 0x69, 0x06,
-	0xd2, 0xa2, 0x92, 0x69, 0xea, 0x31, 0x30, 0xa1, 0x51, 0xcc, 0x69, 0x1a, 0x0b, 0x6e, 0xb0, 0xa5,
-	0x48, 0x44, 0x02, 0x8e, 0x44, 0x9d, 0x4c, 0xf4, 0x56, 0x24, 0x44, 0xd4, 0x61, 0x04, 0xbe, 0x5a,
-	0xfd, 0x63, 0x42, 0xb9, 0x91, 0x57, 0xbe, 0x6d, 0x52, 0x34, 0x89, 0x09, 0xe5, 0x5c, 0xa4, 0xc0,
-	0x26, 0xb3, 0x42, 0xdd, 0xba, 0xa9, 0x19, 0xcd, 0x4d, 0xe0, 0xc3, 0x2b, 0x21, 0xfc, 0x4c, 0x69,
-	0x39, 0xa2, 0x3d, 0xda, 0x95, 0x01, 0x3b, 0xe9, 0x33, 0x99, 0x7a, 0xcf, 0xd1, 0xda, 0x54, 0x54,
-	0x26, 0x82, 0x4b, 0x86, 0x1f, 0xa2, 0x62, 0x02, 0x11, 0xc7, 0xda, 0xb0, 0x2a, 0x2b, 0x75, 0xd7,
-	0xbf, 0x7c, 0x2a, 0xbe, 0xae, 0x6b, 0xd8, 0xa7, 0x7f, 0xd6, 0x73, 0x81, 0xa9, 0xf1, 0xbe, 0xe5,
-	0xd1, 0x75, 0xcd, 0xda, 0xa1, 0x3c, 0x6b, 0x85, 0x31, 0xb2, 0xd3, 0x41, 0xc2, 0x80, 0x71, 0x39,
-	0x80, 0x33, 0xbe, 0x8f, 0x4a, 0x86, 0xb1, 0x99, 0x08, 0xd1, 0x69, 0xd2, 0x30, 0xec, 0x31, 0x29,
-	0x9d, 0x3c, 0x60, 0xb0, 0xc9, 0x1d, 0x09, 0xd1, 0xd9, 0xd7, 0x19, 0x4c, 0xd0, 0x5a, 0x0a, 0x5b,
-	0x80, 0x7b, 0x8f, 0x0b, 0x96, 0x74, 0xc1, 0x44, 0x2a, 0x2b, 0xb8, 0x87, 0xb0, 0x4c, 0xe9, 0x2b,
-	0xd5, 0xa2, 0x2d, 0x62, 0xde, 0x0c, 0x19, 0x17, 0x5d, 0xc7, 0x06, 0xfc, 0xaa, 0xc9, 0x3c, 0x12,
-	0x31, 0x7f, 0xac, 0xe2, 0xd8, 0x45, 0x28, 0xe3, 0x60, 0xa1, 0x53, 0x00, 0xd4, 0x44, 0x04, 0x3f,
-	0x41, 0xe8, 0x7c, 0x87, 0x4e, 0x11, 0x86, 0xb3, 0x99, 0x0d, 0x47, 0x2d, 0xdc, 0xd7, 0x5e, 0x3a,
-	0x9f, 0x4f, 0xc4, 0xcc, 0x00, 0x82, 0x89, 0x4a, 0xef, 0xab, 0x95, 0xad, 0x43, 0x8f, 0xc8, 0xcc,
-	0xfd, 0x01, 0x2a, 0x24, 0x2a, 0xe0, 0x58, 0x1b, 0x4b, 0x95, 0x95, 0x7a, 0xc9, 0xd7, 0xdb, 0xf6,
-	0x33, 0x23, 0xf8, 0xfb, 0x7c, 0xd0, 0x58, 0xfe, 0xf9, 0x63, 0xa7, 0xa0, 0xea, 0x0e, 0x03, 0x8d,
-	0xc6, 0x07, 0x53, 0xaa, 0xf2, 0xa0, 0x6a, 0x6b, 0xae, 0x2a, 0xdd, 0x73, 0x4a, 0xd6, 0x36, 0x5a,
-	0x1d, 0xab, 0xca, 0xf6, 0x76, 0x13, 0x5d, 0x53, 0x5d, 0x9a, 0x71, 0x08, 0xab, 0xb3, 0x83, 0xa2,
-	0xfa, 0x3c, 0x0c, 0xbd, 0xa7, 0x13, 0x5b, 0x1e, 0xdf, 0x60, 0x0f, 0xd9, 0x2a, 0x6d, 0x7c, 0x33,
-	0xf7, 0x02, 0x00, 0xae, 0x7f, 0x5f, 0x42, 0x05, 0xa0, 0xc2, 0x1f, 0x2d, 0x54, 0xd4, 0x9e, 0xc2,
-	0xb5, 0xab, 0x3c, 0x77, 0xd1, 0xc6, 0xe5, 0xed, 0x85, 0xb0, 0x5a, 0xa2, 0xb7, 0xf9, 0xfe, 0xd7,
-	0xbf, 0x2f, 0xf9, 0x0d, 0xec, 0x9a, 0x07, 0x72, 0xe1, 0x39, 0x6b, 0x1b, 0xe3, 0x0f, 0x16, 0x02,
-	0x95, 0x12, 0x57, 0x67, 0xd3, 0x4f, 0xb8, 0xbc, 0x5c, 0x5b, 0x04, 0x6a, 0x84, 0xdc, 0x05, 0x21,
-	0xeb, 0xf8, 0xce, 0x95, 0x42, 0xa0, 0xfb, 0x27, 0x0b, 0xd9, 0xaa, 0x10, 0x57, 0xe6, 0x72, 0x67,
-	0x2a, 0xaa, 0x0b, 0x20, 0x8d, 0x08, 0x02, 0x22, 0xaa, 0x78, 0x6b, 0xa6, 0x08, 0xf2, 0xd6, 0x78,
-	0xe0, 0x5d, 0xe3, 0xe0, 0x74, 0xe8, 0x5a, 0x67, 0x43, 0xd7, 0xfa, 0x3b, 0x74, 0xad, 0xcf, 0x23,
-	0x37, 0x77, 0x36, 0x72, 0x73, 0xbf, 0x47, 0x6e, 0xee, 0xc5, 0x4e, 0x14, 0xa7, 0x2f, 0xfb, 0x2d,
-	0xbf, 0x2d, 0xba, 0xe4, 0x92, 0x7f, 0xcb, 0x37, 0xe3, 0x93, 0x7a, 0xfb, 0xb2, 0x55, 0x04, 0x53,
-	0xec, 0xfd, 0x0f, 0x00, 0x00, 0xff, 0xff, 0x5c, 0xa7, 0x38, 0xa5, 0x9a, 0x05, 0x00, 0x00,
+	// 918 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcd, 0x6f, 0x1b, 0x45,
+	0x14, 0xcf, 0xba, 0x8e, 0x43, 0x5f, 0x40, 0x2a, 0x53, 0x53, 0x9c, 0x15, 0x6c, 0xa2, 0x95, 0x48,
+	0x9d, 0xaf, 0xdd, 0x24, 0x15, 0x27, 0xe0, 0x50, 0x17, 0xb5, 0xe4, 0x56, 0xb6, 0x9c, 0x00, 0xc9,
+	0x1a, 0x67, 0xa7, 0x66, 0x55, 0x7b, 0x67, 0xb3, 0xb3, 0x06, 0xa2, 0x2a, 0x17, 0x24, 0x0e, 0x48,
+	0x1c, 0x90, 0x40, 0x1c, 0x38, 0x20, 0xce, 0x9c, 0xb9, 0xf1, 0x0f, 0x54, 0x9c, 0x2a, 0x71, 0x41,
+	0x1c, 0x0a, 0x4a, 0xf8, 0x1f, 0xb8, 0xa2, 0x79, 0xf3, 0x66, 0x63, 0xbb, 0xb6, 0x63, 0xa4, 0xf6,
+	0xe4, 0xf9, 0x78, 0xef, 0xf7, 0x7e, 0xf3, 0x7b, 0x1f, 0x6b, 0x58, 0x2f, 0x44, 0x1a, 0x8b, 0xbc,
+	0x9f, 0xa4, 0x45, 0x78, 0x9f, 0xeb, 0xdf, 0x6e, 0xf8, 0xe9, 0x5e, 0x47, 0x14, 0x7c, 0x2f, 0x3c,
+	0x1a, 0x88, 0xfc, 0x38, 0xc8, 0x72, 0x59, 0x48, 0x76, 0xed, 0x50, 0xaa, 0xbe, 0x54, 0x01, 0xd9,
+	0x04, 0x64, 0xe3, 0x36, 0x67, 0xf8, 0x5b, 0x5b, 0x44, 0x70, 0x37, 0x0d, 0x42, 0xd8, 0xe1, 0x4a,
+	0x18, 0xe8, 0xd2, 0x30, 0xe3, 0xdd, 0x24, 0xe5, 0x45, 0x22, 0x53, 0xb2, 0xad, 0x77, 0x65, 0x57,
+	0xe2, 0x32, 0xd4, 0x2b, 0x3a, 0x5d, 0xe9, 0x4a, 0xd9, 0xed, 0x89, 0x10, 0x77, 0x9d, 0xc1, 0xfd,
+	0x90, 0xa7, 0x44, 0xcf, 0x7d, 0x8d, 0xae, 0x78, 0x96, 0x84, 0x3c, 0x4d, 0x65, 0x81, 0x68, 0xca,
+	0x3a, 0x9a, 0xd0, 0x6d, 0x83, 0x48, 0x2f, 0x31, 0x57, 0xde, 0x30, 0x2b, 0xcb, 0xe7, 0x50, 0x26,
+	0xc4, 0xc4, 0xaf, 0x03, 0x7b, 0x5f, 0x73, 0xbd, 0xcb, 0x73, 0xde, 0x57, 0x91, 0x38, 0x1a, 0x08,
+	0x55, 0xf8, 0xf7, 0xe0, 0xea, 0xc8, 0xa9, 0xca, 0x64, 0xaa, 0x04, 0x7b, 0x1b, 0x6a, 0x19, 0x9e,
+	0x34, 0x9c, 0x35, 0xa7, 0xb9, 0xbc, 0xef, 0x05, 0x93, 0x55, 0x0b, 0x8c, 0x5f, 0xab, 0xfa, 0xe8,
+	0xc9, 0xea, 0x42, 0x44, 0x3e, 0xfe, 0x4f, 0x15, 0x78, 0xd9, 0xa0, 0xf6, 0x78, 0x6a, 0x43, 0x31,
+	0x06, 0xd5, 0xe2, 0x38, 0x13, 0x88, 0x78, 0x39, 0xc2, 0x35, 0xdb, 0x85, 0x3a, 0x21, 0xb6, 0x33,
+	0x29, 0x7b, 0x6d, 0x1e, 0xc7, 0xb9, 0x50, 0xaa, 0x51, 0x41, 0x1b, 0x46, 0x77, 0x77, 0xa5, 0xec,
+	0xdd, 0x34, 0x37, 0x2c, 0x84, 0xab, 0x05, 0x66, 0x09, 0x75, 0x29, 0x1d, 0x2e, 0x19, 0x87, 0xa1,
+	0x2b, 0xeb, 0xb0, 0x0d, 0x4c, 0x15, 0xfc, 0x81, 0x0e, 0xa1, 0xd5, 0x68, 0xc7, 0x22, 0x95, 0xfd,
+	0x46, 0x15, 0xed, 0xaf, 0xd0, 0xcd, 0x2d, 0x99, 0xa4, 0xef, 0xea, 0x73, 0xe6, 0x01, 0x58, 0x0c,
+	0x11, 0x37, 0x16, 0xd1, 0x6a, 0xe8, 0x84, 0xdd, 0x06, 0x38, 0xcf, 0x71, 0xa3, 0x86, 0xe2, 0xac,
+	0x5b, 0x71, 0xb4, 0xf4, 0x81, 0xa9, 0xb5, 0x73, 0x7d, 0xba, 0x82, 0x04, 0x88, 0x86, 0x3c, 0xfd,
+	0xef, 0x1c, 0x9b, 0x0e, 0x23, 0x11, 0xe9, 0xfe, 0x26, 0x2c, 0x66, 0xfa, 0xa0, 0xe1, 0xac, 0x5d,
+	0x6a, 0x2e, 0xef, 0xd7, 0x03, 0x53, 0x0d, 0x81, 0x2d, 0x94, 0xe0, 0x66, 0x7a, 0xdc, 0xba, 0xfc,
+	0xdb, 0x2f, 0x3b, 0x8b, 0xda, 0xef, 0x20, 0x32, 0xd6, 0xec, 0xce, 0x08, 0xab, 0x0a, 0xb2, 0xba,
+	0x7e, 0x21, 0x2b, 0x13, 0x73, 0x84, 0xd6, 0x16, 0x5c, 0x29, 0x59, 0xd9, 0xbc, 0xbd, 0x0a, 0x4b,
+	0x3a, 0x4a, 0x3b, 0x89, 0x31, 0x75, 0xd5, 0xa8, 0xa6, 0xb7, 0x07, 0xb1, 0xff, 0xde, 0x50, 0x96,
+	0xcb, 0x17, 0xdc, 0x80, 0xaa, 0xbe, 0xa6, 0xba, 0xb9, 0xf0, 0x01, 0x68, 0xec, 0x7f, 0x0c, 0x75,
+	0x44, 0xba, 0x67, 0xd2, 0x51, 0x96, 0xcc, 0x35, 0xa8, 0xe9, 0x12, 0x10, 0x39, 0x15, 0x0d, 0xed,
+	0xa6, 0xe4, 0xb4, 0x32, 0x39, 0xa7, 0xfe, 0xbf, 0x0e, 0xbc, 0x32, 0x06, 0x4f, 0x64, 0x53, 0x78,
+	0x51, 0x5b, 0x8b, 0x18, 0x61, 0xac, 0xea, 0x2b, 0x23, 0xca, 0x59, 0xcd, 0x34, 0x5e, 0x6b, 0x57,
+	0xd7, 0xf9, 0xcf, 0x7f, 0xad, 0x36, 0xbb, 0x49, 0xf1, 0xc9, 0xa0, 0x13, 0x1c, 0xca, 0x3e, 0x75,
+	0x21, 0xfd, 0xec, 0xa8, 0xf8, 0x41, 0xa8, 0x4b, 0x5b, 0xa1, 0x83, 0x8a, 0x96, 0x4d, 0x00, 0xdc,
+	0xe8, 0x78, 0x47, 0x03, 0x31, 0x28, 0xe3, 0x55, 0x9e, 0x43, 0x3c, 0x13, 0x00, 0x37, 0xfe, 0x01,
+	0xac, 0xe0, 0xc3, 0x3f, 0x90, 0x05, 0xef, 0x8d, 0x8b, 0x3b, 0x59, 0x44, 0x67, 0x8a, 0x88, 0x31,
+	0xb8, 0x93, 0xa0, 0x48, 0xc8, 0xdb, 0x50, 0xe3, 0x7d, 0x39, 0x48, 0x0b, 0xe3, 0xdf, 0x0a, 0x34,
+	0xef, 0x3f, 0x9f, 0xac, 0xae, 0xcf, 0xc1, 0xfb, 0x20, 0x2d, 0x22, 0xf2, 0xf6, 0x3f, 0xa2, 0x71,
+	0x14, 0x89, 0xcf, 0x78, 0x1e, 0x3f, 0xe3, 0x3a, 0x38, 0xa1, 0x2a, 0x2b, 0xc1, 0x89, 0xbc, 0x80,
+	0xa5, 0xdc, 0x1c, 0x3d, 0x8f, 0x02, 0xb0, 0xd8, 0xfb, 0x3f, 0x2e, 0xc1, 0x22, 0xc6, 0x67, 0x5f,
+	0x39, 0x50, 0x33, 0x83, 0x93, 0x6d, 0x4e, 0x1b, 0xac, 0x4f, 0xcf, 0x6a, 0x77, 0x6b, 0x2e, 0x5b,
+	0xf3, 0x28, 0x7f, 0xfd, 0x8b, 0xdf, 0xff, 0xf9, 0xb6, 0xb2, 0xc6, 0x3c, 0x4b, 0x6f, 0xfc, 0x9b,
+	0x66, 0x66, 0x35, 0xfb, 0xd2, 0x01, 0x6c, 0x45, 0xc5, 0x36, 0x66, 0xc3, 0x0f, 0x8d, 0x72, 0x77,
+	0x73, 0x1e, 0x53, 0x22, 0xf2, 0x06, 0x12, 0x59, 0x65, 0xaf, 0x4f, 0x25, 0x82, 0xd1, 0xbf, 0x76,
+	0xa0, 0xaa, 0x1d, 0x59, 0xf3, 0x42, 0x6c, 0xcb, 0x62, 0x63, 0x0e, 0x4b, 0x22, 0x11, 0x22, 0x89,
+	0x0d, 0x76, 0x7d, 0x26, 0x89, 0xf0, 0x21, 0x0d, 0xba, 0x13, 0xf6, 0x83, 0x03, 0x2f, 0xd8, 0x2a,
+	0x67, 0xdb, 0x33, 0x03, 0x8d, 0xf5, 0x95, 0xbb, 0x33, 0xa7, 0x35, 0x51, 0xdb, 0x43, 0x6a, 0x5b,
+	0x6c, 0x63, 0x1a, 0x35, 0xaa, 0x63, 0x15, 0x3e, 0x34, 0x55, 0x7f, 0xc2, 0x7e, 0x75, 0xe0, 0xa5,
+	0x91, 0x3e, 0x64, 0x7b, 0x33, 0x63, 0x4e, 0x6a, 0x7f, 0x77, 0xff, 0xff, 0xb8, 0x10, 0xd7, 0x5b,
+	0xc8, 0xf5, 0x1d, 0xf6, 0xd6, 0x34, 0xae, 0x85, 0x76, 0x6b, 0x9f, 0x33, 0x7e, 0xba, 0x3b, 0x4f,
+	0xd8, 0xf7, 0x0e, 0x2c, 0x51, 0x0b, 0xb2, 0xd9, 0x25, 0x3d, 0x3a, 0x05, 0xdc, 0xed, 0xf9, 0x8c,
+	0x89, 0xeb, 0x2e, 0x72, 0xdd, 0x64, 0xcd, 0x69, 0x5c, 0xa9, 0x2f, 0x4b, 0x59, 0x5b, 0x77, 0x1e,
+	0x9d, 0x7a, 0xce, 0xe3, 0x53, 0xcf, 0xf9, 0xfb, 0xd4, 0x73, 0xbe, 0x39, 0xf3, 0x16, 0x1e, 0x9f,
+	0x79, 0x0b, 0x7f, 0x9c, 0x79, 0x0b, 0x1f, 0xee, 0x0c, 0x75, 0xfb, 0x84, 0xbf, 0x89, 0x9f, 0x97,
+	0x2b, 0x6c, 0xfc, 0x4e, 0x0d, 0xbf, 0x76, 0x37, 0xfe, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x8a, 0xd0,
+	0x8c, 0x18, 0x93, 0x0a, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -416,6 +724,9 @@ type QueryClient interface {
 	Plans(ctx context.Context, in *QueryPlansRequest, opts ...grpc.CallOption) (*QueryPlansResponse, error)
 	// Plan returns a specific plan.
 	Plan(ctx context.Context, in *QueryPlanRequest, opts ...grpc.CallOption) (*QueryPlanResponse, error)
+	Stakings(ctx context.Context, in *QueryStakingsRequest, opts ...grpc.CallOption) (*QueryStakingsResponse, error)
+	TotalStakings(ctx context.Context, in *QueryTotalStakingsRequest, opts ...grpc.CallOption) (*QueryTotalStakingsResponse, error)
+	Rewards(ctx context.Context, in *QueryRewardsRequest, opts ...grpc.CallOption) (*QueryRewardsResponse, error)
 }
 
 type queryClient struct {
@@ -453,6 +764,33 @@ func (c *queryClient) Plan(ctx context.Context, in *QueryPlanRequest, opts ...gr
 	return out, nil
 }
 
+func (c *queryClient) Stakings(ctx context.Context, in *QueryStakingsRequest, opts ...grpc.CallOption) (*QueryStakingsResponse, error) {
+	out := new(QueryStakingsResponse)
+	err := c.cc.Invoke(ctx, "/cosmos.farming.v1beta1.Query/Stakings", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) TotalStakings(ctx context.Context, in *QueryTotalStakingsRequest, opts ...grpc.CallOption) (*QueryTotalStakingsResponse, error) {
+	out := new(QueryTotalStakingsResponse)
+	err := c.cc.Invoke(ctx, "/cosmos.farming.v1beta1.Query/TotalStakings", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) Rewards(ctx context.Context, in *QueryRewardsRequest, opts ...grpc.CallOption) (*QueryRewardsResponse, error) {
+	out := new(QueryRewardsResponse)
+	err := c.cc.Invoke(ctx, "/cosmos.farming.v1beta1.Query/Rewards", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // QueryServer is the server API for Query service.
 type QueryServer interface {
 	// Params returns parameters of the farming module.
@@ -461,6 +799,9 @@ type QueryServer interface {
 	Plans(context.Context, *QueryPlansRequest) (*QueryPlansResponse, error)
 	// Plan returns a specific plan.
 	Plan(context.Context, *QueryPlanRequest) (*QueryPlanResponse, error)
+	Stakings(context.Context, *QueryStakingsRequest) (*QueryStakingsResponse, error)
+	TotalStakings(context.Context, *QueryTotalStakingsRequest) (*QueryTotalStakingsResponse, error)
+	Rewards(context.Context, *QueryRewardsRequest) (*QueryRewardsResponse, error)
 }
 
 // UnimplementedQueryServer can be embedded to have forward compatible implementations.
@@ -476,6 +817,15 @@ func (*UnimplementedQueryServer) Plans(ctx context.Context, req *QueryPlansReque
 func (*UnimplementedQueryServer) Plan(ctx context.Context, req *QueryPlanRequest) (*QueryPlanResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Plan not implemented")
 }
+func (*UnimplementedQueryServer) Stakings(ctx context.Context, req *QueryStakingsRequest) (*QueryStakingsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Stakings not implemented")
+}
+func (*UnimplementedQueryServer) TotalStakings(ctx context.Context, req *QueryTotalStakingsRequest) (*QueryTotalStakingsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method TotalStakings not implemented")
+}
+func (*UnimplementedQueryServer) Rewards(ctx context.Context, req *QueryRewardsRequest) (*QueryRewardsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Rewards not implemented")
+}
 
 func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
 	s.RegisterService(&_Query_serviceDesc, srv)
@@ -535,6 +885,60 @@ func _Query_Plan_Handler(srv interface{}, ctx context.Context, dec func(interfac
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Query_Stakings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryStakingsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).Stakings(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/cosmos.farming.v1beta1.Query/Stakings",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).Stakings(ctx, req.(*QueryStakingsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_TotalStakings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryTotalStakingsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).TotalStakings(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/cosmos.farming.v1beta1.Query/TotalStakings",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).TotalStakings(ctx, req.(*QueryTotalStakingsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_Rewards_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryRewardsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).Rewards(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/cosmos.farming.v1beta1.Query/Rewards",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).Rewards(ctx, req.(*QueryRewardsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Query_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "cosmos.farming.v1beta1.Query",
 	HandlerType: (*QueryServer)(nil),
@@ -551,6 +955,18 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 			MethodName: "Plan",
 			Handler:    _Query_Plan_Handler,
 		},
+		{
+			MethodName: "Stakings",
+			Handler:    _Query_Stakings_Handler,
+		},
+		{
+			MethodName: "TotalStakings",
+			Handler:    _Query_TotalStakings_Handler,
+		},
+		{
+			MethodName: "Rewards",
+			Handler:    _Query_Rewards_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "tendermint/farming/v1beta1/query.proto",
@@ -794,23 +1210,248 @@ func (m *QueryPlanResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
-	offset -= sovQuery(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
+func (m *QueryStakingsRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
 	}
-	dAtA[offset] = uint8(v)
-	return base
+	return dAtA[:n], nil
 }
-func (m *QueryParamsRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
+
+func (m *QueryStakingsRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryStakingsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.StakingCoinDenom) > 0 {
+		i -= len(m.StakingCoinDenom)
+		copy(dAtA[i:], m.StakingCoinDenom)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.StakingCoinDenom)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Farmer) > 0 {
+		i -= len(m.Farmer)
+		copy(dAtA[i:], m.Farmer)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.Farmer)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryStakingsResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryStakingsResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryStakingsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.QueuedCoins) > 0 {
+		for iNdEx := len(m.QueuedCoins) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.QueuedCoins[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintQuery(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x12
+		}
+	}
+	if len(m.StakedCoins) > 0 {
+		for iNdEx := len(m.StakedCoins) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.StakedCoins[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintQuery(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryTotalStakingsRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryTotalStakingsRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryTotalStakingsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.StakingCoinDenom) > 0 {
+		i -= len(m.StakingCoinDenom)
+		copy(dAtA[i:], m.StakingCoinDenom)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.StakingCoinDenom)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryTotalStakingsResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryTotalStakingsResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryTotalStakingsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size := m.Amount.Size()
+		i -= size
+		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintQuery(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryRewardsRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryRewardsRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryRewardsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.StakingCoinDenom) > 0 {
+		i -= len(m.StakingCoinDenom)
+		copy(dAtA[i:], m.StakingCoinDenom)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.StakingCoinDenom)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Farmer) > 0 {
+		i -= len(m.Farmer)
+		copy(dAtA[i:], m.Farmer)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.Farmer)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryRewardsResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryRewardsResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryRewardsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Rewards) > 0 {
+		for iNdEx := len(m.Rewards) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Rewards[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintQuery(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
+	offset -= sovQuery(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *QueryParamsRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
 	return n
 }
 
@@ -870,45 +1511,518 @@ func (m *QueryPlansResponse) Size() (n int) {
 			n += 1 + l + sovQuery(uint64(l))
 		}
 	}
-	if m.Pagination != nil {
-		l = m.Pagination.Size()
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	return n
-}
-
-func (m *QueryPlanRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.PlanId != 0 {
-		n += 1 + sovQuery(uint64(m.PlanId))
-	}
-	return n
-}
+	if m.Pagination != nil {
+		l = m.Pagination.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryPlanRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.PlanId != 0 {
+		n += 1 + sovQuery(uint64(m.PlanId))
+	}
+	return n
+}
+
+func (m *QueryPlanResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Plan != nil {
+		l = m.Plan.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryStakingsRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Farmer)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	l = len(m.StakingCoinDenom)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryStakingsResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.StakedCoins) > 0 {
+		for _, e := range m.StakedCoins {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	if len(m.QueuedCoins) > 0 {
+		for _, e := range m.QueuedCoins {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *QueryTotalStakingsRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.StakingCoinDenom)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryTotalStakingsResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.Amount.Size()
+	n += 1 + l + sovQuery(uint64(l))
+	return n
+}
+
+func (m *QueryRewardsRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Farmer)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	l = len(m.StakingCoinDenom)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryRewardsResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Rewards) > 0 {
+		for _, e := range m.Rewards {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	return n
+}
+
+func sovQuery(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozQuery(x uint64) (n int) {
+	return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryParamsResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryPlansRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryPlansRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryPlansRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Type = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field FarmingPoolAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.FarmingPoolAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TerminationAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.TerminationAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StakingCoinDenom", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.StakingCoinDenom = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Terminated", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Terminated = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageRequest{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
 
-func (m *QueryPlanResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.Plan != nil {
-		l = m.Plan.Size()
-		n += 1 + l + sovQuery(uint64(l))
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
 	}
-	return n
-}
-
-func sovQuery(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozQuery(x uint64) (n int) {
-	return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+	return nil
 }
-func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryPlansResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -931,12 +2045,82 @@ func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryPlansResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryPlansResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Plans", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Plans = append(m.Plans, &types.Any{})
+			if err := m.Plans[len(m.Plans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageResponse{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -958,7 +2142,7 @@ func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryPlanRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -981,17 +2165,17 @@ func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryParamsResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryPlanRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryPlanRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PlanId", wireType)
 			}
-			var msglen int
+			m.PlanId = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -1001,25 +2185,11 @@ func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.PlanId |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -1041,7 +2211,7 @@ func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryPlansRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryPlanResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -1064,17 +2234,17 @@ func (m *QueryPlansRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryPlansRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryPlanResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryPlansRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryPlanResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Plan", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -1084,27 +2254,81 @@ func (m *QueryPlansRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Type = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
+			if m.Plan == nil {
+				m.Plan = &types.Any{}
+			}
+			if err := m.Plan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryStakingsRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryStakingsRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryStakingsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field FarmingPoolAddress", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Farmer", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -1132,11 +2356,11 @@ func (m *QueryPlansRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.FarmingPoolAddress = string(dAtA[iNdEx:postIndex])
+			m.Farmer = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 3:
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TerminationAddress", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field StakingCoinDenom", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -1164,45 +2388,63 @@ func (m *QueryPlansRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.TerminationAddress = string(dAtA[iNdEx:postIndex])
+			m.StakingCoinDenom = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StakingCoinDenom", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
 			}
-			if postIndex > l {
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryStakingsResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
 				return io.ErrUnexpectedEOF
 			}
-			m.StakingCoinDenom = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 5:
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryStakingsResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryStakingsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Terminated", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field StakedCoins", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -1212,27 +2454,29 @@ func (m *QueryPlansRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Terminated = string(dAtA[iNdEx:postIndex])
+			m.StakedCoins = append(m.StakedCoins, types1.Coin{})
+			if err := m.StakedCoins[len(m.StakedCoins)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
-		case 6:
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field QueuedCoins", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -1259,10 +2503,8 @@ func (m *QueryPlansRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageRequest{}
-			}
-			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.QueuedCoins = append(m.QueuedCoins, types1.Coin{})
+			if err := m.QueuedCoins[len(m.QueuedCoins)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -1287,7 +2529,7 @@ func (m *QueryPlansRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryPlansResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryTotalStakingsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -1310,17 +2552,17 @@ func (m *QueryPlansResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryPlansResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryTotalStakingsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryPlansResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryTotalStakingsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Plans", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field StakingCoinDenom", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -1330,31 +2572,79 @@ func (m *QueryPlansResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Plans = append(m.Plans, &types.Any{})
-			if err := m.Plans[len(m.Plans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.StakingCoinDenom = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
 				return err
 			}
-			iNdEx = postIndex
-		case 2:
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryTotalStakingsResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryTotalStakingsResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryTotalStakingsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -1364,25 +2654,23 @@ func (m *QueryPlansResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageResponse{}
-			}
-			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -1407,7 +2695,7 @@ func (m *QueryPlansResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryPlanRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryRewardsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -1430,17 +2718,17 @@ func (m *QueryPlanRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryPlanRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryRewardsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryPlanRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryRewardsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PlanId", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Farmer", wireType)
 			}
-			m.PlanId = 0
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -1450,11 +2738,56 @@ func (m *QueryPlanRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.PlanId |= uint64(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Farmer = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StakingCoinDenom", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.StakingCoinDenom = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -1476,7 +2809,7 @@ func (m *QueryPlanRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryPlanResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryRewardsResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -1499,15 +2832,15 @@ func (m *QueryPlanResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryPlanResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryRewardsResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryPlanResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryRewardsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Plan", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Rewards", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -1534,10 +2867,8 @@ func (m *QueryPlanResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Plan == nil {
-				m.Plan = &types.Any{}
-			}
-			if err := m.Plan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Rewards = append(m.Rewards, types1.Coin{})
+			if err := m.Rewards[len(m.Rewards)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
diff --git a/x/farming/types/query.pb.gw.go b/x/farming/types/query.pb.gw.go
index 1dba8329..3dedeb45 100644
--- a/x/farming/types/query.pb.gw.go
+++ b/x/farming/types/query.pb.gw.go
@@ -139,6 +139,204 @@ func local_request_Query_Plan_0(ctx context.Context, marshaler runtime.Marshaler
 
 }
 
+var (
+	filter_Query_Stakings_0 = &utilities.DoubleArray{Encoding: map[string]int{"farmer": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
+)
+
+func request_Query_Stakings_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryStakingsRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["farmer"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "farmer")
+	}
+
+	protoReq.Farmer, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "farmer", err)
+	}
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_Stakings_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.Stakings(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_Stakings_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryStakingsRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["farmer"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "farmer")
+	}
+
+	protoReq.Farmer, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "farmer", err)
+	}
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_Stakings_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.Stakings(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+func request_Query_TotalStakings_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryTotalStakingsRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["staking_coin_denom"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "staking_coin_denom")
+	}
+
+	protoReq.StakingCoinDenom, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "staking_coin_denom", err)
+	}
+
+	msg, err := client.TotalStakings(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_TotalStakings_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryTotalStakingsRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["staking_coin_denom"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "staking_coin_denom")
+	}
+
+	protoReq.StakingCoinDenom, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "staking_coin_denom", err)
+	}
+
+	msg, err := server.TotalStakings(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+var (
+	filter_Query_Rewards_0 = &utilities.DoubleArray{Encoding: map[string]int{"farmer": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
+)
+
+func request_Query_Rewards_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryRewardsRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["farmer"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "farmer")
+	}
+
+	protoReq.Farmer, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "farmer", err)
+	}
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_Rewards_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.Rewards(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_Rewards_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryRewardsRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["farmer"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "farmer")
+	}
+
+	protoReq.Farmer, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "farmer", err)
+	}
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_Rewards_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.Rewards(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 // RegisterQueryHandlerServer registers the http handlers for service Query to "mux".
 // UnaryRPC     :call QueryServer directly.
 // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
@@ -205,6 +403,66 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 
 	})
 
+	mux.Handle("GET", pattern_Query_Stakings_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_Stakings_0(rctx, inboundMarshaler, server, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_Stakings_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_TotalStakings_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_TotalStakings_0(rctx, inboundMarshaler, server, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_TotalStakings_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_Rewards_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_Rewards_0(rctx, inboundMarshaler, server, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_Rewards_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
@@ -306,6 +564,66 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 
 	})
 
+	mux.Handle("GET", pattern_Query_Stakings_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_Stakings_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_Stakings_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_TotalStakings_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_TotalStakings_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_TotalStakings_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_Rewards_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_Rewards_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_Rewards_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
@@ -315,6 +633,12 @@ var (
 	pattern_Query_Plans_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"cosmos", "farming", "v1beta1", "plans"}, "", runtime.AssumeColonVerbOpt(false)))
 
 	pattern_Query_Plan_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"cosmos", "farming", "v1beta1", "plans", "plan_id"}, "", runtime.AssumeColonVerbOpt(false)))
+
+	pattern_Query_Stakings_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"cosmos", "farming", "v1beta1", "stakings", "farmer"}, "", runtime.AssumeColonVerbOpt(false)))
+
+	pattern_Query_TotalStakings_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"cosmos", "farming", "v1beta1", "total_stakings", "staking_coin_denom"}, "", runtime.AssumeColonVerbOpt(false)))
+
+	pattern_Query_Rewards_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"cosmos", "farming", "v1beta1", "rewards", "farmer"}, "", runtime.AssumeColonVerbOpt(false)))
 )
 
 var (
@@ -323,4 +647,10 @@ var (
 	forward_Query_Plans_0 = runtime.ForwardResponseMessage
 
 	forward_Query_Plan_0 = runtime.ForwardResponseMessage
+
+	forward_Query_Stakings_0 = runtime.ForwardResponseMessage
+
+	forward_Query_TotalStakings_0 = runtime.ForwardResponseMessage
+
+	forward_Query_Rewards_0 = runtime.ForwardResponseMessage
 )
diff --git a/x/farming/types/tx.pb.go b/x/farming/types/tx.pb.go
index ebe80acb..316b6f0d 100644
--- a/x/farming/types/tx.pb.go
+++ b/x/farming/types/tx.pb.go
@@ -448,6 +448,82 @@ func (m *MsgHarvestResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_MsgHarvestResponse proto.InternalMessageInfo
 
+// MsgAdvanceEpoch defines a message to advance epoch by one.
+type MsgAdvanceEpoch struct {
+	// requester defines the bech32-encoded address of the requester
+	Requester string `protobuf:"bytes,1,opt,name=requester,proto3" json:"requester,omitempty"`
+}
+
+func (m *MsgAdvanceEpoch) Reset()         { *m = MsgAdvanceEpoch{} }
+func (m *MsgAdvanceEpoch) String() string { return proto.CompactTextString(m) }
+func (*MsgAdvanceEpoch) ProtoMessage()    {}
+func (*MsgAdvanceEpoch) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a33d9a3ff13f514a, []int{10}
+}
+func (m *MsgAdvanceEpoch) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgAdvanceEpoch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgAdvanceEpoch.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgAdvanceEpoch) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgAdvanceEpoch.Merge(m, src)
+}
+func (m *MsgAdvanceEpoch) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgAdvanceEpoch) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgAdvanceEpoch.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgAdvanceEpoch proto.InternalMessageInfo
+
+// MsgAdvanceEpochResponse defines the Msg/AdvanceEpoch response type.
+type MsgAdvanceEpochResponse struct {
+}
+
+func (m *MsgAdvanceEpochResponse) Reset()         { *m = MsgAdvanceEpochResponse{} }
+func (m *MsgAdvanceEpochResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgAdvanceEpochResponse) ProtoMessage()    {}
+func (*MsgAdvanceEpochResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a33d9a3ff13f514a, []int{11}
+}
+func (m *MsgAdvanceEpochResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgAdvanceEpochResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgAdvanceEpochResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgAdvanceEpochResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgAdvanceEpochResponse.Merge(m, src)
+}
+func (m *MsgAdvanceEpochResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgAdvanceEpochResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgAdvanceEpochResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgAdvanceEpochResponse proto.InternalMessageInfo
+
 func init() {
 	proto.RegisterType((*MsgCreateFixedAmountPlan)(nil), "cosmos.farming.v1beta1.MsgCreateFixedAmountPlan")
 	proto.RegisterType((*MsgCreateFixedAmountPlanResponse)(nil), "cosmos.farming.v1beta1.MsgCreateFixedAmountPlanResponse")
@@ -459,6 +535,8 @@ func init() {
 	proto.RegisterType((*MsgUnstakeResponse)(nil), "cosmos.farming.v1beta1.MsgUnstakeResponse")
 	proto.RegisterType((*MsgHarvest)(nil), "cosmos.farming.v1beta1.MsgHarvest")
 	proto.RegisterType((*MsgHarvestResponse)(nil), "cosmos.farming.v1beta1.MsgHarvestResponse")
+	proto.RegisterType((*MsgAdvanceEpoch)(nil), "cosmos.farming.v1beta1.MsgAdvanceEpoch")
+	proto.RegisterType((*MsgAdvanceEpochResponse)(nil), "cosmos.farming.v1beta1.MsgAdvanceEpochResponse")
 }
 
 func init() {
@@ -466,57 +544,60 @@ func init() {
 }
 
 var fileDescriptor_a33d9a3ff13f514a = []byte{
-	// 785 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x56, 0xcd, 0x4e, 0xdb, 0x4a,
-	0x18, 0x8d, 0x21, 0x04, 0x18, 0xb8, 0x97, 0xcb, 0x90, 0x8b, 0x8c, 0xa1, 0x76, 0xe4, 0x4a, 0x55,
-	0x44, 0x85, 0x5d, 0xd2, 0x4d, 0xc5, 0xae, 0x01, 0x15, 0x54, 0x29, 0x55, 0x65, 0x5a, 0xf5, 0x67,
-	0x13, 0x39, 0xc9, 0x60, 0x2c, 0xf0, 0x4c, 0xea, 0x99, 0x50, 0xe8, 0xb2, 0x55, 0x25, 0xba, 0xa9,
-	0x78, 0x84, 0xaa, 0xbb, 0x76, 0xdb, 0x65, 0x5f, 0x80, 0x25, 0xcb, 0xaa, 0x8b, 0x50, 0xc1, 0x1b,
-	0xf0, 0x04, 0x95, 0x67, 0xc6, 0x96, 0x81, 0x90, 0x90, 0x5d, 0x17, 0x5d, 0xc5, 0x63, 0x9f, 0xef,
-	0xf8, 0x3b, 0xe7, 0x3b, 0x33, 0x0e, 0xb8, 0xc9, 0x10, 0x6e, 0xa0, 0x30, 0xf0, 0x31, 0xb3, 0x37,
-	0xdc, 0xe8, 0xd7, 0xb3, 0x77, 0x16, 0x6b, 0x88, 0xb9, 0x8b, 0x36, 0xdb, 0xb5, 0x9a, 0x21, 0x61,
-	0x04, 0x4e, 0xd7, 0x09, 0x0d, 0x08, 0xb5, 0x24, 0xc0, 0x92, 0x00, 0x2d, 0xef, 0x11, 0x8f, 0x70,
-	0x88, 0x1d, 0x5d, 0x09, 0xb4, 0x36, 0x23, 0xd0, 0x55, 0xf1, 0x40, 0x96, 0x8a, 0x47, 0xba, 0x58,
-	0xd9, 0x35, 0x97, 0xa2, 0xe4, 0x35, 0x75, 0xe2, 0x63, 0xf9, 0xdc, 0xf0, 0x08, 0xf1, 0xb6, 0x91,
-	0xcd, 0x57, 0xb5, 0xd6, 0x86, 0xcd, 0xfc, 0x00, 0x51, 0xe6, 0x06, 0x4d, 0x01, 0x30, 0xbf, 0x64,
-	0x81, 0x5a, 0xa1, 0xde, 0x72, 0x88, 0x5c, 0x86, 0x1e, 0xf8, 0xbb, 0xa8, 0x71, 0x3f, 0x20, 0x2d,
-	0xcc, 0x1e, 0x6f, 0xbb, 0x18, 0x42, 0x90, 0xc5, 0x6e, 0x80, 0x54, 0xa5, 0xa0, 0x14, 0x47, 0x1d,
-	0x7e, 0x0d, 0x55, 0x30, 0x5c, 0x8f, 0xc0, 0x24, 0x54, 0x07, 0xf8, 0xed, 0x78, 0x09, 0x3f, 0x2b,
-	0x20, 0x4f, 0x99, 0xbb, 0xe5, 0x63, 0xaf, 0x1a, 0xb5, 0x50, 0x7d, 0x8d, 0x7c, 0x6f, 0x93, 0x51,
-	0x75, 0xb0, 0x30, 0x58, 0x1c, 0x2b, 0xcd, 0x59, 0xb2, 0xf3, 0xa8, 0xd7, 0x58, 0xb1, 0xb5, 0x82,
-	0xea, 0xcb, 0xc4, 0xc7, 0x65, 0xe7, 0xb0, 0x6d, 0x64, 0xce, 0xda, 0xc6, 0xec, 0x9e, 0x1b, 0x6c,
-	0x2f, 0x99, 0x9d, 0x78, 0xcc, 0xaf, 0xc7, 0xc6, 0x6d, 0xcf, 0x67, 0x9b, 0xad, 0x9a, 0x55, 0x27,
-	0x81, 0x34, 0x42, 0xfe, 0x2c, 0xd0, 0xc6, 0x96, 0xcd, 0xf6, 0x9a, 0x88, 0xc6, 0x94, 0xd4, 0x81,
-	0x92, 0x25, 0x5a, 0x3d, 0x13, 0x1c, 0xf0, 0x39, 0x00, 0x94, 0xb9, 0x21, 0xab, 0x46, 0x46, 0xa8,
-	0xd9, 0x82, 0x52, 0x1c, 0x2b, 0x69, 0x96, 0x70, 0xc9, 0x8a, 0x5d, 0xb2, 0x9e, 0xc4, 0x2e, 0x95,
-	0x6f, 0xc8, 0xbe, 0x26, 0x93, 0xbe, 0x64, 0xad, 0x79, 0x70, 0x6c, 0x28, 0xce, 0x28, 0xbf, 0x11,
-	0xc1, 0xa1, 0x03, 0x46, 0x10, 0x6e, 0x08, 0xde, 0xa1, 0x9e, 0xbc, 0xb3, 0x92, 0x77, 0x42, 0xf0,
-	0xc6, 0x95, 0x82, 0x75, 0x18, 0xe1, 0x06, 0xe7, 0x7c, 0xaf, 0x80, 0x71, 0xd4, 0x24, 0xf5, 0xcd,
-	0xaa, 0xcb, 0xa7, 0xa2, 0xe6, 0xb8, 0x95, 0x33, 0x1d, 0xad, 0xe4, 0x3e, 0xae, 0x4a, 0xde, 0x29,
-	0xc9, 0x9b, 0x2a, 0x8e, 0xfc, 0x2b, 0x5e, 0xc3, 0x3f, 0x61, 0xde, 0x18, 0x2f, 0x15, 0x61, 0x58,
-	0xca, 0xee, 0x7f, 0x32, 0x32, 0xa6, 0x09, 0x0a, 0x57, 0x45, 0xc5, 0x41, 0xb4, 0x49, 0x30, 0x45,
-	0xe6, 0xdb, 0x2c, 0x80, 0x09, 0xc8, 0x71, 0x99, 0x4f, 0xfe, 0x26, 0xe9, 0x4f, 0x48, 0x12, 0x02,
-	0x62, 0xa0, 0xd5, 0x30, 0x9a, 0x89, 0x9a, 0x8b, 0x0c, 0x2f, 0xaf, 0x44, 0xa5, 0x3f, 0xdb, 0xc6,
-	0xad, 0xeb, 0x79, 0x71, 0xd6, 0x36, 0x60, 0x3a, 0x56, 0x9c, 0xca, 0x74, 0x00, 0x5f, 0xf1, 0x59,
-	0xcb, 0xa0, 0xcc, 0x01, 0xed, 0x72, 0x06, 0x92, 0x88, 0x7c, 0x53, 0xc0, 0x48, 0x85, 0x7a, 0xeb,
-	0xcc, 0xdd, 0x42, 0x70, 0x1a, 0xe4, 0xa2, 0x43, 0x10, 0x85, 0x32, 0x1a, 0x72, 0x05, 0xf7, 0x15,
-	0xf0, 0x4f, 0x7a, 0x74, 0x54, 0x1d, 0xe8, 0x15, 0xfd, 0x35, 0x69, 0x44, 0xfe, 0xf2, 0xe0, 0x69,
-	0x7f, 0xd9, 0x1f, 0x4f, 0x8d, 0x9b, 0x4a, 0x4d, 0x10, 0xfc, 0x17, 0x37, 0x9d, 0x28, 0xf9, 0xae,
-	0x00, 0x50, 0xa1, 0xde, 0x53, 0x4c, 0xbb, 0x6a, 0xf9, 0xa8, 0x80, 0x89, 0x16, 0xee, 0x53, 0xcd,
-	0x43, 0xa9, 0x66, 0x5a, 0xa8, 0xb9, 0x50, 0xdf, 0x9f, 0x9e, 0x7f, 0x93, 0xea, 0xb4, 0xa2, 0x3c,
-	0xdf, 0xa9, 0xb2, 0xf9, 0x44, 0xd3, 0x1b, 0x2e, 0x69, 0xcd, 0x0d, 0x77, 0x10, 0x65, 0x57, 0x4a,
-	0x7a, 0x04, 0xa6, 0xce, 0x6d, 0xac, 0x06, 0xc2, 0x24, 0x10, 0xaa, 0x46, 0xcb, 0xfa, 0x59, 0xdb,
-	0xd0, 0x3a, 0xec, 0x3e, 0x01, 0x32, 0x9d, 0xc9, 0x54, 0x33, 0x2b, 0xfc, 0xde, 0xb9, 0x8e, 0xe4,
-	0xbb, 0xe3, 0x8e, 0x4a, 0x1f, 0xb2, 0x60, 0xb0, 0x42, 0x3d, 0xf8, 0x4e, 0x01, 0xff, 0x77, 0xfe,
-	0x4e, 0xdd, 0xb1, 0x3a, 0x7f, 0x4f, 0xad, 0xab, 0x8e, 0x2b, 0xed, 0x5e, 0xbf, 0x15, 0x71, 0x37,
-	0xf0, 0x15, 0x98, 0xb8, 0x78, 0xb8, 0xcd, 0xf7, 0x24, 0x4b, 0xb0, 0x5a, 0xe9, 0xfa, 0xd8, 0xe4,
-	0x95, 0xeb, 0x60, 0x48, 0x6c, 0x96, 0x42, 0x97, 0x62, 0x8e, 0xd0, 0x8a, 0xbd, 0x10, 0x09, 0xe9,
-	0x0b, 0x30, 0x1c, 0xe7, 0xd6, 0xec, 0x52, 0x24, 0x31, 0xda, 0x7c, 0x6f, 0x4c, 0x9a, 0x3a, 0xce,
-	0x4f, 0x37, 0x6a, 0x89, 0xe9, 0x4a, 0x7d, 0x21, 0x0b, 0xe5, 0xd5, 0xc3, 0x13, 0x5d, 0x39, 0x3a,
-	0xd1, 0x95, 0x5f, 0x27, 0xba, 0x72, 0x70, 0xaa, 0x67, 0x8e, 0x4e, 0xf5, 0xcc, 0x8f, 0x53, 0x3d,
-	0xf3, 0x72, 0x21, 0xb5, 0x1b, 0x3a, 0xfc, 0x05, 0xdb, 0x4d, 0xae, 0xf8, 0xc6, 0xa8, 0xe5, 0xf8,
-	0x49, 0x7a, 0xf7, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0x75, 0x71, 0xd2, 0xf4, 0xaf, 0x09, 0x00,
-	0x00,
+	// 842 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x56, 0x4f, 0x4f, 0x1b, 0x47,
+	0x14, 0xf7, 0x82, 0x31, 0x78, 0xa0, 0x75, 0x19, 0x5c, 0xba, 0x2c, 0x74, 0xd7, 0xda, 0x4a, 0xad,
+	0x45, 0xc5, 0x6e, 0x71, 0x55, 0xa9, 0xe2, 0x86, 0xa1, 0x05, 0x55, 0x72, 0x55, 0x2d, 0xad, 0x9a,
+	0xe4, 0x62, 0xad, 0xed, 0x61, 0xbd, 0x82, 0xdd, 0x31, 0x3b, 0x63, 0x02, 0x39, 0x26, 0x8a, 0xc4,
+	0x29, 0xe2, 0x23, 0x44, 0xb9, 0x25, 0xd7, 0x1c, 0xf3, 0x05, 0x38, 0x72, 0x8c, 0x72, 0x30, 0x11,
+	0x7c, 0x03, 0xf2, 0x05, 0xa2, 0x9d, 0x99, 0xdd, 0x2c, 0xc6, 0xf8, 0xcf, 0x2d, 0x87, 0x9c, 0xbc,
+	0x33, 0xfb, 0x7b, 0xbf, 0x79, 0xef, 0xf7, 0x7e, 0x6f, 0xc7, 0xe0, 0x07, 0x8a, 0xfc, 0x06, 0x0a,
+	0x3c, 0xd7, 0xa7, 0xe6, 0xae, 0x1d, 0xfe, 0x3a, 0xe6, 0xe1, 0x6a, 0x0d, 0x51, 0x7b, 0xd5, 0xa4,
+	0x47, 0x46, 0x2b, 0xc0, 0x14, 0xc3, 0xf9, 0x3a, 0x26, 0x1e, 0x26, 0x86, 0x00, 0x18, 0x02, 0xa0,
+	0xe4, 0x1d, 0xec, 0x60, 0x06, 0x31, 0xc3, 0x27, 0x8e, 0x56, 0x16, 0x38, 0xba, 0xca, 0x5f, 0x88,
+	0x50, 0xfe, 0x4a, 0xe5, 0x2b, 0xb3, 0x66, 0x13, 0x14, 0x1f, 0x53, 0xc7, 0xae, 0x2f, 0xde, 0x6b,
+	0x0e, 0xc6, 0xce, 0x3e, 0x32, 0xd9, 0xaa, 0xd6, 0xde, 0x35, 0xa9, 0xeb, 0x21, 0x42, 0x6d, 0xaf,
+	0xc5, 0x01, 0xfa, 0xcb, 0x34, 0x90, 0x2b, 0xc4, 0xd9, 0x08, 0x90, 0x4d, 0xd1, 0x9f, 0xee, 0x11,
+	0x6a, 0xac, 0x7b, 0xb8, 0xed, 0xd3, 0x7f, 0xf6, 0x6d, 0x1f, 0x42, 0x90, 0xf6, 0x6d, 0x0f, 0xc9,
+	0x52, 0x41, 0x2a, 0x66, 0x2d, 0xf6, 0x0c, 0x65, 0x30, 0x59, 0x0f, 0xc1, 0x38, 0x90, 0xc7, 0xd8,
+	0x76, 0xb4, 0x84, 0x2f, 0x24, 0x90, 0x27, 0xd4, 0xde, 0x73, 0x7d, 0xa7, 0x1a, 0xa6, 0x50, 0x7d,
+	0x88, 0x5c, 0xa7, 0x49, 0x89, 0x3c, 0x5e, 0x18, 0x2f, 0x4e, 0x97, 0x96, 0x0c, 0x91, 0x79, 0x98,
+	0x6b, 0x54, 0xb1, 0xb1, 0x89, 0xea, 0x1b, 0xd8, 0xf5, 0xcb, 0xd6, 0x59, 0x47, 0x4b, 0x5d, 0x77,
+	0xb4, 0xc5, 0x63, 0xdb, 0xdb, 0x5f, 0xd3, 0x7b, 0xf1, 0xe8, 0xaf, 0x2e, 0xb4, 0x9f, 0x1d, 0x97,
+	0x36, 0xdb, 0x35, 0xa3, 0x8e, 0x3d, 0x21, 0x84, 0xf8, 0x59, 0x21, 0x8d, 0x3d, 0x93, 0x1e, 0xb7,
+	0x10, 0x89, 0x28, 0x89, 0x05, 0x05, 0x4b, 0xb8, 0xfa, 0x9f, 0x73, 0xc0, 0x7b, 0x00, 0x10, 0x6a,
+	0x07, 0xb4, 0x1a, 0x0a, 0x21, 0xa7, 0x0b, 0x52, 0x71, 0xba, 0xa4, 0x18, 0x5c, 0x25, 0x23, 0x52,
+	0xc9, 0xf8, 0x37, 0x52, 0xa9, 0xfc, 0xbd, 0xc8, 0x6b, 0x36, 0xce, 0x4b, 0xc4, 0xea, 0xa7, 0x17,
+	0x9a, 0x64, 0x65, 0xd9, 0x46, 0x08, 0x87, 0x16, 0x98, 0x42, 0x7e, 0x83, 0xf3, 0x4e, 0x0c, 0xe4,
+	0x5d, 0x14, 0xbc, 0x39, 0xce, 0x1b, 0x45, 0x72, 0xd6, 0x49, 0xe4, 0x37, 0x18, 0xe7, 0x53, 0x09,
+	0xcc, 0xa0, 0x16, 0xae, 0x37, 0xab, 0x36, 0xeb, 0x8a, 0x9c, 0x61, 0x52, 0x2e, 0xf4, 0x94, 0x92,
+	0xe9, 0xb8, 0x25, 0x78, 0xe7, 0x04, 0x6f, 0x22, 0x38, 0xd4, 0xaf, 0x38, 0x84, 0x7e, 0x5c, 0xbc,
+	0x69, 0x16, 0xca, 0xcd, 0xb0, 0x96, 0x3e, 0x79, 0xae, 0xa5, 0x74, 0x1d, 0x14, 0xee, 0xb2, 0x8a,
+	0x85, 0x48, 0x0b, 0xfb, 0x04, 0xe9, 0x8f, 0xd3, 0x00, 0xc6, 0x20, 0xcb, 0xa6, 0x2e, 0xfe, 0xe2,
+	0xa4, 0xcf, 0xc1, 0x49, 0x08, 0xf0, 0x86, 0x56, 0x83, 0xb0, 0x27, 0x72, 0x26, 0x14, 0xbc, 0xbc,
+	0x19, 0x86, 0xbe, 0xeb, 0x68, 0x3f, 0x0e, 0xa7, 0xc5, 0x75, 0x47, 0x83, 0x49, 0x5b, 0x31, 0x2a,
+	0xdd, 0x02, 0x6c, 0xc5, 0x7a, 0x2d, 0x8c, 0xb2, 0x04, 0x94, 0xdb, 0x1e, 0x88, 0x2d, 0xf2, 0x5a,
+	0x02, 0x53, 0x15, 0xe2, 0xec, 0x50, 0x7b, 0x0f, 0xc1, 0x79, 0x90, 0x09, 0x3f, 0x82, 0x28, 0x10,
+	0xd6, 0x10, 0x2b, 0x78, 0x22, 0x81, 0xaf, 0x92, 0xad, 0x23, 0xf2, 0xd8, 0x20, 0xeb, 0x6f, 0x0b,
+	0x21, 0xf2, 0xb7, 0x1b, 0x4f, 0x46, 0xf3, 0xfe, 0x4c, 0xa2, 0xdd, 0x44, 0xd4, 0x04, 0xc1, 0x37,
+	0x51, 0xd2, 0x71, 0x25, 0x6f, 0x24, 0x00, 0x2a, 0xc4, 0xf9, 0xcf, 0x27, 0x7d, 0x6b, 0x79, 0x26,
+	0x81, 0x5c, 0xdb, 0x1f, 0xb1, 0x9a, 0xbf, 0x44, 0x35, 0xf3, 0xbc, 0x9a, 0xae, 0xf8, 0xd1, 0xea,
+	0xf9, 0x3a, 0x8e, 0x4e, 0x56, 0x94, 0x67, 0x93, 0x2a, 0x92, 0x8f, 0x6b, 0x7a, 0xc4, 0x4a, 0xda,
+	0xb6, 0x83, 0x43, 0x44, 0xe8, 0x9d, 0x25, 0xfd, 0x0d, 0xe6, 0x6e, 0x0c, 0x56, 0x03, 0xf9, 0xd8,
+	0xe3, 0x55, 0x65, 0xcb, 0xea, 0x75, 0x47, 0x53, 0x7a, 0x4c, 0x1f, 0x07, 0xe9, 0xd6, 0x6c, 0x22,
+	0x99, 0x4d, 0xb6, 0x77, 0x23, 0x23, 0x71, 0x76, 0x9c, 0xd1, 0x6f, 0x20, 0x57, 0x21, 0xce, 0x7a,
+	0xe3, 0xd0, 0xf6, 0xeb, 0xe8, 0x8f, 0xd0, 0x6b, 0x70, 0x09, 0x64, 0x03, 0x74, 0xd0, 0x46, 0x84,
+	0xc6, 0x99, 0x7d, 0xda, 0x10, 0x64, 0x0b, 0xe0, 0xbb, 0xae, 0xb0, 0x88, 0xb1, 0xf4, 0x21, 0x0d,
+	0xc6, 0x2b, 0xc4, 0x81, 0x4f, 0x24, 0xf0, 0x6d, 0xef, 0x9b, 0xef, 0x17, 0xa3, 0xf7, 0x0d, 0x6d,
+	0xdc, 0xf5, 0x01, 0x54, 0x7e, 0x1f, 0x35, 0x22, 0xca, 0x06, 0x1e, 0x80, 0x5c, 0xf7, 0xe7, 0x72,
+	0x79, 0x20, 0x59, 0x8c, 0x55, 0x4a, 0xc3, 0x63, 0xe3, 0x23, 0x77, 0xc0, 0x04, 0x1f, 0xbf, 0x42,
+	0x9f, 0x60, 0x86, 0x50, 0x8a, 0x83, 0x10, 0x31, 0xe9, 0x7d, 0x30, 0x19, 0x4d, 0x82, 0xde, 0x27,
+	0x48, 0x60, 0x94, 0xe5, 0xc1, 0x98, 0x24, 0x75, 0xe4, 0xc8, 0x7e, 0xd4, 0x02, 0xd3, 0x97, 0xba,
+	0xcb, 0x5d, 0xb0, 0x09, 0x66, 0x6e, 0x58, 0xeb, 0xa7, 0x3e, 0xb1, 0x49, 0xa0, 0x62, 0x0e, 0x09,
+	0x8c, 0x4e, 0x2a, 0x6f, 0x9d, 0x5d, 0xaa, 0xd2, 0xf9, 0xa5, 0x2a, 0xbd, 0xbf, 0x54, 0xa5, 0xd3,
+	0x2b, 0x35, 0x75, 0x7e, 0xa5, 0xa6, 0xde, 0x5e, 0xa9, 0xa9, 0x07, 0x2b, 0x89, 0x49, 0xee, 0xf1,
+	0xf7, 0xf1, 0x28, 0x7e, 0x62, 0x43, 0x5d, 0xcb, 0xb0, 0x5b, 0xe0, 0xd7, 0x8f, 0x01, 0x00, 0x00,
+	0xff, 0xff, 0x08, 0x76, 0x43, 0x79, 0x6b, 0x0a, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -540,8 +621,11 @@ type MsgClient interface {
 	Stake(ctx context.Context, in *MsgStake, opts ...grpc.CallOption) (*MsgStakeResponse, error)
 	// Unstake defines a method for unstaking coins from the farming plan
 	Unstake(ctx context.Context, in *MsgUnstake, opts ...grpc.CallOption) (*MsgUnstakeResponse, error)
-	// harvest defines a method for claiming farming rewards
+	// Harvest defines a method for claiming farming rewards
 	Harvest(ctx context.Context, in *MsgHarvest, opts ...grpc.CallOption) (*MsgHarvestResponse, error)
+	// AdvanceEpoch defines a method for advancing epoch by one, just for testing purpose
+	// and shouldn't be used in real world
+	AdvanceEpoch(ctx context.Context, in *MsgAdvanceEpoch, opts ...grpc.CallOption) (*MsgAdvanceEpochResponse, error)
 }
 
 type msgClient struct {
@@ -597,6 +681,15 @@ func (c *msgClient) Harvest(ctx context.Context, in *MsgHarvest, opts ...grpc.Ca
 	return out, nil
 }
 
+func (c *msgClient) AdvanceEpoch(ctx context.Context, in *MsgAdvanceEpoch, opts ...grpc.CallOption) (*MsgAdvanceEpochResponse, error) {
+	out := new(MsgAdvanceEpochResponse)
+	err := c.cc.Invoke(ctx, "/cosmos.farming.v1beta1.Msg/AdvanceEpoch", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // MsgServer is the server API for Msg service.
 type MsgServer interface {
 	// CreateFixedAmountPlan defines a method for creating a new fixed amount
@@ -608,8 +701,11 @@ type MsgServer interface {
 	Stake(context.Context, *MsgStake) (*MsgStakeResponse, error)
 	// Unstake defines a method for unstaking coins from the farming plan
 	Unstake(context.Context, *MsgUnstake) (*MsgUnstakeResponse, error)
-	// harvest defines a method for claiming farming rewards
+	// Harvest defines a method for claiming farming rewards
 	Harvest(context.Context, *MsgHarvest) (*MsgHarvestResponse, error)
+	// AdvanceEpoch defines a method for advancing epoch by one, just for testing purpose
+	// and shouldn't be used in real world
+	AdvanceEpoch(context.Context, *MsgAdvanceEpoch) (*MsgAdvanceEpochResponse, error)
 }
 
 // UnimplementedMsgServer can be embedded to have forward compatible implementations.
@@ -631,6 +727,9 @@ func (*UnimplementedMsgServer) Unstake(ctx context.Context, req *MsgUnstake) (*M
 func (*UnimplementedMsgServer) Harvest(ctx context.Context, req *MsgHarvest) (*MsgHarvestResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Harvest not implemented")
 }
+func (*UnimplementedMsgServer) AdvanceEpoch(ctx context.Context, req *MsgAdvanceEpoch) (*MsgAdvanceEpochResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method AdvanceEpoch not implemented")
+}
 
 func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
 	s.RegisterService(&_Msg_serviceDesc, srv)
@@ -726,6 +825,24 @@ func _Msg_Harvest_Handler(srv interface{}, ctx context.Context, dec func(interfa
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Msg_AdvanceEpoch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgAdvanceEpoch)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).AdvanceEpoch(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/cosmos.farming.v1beta1.Msg/AdvanceEpoch",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).AdvanceEpoch(ctx, req.(*MsgAdvanceEpoch))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Msg_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "cosmos.farming.v1beta1.Msg",
 	HandlerType: (*MsgServer)(nil),
@@ -750,6 +867,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
 			MethodName: "Harvest",
 			Handler:    _Msg_Harvest_Handler,
 		},
+		{
+			MethodName: "AdvanceEpoch",
+			Handler:    _Msg_AdvanceEpoch_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "tendermint/farming/v1beta1/tx.proto",
@@ -1155,6 +1276,59 @@ func (m *MsgHarvestResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *MsgAdvanceEpoch) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MsgAdvanceEpoch) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgAdvanceEpoch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Requester) > 0 {
+		i -= len(m.Requester)
+		copy(dAtA[i:], m.Requester)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Requester)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *MsgAdvanceEpochResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MsgAdvanceEpochResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgAdvanceEpochResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
 	offset -= sovTx(v)
 	base := offset
@@ -1330,6 +1504,28 @@ func (m *MsgHarvestResponse) Size() (n int) {
 	return n
 }
 
+func (m *MsgAdvanceEpoch) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Requester)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	return n
+}
+
+func (m *MsgAdvanceEpochResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
 func sovTx(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -2428,6 +2624,138 @@ func (m *MsgHarvestResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *MsgAdvanceEpoch) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgAdvanceEpoch: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgAdvanceEpoch: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Requester", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Requester = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MsgAdvanceEpochResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgAdvanceEpochResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgAdvanceEpochResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipTx(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0