genesis.pb.go

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

package types

import (
	encoding_json "encoding/json"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"

	_ "github.com/CosmWasm/wasmd/x/wasm/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"
	_ "google.golang.org/protobuf/types/known/durationpb"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal

var (
	_ = fmt.Errorf
	_ = math.Inf
	_ = 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 - initial state of module
type GenesisState struct {
	// params defines all the parameter of the module
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
	// SetupMode defines which scenario to apply on a genesis import.
	// Either it is a fresh chain that needs PoE contracts bootstrapped or
	// the module state has to be restored from a previous state dump.
	//
	// Types that are valid to be assigned to SetupMode:
	//	*GenesisState_SeedContracts
	//	*GenesisState_ImportDump
	SetupMode isGenesisState_SetupMode `protobuf_oneof:"setup_mode"`
}

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_a165193bab811d9d, []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

type isGenesisState_SetupMode interface {
	isGenesisState_SetupMode()
	MarshalTo([]byte) (int, error)
	Size() int
}

type GenesisState_SeedContracts struct {
	SeedContracts *SeedContracts `protobuf:"bytes,2,opt,name=seed_contracts,json=seedContracts,proto3,oneof" json:"seed_contracts,omitempty"`
}
type GenesisState_ImportDump struct {
	ImportDump *ImportDump `protobuf:"bytes,3,opt,name=import_dump,json=importDump,proto3,oneof" json:"import_dump,omitempty"`
}

func (*GenesisState_SeedContracts) isGenesisState_SetupMode() {}
func (*GenesisState_ImportDump) isGenesisState_SetupMode()    {}

func (m *GenesisState) GetSetupMode() isGenesisState_SetupMode {
	if m != nil {
		return m.SetupMode
	}
	return nil
}

func (m *GenesisState) GetParams() Params {
	if m != nil {
		return m.Params
	}
	return Params{}
}

func (m *GenesisState) GetSeedContracts() *SeedContracts {
	if x, ok := m.GetSetupMode().(*GenesisState_SeedContracts); ok {
		return x.SeedContracts
	}
	return nil
}

func (m *GenesisState) GetImportDump() *ImportDump {
	if x, ok := m.GetSetupMode().(*GenesisState_ImportDump); ok {
		return x.ImportDump
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*GenesisState) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*GenesisState_SeedContracts)(nil),
		(*GenesisState_ImportDump)(nil),
	}
}

// ImportDump has all module data for non seed mode.
type ImportDump struct {
	// Contracts PoE contract addresses and types
	Contracts []PoEContract `protobuf:"bytes,1,rep,name=contracts,proto3" json:"contracts,omitempty"`
}

func (m *ImportDump) Reset()         { *m = ImportDump{} }
func (m *ImportDump) String() string { return proto.CompactTextString(m) }
func (*ImportDump) ProtoMessage()    {}
func (*ImportDump) Descriptor() ([]byte, []int) {
	return fileDescriptor_a165193bab811d9d, []int{1}
}

func (m *ImportDump) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ImportDump) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ImportDump.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 *ImportDump) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ImportDump.Merge(m, src)
}

func (m *ImportDump) XXX_Size() int {
	return m.Size()
}

func (m *ImportDump) XXX_DiscardUnknown() {
	xxx_messageInfo_ImportDump.DiscardUnknown(m)
}

var xxx_messageInfo_ImportDump proto.InternalMessageInfo

func (m *ImportDump) GetContracts() []PoEContract {
	if m != nil {
		return m.Contracts
	}
	return nil
}

// SeedContracts contains the contract configuration and group members to setup
// all PoE contracts on chain.
type SeedContracts struct {
	// GenTxs defines the genesis transactions to create a validator.
	GenTxs []encoding_json.RawMessage `protobuf:"bytes,1,rep,name=gen_txs,json=genTxs,proto3,casttype=encoding/json.RawMessage" json:"gentxs" yaml:"gentxs"`
	// BootstrapAccountAddress single address that is set as bootstrap-account for
	// the PoE contracts in seed mode.
	BootstrapAccountAddress string `protobuf:"bytes,2,opt,name=bootstrap_account_address,json=bootstrapAccountAddress,proto3" json:"bootstrap_account_address,omitempty"`
	// Engagement weighted members of the engagement group. Validators should be
	// in here.
	Engagement               []TG4Member               `protobuf:"bytes,3,rep,name=engagement,proto3" json:"engagement,omitempty"`
	StakeContractConfig      *StakeContractConfig      `protobuf:"bytes,4,opt,name=stake_contract_config,json=stakeContractConfig,proto3" json:"stake_contract_config,omitempty"`
	ValsetContractConfig     *ValsetContractConfig     `protobuf:"bytes,5,opt,name=valset_contract_config,json=valsetContractConfig,proto3" json:"valset_contract_config,omitempty"`
	EngagementContractConfig *EngagementContractConfig `protobuf:"bytes,6,opt,name=engagement_contract_config,json=engagementContractConfig,proto3" json:"engagement_contract_config,omitempty"`
	// BondDenom defines the bondable coin denomination.
	BondDenom                        string                            `protobuf:"bytes,7,opt,name=bond_denom,json=bondDenom,proto3" json:"bond_denom,omitempty" yaml:"bond_denom"`
	OversightCommitteeContractConfig *OversightCommitteeContractConfig `protobuf:"bytes,8,opt,name=oversight_committee_contract_config,json=oversightCommitteeContractConfig,proto3" json:"oversight_committee_contract_config,omitempty"`
	CommunityPoolContractConfig      *CommunityPoolContractConfig      `protobuf:"bytes,9,opt,name=community_pool_contract_config,json=communityPoolContractConfig,proto3" json:"community_pool_contract_config,omitempty"`
	ValidatorVotingContractConfig    *ValidatorVotingContractConfig    `protobuf:"bytes,10,opt,name=validator_voting_contract_config,json=validatorVotingContractConfig,proto3" json:"validator_voting_contract_config,omitempty"`
	OversightCommunityMembers        []string                          `protobuf:"bytes,11,rep,name=oversight_community_members,json=oversightCommunityMembers,proto3" json:"oversight_community_members,omitempty"`
	ArbiterPoolMembers               []string                          `protobuf:"bytes,12,rep,name=arbiter_pool_members,json=arbiterPoolMembers,proto3" json:"arbiter_pool_members,omitempty"`
	ArbiterPoolContractConfig        *ArbiterPoolContractConfig        `protobuf:"bytes,13,opt,name=arbiter_pool_contract_config,json=arbiterPoolContractConfig,proto3" json:"arbiter_pool_contract_config,omitempty"`
	MixerContractConfig              *MixerContractConfig              `protobuf:"bytes,14,opt,name=mixer_contract_config,json=mixerContractConfig,proto3" json:"mixer_contract_config,omitempty"`
}

