genesis.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: tendermint/farming/v1beta1/genesis.proto

package types

import (
	fmt "fmt"
	types1 "github.com/cosmos/cosmos-sdk/codec/types"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	_ "github.com/regen-network/cosmos-proto"
	_ "google.golang.org/protobuf/types/known/timestamppb"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
var _ = time.Kitchen

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// GenesisState defines the farming module's genesis state.
type GenesisState struct {
	// params defines all the parameters for the farming module
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
	// plan_records defines the plan records used for genesis state
	PlanRecords               []PlanRecord               `protobuf:"bytes,2,rep,name=plan_records,json=planRecords,proto3" json:"plan_records" yaml:"plan_records"`
	StakingRecords            []StakingRecord            `protobuf:"bytes,3,rep,name=staking_records,json=stakingRecords,proto3" json:"staking_records" yaml:"staking_records"`
	QueuedStakingRecords      []QueuedStakingRecord      `protobuf:"bytes,4,rep,name=queued_staking_records,json=queuedStakingRecords,proto3" json:"queued_staking_records" yaml:"queued_staking_records"`
	HistoricalRewardsRecords  []HistoricalRewardsRecord  `protobuf:"bytes,5,rep,name=historical_rewards_records,json=historicalRewardsRecords,proto3" json:"historical_rewards_records" yaml:"historical_rewards_records"`
	OutstandingRewardsRecords []OutstandingRewardsRecord `protobuf:"bytes,6,rep,name=outstanding_rewards_records,json=outstandingRewardsRecords,proto3" json:"outstanding_rewards_records" yaml:"outstanding_rewards_records"`
	CurrentEpochRecords       []CurrentEpochRecord       `protobuf:"bytes,7,rep,name=current_epoch_records,json=currentEpochRecords,proto3" json:"current_epoch_records" yaml:"current_epoch_records"`
	TotalStakingsRecords      []TotalStakingsRecord      `protobuf:"bytes,8,rep,name=total_stakings_records,json=totalStakingsRecords,proto3" json:"total_stakings_records" yaml:"total_stakings_records"`
	// reward_pool_coins specifies balance of the reward pool to be distributed in the plans
	// this param is needed for import/export validation
	RewardPoolCoins github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,9,rep,name=reward_pool_coins,json=rewardPoolCoins,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"reward_pool_coins" yaml:"reward_pool_coins"`
	// last_epoch_time specifies the last executed epoch time of the plans
	LastEpochTime *time.Time `protobuf:"bytes,10,opt,name=last_epoch_time,json=lastEpochTime,proto3,stdtime" json:"last_epoch_time,omitempty" yaml:"last_epoch_time"`
	// current_epoch_days specifies the epoch used when allocating farming rewards in end blocker
	CurrentEpochDays uint32 `protobuf:"varint,11,opt,name=current_epoch_days,json=currentEpochDays,proto3" json:"current_epoch_days,omitempty"`
}

func (m *GenesisState) Reset()         { *m = GenesisState{} }
func (m *GenesisState) String() string { return proto.CompactTextString(m) }
func (*GenesisState) ProtoMessage()    {}
func (*GenesisState) Descriptor() ([]byte, []int) {
	return fileDescriptor_c67612b66bcd2967, []int{0}
}
func (m *GenesisState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GenesisState.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 *GenesisState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GenesisState.Merge(m, src)
}
func (m *GenesisState) XXX_Size() int {
	return m.Size()
}
func (m *GenesisState) XXX_DiscardUnknown() {
	xxx_messageInfo_GenesisState.DiscardUnknown(m)
}

var xxx_messageInfo_GenesisState proto.InternalMessageInfo

// PlanRecord is used for import/export via genesis json.
type PlanRecord struct {
	// plan specifies the plan interface; it can be FixedAmountPlan or RatioPlan
	Plan types1.Any `protobuf:"bytes,1,opt,name=plan,proto3" json:"plan"`
	// farming_pool_coins specifies balance of the farming pool for the plan
	// this param is needed for import/export validation
	FarmingPoolCoins github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=farming_pool_coins,json=farmingPoolCoins,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"farming_pool_coins" yaml:"farming_pool_coins"`
}

func (m *PlanRecord) Reset()         { *m = PlanRecord{} }
func (m *PlanRecord) String() string { return proto.CompactTextString(m) }
func (*PlanRecord) ProtoMessage()    {}
func (*PlanRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_c67612b66bcd2967, []int{1}
}
func (m *PlanRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PlanRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PlanRecord.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 *PlanRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PlanRecord.Merge(m, src)
}
func (m *PlanRecord) XXX_Size() int {
	return m.Size()
}
func (m *PlanRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_PlanRecord.DiscardUnknown(m)
}

var xxx_messageInfo_PlanRecord proto.InternalMessageInfo

// StakingRecord is used for import/export via genesis json.
type StakingRecord struct {
	StakingCoinDenom string  `protobuf:"bytes,1,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty" yaml:"staking_coin_denom"`
	Farmer           string  `protobuf:"bytes,2,opt,name=farmer,proto3" json:"farmer,omitempty"`
	Staking          Staking `protobuf:"bytes,3,opt,name=staking,proto3" json:"staking"`
}

func (m *StakingRecord) Reset()         { *m = StakingRecord{} }
func (m *StakingRecord) String() string { return proto.CompactTextString(m) }
func (*StakingRecord) ProtoMessage()    {}
func (*StakingRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_c67612b66bcd2967, []int{2}
}
func (m *StakingRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StakingRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StakingRecord.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 *StakingRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StakingRecord.Merge(m, src)
}
func (m *StakingRecord) XXX_Size() int {
	return m.Size()
}
func (m *StakingRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_StakingRecord.DiscardUnknown(m)
}

var xxx_messageInfo_StakingRecord proto.InternalMessageInfo

// QueuedStakingRecord is used for import/export via genesis json.
type QueuedStakingRecord struct {
	StakingCoinDenom string        `protobuf:"bytes,1,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty" yaml:"staking_coin_denom"`
	Farmer           string        `protobuf:"bytes,2,opt,name=farmer,proto3" json:"farmer,omitempty"`
	QueuedStaking    QueuedStaking `protobuf:"bytes,3,opt,name=queued_staking,json=queuedStaking,proto3" json:"queued_staking" yaml:"queued_staking"`
}

func (m *QueuedStakingRecord) Reset()         { *m = QueuedStakingRecord{} }
func (m *QueuedStakingRecord) String() string { return proto.CompactTextString(m) }
func (*QueuedStakingRecord) ProtoMessage()    {}
func (*QueuedStakingRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_c67612b66bcd2967, []int{3}
}
func (m *QueuedStakingRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueuedStakingRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueuedStakingRecord.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 *QueuedStakingRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueuedStakingRecord.Merge(m, src)
}
func (m *QueuedStakingRecord) XXX_Size() int {
	return m.Size()
}
func (m *QueuedStakingRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_QueuedStakingRecord.DiscardUnknown(m)
}

var xxx_messageInfo_QueuedStakingRecord proto.InternalMessageInfo

// TotalStakingsRecord is used for import/export via genesis json.
type TotalStakingsRecord struct {
	StakingCoinDenom string `protobuf:"bytes,1,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty" yaml:"staking_coin_denom"`
	// amount specifies total amount of the staking for the staking coin denom except queued staking
	Amount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount"`
	// staking_reserve_coins specifies balance of the staking reserve account where staking and queued staking for the
	// staking coin denom is stored this param is needed for import/export validation
	StakingReserveCoins github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,9,rep,name=staking_reserve_coins,json=stakingReserveCoins,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"staking_reserve_coins" yaml:"staking_reserve_coins"`
}

func (m *TotalStakingsRecord) Reset()         { *m = TotalStakingsRecord{} }
func (m *TotalStakingsRecord) String() string { return proto.CompactTextString(m) }
func (*TotalStakingsRecord) ProtoMessage()    {}
func (*TotalStakingsRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_c67612b66bcd2967, []int{4}
}
func (m *TotalStakingsRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TotalStakingsRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TotalStakingsRecord.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 *TotalStakingsRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TotalStakingsRecord.Merge(m, src)
}
func (m *TotalStakingsRecord) XXX_Size() int {
	return m.Size()
}
func (m *TotalStakingsRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_TotalStakingsRecord.DiscardUnknown(m)
}

var xxx_messageInfo_TotalStakingsRecord proto.InternalMessageInfo

// HistoricalRewardsRecord is used for import/export via genesis json.
type HistoricalRewardsRecord struct {
	StakingCoinDenom  string            `protobuf:"bytes,1,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty" yaml:"staking_coin_denom"`
	Epoch             uint64            `protobuf:"varint,2,opt,name=epoch,proto3" json:"epoch,omitempty"`
	HistoricalRewards HistoricalRewards `protobuf:"bytes,3,opt,name=historical_rewards,json=historicalRewards,proto3" json:"historical_rewards" yaml:"historical_rewards"`
}

func (m *HistoricalRewardsRecord) Reset()         { *m = HistoricalRewardsRecord{} }
func (m *HistoricalRewardsRecord) String() string { return proto.CompactTextString(m) }
func (*HistoricalRewardsRecord) ProtoMessage()    {}
func (*HistoricalRewardsRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_c67612b66bcd2967, []int{5}
}
func (m *HistoricalRewardsRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HistoricalRewardsRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HistoricalRewardsRecord.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 *HistoricalRewardsRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HistoricalRewardsRecord.Merge(m, src)
}
func (m *HistoricalRewardsRecord) XXX_Size() int {
	return m.Size()
}
func (m *HistoricalRewardsRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_HistoricalRewardsRecord.DiscardUnknown(m)
}

var xxx_messageInfo_HistoricalRewardsRecord proto.InternalMessageInfo

// OutstandingRewardsRecord is used for import/export via genesis json.
type OutstandingRewardsRecord struct {
	StakingCoinDenom   string             `protobuf:"bytes,1,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty" yaml:"staking_coin_denom"`
	OutstandingRewards OutstandingRewards `protobuf:"bytes,2,opt,name=outstanding_rewards,json=outstandingRewards,proto3" json:"outstanding_rewards" yaml:"outstanding_rewards"`
}

func (m *OutstandingRewardsRecord) Reset()         { *m = OutstandingRewardsRecord{} }
func (m *OutstandingRewardsRecord) String() string { return proto.CompactTextString(m) }
func (*OutstandingRewardsRecord) ProtoMessage()    {}
func (*OutstandingRewardsRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_c67612b66bcd2967, []int{6}
}
func (m *OutstandingRewardsRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OutstandingRewardsRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OutstandingRewardsRecord.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 *OutstandingRewardsRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OutstandingRewardsRecord.Merge(m, src)
}
func (m *OutstandingRewardsRecord) XXX_Size() int {
	return m.Size()
}
func (m *OutstandingRewardsRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_OutstandingRewardsRecord.DiscardUnknown(m)
}

var xxx_messageInfo_OutstandingRewardsRecord proto.InternalMessageInfo

// CurrentEpochRecord is used for import/export via genesis json.
type CurrentEpochRecord struct {
	StakingCoinDenom string `protobuf:"bytes,1,opt,name=staking_coin_denom,json=stakingCoinDenom,proto3" json:"staking_coin_denom,omitempty" yaml:"staking_coin_denom"`
	CurrentEpoch     uint64 `protobuf:"varint,2,opt,name=current_epoch,json=currentEpoch,proto3" json:"current_epoch,omitempty" yaml:"current_epoch"`
}

func (m *CurrentEpochRecord) Reset()         { *m = CurrentEpochRecord{} }
func (m *CurrentEpochRecord) String() string { return proto.CompactTextString(m) }
func (*CurrentEpochRecord) ProtoMessage()    {}
func (*CurrentEpochRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_c67612b66bcd2967, []int{7}
}
func (m *CurrentEpochRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CurrentEpochRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CurrentEpochRecord.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 *CurrentEpochRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CurrentEpochRecord.Merge(m, src)
}
func (m *CurrentEpochRecord) XXX_Size() int {
	return m.Size()
}
func (m *CurrentEpochRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_CurrentEpochRecord.DiscardUnknown(m)
}

var xxx_messageInfo_CurrentEpochRecord proto.InternalMessageInfo

func init() {
	proto.RegisterType((*GenesisState)(nil), "cosmos.farming.v1beta1.GenesisState")
	proto.RegisterType((*PlanRecord)(nil), "cosmos.farming.v1beta1.PlanRecord")
	proto.RegisterType((*StakingRecord)(nil), "cosmos.farming.v1beta1.StakingRecord")
	proto.RegisterType((*QueuedStakingRecord)(nil), "cosmos.farming.v1beta1.QueuedStakingRecord")
	proto.RegisterType((*TotalStakingsRecord)(nil), "cosmos.farming.v1beta1.TotalStakingsRecord")
	proto.RegisterType((*HistoricalRewardsRecord)(nil), "cosmos.farming.v1beta1.HistoricalRewardsRecord")
	proto.RegisterType((*OutstandingRewardsRecord)(nil), "cosmos.farming.v1beta1.OutstandingRewardsRecord")
	proto.RegisterType((*CurrentEpochRecord)(nil), "cosmos.farming.v1beta1.CurrentEpochRecord")
}

func init() {
	proto.RegisterFile("tendermint/farming/v1beta1/genesis.proto", fileDescriptor_c67612b66bcd2967)
}

var fileDescriptor_c67612b66bcd2967 = []byte{
	// 1065 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0xcf, 0x6f, 0x1b, 0x45,
	0x14, 0xf6, 0x38, 0x89, 0xdb, 0x4e, 0xe2, 0x26, 0x1d, 0x3b, 0x61, 0xed, 0x92, 0xdd, 0x74, 0x44,
	0x90, 0x5b, 0xc8, 0x9a, 0x96, 0x03, 0x52, 0x05, 0x42, 0x2c, 0xe5, 0x47, 0x55, 0x10, 0x61, 0xda,
	0x13, 0x17, 0x6b, 0x6c, 0x4f, 0x1d, 0x2b, 0xf6, 0x8e, 0xbb, 0x33, 0x2e, 0x58, 0x1c, 0x38, 0xc0,
	0xa1, 0xc7, 0x4a, 0x48, 0x88, 0x03, 0x12, 0x3d, 0x42, 0xcf, 0xdc, 0xb9, 0x56, 0x9c, 0x7a, 0x42,
	0x88, 0x43, 0x8a, 0x92, 0x4b, 0xaf, 0xe4, 0x2f, 0x40, 0x3b, 0x33, 0xb6, 0x77, 0xbd, 0xbb, 0x69,
	0x22, 0x45, 0x9c, 0xbc, 0x3f, 0xde, 0xfb, 0xbe, 0xef, 0xbd, 0x99, 0xf9, 0xde, 0x1a, 0xd6, 0x24,
	0xf3, 0xdb, 0x2c, 0xe8, 0x77, 0x7d, 0x59, 0xbf, 0x4b, 0xc3, 0xdf, 0x4e, 0xfd, 0xfe, 0xd5, 0x26,
	0x93, 0xf4, 0x6a, 0xbd, 0xc3, 0x7c, 0x26, 0xba, 0xc2, 0x1d, 0x04, 0x5c, 0x72, 0xb4, 0xd6, 0xe2,
	0xa2, 0xcf, 0x85, 0x6b, 0xa2, 0x5c, 0x13, 0x55, 0xad, 0x74, 0x38, 0xef, 0xf4, 0x58, 0x5d, 0x45,
	0x35, 0x87, 0x77, 0xeb, 0xd4, 0x1f, 0xe9, 0x94, 0x6a, 0xb9, 0xc3, 0x3b, 0x5c, 0x5d, 0xd6, 0xc3,
	0x2b, 0xf3, 0xb4, 0xa2, 0x81, 0x1a, 0xfa, 0x85, 0x41, 0xd5, 0xaf, 0x6c, 0x7d, 0x57, 0x6f, 0x52,
	0xc1, 0x26, 0x32, 0x5a, 0xbc, 0xeb, 0x9b, 0xf7, 0x47, 0xa9, 0x1d, 0xeb, 0xd2, 0x91, 0xce, 0xac,
	0x2a, 0xd9, 0xed, 0x33, 0x21, 0x69, 0x7f, 0xa0, 0x03, 0xf0, 0xaf, 0x10, 0x2e, 0x7d, 0xa4, 0x0b,
	0xbc, 0x2d, 0xa9, 0x64, 0xe8, 0x6d, 0x58, 0x18, 0xd0, 0x80, 0xf6, 0x85, 0x05, 0x36, 0x40, 0x6d,
	0xf1, 0x9a, 0xed, 0xa6, 0x17, 0xec, 0x6e, 0xab, 0x28, 0x6f, 0xfe, 0xc9, 0x9e, 0x93, 0x23, 0x26,
	0x07, 0x35, 0xe1, 0xd2, 0xa0, 0x47, 0xfd, 0x46, 0xc0, 0x5a, 0x3c, 0x68, 0x0b, 0x2b, 0xbf, 0x31,
	0x57, 0x5b, 0xbc, 0x86, 0x33, 0x31, 0x7a, 0xd4, 0x27, 0x2a, 0xd4, 0xbb, 0x18, 0xe2, 0x1c, 0xee,
	0x39, 0xa5, 0x11, 0xed, 0xf7, 0xae, 0xe3, 0x28, 0x0a, 0x26, 0x8b, 0x83, 0x49, 0xa0, 0x40, 0x3e,
	0x5c, 0x16, 0x92, 0xee, 0x76, 0xfd, 0xce, 0x84, 0x66, 0x4e, 0xd1, 0x6c, 0x66, 0xd1, 0xdc, 0xd6,
	0xe1, 0x86, 0xc9, 0x36, 0x4c, 0x6b, 0x9a, 0x69, 0x06, 0x0b, 0x93, 0xf3, 0x22, 0x1a, 0x2e, 0xd0,
	0x03, 0x00, 0xd7, 0xee, 0x0d, 0xd9, 0x90, 0xb5, 0x1b, 0xb3, 0xbc, 0xf3, 0x8a, 0xf7, 0xb5, 0x2c,
	0xde, 0xcf, 0x55, 0x56, 0x9c, 0x7d, 0xd3, 0xb0, 0xaf, 0x6b, 0xf6, 0x74, 0x60, 0x4c, 0xca, 0xf7,
	0x92, 0xb9, 0x02, 0xfd, 0x08, 0x60, 0x75, 0xa7, 0x2b, 0x24, 0x0f, 0xba, 0x2d, 0xda, 0x6b, 0x04,
	0xec, 0x4b, 0x1a, 0xb4, 0xc5, 0x44, 0xce, 0x82, 0x92, 0x53, 0xcf, 0x92, 0xf3, 0xf1, 0x24, 0x93,
	0xe8, 0x44, 0x23, 0xe9, 0xb2, 0x91, 0x74, 0x49, 0x4b, 0xca, 0x26, 0xc0, 0xc4, 0xda, 0x49, 0xc7,
	0x10, 0xe8, 0x27, 0x00, 0x2f, 0xf2, 0xa1, 0x14, 0x92, 0xfa, 0x6d, 0x5d, 0x49, 0x5c, 0x5b, 0x41,
	0x69, 0x7b, 0x23, 0x4b, 0xdb, 0x67, 0xd3, 0xd4, 0xb8, 0xb8, 0x2b, 0x46, 0x1c, 0xd6, 0xe2, 0x8e,
	0xa0, 0xc0, 0xa4, 0xc2, 0x33, 0x50, 0x04, 0xfa, 0x0e, 0xc0, 0xd5, 0xd6, 0x30, 0x08, 0x98, 0x2f,
	0x1b, 0x6c, 0xc0, 0x5b, 0x3b, 0x13, 0x61, 0x67, 0x94, 0xb0, 0x2b, 0x59, 0xc2, 0xde, 0xd7, 0x49,
	0x1f, 0x84, 0x39, 0x46, 0xd2, 0x2b, 0x46, 0xd2, 0xcb, 0x5a, 0x52, 0x2a, 0x2c, 0x26, 0xa5, 0x56,
	0x22, 0x53, 0xef, 0x25, 0xc9, 0x25, 0xed, 0x8d, 0x57, 0x7c, 0xda, 0xa0, 0xb3, 0x47, 0xef, 0xa5,
	0x3b, 0x61, 0x96, 0xd9, 0x0e, 0x22, 0x7d, 0x2f, 0xa5, 0x03, 0x63, 0x52, 0x96, 0xc9, 0x5c, 0x81,
	0xbe, 0x07, 0xf0, 0x82, 0xee, 0x60, 0x63, 0xc0, 0x79, 0xaf, 0x11, 0xfa, 0x8b, 0xb0, 0xce, 0x29,
	0x15, 0x95, 0xb1, 0x8a, 0xd0, 0x81, 0xa6, 0xad, 0xe0, 0x5d, 0xdf, 0xfb, 0xc4, 0x70, 0x5a, 0x9a,
	0x33, 0x81, 0x80, 0x1f, 0x3f, 0x73, 0x6a, 0x9d, 0xae, 0xdc, 0x19, 0x36, 0xdd, 0x16, 0xef, 0x1b,
	0x63, 0x33, 0x3f, 0x5b, 0xa2, 0xbd, 0x5b, 0x97, 0xa3, 0x01, 0x13, 0x0a, 0x4c, 0x90, 0x65, 0x9d,
	0xbf, 0xcd, 0x79, 0x4f, 0x3d, 0x40, 0x4d, 0xb8, 0xdc, 0xa3, 0x62, 0xdc, 0xcc, 0xd0, 0xad, 0x2c,
	0xa8, 0x7c, 0xa8, 0xea, 0x6a, 0x2b, 0x73, 0xc7, 0x56, 0xe6, 0xde, 0x19, 0x5b, 0x99, 0x67, 0x4f,
	0x4f, 0xf3, 0x4c, 0x32, 0x7e, 0xf8, 0xcc, 0x01, 0xa4, 0x18, 0x3e, 0x55, 0xeb, 0x10, 0xe6, 0xa0,
	0xd7, 0x21, 0x8a, 0xaf, 0x59, 0x9b, 0x8e, 0x84, 0xb5, 0xb8, 0x01, 0x6a, 0x45, 0xb2, 0x12, 0x5d,
	0xb5, 0x1b, 0x74, 0x24, 0xae, 0x9f, 0x7d, 0xf0, 0xc8, 0xc9, 0x3d, 0x7f, 0xe4, 0xe4, 0xf0, 0x73,
	0x00, 0xe1, 0xd4, 0xb1, 0xd0, 0x5b, 0x70, 0x3e, 0xb4, 0x25, 0xe3, 0x93, 0xe5, 0x84, 0xbe, 0xf7,
	0xfc, 0x91, 0x57, 0x0c, 0xbb, 0xf5, 0xc7, 0x6f, 0x5b, 0x0b, 0x61, 0xde, 0x4d, 0xa2, 0x12, 0xd0,
	0x0f, 0x00, 0x22, 0xb3, 0xbc, 0xd1, 0xd6, 0xe7, 0x5f, 0xd4, 0xfa, 0x4f, 0x4d, 0xeb, 0x2b, 0xba,
	0xd4, 0x24, 0xc4, 0xc9, 0x7a, 0xbf, 0x62, 0x00, 0x26, 0xcd, 0x8f, 0x94, 0xfa, 0x3b, 0x80, 0xc5,
	0x98, 0xf7, 0xa0, 0x5b, 0x10, 0x8d, 0x4d, 0x2a, 0xe4, 0x6a, 0xb4, 0x99, 0xcf, 0xfb, 0xaa, 0xf6,
	0x73, 0xde, 0xfa, 0x54, 0x54, 0x32, 0x06, 0x93, 0x15, 0xf3, 0x30, 0x24, 0xb9, 0x11, 0x3e, 0x42,
	0x6b, 0xb0, 0x10, 0x92, 0xb3, 0xc0, 0xca, 0x87, 0x00, 0xc4, 0xdc, 0xa1, 0x77, 0xe1, 0x19, 0x13,
	0x6b, 0xcd, 0xa9, 0xae, 0x3a, 0x2f, 0xb0, 0x74, 0x33, 0x7e, 0xc6, 0x59, 0x91, 0x0a, 0xfe, 0x05,
	0xb0, 0x94, 0xe2, 0xbf, 0xff, 0x4f, 0x1d, 0xbb, 0xf0, 0x7c, 0xdc, 0xd8, 0x4d, 0x39, 0x9b, 0xc7,
	0x9a, 0x14, 0xde, 0xba, 0x59, 0xe8, 0xd5, 0xb4, 0x19, 0x81, 0x49, 0x31, 0x36, 0x1b, 0x22, 0x35,
	0xff, 0x99, 0x87, 0xa5, 0x14, 0x9f, 0x38, 0xdd, 0x9a, 0x3f, 0x84, 0x05, 0xda, 0xe7, 0x43, 0x5f,
	0xea, 0x9a, 0x3d, 0x37, 0x14, 0xfb, 0xf7, 0x9e, 0xf3, 0xea, 0x31, 0x36, 0xde, 0x4d, 0x5f, 0x12,
	0x93, 0x8d, 0x7e, 0x06, 0x70, 0x75, 0x3a, 0xf6, 0x04, 0x0b, 0xee, 0xb3, 0xe3, 0x7a, 0xd0, 0x76,
	0xdc, 0x80, 0x53, 0x51, 0x4e, 0x76, 0x16, 0x4a, 0x93, 0x99, 0xaf, 0x20, 0x66, 0x8f, 0xc3, 0xb7,
	0x79, 0xf8, 0x52, 0xc6, 0xf4, 0x3c, 0xdd, 0xe6, 0x96, 0xe1, 0x82, 0xb2, 0x24, 0xd5, 0xdb, 0x79,
	0xa2, 0x6f, 0xd0, 0xd7, 0x10, 0x25, 0x87, 0xb2, 0xd9, 0x52, 0x97, 0x8f, 0x3d, 0xed, 0xbd, 0x4b,
	0x71, 0xff, 0x48, 0x42, 0x62, 0x72, 0x21, 0x31, 0xdf, 0x23, 0x5d, 0x38, 0x04, 0xd0, 0xca, 0x9a,
	0xd3, 0xa7, 0xdb, 0x86, 0x6f, 0x60, 0x29, 0x65, 0xd0, 0xab, 0xa6, 0x1c, 0x31, 0xaa, 0x93, 0xda,
	0x3c, 0x6c, 0x4a, 0xae, 0x66, 0x7e, 0x3d, 0x60, 0x82, 0x92, 0x5f, 0x0d, 0x91, 0xa2, 0x1f, 0x03,
	0x88, 0x92, 0xdf, 0x00, 0xa7, 0x5b, 0xee, 0x3b, 0xb0, 0x18, 0x1b, 0x48, 0x7a, 0xf5, 0x3d, 0xeb,
	0x70, 0xcf, 0x29, 0xa7, 0x7c, 0x63, 0x60, 0xb2, 0x14, 0x9d, 0x52, 0x53, 0xb1, 0xde, 0xad, 0x5f,
	0xf6, 0x6d, 0xf0, 0x64, 0xdf, 0x06, 0x4f, 0xf7, 0x6d, 0xf0, 0xcf, 0xbe, 0x0d, 0x1e, 0x1e, 0xd8,
	0xb9, 0xa7, 0x07, 0x76, 0xee, 0xaf, 0x03, 0x3b, 0xf7, 0xc5, 0x56, 0xe4, 0x38, 0xa4, 0xfc, 0x83,
	0xf8, 0x6a, 0x72, 0xa5, 0x4e, 0x46, 0xb3, 0xa0, 0x26, 0xd9, 0x9b, 0xff, 0x05, 0x00, 0x00, 0xff,
	0xff, 0x9f, 0xd8, 0xc2, 0x6a, 0x1c, 0x0d, 0x00, 0x00,
}

func (m *GenesisState) 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 *GenesisState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CurrentEpochDays != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.CurrentEpochDays))
		i--
		dAtA[i] = 0x58
	}
	if m.LastEpochTime != nil {
		n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.LastEpochTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.LastEpochTime):])
		if err1 != nil {
			return 0, err1
		}
		i -= n1
		i = encodeVarintGenesis(dAtA, i, uint64(n1))
		i--
		dAtA[i] = 0x52
	}
	if len(m.RewardPoolCoins) > 0 {
		for iNdEx := len(m.RewardPoolCoins) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.RewardPoolCoins[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.TotalStakingsRecords) > 0 {
		for iNdEx := len(m.TotalStakingsRecords) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TotalStakingsRecords[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.CurrentEpochRecords) > 0 {
		for iNdEx := len(m.CurrentEpochRecords) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.CurrentEpochRecords[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.OutstandingRewardsRecords) > 0 {
		for iNdEx := len(m.OutstandingRewardsRecords) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OutstandingRewardsRecords[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.HistoricalRewardsRecords) > 0 {
		for iNdEx := len(m.HistoricalRewardsRecords) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.HistoricalRewardsRecords[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.QueuedStakingRecords) > 0 {
		for iNdEx := len(m.QueuedStakingRecords) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.QueuedStakingRecords[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.StakingRecords) > 0 {
		for iNdEx := len(m.StakingRecords) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.StakingRecords[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.PlanRecords) > 0 {
		for iNdEx := len(m.PlanRecords) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PlanRecords[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	{
		size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *PlanRecord) 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 *PlanRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PlanRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.FarmingPoolCoins) > 0 {
		for iNdEx := len(m.FarmingPoolCoins) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.FarmingPoolCoins[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	{
		size, err := m.Plan.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *StakingRecord) 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 *StakingRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StakingRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Staking.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Farmer) > 0 {
		i -= len(m.Farmer)
		copy(dAtA[i:], m.Farmer)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Farmer)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.StakingCoinDenom) > 0 {
		i -= len(m.StakingCoinDenom)
		copy(dAtA[i:], m.StakingCoinDenom)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.StakingCoinDenom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueuedStakingRecord) 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 *QueuedStakingRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueuedStakingRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.QueuedStaking.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Farmer) > 0 {
		i -= len(m.Farmer)
		copy(dAtA[i:], m.Farmer)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Farmer)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.StakingCoinDenom) > 0 {
		i -= len(m.StakingCoinDenom)
		copy(dAtA[i:], m.StakingCoinDenom)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.StakingCoinDenom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TotalStakingsRecord) 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 *TotalStakingsRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TotalStakingsRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.StakingReserveCoins) > 0 {
		for iNdEx := len(m.StakingReserveCoins) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.StakingReserveCoins[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4a
		}
	}
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.StakingCoinDenom) > 0 {
		i -= len(m.StakingCoinDenom)
		copy(dAtA[i:], m.StakingCoinDenom)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.StakingCoinDenom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *HistoricalRewardsRecord) 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 *HistoricalRewardsRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HistoricalRewardsRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.HistoricalRewards.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.Epoch != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.Epoch))
		i--
		dAtA[i] = 0x10
	}
	if len(m.StakingCoinDenom) > 0 {
		i -= len(m.StakingCoinDenom)
		copy(dAtA[i:], m.StakingCoinDenom)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.StakingCoinDenom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *OutstandingRewardsRecord) 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 *OutstandingRewardsRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OutstandingRewardsRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.OutstandingRewards.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.StakingCoinDenom) > 0 {
		i -= len(m.StakingCoinDenom)
		copy(dAtA[i:], m.StakingCoinDenom)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.StakingCoinDenom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CurrentEpochRecord) 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 *CurrentEpochRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CurrentEpochRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CurrentEpoch != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.CurrentEpoch))
		i--
		dAtA[i] = 0x10
	}
	if len(m.StakingCoinDenom) > 0 {
		i -= len(m.StakingCoinDenom)
		copy(dAtA[i:], m.StakingCoinDenom)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.StakingCoinDenom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int {
	offset -= sovGenesis(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *GenesisState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Params.Size()
	n += 1 + l + sovGenesis(uint64(l))
	if len(m.PlanRecords) > 0 {
		for _, e := range m.PlanRecords {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.StakingRecords) > 0 {
		for _, e := range m.StakingRecords {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.QueuedStakingRecords) > 0 {
		for _, e := range m.QueuedStakingRecords {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.HistoricalRewardsRecords) > 0 {
		for _, e := range m.HistoricalRewardsRecords {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.OutstandingRewardsRecords) > 0 {
		for _, e := range m.OutstandingRewardsRecords {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.CurrentEpochRecords) > 0 {
		for _, e := range m.CurrentEpochRecords {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.TotalStakingsRecords) > 0 {
		for _, e := range m.TotalStakingsRecords {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.RewardPoolCoins) > 0 {
		for _, e := range m.RewardPoolCoins {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if m.LastEpochTime != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.LastEpochTime)
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.CurrentEpochDays != 0 {
		n += 1 + sovGenesis(uint64(m.CurrentEpochDays))
	}
	return n
}

func (m *PlanRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Plan.Size()
	n += 1 + l + sovGenesis(uint64(l))
	if len(m.FarmingPoolCoins) > 0 {
		for _, e := range m.FarmingPoolCoins {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	return n
}

func (m *StakingRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StakingCoinDenom)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = len(m.Farmer)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = m.Staking.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *QueuedStakingRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StakingCoinDenom)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = len(m.Farmer)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = m.QueuedStaking.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *TotalStakingsRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StakingCoinDenom)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovGenesis(uint64(l))
	if len(m.StakingReserveCoins) > 0 {
		for _, e := range m.StakingReserveCoins {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	return n
}

func (m *HistoricalRewardsRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StakingCoinDenom)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.Epoch != 0 {
		n += 1 + sovGenesis(uint64(m.Epoch))
	}
	l = m.HistoricalRewards.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *OutstandingRewardsRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StakingCoinDenom)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = m.OutstandingRewards.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *CurrentEpochRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StakingCoinDenom)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.CurrentEpoch != 0 {
		n += 1 + sovGenesis(uint64(m.CurrentEpoch))
	}
	return n
}

func sovGenesis(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozGenesis(x uint64) (n int) {
	return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *GenesisState) 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 ErrIntOverflowGenesis
			}
			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: GenesisState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GenesisState: 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 ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PlanRecords", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PlanRecords = append(m.PlanRecords, PlanRecord{})
			if err := m.PlanRecords[len(m.PlanRecords)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakingRecords", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakingRecords = append(m.StakingRecords, StakingRecord{})
			if err := m.StakingRecords[len(m.StakingRecords)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueuedStakingRecords", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QueuedStakingRecords = append(m.QueuedStakingRecords, QueuedStakingRecord{})
			if err := m.QueuedStakingRecords[len(m.QueuedStakingRecords)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HistoricalRewardsRecords", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HistoricalRewardsRecords = append(m.HistoricalRewardsRecords, HistoricalRewardsRecord{})
			if err := m.HistoricalRewardsRecords[len(m.HistoricalRewardsRecords)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutstandingRewardsRecords", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OutstandingRewardsRecords = append(m.OutstandingRewardsRecords, OutstandingRewardsRecord{})
			if err := m.OutstandingRewardsRecords[len(m.OutstandingRewardsRecords)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentEpochRecords", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CurrentEpochRecords = append(m.CurrentEpochRecords, CurrentEpochRecord{})
			if err := m.CurrentEpochRecords[len(m.CurrentEpochRecords)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalStakingsRecords", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TotalStakingsRecords = append(m.TotalStakingsRecords, TotalStakingsRecord{})
			if err := m.TotalStakingsRecords[len(m.TotalStakingsRecords)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RewardPoolCoins", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RewardPoolCoins = append(m.RewardPoolCoins, types.Coin{})
			if err := m.RewardPoolCoins[len(m.RewardPoolCoins)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastEpochTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastEpochTime == nil {
				m.LastEpochTime = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.LastEpochTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentEpochDays", wireType)
			}
			m.CurrentEpochDays = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CurrentEpochDays |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PlanRecord) 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 ErrIntOverflowGenesis
			}
			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: PlanRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PlanRecord: 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)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Plan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FarmingPoolCoins", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FarmingPoolCoins = append(m.FarmingPoolCoins, types.Coin{})
			if err := m.FarmingPoolCoins[len(m.FarmingPoolCoins)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StakingRecord) 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 ErrIntOverflowGenesis
			}
			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: StakingRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StakingRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakingCoinDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Farmer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Farmer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Staking", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Staking.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueuedStakingRecord) 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 ErrIntOverflowGenesis
			}
			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: QueuedStakingRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueuedStakingRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakingCoinDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Farmer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Farmer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueuedStaking", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.QueuedStaking.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TotalStakingsRecord) 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 ErrIntOverflowGenesis
			}
			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: TotalStakingsRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TotalStakingsRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakingCoinDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakingReserveCoins", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakingReserveCoins = append(m.StakingReserveCoins, types.Coin{})
			if err := m.StakingReserveCoins[len(m.StakingReserveCoins)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HistoricalRewardsRecord) 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 ErrIntOverflowGenesis
			}
			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: HistoricalRewardsRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HistoricalRewardsRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakingCoinDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			m.Epoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Epoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HistoricalRewards", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.HistoricalRewards.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OutstandingRewardsRecord) 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 ErrIntOverflowGenesis
			}
			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: OutstandingRewardsRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutstandingRewardsRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakingCoinDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutstandingRewards", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OutstandingRewards.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CurrentEpochRecord) 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 ErrIntOverflowGenesis
			}
			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: CurrentEpochRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CurrentEpochRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowGenesis
				}
				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 ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakingCoinDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentEpoch", wireType)
			}
			m.CurrentEpoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CurrentEpoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipGenesis(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthGenesis
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupGenesis
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthGenesis
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthGenesis        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowGenesis          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
)