genesis.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: mhub2/v1/genesis.proto

package types

import (
	fmt "fmt"
	types "github.com/cosmos/cosmos-sdk/codec/types"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

// 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

// Params represent the Mhub2 genesis and store parameters
// gravity_id:
// a random 32 byte value to prevent signature reuse, for example if the
// cosmos validators decided to use the same Ethereum keys for another chain
// also running Mhub2 we would not want it to be possible to play a deposit
// from chain A back on chain B's Mhub2. This value IS USED ON ETHEREUM so
// it must be set in your genesis.json before launch and not changed after
// deploying Mhub2
//
// contract_hash:
// the code hash of a known good version of the Mhub2 contract
// solidity code. This can be used to verify the correct version
// of the contract has been deployed. This is a reference value for
// goernance action only it is never read by any Mhub2 code
//
// bridge_ethereum_address:
// is address of the bridge contract on the Ethereum side, this is a
// reference value for governance only and is not actually used by any
// Mhub2 code
//
// bridge_chain_id:
// the unique identifier of the Ethereum chain, this is a reference value
// only and is not actually used by any Mhub2 code
//
// These reference values may be used by future Mhub2 client implemetnations
// to allow for saftey features or convenience features like the Mhub2 address
// in your relayer. A relayer would require a configured Mhub2 address if
// governance had not set the address on the chain it was relaying for.
//
// signed_signer_set_txs_window
// signed_batches_window
// signed_ethereum_signatures_window
//
// These values represent the time in blocks that a validator has to submit
// a signature for a batch or valset, or to submit a ethereum_signature for a
// particular attestation nonce. In the case of attestations this clock starts
// when the attestation is created, but only allows for slashing once the event
// has passed
//
// target_eth_tx_timeout:
//
// This is the 'target' value for when ethereum transactions time out, this is a target
// because Ethereum is a probabilistic chain and you can't say for sure what the
// block frequency is ahead of time.
//
// average_block_time
// average_ethereum_block_time
//
// These values are the average Cosmos block time and Ethereum block time
// respectively and they are used to compute what the target batch timeout is. It
// is important that governance updates these in case of any major, prolonged
// change in the time it takes to produce a block
//
// slash_fraction_signer_set_tx
// slash_fraction_batch
// slash_fraction_ethereum_signature
// slash_fraction_conflicting_ethereum_signature
//
// The slashing fractions for the various Mhub2 related slashing conditions.
// The first three refer to not submitting a particular message, the third for
// submitting a different ethereum_signature for the same Ethereum event
type Params struct {
	GravityId                string `protobuf:"bytes,1,opt,name=gravity_id,json=gravityId,proto3" json:"gravity_id,omitempty"`
	ContractSourceHash       string `protobuf:"bytes,2,opt,name=contract_source_hash,json=contractSourceHash,proto3" json:"contract_source_hash,omitempty"`
	BridgeEthereumAddress    string `protobuf:"bytes,4,opt,name=bridge_ethereum_address,json=bridgeEthereumAddress,proto3" json:"bridge_ethereum_address,omitempty"`
	BridgeChainId            uint64 `protobuf:"varint,5,opt,name=bridge_chain_id,json=bridgeChainId,proto3" json:"bridge_chain_id,omitempty"`
	SignedSignerSetTxsWindow uint64 `protobuf:"varint,6,opt,name=signed_signer_set_txs_window,json=signedSignerSetTxsWindow,proto3" json:"signed_signer_set_txs_window,omitempty"`
	SignedBatchesWindow      uint64 `protobuf:"varint,7,opt,name=signed_batches_window,json=signedBatchesWindow,proto3" json:"signed_batches_window,omitempty"`
	EthereumSignaturesWindow uint64 `protobuf:"varint,8,opt,name=ethereum_signatures_window,json=ethereumSignaturesWindow,proto3" json:"ethereum_signatures_window,omitempty"`
	TargetEthTxTimeout       uint64 `protobuf:"varint,10,opt,name=target_eth_tx_timeout,json=targetEthTxTimeout,proto3" json:"target_eth_tx_timeout,omitempty"`
	AverageBlockTime         uint64 `protobuf:"varint,11,opt,name=average_block_time,json=averageBlockTime,proto3" json:"average_block_time,omitempty"`
	AverageEthereumBlockTime uint64 `protobuf:"varint,12,opt,name=average_ethereum_block_time,json=averageEthereumBlockTime,proto3" json:"average_ethereum_block_time,omitempty"`
	AverageBscBlockTime      uint64 `protobuf:"varint,13,opt,name=average_bsc_block_time,json=averageBscBlockTime,proto3" json:"average_bsc_block_time,omitempty"`
	// TODO: slash fraction for contract call txs too
	SlashFractionSignerSetTx                  github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,14,opt,name=slash_fraction_signer_set_tx,json=slashFractionSignerSetTx,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"slash_fraction_signer_set_tx"`
	SlashFractionBatch                        github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,15,opt,name=slash_fraction_batch,json=slashFractionBatch,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"slash_fraction_batch"`
	SlashFractionEthereumSignature            github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,16,opt,name=slash_fraction_ethereum_signature,json=slashFractionEthereumSignature,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"slash_fraction_ethereum_signature"`
	SlashFractionConflictingEthereumSignature github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,17,opt,name=slash_fraction_conflicting_ethereum_signature,json=slashFractionConflictingEthereumSignature,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"slash_fraction_conflicting_ethereum_signature"`
	UnbondSlashingSignerSetTxsWindow          uint64                                 `protobuf:"varint,18,opt,name=unbond_slashing_signer_set_txs_window,json=unbondSlashingSignerSetTxsWindow,proto3" json:"unbond_slashing_signer_set_txs_window,omitempty"`
	Chains                                    []string                               `protobuf:"bytes,19,rep,name=chains,proto3" json:"chains,omitempty"`
	OutgoingTxTimeout                         uint64                                 `protobuf:"varint,20,opt,name=outgoing_tx_timeout,json=outgoingTxTimeout,proto3" json:"outgoing_tx_timeout,omitempty"`
}

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

var xxx_messageInfo_Params proto.InternalMessageInfo

func (m *Params) GetGravityId() string {
	if m != nil {
		return m.GravityId
	}
	return ""
}

func (m *Params) GetContractSourceHash() string {
	if m != nil {
		return m.ContractSourceHash
	}
	return ""
}

func (m *Params) GetBridgeEthereumAddress() string {
	if m != nil {
		return m.BridgeEthereumAddress
	}
	return ""
}

func (m *Params) GetBridgeChainId() uint64 {
	if m != nil {
		return m.BridgeChainId
	}
	return 0
}

func (m *Params) GetSignedSignerSetTxsWindow() uint64 {
	if m != nil {
		return m.SignedSignerSetTxsWindow
	}
	return 0
}

func (m *Params) GetSignedBatchesWindow() uint64 {
	if m != nil {
		return m.SignedBatchesWindow
	}
	return 0
}

func (m *Params) GetEthereumSignaturesWindow() uint64 {
	if m != nil {
		return m.EthereumSignaturesWindow
	}
	return 0
}

func (m *Params) GetTargetEthTxTimeout() uint64 {
	if m != nil {
		return m.TargetEthTxTimeout
	}
	return 0
}

func (m *Params) GetAverageBlockTime() uint64 {
	if m != nil {
		return m.AverageBlockTime
	}
	return 0
}

func (m *Params) GetAverageEthereumBlockTime() uint64 {
	if m != nil {
		return m.AverageEthereumBlockTime
	}
	return 0
}

func (m *Params) GetAverageBscBlockTime() uint64 {
	if m != nil {
		return m.AverageBscBlockTime
	}
	return 0
}

func (m *Params) GetUnbondSlashingSignerSetTxsWindow() uint64 {
	if m != nil {
		return m.UnbondSlashingSignerSetTxsWindow
	}
	return 0
}

func (m *Params) GetChains() []string {
	if m != nil {
		return m.Chains
	}
	return nil
}

func (m *Params) GetOutgoingTxTimeout() uint64 {
	if m != nil {
		return m.OutgoingTxTimeout
	}
	return 0
}

// GenesisState struct
// TODO: this need to be audited and potentially simplified using the new
// interfaces
type GenesisState struct {
	Params         *Params          `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"`
	ExternalStates []*ExternalState `protobuf:"bytes,5,rep,name=external_states,json=externalStates,proto3" json:"external_states,omitempty"`
	TokenInfos     *TokenInfos      `protobuf:"bytes,6,opt,name=token_infos,json=tokenInfos,proto3" json:"token_infos,omitempty"`
}

func (m *GenesisState) Reset()         { *m = GenesisState{} }
func (m *GenesisState) String() string { return proto.CompactTextString(m) }
func (*GenesisState) ProtoMessage()    {}
func (*GenesisState) Descriptor() ([]byte, []int) {
	return fileDescriptor_fae696fa24230542, []int{1}
}
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

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

func (m *GenesisState) GetExternalStates() []*ExternalState {
	if m != nil {
		return m.ExternalStates
	}
	return nil
}

func (m *GenesisState) GetTokenInfos() *TokenInfos {
	if m != nil {
		return m.TokenInfos
	}
	return nil
}

type Nonce struct {
	ValidatorAddress string `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
	LastEventNonce   uint64 `protobuf:"varint,2,opt,name=last_event_nonce,json=lastEventNonce,proto3" json:"last_event_nonce,omitempty"`
}

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

var xxx_messageInfo_Nonce proto.InternalMessageInfo

func (m *Nonce) GetValidatorAddress() string {
	if m != nil {
		return m.ValidatorAddress
	}
	return ""
}

func (m *Nonce) GetLastEventNonce() uint64 {
	if m != nil {
		return m.LastEventNonce
	}
	return 0
}

type ExternalState struct {
	ChainId                    string                     `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	ExternalEventVoteRecords   []*ExternalEventVoteRecord `protobuf:"bytes,2,rep,name=external_event_vote_records,json=externalEventVoteRecords,proto3" json:"external_event_vote_records,omitempty"`
	DelegateKeys               []*MsgDelegateKeys         `protobuf:"bytes,3,rep,name=delegate_keys,json=delegateKeys,proto3" json:"delegate_keys,omitempty"`
	UnbatchedSendToExternalTxs []*SendToExternal          `protobuf:"bytes,4,rep,name=unbatched_send_to_external_txs,json=unbatchedSendToExternalTxs,proto3" json:"unbatched_send_to_external_txs,omitempty"`
	LastObservedEventNonce     uint64                     `protobuf:"varint,5,opt,name=last_observed_event_nonce,json=lastObservedEventNonce,proto3" json:"last_observed_event_nonce,omitempty"`
	OutgoingTxs                []*types.Any               `protobuf:"bytes,6,rep,name=outgoing_txs,json=outgoingTxs,proto3" json:"outgoing_txs,omitempty"`
	Confirmations              []*types.Any               `protobuf:"bytes,7,rep,name=confirmations,proto3" json:"confirmations,omitempty"`
	Sequence                   uint64                     `protobuf:"varint,8,opt,name=sequence,proto3" json:"sequence,omitempty"`
	Nonces                     []*Nonce                   `protobuf:"bytes,9,rep,name=nonces,proto3" json:"nonces,omitempty"`
	LastObservedValset         *SignerSetTx               `protobuf:"bytes,10,opt,name=last_observed_valset,json=lastObservedValset,proto3" json:"last_observed_valset,omitempty"`
	LastOutgoingBatchTxNonce   uint64                     `protobuf:"varint,11,opt,name=last_outgoing_batch_tx_nonce,json=lastOutgoingBatchTxNonce,proto3" json:"last_outgoing_batch_tx_nonce,omitempty"`
	LatestBlockHeight          LatestBlockHeight          `protobuf:"bytes,12,opt,name=latest_block_height,json=latestBlockHeight,proto3" json:"latest_block_height"`
}

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

var xxx_messageInfo_ExternalState proto.InternalMessageInfo

func (m *ExternalState) GetChainId() string {
	if m != nil {
		return m.ChainId
	}
	return ""
}

func (m *ExternalState) GetExternalEventVoteRecords() []*ExternalEventVoteRecord {
	if m != nil {
		return m.ExternalEventVoteRecords
	}
	return nil
}

func (m *ExternalState) GetDelegateKeys() []*MsgDelegateKeys {
	if m != nil {
		return m.DelegateKeys
	}
	return nil
}

func (m *ExternalState) GetUnbatchedSendToExternalTxs() []*SendToExternal {
	if m != nil {
		return m.UnbatchedSendToExternalTxs
	}
	return nil
}

func (m *ExternalState) GetLastObservedEventNonce() uint64 {
	if m != nil {
		return m.LastObservedEventNonce
	}
	return 0
}

func (m *ExternalState) GetOutgoingTxs() []*types.Any {
	if m != nil {
		return m.OutgoingTxs
	}
	return nil
}

func (m *ExternalState) GetConfirmations() []*types.Any {
	if m != nil {
		return m.Confirmations
	}
	return nil
}

func (m *ExternalState) GetSequence() uint64 {
	if m != nil {
		return m.Sequence
	}
	return 0
}

func (m *ExternalState) GetNonces() []*Nonce {
	if m != nil {
		return m.Nonces
	}
	return nil
}

func (m *ExternalState) GetLastObservedValset() *SignerSetTx {
	if m != nil {
		return m.LastObservedValset
	}
	return nil
}

func (m *ExternalState) GetLastOutgoingBatchTxNonce() uint64 {
	if m != nil {
		return m.LastOutgoingBatchTxNonce
	}
	return 0
}

func (m *ExternalState) GetLatestBlockHeight() LatestBlockHeight {
	if m != nil {
		return m.LatestBlockHeight
	}
	return LatestBlockHeight{}
}

func init() {
	proto.RegisterType((*Params)(nil), "mhub2.v1.Params")
	proto.RegisterType((*GenesisState)(nil), "mhub2.v1.GenesisState")
	proto.RegisterType((*Nonce)(nil), "mhub2.v1.Nonce")
	proto.RegisterType((*ExternalState)(nil), "mhub2.v1.ExternalState")
}

func init() { proto.RegisterFile("mhub2/v1/genesis.proto", fileDescriptor_fae696fa24230542) }

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

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

func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.OutgoingTxTimeout != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.OutgoingTxTimeout))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa0
	}
	if len(m.Chains) > 0 {
		for iNdEx := len(m.Chains) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Chains[iNdEx])
			copy(dAtA[i:], m.Chains[iNdEx])
			i = encodeVarintGenesis(dAtA, i, uint64(len(m.Chains[iNdEx])))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	if m.UnbondSlashingSignerSetTxsWindow != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.UnbondSlashingSignerSetTxsWindow))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x90
	}
	{
		size := m.SlashFractionConflictingEthereumSignature.Size()
		i -= size
		if _, err := m.SlashFractionConflictingEthereumSignature.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x8a
	{
		size := m.SlashFractionEthereumSignature.Size()
		i -= size
		if _, err := m.SlashFractionEthereumSignature.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x82
	{
		size := m.SlashFractionBatch.Size()
		i -= size
		if _, err := m.SlashFractionBatch.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x7a
	{
		size := m.SlashFractionSignerSetTx.Size()
		i -= size
		if _, err := m.SlashFractionSignerSetTx.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x72
	if m.AverageBscBlockTime != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.AverageBscBlockTime))
		i--
		dAtA[i] = 0x68
	}
	if m.AverageEthereumBlockTime != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.AverageEthereumBlockTime))
		i--
		dAtA[i] = 0x60
	}
	if m.AverageBlockTime != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.AverageBlockTime))
		i--
		dAtA[i] = 0x58
	}
	if m.TargetEthTxTimeout != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TargetEthTxTimeout))
		i--
		dAtA[i] = 0x50
	}
	if m.EthereumSignaturesWindow != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.EthereumSignaturesWindow))
		i--
		dAtA[i] = 0x40
	}
	if m.SignedBatchesWindow != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.SignedBatchesWindow))
		i--
		dAtA[i] = 0x38
	}
	if m.SignedSignerSetTxsWindow != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.SignedSignerSetTxsWindow))
		i--
		dAtA[i] = 0x30
	}
	if m.BridgeChainId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.BridgeChainId))
		i--
		dAtA[i] = 0x28
	}
	if len(m.BridgeEthereumAddress) > 0 {
		i -= len(m.BridgeEthereumAddress)
		copy(dAtA[i:], m.BridgeEthereumAddress)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.BridgeEthereumAddress)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ContractSourceHash) > 0 {
		i -= len(m.ContractSourceHash)
		copy(dAtA[i:], m.ContractSourceHash)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.ContractSourceHash)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.GravityId) > 0 {
		i -= len(m.GravityId)
		copy(dAtA[i:], m.GravityId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.GravityId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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.TokenInfos != nil {
		{
			size, err := m.TokenInfos.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.ExternalStates) > 0 {
		for iNdEx := len(m.ExternalStates) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ExternalStates[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.Params != nil {
		{
			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 *Nonce) 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 *Nonce) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *ExternalState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.LatestBlockHeight.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x62
	if m.LastOutgoingBatchTxNonce != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.LastOutgoingBatchTxNonce))
		i--
		dAtA[i] = 0x58
	}
	if m.LastObservedValset != nil {
		{
			size, err := m.LastObservedValset.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if len(m.Nonces) > 0 {
		for iNdEx := len(m.Nonces) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Nonces[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4a
		}
	}
	if m.Sequence != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.Sequence))
		i--
		dAtA[i] = 0x40
	}
	if len(m.Confirmations) > 0 {
		for iNdEx := len(m.Confirmations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Confirmations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.OutgoingTxs) > 0 {
		for iNdEx := len(m.OutgoingTxs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OutgoingTxs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if m.LastObservedEventNonce != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.LastObservedEventNonce))
		i--
		dAtA[i] = 0x28
	}
	if len(m.UnbatchedSendToExternalTxs) > 0 {
		for iNdEx := len(m.UnbatchedSendToExternalTxs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.UnbatchedSendToExternalTxs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.DelegateKeys) > 0 {
		for iNdEx := len(m.DelegateKeys) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DelegateKeys[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.ExternalEventVoteRecords) > 0 {
		for iNdEx := len(m.ExternalEventVoteRecords) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ExternalEventVoteRecords[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ChainId) > 0 {
		i -= len(m.ChainId)
		copy(dAtA[i:], m.ChainId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.ChainId)))
		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 *Params) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.GravityId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = len(m.ContractSourceHash)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = len(m.BridgeEthereumAddress)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.BridgeChainId != 0 {
		n += 1 + sovGenesis(uint64(m.BridgeChainId))
	}
	if m.SignedSignerSetTxsWindow != 0 {
		n += 1 + sovGenesis(uint64(m.SignedSignerSetTxsWindow))
	}
	if m.SignedBatchesWindow != 0 {
		n += 1 + sovGenesis(uint64(m.SignedBatchesWindow))
	}
	if m.EthereumSignaturesWindow != 0 {
		n += 1 + sovGenesis(uint64(m.EthereumSignaturesWindow))
	}
	if m.TargetEthTxTimeout != 0 {
		n += 1 + sovGenesis(uint64(m.TargetEthTxTimeout))
	}
	if m.AverageBlockTime != 0 {
		n += 1 + sovGenesis(uint64(m.AverageBlockTime))
	}
	if m.AverageEthereumBlockTime != 0 {
		n += 1 + sovGenesis(uint64(m.AverageEthereumBlockTime))
	}
	if m.AverageBscBlockTime != 0 {
		n += 1 + sovGenesis(uint64(m.AverageBscBlockTime))
	}
	l = m.SlashFractionSignerSetTx.Size()
	n += 1 + l + sovGenesis(uint64(l))
	l = m.SlashFractionBatch.Size()
	n += 1 + l + sovGenesis(uint64(l))
	l = m.SlashFractionEthereumSignature.Size()
	n += 2 + l + sovGenesis(uint64(l))
	l = m.SlashFractionConflictingEthereumSignature.Size()
	n += 2 + l + sovGenesis(uint64(l))
	if m.UnbondSlashingSignerSetTxsWindow != 0 {
		n += 2 + sovGenesis(uint64(m.UnbondSlashingSignerSetTxsWindow))
	}
	if len(m.Chains) > 0 {
		for _, s := range m.Chains {
			l = len(s)
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if m.OutgoingTxTimeout != 0 {
		n += 2 + sovGenesis(uint64(m.OutgoingTxTimeout))
	}
	return n
}

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

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

func (m *ExternalState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if len(m.ExternalEventVoteRecords) > 0 {
		for _, e := range m.ExternalEventVoteRecords {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.DelegateKeys) > 0 {
		for _, e := range m.DelegateKeys {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.UnbatchedSendToExternalTxs) > 0 {
		for _, e := range m.UnbatchedSendToExternalTxs {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if m.LastObservedEventNonce != 0 {
		n += 1 + sovGenesis(uint64(m.LastObservedEventNonce))
	}
	if len(m.OutgoingTxs) > 0 {
		for _, e := range m.OutgoingTxs {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.Confirmations) > 0 {
		for _, e := range m.Confirmations {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if m.Sequence != 0 {
		n += 1 + sovGenesis(uint64(m.Sequence))
	}
	if len(m.Nonces) > 0 {
		for _, e := range m.Nonces {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if m.LastObservedValset != nil {
		l = m.LastObservedValset.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.LastOutgoingBatchTxNonce != 0 {
		n += 1 + sovGenesis(uint64(m.LastOutgoingBatchTxNonce))
	}
	l = m.LatestBlockHeight.Size()
	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 *Params) 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: Params: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GravityId", 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.GravityId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractSourceHash", 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.ContractSourceHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BridgeEthereumAddress", 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.BridgeEthereumAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BridgeChainId", wireType)
			}
			m.BridgeChainId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BridgeChainId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignedSignerSetTxsWindow", wireType)
			}
			m.SignedSignerSetTxsWindow = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SignedSignerSetTxsWindow |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignedBatchesWindow", wireType)
			}
			m.SignedBatchesWindow = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SignedBatchesWindow |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EthereumSignaturesWindow", wireType)
			}
			m.EthereumSignaturesWindow = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EthereumSignaturesWindow |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetEthTxTimeout", wireType)
			}
			m.TargetEthTxTimeout = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TargetEthTxTimeout |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AverageBlockTime", wireType)
			}
			m.AverageBlockTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AverageBlockTime |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AverageEthereumBlockTime", wireType)
			}
			m.AverageEthereumBlockTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AverageEthereumBlockTime |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AverageBscBlockTime", wireType)
			}
			m.AverageBscBlockTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AverageBscBlockTime |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlashFractionSignerSetTx", 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
			}
			if err := m.SlashFractionSignerSetTx.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlashFractionBatch", 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
			}
			if err := m.SlashFractionBatch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlashFractionEthereumSignature", 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
			}
			if err := m.SlashFractionEthereumSignature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlashFractionConflictingEthereumSignature", 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
			}
			if err := m.SlashFractionConflictingEthereumSignature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnbondSlashingSignerSetTxsWindow", wireType)
			}
			m.UnbondSlashingSignerSetTxsWindow = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UnbondSlashingSignerSetTxsWindow |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chains", 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.Chains = append(m.Chains, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 20:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutgoingTxTimeout", wireType)
			}
			m.OutgoingTxTimeout = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OutgoingTxTimeout |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
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 m.Params == nil {
				m.Params = &Params{}
			}
			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExternalStates", 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.ExternalStates = append(m.ExternalStates, &ExternalState{})
			if err := m.ExternalStates[len(m.ExternalStates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenInfos", 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.TokenInfos == nil {
				m.TokenInfos = &TokenInfos{}
			}
			if err := m.TokenInfos.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 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExternalState) 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: ExternalState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExternalState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", 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.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExternalEventVoteRecords", 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.ExternalEventVoteRecords = append(m.ExternalEventVoteRecords, &ExternalEventVoteRecord{})
			if err := m.ExternalEventVoteRecords[len(m.ExternalEventVoteRecords)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegateKeys", 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.DelegateKeys = append(m.DelegateKeys, &MsgDelegateKeys{})
			if err := m.DelegateKeys[len(m.DelegateKeys)-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 UnbatchedSendToExternalTxs", 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.UnbatchedSendToExternalTxs = append(m.UnbatchedSendToExternalTxs, &SendToExternal{})
			if err := m.UnbatchedSendToExternalTxs[len(m.UnbatchedSendToExternalTxs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastObservedEventNonce", wireType)
			}
			m.LastObservedEventNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastObservedEventNonce |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutgoingTxs", 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.OutgoingTxs = append(m.OutgoingTxs, &types.Any{})
			if err := m.OutgoingTxs[len(m.OutgoingTxs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Confirmations", 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.Confirmations = append(m.Confirmations, &types.Any{})
			if err := m.Confirmations[len(m.Confirmations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
			}
			m.Sequence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sequence |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonces", 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.Nonces = append(m.Nonces, &Nonce{})
			if err := m.Nonces[len(m.Nonces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastObservedValset", 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.LastObservedValset == nil {
				m.LastObservedValset = &SignerSetTx{}
			}
			if err := m.LastObservedValset.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastOutgoingBatchTxNonce", wireType)
			}
			m.LastOutgoingBatchTxNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastOutgoingBatchTxNonce |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatestBlockHeight", 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.LatestBlockHeight.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 {
				return ErrInvalidLengthGenesis
			}
			if (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")
)