func (m *SeedContracts) Reset()         { *m = SeedContracts{} }
func (m *SeedContracts) String() string { return proto.CompactTextString(m) }
func (*SeedContracts) ProtoMessage()    {}
func (*SeedContracts) Descriptor() ([]byte, []int) {
	return fileDescriptor_a165193bab811d9d, []int{2}
}

func (m *SeedContracts) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *SeedContracts) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SeedContracts.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 *SeedContracts) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SeedContracts.Merge(m, src)
}

func (m *SeedContracts) XXX_Size() int {
	return m.Size()
}

func (m *SeedContracts) XXX_DiscardUnknown() {
	xxx_messageInfo_SeedContracts.DiscardUnknown(m)
}

var xxx_messageInfo_SeedContracts proto.InternalMessageInfo

func (m *SeedContracts) GetGenTxs() []encoding_json.RawMessage {
	if m != nil {
		return m.GenTxs
	}
	return nil
}

func (m *SeedContracts) GetBootstrapAccountAddress() string {
	if m != nil {
		return m.BootstrapAccountAddress
	}
	return ""
}

func (m *SeedContracts) GetEngagement() []TG4Member {
	if m != nil {
		return m.Engagement
	}
	return nil
}

func (m *SeedContracts) GetStakeContractConfig() *StakeContractConfig {
	if m != nil {
		return m.StakeContractConfig
	}
	return nil
}

func (m *SeedContracts) GetValsetContractConfig() *ValsetContractConfig {
	if m != nil {
		return m.ValsetContractConfig
	}
	return nil
}

func (m *SeedContracts) GetEngagementContractConfig() *EngagementContractConfig {
	if m != nil {
		return m.EngagementContractConfig
	}
	return nil
}

func (m *SeedContracts) GetBondDenom() string {
	if m != nil {
		return m.BondDenom
	}
	return ""
}

func (m *SeedContracts) GetOversightCommitteeContractConfig() *OversightCommitteeContractConfig {
	if m != nil {
		return m.OversightCommitteeContractConfig
	}
	return nil
}

func (m *SeedContracts) GetCommunityPoolContractConfig() *CommunityPoolContractConfig {
	if m != nil {
		return m.CommunityPoolContractConfig
	}
	return nil
}

func (m *SeedContracts) GetValidatorVotingContractConfig() *ValidatorVotingContractConfig {
	if m != nil {
		return m.ValidatorVotingContractConfig
	}
	return nil
}

func (m *SeedContracts) GetOversightCommunityMembers() []string {
	if m != nil {
		return m.OversightCommunityMembers
	}
	return nil
}

func (m *SeedContracts) GetArbiterPoolMembers() []string {
	if m != nil {
		return m.ArbiterPoolMembers
	}
	return nil
}

func (m *SeedContracts) GetArbiterPoolContractConfig() *ArbiterPoolContractConfig {
	if m != nil {
		return m.ArbiterPoolContractConfig
	}
	return nil
}

func (m *SeedContracts) GetMixerContractConfig() *MixerContractConfig {
	if m != nil {
		return m.MixerContractConfig
	}
	return nil
}

// Mixer contract setup. See
// https://github.com/confio/poe-contracts/tree/main/contracts/tg4-mixer
type MixerContractConfig struct {
	// Sigmoid returns a sigmoid-like value of staked amount times engagement
	// points. See the Proof-of-Engagement white-paper for details.
	Sigmoid MixerContractConfig_Sigmoid `protobuf:"bytes,1,opt,name=sigmoid,proto3" json:"sigmoid"`
}

func (m *MixerContractConfig) Reset()         { *m = MixerContractConfig{} }
func (m *MixerContractConfig) String() string { return proto.CompactTextString(m) }
func (*MixerContractConfig) ProtoMessage()    {}
func (*MixerContractConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_a165193bab811d9d, []int{3}
}

func (m *MixerContractConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *MixerContractConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MixerContractConfig.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 *MixerContractConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MixerContractConfig.Merge(m, src)
}

func (m *MixerContractConfig) XXX_Size() int {
	return m.Size()
}

func (m *MixerContractConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_MixerContractConfig.DiscardUnknown(m)
}

var xxx_messageInfo_MixerContractConfig proto.InternalMessageInfo

func (m *MixerContractConfig) GetSigmoid() MixerContractConfig_Sigmoid {
	if m != nil {
		return m.Sigmoid
	}
	return MixerContractConfig_Sigmoid{}
}

type MixerContractConfig_Sigmoid struct {
	MaxPoints uint64                                 `protobuf:"varint,1,opt,name=max_points,json=maxPoints,proto3" json:"max_points,omitempty"`
	P         github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=p,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"p"`
	S         github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=s,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"s"`
}

func (m *MixerContractConfig_Sigmoid) Reset()         { *m = MixerContractConfig_Sigmoid{} }
func (m *MixerContractConfig_Sigmoid) String() string { return proto.CompactTextString(m) }
func (*MixerContractConfig_Sigmoid) ProtoMessage()    {}
func (*MixerContractConfig_Sigmoid) Descriptor() ([]byte, []int) {
	return fileDescriptor_a165193bab811d9d, []int{3, 0}
}

func (m *MixerContractConfig_Sigmoid) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *MixerContractConfig_Sigmoid) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MixerContractConfig_Sigmoid.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 *MixerContractConfig_Sigmoid) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MixerContractConfig_Sigmoid.Merge(m, src)
}

func (m *MixerContractConfig_Sigmoid) XXX_Size() int {
	return m.Size()
}

func (m *MixerContractConfig_Sigmoid) XXX_DiscardUnknown() {
	xxx_messageInfo_MixerContractConfig_Sigmoid.DiscardUnknown(m)
}

var xxx_messageInfo_MixerContractConfig_Sigmoid proto.InternalMessageInfo

func (m *MixerContractConfig_Sigmoid) GetMaxPoints() uint64 {
	if m != nil {
		return m.MaxPoints
	}
	return 0
}

// StakeContractConfig initial setup config
type StakeContractConfig struct {
	MinBond              uint64        `protobuf:"varint,1,opt,name=min_bond,json=minBond,proto3" json:"min_bond,omitempty"`
	TokensPerPoint       uint64        `protobuf:"varint,2,opt,name=tokens_per_point,json=tokensPerPoint,proto3" json:"tokens_per_point,omitempty"`
	UnbondingPeriod      time.Duration `protobuf:"bytes,3,opt,name=unbonding_period,json=unbondingPeriod,proto3,stdduration" json:"unbonding_period"`
	ClaimAutoreturnLimit uint32        `protobuf:"varint,4,opt,name=claim_autoreturn_limit,json=claimAutoreturnLimit,proto3" json:"claim_autoreturn_limit,omitempty"`
}

func (m *StakeContractConfig) Reset()         { *m = StakeContractConfig{} }
func (m *StakeContractConfig) String() string { return proto.CompactTextString(m) }
func (*StakeContractConfig) ProtoMessage()    {}
func (*StakeContractConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_a165193bab811d9d, []int{4}
}

func (m *StakeContractConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *StakeContractConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StakeContractConfig.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 *StakeContractConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StakeContractConfig.Merge(m, src)
}

func (m *StakeContractConfig) XXX_Size() int {
	return m.Size()
}

func (m *StakeContractConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_StakeContractConfig.DiscardUnknown(m)
}

var xxx_messageInfo_StakeContractConfig proto.InternalMessageInfo

func (m *StakeContractConfig) GetMinBond() uint64 {
	if m != nil {
		return m.MinBond
	}
	return 0
}

func (m *StakeContractConfig) GetTokensPerPoint() uint64 {
	if m != nil {
		return m.TokensPerPoint
	}
	return 0
}

func (m *StakeContractConfig) GetUnbondingPeriod() time.Duration {
	if m != nil {
		return m.UnbondingPeriod
	}
	return 0
}

func (m *StakeContractConfig) GetClaimAutoreturnLimit() uint32 {
	if m != nil {
		return m.ClaimAutoreturnLimit
	}
	return 0
}

// ValsetContractConfig initial setup config
type ValsetContractConfig struct {
	MinPoints uint64 `protobuf:"varint,1,opt,name=min_points,json=minPoints,proto3" json:"min_points,omitempty"`
	// MaxValidators The maximum number of validators that can be included in the
	// Tendermint validator set.
	MaxValidators uint32 `protobuf:"varint,2,opt,name=max_validators,json=maxValidators,proto3" json:"max_validators,omitempty"`
	// EpochLength We update the Tendermint validator set only once per epoch.
	// Epoch # is env.block.time/epoch_length (round down). The first block with a
	// new epoch number will trigger a new validator calculation.
	EpochLength time.Duration `protobuf:"bytes,3,opt,name=epoch_length,json=epochLength,proto3,stdduration" json:"epoch_length"`
	EpochReward types.Coin    `protobuf:"bytes,4,opt,name=epoch_reward,json=epochReward,proto3" json:"epoch_reward"`
	// Scaling is the factor to multiply cw4-group weights to produce the
	// Tendermint validator power
	Scaling uint32 `protobuf:"varint,5,opt,name=scaling,proto3" json:"scaling,omitempty"`
	// FeePercentage is the percentage of total accumulated fees that is
	// subtracted from tokens minted as rewards. 50% by default. To disable this
	// feature just set it to 0 (which effectively means that fees don't affect
	// the per-epoch reward).
	FeePercentage github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,6,opt,name=fee_percentage,json=feePercentage,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"fee_percentage"`
	// CommunityPoolRewardRation in percentage
	CommunityPoolRewardRatio github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,7,opt,name=community_pool_reward_ratio,json=communityPoolRewardRatio,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"community_pool_reward_ratio"`
	// EngagementRewardRatio reward ration in percentage for all
	EngagementRewardRatio github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,8,opt,name=engagement_reward_ratio,json=engagementRewardRatio,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"engagement_reward_ratio"`
	// ValidatorRewardRation in percentage for all
	ValidatorRewardRatio github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,9,opt,name=validator_reward_ratio,json=validatorRewardRatio,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"validator_reward_ratio"`
	// AutoUnjail if set to true, we will auto-unjail any validator after their
	// jailtime is over.
	AutoUnjail bool `protobuf:"varint,10,opt,name=auto_unjail,json=autoUnjail,proto3" json:"auto_unjail,omitempty"`
	// DoubleSignSlashRatio Validators who are caught double signing are jailed
	// forever and their bonded tokens are slashed based on this value.
	DoubleSignSlashRatio github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,11,opt,name=double_sign_slash_ratio,json=doubleSignSlashRatio,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"double_sign_slash_ratio"`
	// When a validator joins the valset, verify they sign the first block since
	// joining or jail them for a period otherwise.
	//
	// The verification happens every time the validator becomes an active
	// validator, including when they are unjailed or when they just gain enough
	// power to participate.
	VerifyValidators bool `protobuf:"varint,12,opt,name=verify_validators,json=verifyValidators,proto3" json:"verify_validators,omitempty"`
	// OfflineJailDuration duration to jail a validator for in case they don't
	// sign their first epoch boundary block. After the period, they have to pass
	// verification again, ad infinitum.
	OfflineJailDuration time.Duration `protobuf:"bytes,13,opt,name=offlineJailDuration,proto3,stdduration" json:"offlineJailDuration"`
}

func (m *ValsetContractConfig) Reset()         { *m = ValsetContractConfig{} }
func (m *ValsetContractConfig) String() string { return proto.CompactTextString(m) }
func (*ValsetContractConfig) ProtoMessage()    {}
func (*ValsetContractConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_a165193bab811d9d, []int{5}
}

func (m *ValsetContractConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ValsetContractConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValsetContractConfig.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 *ValsetContractConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValsetContractConfig.Merge(m, src)
}

func (m *ValsetContractConfig) XXX_Size() int {
	return m.Size()
}

func (m *ValsetContractConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_ValsetContractConfig.DiscardUnknown(m)
}

var xxx_messageInfo_ValsetContractConfig proto.InternalMessageInfo

func (m *ValsetContractConfig) GetMinPoints() uint64 {
	if m != nil {
		return m.MinPoints
	}
	return 0
}

func (m *ValsetContractConfig) GetMaxValidators() uint32 {
	if m != nil {
		return m.MaxValidators
	}
	return 0
}

func (m *ValsetContractConfig) GetEpochLength() time.Duration {
	if m != nil {
		return m.EpochLength
	}
	return 0
}

func (m *ValsetContractConfig) GetEpochReward() types.Coin {
	if m != nil {
		return m.EpochReward
	}
	return types.Coin{}
}

func (m *ValsetContractConfig) GetScaling() uint32 {
	if m != nil {
		return m.Scaling
	}
	return 0
}

func (m *ValsetContractConfig) GetAutoUnjail() bool {
	if m != nil {
		return m.AutoUnjail
	}
	return false
}

func (m *ValsetContractConfig) GetVerifyValidators() bool {
	if m != nil {
		return m.VerifyValidators
	}
	return false
}

func (m *ValsetContractConfig) GetOfflineJailDuration() time.Duration {
	if m != nil {
		return m.OfflineJailDuration
	}
	return 0
}

// EngagementContractConfig initial setup config
type EngagementContractConfig struct {
	Halflife time.Duration `protobuf:"bytes,1,opt,name=halflife,proto3,stdduration" json:"halflife"`
}

func (m *EngagementContractConfig) Reset()         { *m = EngagementContractConfig{} }
func (m *EngagementContractConfig) String() string { return proto.CompactTextString(m) }
func (*EngagementContractConfig) ProtoMessage()    {}
func (*EngagementContractConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_a165193bab811d9d, []int{6}
}

func (m *EngagementContractConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *EngagementContractConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EngagementContractConfig.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 *EngagementContractConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EngagementContractConfig.Merge(m, src)
}

func (m *EngagementContractConfig) XXX_Size() int {
	return m.Size()
}

func (m *EngagementContractConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_EngagementContractConfig.DiscardUnknown(m)
}

var xxx_messageInfo_EngagementContractConfig proto.InternalMessageInfo

func (m *EngagementContractConfig) GetHalflife() time.Duration {
	if m != nil {
		return m.Halflife
	}
	return 0
}

// OversightCommitteeContractConfig initial setup config for the trusted circle
type OversightCommitteeContractConfig struct {
	// Name of TRUSTED_CIRCLE
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// EscrowAmount The required escrow amount, in the default denom (ufury)
	EscrowAmount types.Coin `protobuf:"bytes,2,opt,name=escrow_amount,json=escrowAmount,proto3" json:"escrow_amount"`
	// VotingRules rules for the tally
	VotingRules VotingRules `protobuf:"bytes,3,opt,name=voting_rules,json=votingRules,proto3" json:"voting_rules"`
	// DenyListContractAddress is an optional cw4 contract with list of addresses
	// denied to be part of TrustedCircle
	DenyListContractAddress string `protobuf:"bytes,4,opt,name=deny_list_contract_address,json=denyListContractAddress,proto3" json:"deny_list_contract_address,omitempty"`
}

func (m *OversightCommitteeContractConfig) Reset()         { *m = OversightCommitteeContractConfig{} }
func (m *OversightCommitteeContractConfig) String() string { return proto.CompactTextString(m) }
func (*OversightCommitteeContractConfig) ProtoMessage()    {}
func (*OversightCommitteeContractConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_a165193bab811d9d, []int{7}
}

func (m *OversightCommitteeContractConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *OversightCommitteeContractConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OversightCommitteeContractConfig.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 *OversightCommitteeContractConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OversightCommitteeContractConfig.Merge(m, src)
}

func (m *OversightCommitteeContractConfig) XXX_Size() int {
	return m.Size()
}

func (m *OversightCommitteeContractConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_OversightCommitteeContractConfig.DiscardUnknown(m)
}

var xxx_messageInfo_OversightCommitteeContractConfig proto.InternalMessageInfo

func (m *OversightCommitteeContractConfig) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *OversightCommitteeContractConfig) GetEscrowAmount() types.Coin {
	if m != nil {
		return m.EscrowAmount
	}
	return types.Coin{}
}

func (m *OversightCommitteeContractConfig) GetVotingRules() VotingRules {
	if m != nil {
		return m.VotingRules
	}
	return VotingRules{}
}

func (m *OversightCommitteeContractConfig) GetDenyListContractAddress() string {
	if m != nil {
		return m.DenyListContractAddress
	}
	return ""
}

// CommunityPoolContractConfig initial setup config for the contract
type CommunityPoolContractConfig struct {
	// VotingRules rules for the tally
	VotingRules VotingRules `protobuf:"bytes,1,opt,name=voting_rules,json=votingRules,proto3" json:"voting_rules"`
}

func (m *CommunityPoolContractConfig) Reset()         { *m = CommunityPoolContractConfig{} }
func (m *CommunityPoolContractConfig) String() string { return proto.CompactTextString(m) }
func (*CommunityPoolContractConfig) ProtoMessage()    {}
func (*CommunityPoolContractConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_a165193bab811d9d, []int{8}
}

func (m *CommunityPoolContractConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *CommunityPoolContractConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CommunityPoolContractConfig.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 *CommunityPoolContractConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommunityPoolContractConfig.Merge(m, src)
}

func (m *CommunityPoolContractConfig) XXX_Size() int {
	return m.Size()
}

func (m *CommunityPoolContractConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_CommunityPoolContractConfig.DiscardUnknown(m)
}

var xxx_messageInfo_CommunityPoolContractConfig proto.InternalMessageInfo

func (m *CommunityPoolContractConfig) GetVotingRules() VotingRules {
	if m != nil {
		return m.VotingRules
	}
	return VotingRules{}
}

// ValidatorVotingContractConfig CommunityPoolContractConfig
type ValidatorVotingContractConfig struct {
	// VotingRules rules for the tally
	VotingRules VotingRules `protobuf:"bytes,1,opt,name=voting_rules,json=votingRules,proto3" json:"voting_rules"`
}

func (m *ValidatorVotingContractConfig) Reset()         { *m = ValidatorVotingContractConfig{} }
func (m *ValidatorVotingContractConfig) String() string { return proto.CompactTextString(m) }
func (*ValidatorVotingContractConfig) ProtoMessage()    {}
func (*ValidatorVotingContractConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_a165193bab811d9d, []int{9}
}

func (m *ValidatorVotingContractConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ValidatorVotingContractConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorVotingContractConfig.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 *ValidatorVotingContractConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorVotingContractConfig.Merge(m, src)
}

func (m *ValidatorVotingContractConfig) XXX_Size() int {
	return m.Size()
}

func (m *ValidatorVotingContractConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorVotingContractConfig.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorVotingContractConfig proto.InternalMessageInfo

func (m *ValidatorVotingContractConfig) GetVotingRules() VotingRules {
	if m != nil {
		return m.VotingRules
	}
	return VotingRules{}
}

// PoEContract address and type information
type PoEContract struct {
	// ContractType type.
	ContractType PoEContractType `protobuf:"varint,1,opt,name=contract_type,json=contractType,proto3,enum=confio.poe.v1beta1.PoEContractType" json:"contract_type,omitempty"`
	// Address is the bech32 address string
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

func (m *PoEContract) Reset()         { *m = PoEContract{} }
func (m *PoEContract) String() string { return proto.CompactTextString(m) }
func (*PoEContract) ProtoMessage()    {}
func (*PoEContract) Descriptor() ([]byte, []int) {
	return fileDescriptor_a165193bab811d9d, []int{10}
}

func (m *PoEContract) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *PoEContract) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PoEContract.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 *PoEContract) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PoEContract.Merge(m, src)
}

func (m *PoEContract) XXX_Size() int {
	return m.Size()
}

func (m *PoEContract) XXX_DiscardUnknown() {
	xxx_messageInfo_PoEContract.DiscardUnknown(m)
}

var xxx_messageInfo_PoEContract proto.InternalMessageInfo

func (m *PoEContract) GetContractType() PoEContractType {
	if m != nil {
		return m.ContractType
	}
	return PoEContractTypeUndefined
}

func (m *PoEContract) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

// TG4Member member of the Engagement group.
type TG4Member struct {
	// Address is the bech32 address string
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address"`
	Points  uint64 `protobuf:"varint,2,opt,name=points,proto3" json:"points"`
}

func (m *TG4Member) Reset()         { *m = TG4Member{} }
func (m *TG4Member) String() string { return proto.CompactTextString(m) }
func (*TG4Member) ProtoMessage()    {}
func (*TG4Member) Descriptor() ([]byte, []int) {
	return fileDescriptor_a165193bab811d9d, []int{11}
}

func (m *TG4Member) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *TG4Member) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TG4Member.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 *TG4Member) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TG4Member.Merge(m, src)
}

func (m *TG4Member) XXX_Size() int {
	return m.Size()
}

func (m *TG4Member) XXX_DiscardUnknown() {
	xxx_messageInfo_TG4Member.DiscardUnknown(m)
}

var xxx_messageInfo_TG4Member proto.InternalMessageInfo

func (m *TG4Member) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *TG4Member) GetPoints() uint64 {
	if m != nil {
		return m.Points
	}
	return 0
}

// VotingRules contains configuration for the tally.
type VotingRules struct {
	// VotingPeriod Voting period in days
	VotingPeriod uint32 `protobuf:"varint,1,opt,name=voting_period,json=votingPeriod,proto3" json:"voting_period,omitempty"`
	// Quorum  voting quorum percentage (1-100)
	Quorum github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=quorum,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"quorum"`
	// Threshold voting threshold percentage (50-100)
	Threshold github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=threshold,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"threshold"`
	// AllowEndEarly If true, and absolute threshold and quorum are met, we can
	// end before voting period finished. (Recommended value: true, unless you
	// have special needs)
	AllowEndEarly bool `protobuf:"varint,4,opt,name=allow_end_early,json=allowEndEarly,proto3" json:"allow_end_early,omitempty"`
}

func (m *VotingRules) Reset()         { *m = VotingRules{} }
func (m *VotingRules) String() string { return proto.CompactTextString(m) }
func (*VotingRules) ProtoMessage()    {}
func (*VotingRules) Descriptor() ([]byte, []int) {
	return fileDescriptor_a165193bab811d9d, []int{12}
}

func (m *VotingRules) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *VotingRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_VotingRules.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 *VotingRules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VotingRules.Merge(m, src)
}

func (m *VotingRules) XXX_Size() int {
	return m.Size()
}

func (m *VotingRules) XXX_DiscardUnknown() {
	xxx_messageInfo_VotingRules.DiscardUnknown(m)
}

var xxx_messageInfo_VotingRules proto.InternalMessageInfo

func (m *VotingRules) GetVotingPeriod() uint32 {
	if m != nil {
		return m.VotingPeriod
	}
	return 0
}

func (m *VotingRules) GetAllowEndEarly() bool {
	if m != nil {
		return m.AllowEndEarly
	}
	return false
}

// ArbiterPoolContractConfig initial setup config for the trusted circle
type ArbiterPoolContractConfig struct {
	// Name of TRUSTED_CIRCLE
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// EscrowAmount The required escrow amount, in the default denom (ufury)
	EscrowAmount types.Coin `protobuf:"bytes,2,opt,name=escrow_amount,json=escrowAmount,proto3" json:"escrow_amount"`
	// VotingRules rules for the tally
	VotingRules VotingRules `protobuf:"bytes,3,opt,name=voting_rules,json=votingRules,proto3" json:"voting_rules"`
	// DenyListContractAddress is an optional cw4 contract with list of addresses
	// denied to be part of TrustedCircle
	DenyListContractAddress string `protobuf:"bytes,4,opt,name=deny_list_contract_address,json=denyListContractAddress,proto3" json:"deny_list_contract_address,omitempty"`
	// DisputeCost The required dispute amount, in the default denom (ufury)
	DisputeCost   types.Coin    `protobuf:"bytes,5,opt,name=dispute_cost,json=disputeCost,proto3" json:"dispute_cost"`
	WaitingPeriod time.Duration `protobuf:"bytes,6,opt,name=waiting_period,json=waitingPeriod,proto3,stdduration" json:"waiting_period"`
}

func (m *ArbiterPoolContractConfig) Reset()         { *m = ArbiterPoolContractConfig{} }
func (m *ArbiterPoolContractConfig) String() string { return proto.CompactTextString(m) }
func (*ArbiterPoolContractConfig) ProtoMessage()    {}
func (*ArbiterPoolContractConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_a165193bab811d9d, []int{13}
}

func (m *ArbiterPoolContractConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ArbiterPoolContractConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ArbiterPoolContractConfig.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 *ArbiterPoolContractConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ArbiterPoolContractConfig.Merge(m, src)
}

func (m *ArbiterPoolContractConfig) XXX_Size() int {
	return m.Size()
}

func (m *ArbiterPoolContractConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_ArbiterPoolContractConfig.DiscardUnknown(m)
}

var xxx_messageInfo_ArbiterPoolContractConfig proto.InternalMessageInfo

func (m *ArbiterPoolContractConfig) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ArbiterPoolContractConfig) GetEscrowAmount() types.Coin {
	if m != nil {
		return m.EscrowAmount
	}
	return types.Coin{}
}

func (m *ArbiterPoolContractConfig) GetVotingRules() VotingRules {
	if m != nil {
		return m.VotingRules
	}
	return VotingRules{}
}

func (m *ArbiterPoolContractConfig) GetDenyListContractAddress() string {
	if m != nil {
		return m.DenyListContractAddress
	}
	return ""
}

func (m *ArbiterPoolContractConfig) GetDisputeCost() types.Coin {
	if m != nil {
		return m.DisputeCost
	}
	return types.Coin{}
}

func (m *ArbiterPoolContractConfig) GetWaitingPeriod() time.Duration {
	if m != nil {
		return m.WaitingPeriod
	}
	return 0
}

func init() {
	proto.RegisterType((*GenesisState)(nil), "confio.poe.v1beta1.GenesisState")
	proto.RegisterType((*ImportDump)(nil), "confio.poe.v1beta1.ImportDump")
	proto.RegisterType((*SeedContracts)(nil), "confio.poe.v1beta1.SeedContracts")
	proto.RegisterType((*MixerContractConfig)(nil), "confio.poe.v1beta1.MixerContractConfig")
	proto.RegisterType((*MixerContractConfig_Sigmoid)(nil), "confio.poe.v1beta1.MixerContractConfig.Sigmoid")
	proto.RegisterType((*StakeContractConfig)(nil), "confio.poe.v1beta1.StakeContractConfig")
	proto.RegisterType((*ValsetContractConfig)(nil), "confio.poe.v1beta1.ValsetContractConfig")
	proto.RegisterType((*EngagementContractConfig)(nil), "confio.poe.v1beta1.EngagementContractConfig")
	proto.RegisterType((*OversightCommitteeContractConfig)(nil), "confio.poe.v1beta1.OversightCommitteeContractConfig")
	proto.RegisterType((*CommunityPoolContractConfig)(nil), "confio.poe.v1beta1.CommunityPoolContractConfig")
	proto.RegisterType((*ValidatorVotingContractConfig)(nil), "confio.poe.v1beta1.ValidatorVotingContractConfig")
	proto.RegisterType((*PoEContract)(nil), "confio.poe.v1beta1.PoEContract")
	proto.RegisterType((*TG4Member)(nil), "confio.poe.v1beta1.TG4Member")
	proto.RegisterType((*VotingRules)(nil), "confio.poe.v1beta1.VotingRules")
	proto.RegisterType((*ArbiterPoolContractConfig)(nil), "confio.poe.v1beta1.ArbiterPoolContractConfig")
}

func init() { proto.RegisterFile("confio/poe/v1beta1/genesis.proto", fileDescriptor_a165193bab811d9d) }

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

func (m *GenesisState_SeedContracts) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SeedContracts != nil {
		{
			size, err := m.SeedContracts.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

func (m *GenesisState_ImportDump) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GenesisState_ImportDump) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ImportDump != nil {
		{
			size, err := m.ImportDump.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}

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

func (m *ImportDump) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Contracts) > 0 {
		for iNdEx := len(m.Contracts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Contracts[iNdEx].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 *SeedContracts) 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 *SeedContracts) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SeedContracts) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MixerContractConfig != nil {
		{
			size, err := m.MixerContractConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x72
	}
	if m.ArbiterPoolContractConfig != nil {
		{
			size, err := m.ArbiterPoolContractConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6a
	}
	if len(m.ArbiterPoolMembers) > 0 {
		for iNdEx := len(m.ArbiterPoolMembers) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ArbiterPoolMembers[iNdEx])
			copy(dAtA[i:], m.ArbiterPoolMembers[iNdEx])
			i = encodeVarintGenesis(dAtA, i, uint64(len(m.ArbiterPoolMembers[iNdEx])))
			i--
			dAtA[i] = 0x62
		}
	}
	if len(m.OversightCommunityMembers) > 0 {
		for iNdEx := len(m.OversightCommunityMembers) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.OversightCommunityMembers[iNdEx])
			copy(dAtA[i:], m.OversightCommunityMembers[iNdEx])
			i = encodeVarintGenesis(dAtA, i, uint64(len(m.OversightCommunityMembers[iNdEx])))
			i--
			dAtA[i] = 0x5a
		}
	}
	if m.ValidatorVotingContractConfig != nil {
		{
			size, err := m.ValidatorVotingContractConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.CommunityPoolContractConfig != nil {
		{
			size, err := m.CommunityPoolContractConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.OversightCommitteeContractConfig != nil {
		{
			size, err := m.OversightCommitteeContractConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if len(m.BondDenom) > 0 {
		i -= len(m.BondDenom)
		copy(dAtA[i:], m.BondDenom)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.BondDenom)))
		i--
		dAtA[i] = 0x3a
	}
	if m.EngagementContractConfig != nil {
		{
			size, err := m.EngagementContractConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.ValsetContractConfig != nil {
		{
			size, err := m.ValsetContractConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.StakeContractConfig != nil {
		{
			size, err := m.StakeContractConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Engagement) > 0 {
		for iNdEx := len(m.Engagement) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Engagement[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.BootstrapAccountAddress) > 0 {
		i -= len(m.BootstrapAccountAddress)
		copy(dAtA[i:], m.BootstrapAccountAddress)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.BootstrapAccountAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.GenTxs) > 0 {
		for iNdEx := len(m.GenTxs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.GenTxs[iNdEx])
			copy(dAtA[i:], m.GenTxs[iNdEx])
			i = encodeVarintGenesis(dAtA, i, uint64(len(m.GenTxs[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *MixerContractConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Sigmoid.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 *MixerContractConfig_Sigmoid) 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 *MixerContractConfig_Sigmoid) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MixerContractConfig_Sigmoid) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.S.Size()
		i -= size
		if _, err := m.S.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.P.Size()
		i -= size
		if _, err := m.P.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.MaxPoints != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.MaxPoints))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *StakeContractConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ClaimAutoreturnLimit != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.ClaimAutoreturnLimit))
		i--
		dAtA[i] = 0x20
	}
	n13, err13 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.UnbondingPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.UnbondingPeriod):])
	if err13 != nil {
		return 0, err13
	}
	i -= n13
	i = encodeVarintGenesis(dAtA, i, uint64(n13))
	i--
	dAtA[i] = 0x1a
	if m.TokensPerPoint != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TokensPerPoint))
		i--
		dAtA[i] = 0x10
	}
	if m.MinBond != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.MinBond))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ValsetContractConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n14, err14 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.OfflineJailDuration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.OfflineJailDuration):])
	if err14 != nil {
		return 0, err14
	}
	i -= n14
	i = encodeVarintGenesis(dAtA, i, uint64(n14))
	i--
	dAtA[i] = 0x6a
	if m.VerifyValidators {
		i--
		if m.VerifyValidators {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x60
	}
	{
		size := m.DoubleSignSlashRatio.Size()
		i -= size
		if _, err := m.DoubleSignSlashRatio.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x5a
	if m.AutoUnjail {
		i--
		if m.AutoUnjail {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x50
	}
	{
		size := m.ValidatorRewardRatio.Size()
		i -= size
		if _, err := m.ValidatorRewardRatio.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x4a
	{
		size := m.EngagementRewardRatio.Size()
		i -= size
		if _, err := m.EngagementRewardRatio.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x42
	{
		size := m.CommunityPoolRewardRatio.Size()
		i -= size
		if _, err := m.CommunityPoolRewardRatio.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	{
		size := m.FeePercentage.Size()
		i -= size
		if _, err := m.FeePercentage.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	if m.Scaling != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.Scaling))
		i--
		dAtA[i] = 0x28
	}
	{
		size, err := m.EpochReward.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	n16, err16 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.EpochLength, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.EpochLength):])
	if err16 != nil {
		return 0, err16
	}
	i -= n16
	i = encodeVarintGenesis(dAtA, i, uint64(n16))
	i--
	dAtA[i] = 0x1a
	if m.MaxValidators != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.MaxValidators))
		i--
		dAtA[i] = 0x10
	}
	if m.MinPoints != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.MinPoints))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *EngagementContractConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n17, err17 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Halflife, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Halflife):])
	if err17 != nil {
		return 0, err17
	}
	i -= n17
	i = encodeVarintGenesis(dAtA, i, uint64(n17))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *OversightCommitteeContractConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DenyListContractAddress) > 0 {
		i -= len(m.DenyListContractAddress)
		copy(dAtA[i:], m.DenyListContractAddress)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.DenyListContractAddress)))
		i--
		dAtA[i] = 0x22
	}
	{
		size, err := m.VotingRules.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.EscrowAmount.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CommunityPoolContractConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.VotingRules.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 *ValidatorVotingContractConfig) 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 *ValidatorVotingContractConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValidatorVotingContractConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.VotingRules.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 *PoEContract) 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 *PoEContract) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PoEContract) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if m.ContractType != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.ContractType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *VotingRules) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.AllowEndEarly {
		i--
		if m.AllowEndEarly {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	{
		size := m.Threshold.Size()
		i -= size
		if _, err := m.Threshold.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.Quorum.Size()
		i -= size
		if _, err := m.Quorum.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.VotingPeriod != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.VotingPeriod))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ArbiterPoolContractConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n22, err22 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.WaitingPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.WaitingPeriod):])
	if err22 != nil {
		return 0, err22
	}
	i -= n22
	i = encodeVarintGenesis(dAtA, i, uint64(n22))
	i--
	dAtA[i] = 0x32
	{
		size, err := m.DisputeCost.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if len(m.DenyListContractAddress) > 0 {
		i -= len(m.DenyListContractAddress)
		copy(dAtA[i:], m.DenyListContractAddress)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.DenyListContractAddress)))
		i--
		dAtA[i] = 0x22
	}
	{
		size, err := m.VotingRules.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.EscrowAmount.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Name)))
		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 m.SetupMode != nil {
		n += m.SetupMode.Size()
	}
	return n
}

func (m *GenesisState_SeedContracts) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SeedContracts != nil {
		l = m.SeedContracts.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *GenesisState_ImportDump) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ImportDump != nil {
		l = m.ImportDump.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

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

func (m *SeedContracts) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.GenTxs) > 0 {
		for _, b := range m.GenTxs {
			l = len(b)
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	l = len(m.BootstrapAccountAddress)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if len(m.Engagement) > 0 {
		for _, e := range m.Engagement {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if m.StakeContractConfig != nil {
		l = m.StakeContractConfig.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.ValsetContractConfig != nil {
		l = m.ValsetContractConfig.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.EngagementContractConfig != nil {
		l = m.EngagementContractConfig.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = len(m.BondDenom)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.OversightCommitteeContractConfig != nil {
		l = m.OversightCommitteeContractConfig.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.CommunityPoolContractConfig != nil {
		l = m.CommunityPoolContractConfig.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.ValidatorVotingContractConfig != nil {
		l = m.ValidatorVotingContractConfig.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	if len(m.OversightCommunityMembers) > 0 {
		for _, s := range m.OversightCommunityMembers {
			l = len(s)
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.ArbiterPoolMembers) > 0 {
		for _, s := range m.ArbiterPoolMembers {
			l = len(s)
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if m.ArbiterPoolContractConfig != nil {
		l = m.ArbiterPoolContractConfig.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.MixerContractConfig != nil {
		l = m.MixerContractConfig.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *MixerContractConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Sigmoid.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *MixerContractConfig_Sigmoid) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MaxPoints != 0 {
		n += 1 + sovGenesis(uint64(m.MaxPoints))
	}
	l = m.P.Size()
	n += 1 + l + sovGenesis(uint64(l))
	l = m.S.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *StakeContractConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MinBond != 0 {
		n += 1 + sovGenesis(uint64(m.MinBond))
	}
	if m.TokensPerPoint != 0 {
		n += 1 + sovGenesis(uint64(m.TokensPerPoint))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.UnbondingPeriod)
	n += 1 + l + sovGenesis(uint64(l))
	if m.ClaimAutoreturnLimit != 0 {
		n += 1 + sovGenesis(uint64(m.ClaimAutoreturnLimit))
	}
	return n
}

func (m *ValsetContractConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MinPoints != 0 {
		n += 1 + sovGenesis(uint64(m.MinPoints))
	}
	if m.MaxValidators != 0 {
		n += 1 + sovGenesis(uint64(m.MaxValidators))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.EpochLength)
	n += 1 + l + sovGenesis(uint64(l))
	l = m.EpochReward.Size()
	n += 1 + l + sovGenesis(uint64(l))
	if m.Scaling != 0 {
		n += 1 + sovGenesis(uint64(m.Scaling))
	}
	l = m.FeePercentage.Size()
	n += 1 + l + sovGenesis(uint64(l))
	l = m.CommunityPoolRewardRatio.Size()
	n += 1 + l + sovGenesis(uint64(l))
	l = m.EngagementRewardRatio.Size()
	n += 1 + l + sovGenesis(uint64(l))
	l = m.ValidatorRewardRatio.Size()
	n += 1 + l + sovGenesis(uint64(l))
	if m.AutoUnjail {
		n += 2
	}
	l = m.DoubleSignSlashRatio.Size()
	n += 1 + l + sovGenesis(uint64(l))
	if m.VerifyValidators {
		n += 2
	}
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.OfflineJailDuration)
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *EngagementContractConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Halflife)
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *OversightCommitteeContractConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = m.EscrowAmount.Size()
	n += 1 + l + sovGenesis(uint64(l))
	l = m.VotingRules.Size()
	n += 1 + l + sovGenesis(uint64(l))
	l = len(m.DenyListContractAddress)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *CommunityPoolContractConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.VotingRules.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *ValidatorVotingContractConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.VotingRules.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

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

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

func (m *VotingRules) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.VotingPeriod != 0 {
		n += 1 + sovGenesis(uint64(m.VotingPeriod))
	}
	l = m.Quorum.Size()
	n += 1 + l + sovGenesis(uint64(l))
	l = m.Threshold.Size()
	n += 1 + l + sovGenesis(uint64(l))
	if m.AllowEndEarly {
		n += 2
	}
	return n
}

func (m *ArbiterPoolContractConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = m.EscrowAmount.Size()
	n += 1 + l + sovGenesis(uint64(l))
	l = m.VotingRules.Size()
	n += 1 + l + sovGenesis(uint64(l))
	l = len(m.DenyListContractAddress)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = m.DisputeCost.Size()
	n += 1 + l + sovGenesis(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.WaitingPeriod)
	n += 1 + l + sovGenesis(uint64(l))
	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 SeedContracts", 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
			}
			v := &SeedContracts{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.SetupMode = &GenesisState_SeedContracts{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImportDump", 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
			}
			v := &ImportDump{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.SetupMode = &GenesisState_ImportDump{v}
			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 *ImportDump) 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: ImportDump: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ImportDump: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Contracts", 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.Contracts = append(m.Contracts, PoEContract{})
			if err := m.Contracts[len(m.Contracts)-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 *SeedContracts) 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: SeedContracts: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SeedContracts: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GenTxs", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GenTxs = append(m.GenTxs, make([]byte, postIndex-iNdEx))
			copy(m.GenTxs[len(m.GenTxs)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BootstrapAccountAddress", 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.BootstrapAccountAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Engagement", 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.Engagement = append(m.Engagement, TG4Member{})
			if err := m.Engagement[len(m.Engagement)-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 StakeContractConfig", 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.StakeContractConfig == nil {
				m.StakeContractConfig = &StakeContractConfig{}
			}
			if err := m.StakeContractConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValsetContractConfig", 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.ValsetContractConfig == nil {
				m.ValsetContractConfig = &ValsetContractConfig{}
			}
			if err := m.ValsetContractConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EngagementContractConfig", 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.EngagementContractConfig == nil {
				m.EngagementContractConfig = &EngagementContractConfig{}
			}
			if err := m.EngagementContractConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BondDenom", 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.BondDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OversightCommitteeContractConfig", 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.OversightCommitteeContractConfig == nil {
				m.OversightCommitteeContractConfig = &OversightCommitteeContractConfig{}
			}
			if err := m.OversightCommitteeContractConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolContractConfig", 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.CommunityPoolContractConfig == nil {
				m.CommunityPoolContractConfig = &CommunityPoolContractConfig{}
			}
			if err := m.CommunityPoolContractConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorVotingContractConfig", 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.ValidatorVotingContractConfig == nil {
				m.ValidatorVotingContractConfig = &ValidatorVotingContractConfig{}
			}
			if err := m.ValidatorVotingContractConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OversightCommunityMembers", 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.OversightCommunityMembers = append(m.OversightCommunityMembers, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ArbiterPoolMembers", 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.ArbiterPoolMembers = append(m.ArbiterPoolMembers, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ArbiterPoolContractConfig", 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.ArbiterPoolContractConfig == nil {
				m.ArbiterPoolContractConfig = &ArbiterPoolContractConfig{}
			}
			if err := m.ArbiterPoolContractConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MixerContractConfig", 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.MixerContractConfig == nil {
				m.MixerContractConfig = &MixerContractConfig{}
			}
			if err := m.MixerContractConfig.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 *MixerContractConfig) 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: MixerContractConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MixerContractConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sigmoid", 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.Sigmoid.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 *MixerContractConfig_Sigmoid) 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: Sigmoid: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Sigmoid: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxPoints", wireType)
			}
			m.MaxPoints = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxPoints |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field P", 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.P.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field S", 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.S.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 *StakeContractConfig) 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: StakeContractConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StakeContractConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinBond", wireType)
			}
			m.MinBond = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinBond |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokensPerPoint", wireType)
			}
			m.TokensPerPoint = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TokensPerPoint |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingPeriod", 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 := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.UnbondingPeriod, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClaimAutoreturnLimit", wireType)
			}
			m.ClaimAutoreturnLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ClaimAutoreturnLimit |= 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 *ValsetContractConfig) 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: ValsetContractConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValsetContractConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinPoints", wireType)
			}
			m.MinPoints = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinPoints |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxValidators", wireType)
			}
			m.MaxValidators = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxValidators |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochLength", 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 := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.EpochLength, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochReward", 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.EpochReward.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scaling", wireType)
			}
			m.Scaling = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Scaling |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FeePercentage", 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.FeePercentage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolRewardRatio", 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.CommunityPoolRewardRatio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EngagementRewardRatio", 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.EngagementRewardRatio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorRewardRatio", 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.ValidatorRewardRatio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AutoUnjail", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AutoUnjail = bool(v != 0)
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DoubleSignSlashRatio", 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.DoubleSignSlashRatio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VerifyValidators", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.VerifyValidators = bool(v != 0)
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OfflineJailDuration", 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 := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.OfflineJailDuration, 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 *EngagementContractConfig) 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: EngagementContractConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EngagementContractConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Halflife", 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 := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.Halflife, 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 *OversightCommitteeContractConfig) 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: OversightCommitteeContractConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OversightCommitteeContractConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", 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.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowAmount", 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.EscrowAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VotingRules", 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.VotingRules.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DenyListContractAddress", 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.DenyListContractAddress = string(dAtA[iNdEx:postIndex])
			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 *CommunityPoolContractConfig) 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: CommunityPoolContractConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CommunityPoolContractConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VotingRules", 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.VotingRules.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 *ValidatorVotingContractConfig) 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: ValidatorVotingContractConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorVotingContractConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VotingRules", 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.VotingRules.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 *PoEContract) 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: PoEContract: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PoEContract: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractType", wireType)
			}
			m.ContractType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ContractType |= PoEContractType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = string(dAtA[iNdEx:postIndex])
			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 *TG4Member) 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: TG4Member: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TG4Member: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Points", wireType)
			}
			m.Points = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Points |= 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 (m *VotingRules) 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: VotingRules: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VotingRules: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VotingPeriod", wireType)
			}
			m.VotingPeriod = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VotingPeriod |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Quorum", 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.Quorum.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Threshold", 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.Threshold.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllowEndEarly", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AllowEndEarly = bool(v != 0)
		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 *ArbiterPoolContractConfig) 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: ArbiterPoolContractConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ArbiterPoolContractConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", 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.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowAmount", 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.EscrowAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VotingRules", 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.VotingRules.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DenyListContractAddress", 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.DenyListContractAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DisputeCost", 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.DisputeCost.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WaitingPeriod", 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 := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.WaitingPeriod, 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 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")
)