ethereum.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: ibc/lightclients/ethereum/v1/ethereum.proto

package types

import (
	fmt "fmt"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
	github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types"
	types "github.com/cosmos/ibc-go/v7/modules/core/02-client/types"
	_ "google.golang.org/protobuf/types/known/durationpb"
	_ "google.golang.org/protobuf/types/known/timestamppb"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

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

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

type ClientState struct {
	GenesisValidatorsRoot        []byte          `protobuf:"bytes,1,opt,name=genesis_validators_root,json=genesisValidatorsRoot,proto3" json:"genesis_validators_root,omitempty"`
	MinSyncCommitteeParticipants uint64          `protobuf:"varint,2,opt,name=min_sync_committee_participants,json=minSyncCommitteeParticipants,proto3" json:"min_sync_committee_participants,omitempty"`
	GenesisTime                  uint64          `protobuf:"varint,3,opt,name=genesis_time,json=genesisTime,proto3" json:"genesis_time,omitempty"`
	ForkParameters               *ForkParameters `protobuf:"bytes,4,opt,name=fork_parameters,json=forkParameters,proto3" json:"fork_parameters,omitempty"`
	SecondsPerSlot               uint64          `protobuf:"varint,5,opt,name=seconds_per_slot,json=secondsPerSlot,proto3" json:"seconds_per_slot,omitempty"`
	SlotsPerEpoch                uint64          `protobuf:"varint,6,opt,name=slots_per_epoch,json=slotsPerEpoch,proto3" json:"slots_per_epoch,omitempty"`
	EpochsPerSyncCommitteePeriod uint64          `protobuf:"varint,7,opt,name=epochs_per_sync_committee_period,json=epochsPerSyncCommitteePeriod,proto3" json:"epochs_per_sync_committee_period,omitempty"`
	IbcAddress                   []byte          `protobuf:"bytes,8,opt,name=ibc_address,json=ibcAddress,proto3" json:"ibc_address,omitempty"`
	IbcCommitmentsSlot           []byte          `protobuf:"bytes,9,opt,name=ibc_commitments_slot,json=ibcCommitmentsSlot,proto3" json:"ibc_commitments_slot,omitempty"`
	TrustLevel                   *Fraction       `protobuf:"bytes,10,opt,name=trust_level,json=trustLevel,proto3" json:"trust_level,omitempty"`
	TrustingPeriod               time.Duration   `protobuf:"bytes,11,opt,name=trusting_period,json=trustingPeriod,proto3,stdduration" json:"trusting_period"`
	MaxClockDrift                time.Duration   `protobuf:"bytes,12,opt,name=max_clock_drift,json=maxClockDrift,proto3,stdduration" json:"max_clock_drift"`
	LatestSlot                   uint64          `protobuf:"varint,13,opt,name=latest_slot,json=latestSlot,proto3" json:"latest_slot,omitempty"`
	LatestExecutionBlockNumber   uint64          `protobuf:"varint,14,opt,name=latest_execution_block_number,json=latestExecutionBlockNumber,proto3" json:"latest_execution_block_number,omitempty"`
	FrozenHeight                 *types.Height   `protobuf:"bytes,15,opt,name=frozen_height,json=frozenHeight,proto3" json:"frozen_height,omitempty"`
}

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

var xxx_messageInfo_ClientState proto.InternalMessageInfo

type ConsensusState struct {
	Slot                 uint64    `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"`
	StorageRoot          []byte    `protobuf:"bytes,2,opt,name=storage_root,json=storageRoot,proto3" json:"storage_root,omitempty"`
	Timestamp            time.Time `protobuf:"bytes,3,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
	CurrentSyncCommittee []byte    `protobuf:"bytes,4,opt,name=current_sync_committee,json=currentSyncCommittee,proto3" json:"current_sync_committee,omitempty"`
	NextSyncCommittee    []byte    `protobuf:"bytes,5,opt,name=next_sync_committee,json=nextSyncCommittee,proto3" json:"next_sync_committee,omitempty"`
}

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

var xxx_messageInfo_ConsensusState proto.InternalMessageInfo

type Header struct {
	TrustedSyncCommittee *TrustedSyncCommittee `protobuf:"bytes,1,opt,name=trusted_sync_committee,json=trustedSyncCommittee,proto3" json:"trusted_sync_committee,omitempty"`
	ConsensusUpdate      *LightClientUpdate    `protobuf:"bytes,2,opt,name=consensus_update,json=consensusUpdate,proto3" json:"consensus_update,omitempty"`
	ExecutionUpdate      *ExecutionUpdate      `protobuf:"bytes,3,opt,name=execution_update,json=executionUpdate,proto3" json:"execution_update,omitempty"`
	AccountUpdate        *AccountUpdate        `protobuf:"bytes,4,opt,name=account_update,json=accountUpdate,proto3" json:"account_update,omitempty"`
	// seconds from unix epoch
	Timestamp uint64 `protobuf:"varint,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
}

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

var xxx_messageInfo_Header proto.InternalMessageInfo

type TrustedSyncCommittee struct {
	TrustedHeight *types.Height  `protobuf:"bytes,1,opt,name=trusted_height,json=trustedHeight,proto3" json:"trusted_height,omitempty"`
	SyncCommittee *SyncCommittee `protobuf:"bytes,2,opt,name=sync_committee,json=syncCommittee,proto3" json:"sync_committee,omitempty"`
	IsNext        bool           `protobuf:"varint,3,opt,name=is_next,json=isNext,proto3" json:"is_next,omitempty"`
}

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

var xxx_messageInfo_TrustedSyncCommittee proto.InternalMessageInfo

type ForkParameters struct {
	GenesisForkVersion []byte  `protobuf:"bytes,1,opt,name=genesis_fork_version,json=genesisForkVersion,proto3" json:"genesis_fork_version,omitempty"`
	Forks              []*Fork `protobuf:"bytes,2,rep,name=forks,proto3" json:"forks,omitempty"`
}

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

var xxx_messageInfo_ForkParameters proto.InternalMessageInfo

type Fraction struct {
	Numerator   uint64 `protobuf:"varint,1,opt,name=numerator,proto3" json:"numerator,omitempty"`
	Denominator uint64 `protobuf:"varint,2,opt,name=denominator,proto3" json:"denominator,omitempty"`
}

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

var xxx_messageInfo_Fraction proto.InternalMessageInfo

type Fork struct {
	Version []byte `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	Epoch   uint64 `protobuf:"varint,2,opt,name=epoch,proto3" json:"epoch,omitempty"`
}

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

var xxx_messageInfo_Fork proto.InternalMessageInfo

type LightClientUpdate struct {
	AttestedHeader           *BeaconBlockHeader `protobuf:"bytes,1,opt,name=attested_header,json=attestedHeader,proto3" json:"attested_header,omitempty"`
	NextSyncCommittee        *SyncCommittee     `protobuf:"bytes,2,opt,name=next_sync_committee,json=nextSyncCommittee,proto3" json:"next_sync_committee,omitempty"`
	NextSyncCommitteeBranch  [][]byte           `protobuf:"bytes,3,rep,name=next_sync_committee_branch,json=nextSyncCommitteeBranch,proto3" json:"next_sync_committee_branch,omitempty"`
	FinalizedHeader          *BeaconBlockHeader `protobuf:"bytes,4,opt,name=finalized_header,json=finalizedHeader,proto3" json:"finalized_header,omitempty"`
	FinalizedHeaderBranch    [][]byte           `protobuf:"bytes,5,rep,name=finalized_header_branch,json=finalizedHeaderBranch,proto3" json:"finalized_header_branch,omitempty"`
	FinalizedExecutionRoot   []byte             `protobuf:"bytes,6,opt,name=finalized_execution_root,json=finalizedExecutionRoot,proto3" json:"finalized_execution_root,omitempty"`
	FinalizedExecutionBranch [][]byte           `protobuf:"bytes,7,rep,name=finalized_execution_branch,json=finalizedExecutionBranch,proto3" json:"finalized_execution_branch,omitempty"`
	SyncAggregate            *SyncAggregate     `protobuf:"bytes,8,opt,name=sync_aggregate,json=syncAggregate,proto3" json:"sync_aggregate,omitempty"`
	SignatureSlot            uint64             `protobuf:"varint,9,opt,name=signature_slot,json=signatureSlot,proto3" json:"signature_slot,omitempty"`
}

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

var xxx_messageInfo_LightClientUpdate proto.InternalMessageInfo

type SyncCommittee struct {
	Pubkeys         [][]byte `protobuf:"bytes,1,rep,name=pubkeys,proto3" json:"pubkeys,omitempty"`
	AggregatePubkey []byte   `protobuf:"bytes,2,opt,name=aggregate_pubkey,json=aggregatePubkey,proto3" json:"aggregate_pubkey,omitempty"`
}

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

var xxx_messageInfo_SyncCommittee proto.InternalMessageInfo

type SyncAggregate struct {
	SyncCommitteeBits      []byte `protobuf:"bytes,1,opt,name=sync_committee_bits,json=syncCommitteeBits,proto3" json:"sync_committee_bits,omitempty"`
	SyncCommitteeSignature []byte `protobuf:"bytes,2,opt,name=sync_committee_signature,json=syncCommitteeSignature,proto3" json:"sync_committee_signature,omitempty"`
}

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

var xxx_messageInfo_SyncAggregate proto.InternalMessageInfo

type ExecutionUpdate struct {
	StateRoot         []byte   `protobuf:"bytes,1,opt,name=state_root,json=stateRoot,proto3" json:"state_root,omitempty"`
	StateRootBranch   [][]byte `protobuf:"bytes,2,rep,name=state_root_branch,json=stateRootBranch,proto3" json:"state_root_branch,omitempty"`
	BlockNumber       uint64   `protobuf:"varint,3,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
	BlockNumberBranch [][]byte `protobuf:"bytes,4,rep,name=block_number_branch,json=blockNumberBranch,proto3" json:"block_number_branch,omitempty"`
}

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

var xxx_messageInfo_ExecutionUpdate proto.InternalMessageInfo

type AccountUpdate struct {
	AccountProof       []byte `protobuf:"bytes,1,opt,name=account_proof,json=accountProof,proto3" json:"account_proof,omitempty"`
	AccountStorageRoot []byte `protobuf:"bytes,2,opt,name=account_storage_root,json=accountStorageRoot,proto3" json:"account_storage_root,omitempty"`
}

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

var xxx_messageInfo_AccountUpdate proto.InternalMessageInfo

type BeaconBlockHeader struct {
	Slot          uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"`
	ProposerIndex uint64 `protobuf:"varint,2,opt,name=proposer_index,json=proposerIndex,proto3" json:"proposer_index,omitempty"`
	ParentRoot    []byte `protobuf:"bytes,3,opt,name=parent_root,json=parentRoot,proto3" json:"parent_root,omitempty"`
	StateRoot     []byte `protobuf:"bytes,4,opt,name=state_root,json=stateRoot,proto3" json:"state_root,omitempty"`
	BodyRoot      []byte `protobuf:"bytes,5,opt,name=body_root,json=bodyRoot,proto3" json:"body_root,omitempty"`
}

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

var xxx_messageInfo_BeaconBlockHeader proto.InternalMessageInfo

type FinalizedHeaderMisbehaviour struct {
	ClientId             string                `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	TrustedSyncCommittee *TrustedSyncCommittee `protobuf:"bytes,2,opt,name=trusted_sync_committee,json=trustedSyncCommittee,proto3" json:"trusted_sync_committee,omitempty"`
	ConsensusUpdate_1    *LightClientUpdate    `protobuf:"bytes,3,opt,name=consensus_update_1,json=consensusUpdate1,proto3" json:"consensus_update_1,omitempty"`
	ConsensusUpdate_2    *LightClientUpdate    `protobuf:"bytes,4,opt,name=consensus_update_2,json=consensusUpdate2,proto3" json:"consensus_update_2,omitempty"`
}

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

var xxx_messageInfo_FinalizedHeaderMisbehaviour proto.InternalMessageInfo

type NextSyncCommitteeMisbehaviour struct {
	ClientId             string                `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	TrustedSyncCommittee *TrustedSyncCommittee `protobuf:"bytes,2,opt,name=trusted_sync_committee,json=trustedSyncCommittee,proto3" json:"trusted_sync_committee,omitempty"`
	ConsensusUpdate_1    *LightClientUpdate    `protobuf:"bytes,3,opt,name=consensus_update_1,json=consensusUpdate1,proto3" json:"consensus_update_1,omitempty"`
	ConsensusUpdate_2    *LightClientUpdate    `protobuf:"bytes,4,opt,name=consensus_update_2,json=consensusUpdate2,proto3" json:"consensus_update_2,omitempty"`
}

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

var xxx_messageInfo_NextSyncCommitteeMisbehaviour proto.InternalMessageInfo

func init() {
	proto.RegisterType((*ClientState)(nil), "ibc.lightclients.ethereum.v1.ClientState")
	proto.RegisterType((*ConsensusState)(nil), "ibc.lightclients.ethereum.v1.ConsensusState")
	proto.RegisterType((*Header)(nil), "ibc.lightclients.ethereum.v1.Header")
	proto.RegisterType((*TrustedSyncCommittee)(nil), "ibc.lightclients.ethereum.v1.TrustedSyncCommittee")
	proto.RegisterType((*ForkParameters)(nil), "ibc.lightclients.ethereum.v1.ForkParameters")
	proto.RegisterType((*Fraction)(nil), "ibc.lightclients.ethereum.v1.Fraction")
	proto.RegisterType((*Fork)(nil), "ibc.lightclients.ethereum.v1.Fork")
	proto.RegisterType((*LightClientUpdate)(nil), "ibc.lightclients.ethereum.v1.LightClientUpdate")
	proto.RegisterType((*SyncCommittee)(nil), "ibc.lightclients.ethereum.v1.SyncCommittee")
	proto.RegisterType((*SyncAggregate)(nil), "ibc.lightclients.ethereum.v1.SyncAggregate")
	proto.RegisterType((*ExecutionUpdate)(nil), "ibc.lightclients.ethereum.v1.ExecutionUpdate")
	proto.RegisterType((*AccountUpdate)(nil), "ibc.lightclients.ethereum.v1.AccountUpdate")
	proto.RegisterType((*BeaconBlockHeader)(nil), "ibc.lightclients.ethereum.v1.BeaconBlockHeader")
	proto.RegisterType((*FinalizedHeaderMisbehaviour)(nil), "ibc.lightclients.ethereum.v1.FinalizedHeaderMisbehaviour")
	proto.RegisterType((*NextSyncCommitteeMisbehaviour)(nil), "ibc.lightclients.ethereum.v1.NextSyncCommitteeMisbehaviour")
}

func init() {
	proto.RegisterFile("ibc/lightclients/ethereum/v1/ethereum.proto", fileDescriptor_375052802109acf0)
}

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

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

func (m *ClientState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FrozenHeight != nil {
		{
			size, err := m.FrozenHeight.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	if m.LatestExecutionBlockNumber != 0 {
		i = encodeVarintEthereum(dAtA, i, uint64(m.LatestExecutionBlockNumber))
		i--
		dAtA[i] = 0x70
	}
	if m.LatestSlot != 0 {
		i = encodeVarintEthereum(dAtA, i, uint64(m.LatestSlot))
		i--
		dAtA[i] = 0x68
	}
	n2, err2 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.MaxClockDrift, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.MaxClockDrift):])
	if err2 != nil {
		return 0, err2
	}
	i -= n2
	i = encodeVarintEthereum(dAtA, i, uint64(n2))
	i--
	dAtA[i] = 0x62
	n3, err3 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.TrustingPeriod, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.TrustingPeriod):])
	if err3 != nil {
		return 0, err3
	}
	i -= n3
	i = encodeVarintEthereum(dAtA, i, uint64(n3))
	i--
	dAtA[i] = 0x5a
	if m.TrustLevel != nil {
		{
			size, err := m.TrustLevel.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if len(m.IbcCommitmentsSlot) > 0 {
		i -= len(m.IbcCommitmentsSlot)
		copy(dAtA[i:], m.IbcCommitmentsSlot)
		i = encodeVarintEthereum(dAtA, i, uint64(len(m.IbcCommitmentsSlot)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.IbcAddress) > 0 {
		i -= len(m.IbcAddress)
		copy(dAtA[i:], m.IbcAddress)
		i = encodeVarintEthereum(dAtA, i, uint64(len(m.IbcAddress)))
		i--
		dAtA[i] = 0x42
	}
	if m.EpochsPerSyncCommitteePeriod != 0 {
		i = encodeVarintEthereum(dAtA, i, uint64(m.EpochsPerSyncCommitteePeriod))
		i--
		dAtA[i] = 0x38
	}
	if m.SlotsPerEpoch != 0 {
		i = encodeVarintEthereum(dAtA, i, uint64(m.SlotsPerEpoch))
		i--
		dAtA[i] = 0x30
	}
	if m.SecondsPerSlot != 0 {
		i = encodeVarintEthereum(dAtA, i, uint64(m.SecondsPerSlot))
		i--
		dAtA[i] = 0x28
	}
	if m.ForkParameters != nil {
		{
			size, err := m.ForkParameters.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.GenesisTime != 0 {
		i = encodeVarintEthereum(dAtA, i, uint64(m.GenesisTime))
		i--
		dAtA[i] = 0x18
	}
	if m.MinSyncCommitteeParticipants != 0 {
		i = encodeVarintEthereum(dAtA, i, uint64(m.MinSyncCommitteeParticipants))
		i--
		dAtA[i] = 0x10
	}
	if len(m.GenesisValidatorsRoot) > 0 {
		i -= len(m.GenesisValidatorsRoot)
		copy(dAtA[i:], m.GenesisValidatorsRoot)
		i = encodeVarintEthereum(dAtA, i, uint64(len(m.GenesisValidatorsRoot)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ConsensusState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.NextSyncCommittee) > 0 {
		i -= len(m.NextSyncCommittee)
		copy(dAtA[i:], m.NextSyncCommittee)
		i = encodeVarintEthereum(dAtA, i, uint64(len(m.NextSyncCommittee)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.CurrentSyncCommittee) > 0 {
		i -= len(m.CurrentSyncCommittee)
		copy(dAtA[i:], m.CurrentSyncCommittee)
		i = encodeVarintEthereum(dAtA, i, uint64(len(m.CurrentSyncCommittee)))
		i--
		dAtA[i] = 0x22
	}
	n6, err6 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):])
	if err6 != nil {
		return 0, err6
	}
	i -= n6
	i = encodeVarintEthereum(dAtA, i, uint64(n6))
	i--
	dAtA[i] = 0x1a
	if len(m.StorageRoot) > 0 {
		i -= len(m.StorageRoot)
		copy(dAtA[i:], m.StorageRoot)
		i = encodeVarintEthereum(dAtA, i, uint64(len(m.StorageRoot)))
		i--
		dAtA[i] = 0x12
	}
	if m.Slot != 0 {
		i = encodeVarintEthereum(dAtA, i, uint64(m.Slot))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Header) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Timestamp != 0 {
		i = encodeVarintEthereum(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x28
	}
	if m.AccountUpdate != nil {
		{
			size, err := m.AccountUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.ExecutionUpdate != nil {
		{
			size, err := m.ExecutionUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ConsensusUpdate != nil {
		{
			size, err := m.ConsensusUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.TrustedSyncCommittee != nil {
		{
			size, err := m.TrustedSyncCommittee.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TrustedSyncCommittee) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsNext {
		i--
		if m.IsNext {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.SyncCommittee != nil {
		{
			size, err := m.SyncCommittee.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.TrustedHeight != nil {
		{
			size, err := m.TrustedHeight.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *Fraction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Denominator != 0 {
		i = encodeVarintEthereum(dAtA, i, uint64(m.Denominator))
		i--
		dAtA[i] = 0x10
	}
	if m.Numerator != 0 {
		i = encodeVarintEthereum(dAtA, i, uint64(m.Numerator))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *LightClientUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SignatureSlot != 0 {
		i = encodeVarintEthereum(dAtA, i, uint64(m.SignatureSlot))
		i--
		dAtA[i] = 0x48
	}
	if m.SyncAggregate != nil {
		{
			size, err := m.SyncAggregate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if len(m.FinalizedExecutionBranch) > 0 {
		for iNdEx := len(m.FinalizedExecutionBranch) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.FinalizedExecutionBranch[iNdEx])
			copy(dAtA[i:], m.FinalizedExecutionBranch[iNdEx])
			i = encodeVarintEthereum(dAtA, i, uint64(len(m.FinalizedExecutionBranch[iNdEx])))
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.FinalizedExecutionRoot) > 0 {
		i -= len(m.FinalizedExecutionRoot)
		copy(dAtA[i:], m.FinalizedExecutionRoot)
		i = encodeVarintEthereum(dAtA, i, uint64(len(m.FinalizedExecutionRoot)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.FinalizedHeaderBranch) > 0 {
		for iNdEx := len(m.FinalizedHeaderBranch) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.FinalizedHeaderBranch[iNdEx])
			copy(dAtA[i:], m.FinalizedHeaderBranch[iNdEx])
			i = encodeVarintEthereum(dAtA, i, uint64(len(m.FinalizedHeaderBranch[iNdEx])))
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.FinalizedHeader != nil {
		{
			size, err := m.FinalizedHeader.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.NextSyncCommitteeBranch) > 0 {
		for iNdEx := len(m.NextSyncCommitteeBranch) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.NextSyncCommitteeBranch[iNdEx])
			copy(dAtA[i:], m.NextSyncCommitteeBranch[iNdEx])
			i = encodeVarintEthereum(dAtA, i, uint64(len(m.NextSyncCommitteeBranch[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.NextSyncCommittee != nil {
		{
			size, err := m.NextSyncCommittee.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.AttestedHeader != nil {
		{
			size, err := m.AttestedHeader.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SyncCommittee) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AggregatePubkey) > 0 {
		i -= len(m.AggregatePubkey)
		copy(dAtA[i:], m.AggregatePubkey)
		i = encodeVarintEthereum(dAtA, i, uint64(len(m.AggregatePubkey)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Pubkeys) > 0 {
		for iNdEx := len(m.Pubkeys) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Pubkeys[iNdEx])
			copy(dAtA[i:], m.Pubkeys[iNdEx])
			i = encodeVarintEthereum(dAtA, i, uint64(len(m.Pubkeys[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *SyncAggregate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SyncCommitteeSignature) > 0 {
		i -= len(m.SyncCommitteeSignature)
		copy(dAtA[i:], m.SyncCommitteeSignature)
		i = encodeVarintEthereum(dAtA, i, uint64(len(m.SyncCommitteeSignature)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.SyncCommitteeBits) > 0 {
		i -= len(m.SyncCommitteeBits)
		copy(dAtA[i:], m.SyncCommitteeBits)
		i = encodeVarintEthereum(dAtA, i, uint64(len(m.SyncCommitteeBits)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ExecutionUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BlockNumberBranch) > 0 {
		for iNdEx := len(m.BlockNumberBranch) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockNumberBranch[iNdEx])
			copy(dAtA[i:], m.BlockNumberBranch[iNdEx])
			i = encodeVarintEthereum(dAtA, i, uint64(len(m.BlockNumberBranch[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.BlockNumber != 0 {
		i = encodeVarintEthereum(dAtA, i, uint64(m.BlockNumber))
		i--
		dAtA[i] = 0x18
	}
	if len(m.StateRootBranch) > 0 {
		for iNdEx := len(m.StateRootBranch) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.StateRootBranch[iNdEx])
			copy(dAtA[i:], m.StateRootBranch[iNdEx])
			i = encodeVarintEthereum(dAtA, i, uint64(len(m.StateRootBranch[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.StateRoot) > 0 {
		i -= len(m.StateRoot)
		copy(dAtA[i:], m.StateRoot)
		i = encodeVarintEthereum(dAtA, i, uint64(len(m.StateRoot)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *AccountUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AccountStorageRoot) > 0 {
		i -= len(m.AccountStorageRoot)
		copy(dAtA[i:], m.AccountStorageRoot)
		i = encodeVarintEthereum(dAtA, i, uint64(len(m.AccountStorageRoot)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AccountProof) > 0 {
		i -= len(m.AccountProof)
		copy(dAtA[i:], m.AccountProof)
		i = encodeVarintEthereum(dAtA, i, uint64(len(m.AccountProof)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *BeaconBlockHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BodyRoot) > 0 {
		i -= len(m.BodyRoot)
		copy(dAtA[i:], m.BodyRoot)
		i = encodeVarintEthereum(dAtA, i, uint64(len(m.BodyRoot)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.StateRoot) > 0 {
		i -= len(m.StateRoot)
		copy(dAtA[i:], m.StateRoot)
		i = encodeVarintEthereum(dAtA, i, uint64(len(m.StateRoot)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ParentRoot) > 0 {
		i -= len(m.ParentRoot)
		copy(dAtA[i:], m.ParentRoot)
		i = encodeVarintEthereum(dAtA, i, uint64(len(m.ParentRoot)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ProposerIndex != 0 {
		i = encodeVarintEthereum(dAtA, i, uint64(m.ProposerIndex))
		i--
		dAtA[i] = 0x10
	}
	if m.Slot != 0 {
		i = encodeVarintEthereum(dAtA, i, uint64(m.Slot))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *FinalizedHeaderMisbehaviour) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ConsensusUpdate_2 != nil {
		{
			size, err := m.ConsensusUpdate_2.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.ConsensusUpdate_1 != nil {
		{
			size, err := m.ConsensusUpdate_1.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.TrustedSyncCommittee != nil {
		{
			size, err := m.TrustedSyncCommittee.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.ClientId) > 0 {
		i -= len(m.ClientId)
		copy(dAtA[i:], m.ClientId)
		i = encodeVarintEthereum(dAtA, i, uint64(len(m.ClientId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *NextSyncCommitteeMisbehaviour) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ConsensusUpdate_2 != nil {
		{
			size, err := m.ConsensusUpdate_2.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.ConsensusUpdate_1 != nil {
		{
			size, err := m.ConsensusUpdate_1.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.TrustedSyncCommittee != nil {
		{
			size, err := m.TrustedSyncCommittee.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEthereum(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.ClientId) > 0 {
		i -= len(m.ClientId)
		copy(dAtA[i:], m.ClientId)
		i = encodeVarintEthereum(dAtA, i, uint64(len(m.ClientId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintEthereum(dAtA []byte, offset int, v uint64) int {
	offset -= sovEthereum(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *ClientState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.GenesisValidatorsRoot)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	if m.MinSyncCommitteeParticipants != 0 {
		n += 1 + sovEthereum(uint64(m.MinSyncCommitteeParticipants))
	}
	if m.GenesisTime != 0 {
		n += 1 + sovEthereum(uint64(m.GenesisTime))
	}
	if m.ForkParameters != nil {
		l = m.ForkParameters.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	if m.SecondsPerSlot != 0 {
		n += 1 + sovEthereum(uint64(m.SecondsPerSlot))
	}
	if m.SlotsPerEpoch != 0 {
		n += 1 + sovEthereum(uint64(m.SlotsPerEpoch))
	}
	if m.EpochsPerSyncCommitteePeriod != 0 {
		n += 1 + sovEthereum(uint64(m.EpochsPerSyncCommitteePeriod))
	}
	l = len(m.IbcAddress)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	l = len(m.IbcCommitmentsSlot)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	if m.TrustLevel != nil {
		l = m.TrustLevel.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	l = github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.TrustingPeriod)
	n += 1 + l + sovEthereum(uint64(l))
	l = github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.MaxClockDrift)
	n += 1 + l + sovEthereum(uint64(l))
	if m.LatestSlot != 0 {
		n += 1 + sovEthereum(uint64(m.LatestSlot))
	}
	if m.LatestExecutionBlockNumber != 0 {
		n += 1 + sovEthereum(uint64(m.LatestExecutionBlockNumber))
	}
	if m.FrozenHeight != nil {
		l = m.FrozenHeight.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	return n
}

func (m *ConsensusState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Slot != 0 {
		n += 1 + sovEthereum(uint64(m.Slot))
	}
	l = len(m.StorageRoot)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp)
	n += 1 + l + sovEthereum(uint64(l))
	l = len(m.CurrentSyncCommittee)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	l = len(m.NextSyncCommittee)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	return n
}

func (m *Header) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TrustedSyncCommittee != nil {
		l = m.TrustedSyncCommittee.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	if m.ConsensusUpdate != nil {
		l = m.ConsensusUpdate.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	if m.ExecutionUpdate != nil {
		l = m.ExecutionUpdate.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	if m.AccountUpdate != nil {
		l = m.AccountUpdate.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	if m.Timestamp != 0 {
		n += 1 + sovEthereum(uint64(m.Timestamp))
	}
	return n
}

func (m *TrustedSyncCommittee) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TrustedHeight != nil {
		l = m.TrustedHeight.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	if m.SyncCommittee != nil {
		l = m.SyncCommittee.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	if m.IsNext {
		n += 2
	}
	return n
}

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

func (m *Fraction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Numerator != 0 {
		n += 1 + sovEthereum(uint64(m.Numerator))
	}
	if m.Denominator != 0 {
		n += 1 + sovEthereum(uint64(m.Denominator))
	}
	return n
}

func (m *Fork) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	if m.Epoch != 0 {
		n += 1 + sovEthereum(uint64(m.Epoch))
	}
	return n
}

func (m *LightClientUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AttestedHeader != nil {
		l = m.AttestedHeader.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	if m.NextSyncCommittee != nil {
		l = m.NextSyncCommittee.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	if len(m.NextSyncCommitteeBranch) > 0 {
		for _, b := range m.NextSyncCommitteeBranch {
			l = len(b)
			n += 1 + l + sovEthereum(uint64(l))
		}
	}
	if m.FinalizedHeader != nil {
		l = m.FinalizedHeader.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	if len(m.FinalizedHeaderBranch) > 0 {
		for _, b := range m.FinalizedHeaderBranch {
			l = len(b)
			n += 1 + l + sovEthereum(uint64(l))
		}
	}
	l = len(m.FinalizedExecutionRoot)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	if len(m.FinalizedExecutionBranch) > 0 {
		for _, b := range m.FinalizedExecutionBranch {
			l = len(b)
			n += 1 + l + sovEthereum(uint64(l))
		}
	}
	if m.SyncAggregate != nil {
		l = m.SyncAggregate.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	if m.SignatureSlot != 0 {
		n += 1 + sovEthereum(uint64(m.SignatureSlot))
	}
	return n
}

func (m *SyncCommittee) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Pubkeys) > 0 {
		for _, b := range m.Pubkeys {
			l = len(b)
			n += 1 + l + sovEthereum(uint64(l))
		}
	}
	l = len(m.AggregatePubkey)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	return n
}

func (m *SyncAggregate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SyncCommitteeBits)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	l = len(m.SyncCommitteeSignature)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	return n
}

func (m *ExecutionUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StateRoot)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	if len(m.StateRootBranch) > 0 {
		for _, b := range m.StateRootBranch {
			l = len(b)
			n += 1 + l + sovEthereum(uint64(l))
		}
	}
	if m.BlockNumber != 0 {
		n += 1 + sovEthereum(uint64(m.BlockNumber))
	}
	if len(m.BlockNumberBranch) > 0 {
		for _, b := range m.BlockNumberBranch {
			l = len(b)
			n += 1 + l + sovEthereum(uint64(l))
		}
	}
	return n
}

func (m *AccountUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AccountProof)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	l = len(m.AccountStorageRoot)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	return n
}

func (m *BeaconBlockHeader) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Slot != 0 {
		n += 1 + sovEthereum(uint64(m.Slot))
	}
	if m.ProposerIndex != 0 {
		n += 1 + sovEthereum(uint64(m.ProposerIndex))
	}
	l = len(m.ParentRoot)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	l = len(m.StateRoot)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	l = len(m.BodyRoot)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	return n
}

func (m *FinalizedHeaderMisbehaviour) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ClientId)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	if m.TrustedSyncCommittee != nil {
		l = m.TrustedSyncCommittee.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	if m.ConsensusUpdate_1 != nil {
		l = m.ConsensusUpdate_1.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	if m.ConsensusUpdate_2 != nil {
		l = m.ConsensusUpdate_2.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	return n
}

func (m *NextSyncCommitteeMisbehaviour) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ClientId)
	if l > 0 {
		n += 1 + l + sovEthereum(uint64(l))
	}
	if m.TrustedSyncCommittee != nil {
		l = m.TrustedSyncCommittee.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	if m.ConsensusUpdate_1 != nil {
		l = m.ConsensusUpdate_1.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	if m.ConsensusUpdate_2 != nil {
		l = m.ConsensusUpdate_2.Size()
		n += 1 + l + sovEthereum(uint64(l))
	}
	return n
}

func sovEthereum(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozEthereum(x uint64) (n int) {
	return sovEthereum(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ClientState) 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 ErrIntOverflowEthereum
			}
			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: ClientState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClientState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GenesisValidatorsRoot", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GenesisValidatorsRoot = append(m.GenesisValidatorsRoot[:0], dAtA[iNdEx:postIndex]...)
			if m.GenesisValidatorsRoot == nil {
				m.GenesisValidatorsRoot = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinSyncCommitteeParticipants", wireType)
			}
			m.MinSyncCommitteeParticipants = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinSyncCommitteeParticipants |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GenesisTime", wireType)
			}
			m.GenesisTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GenesisTime |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ForkParameters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ForkParameters == nil {
				m.ForkParameters = &ForkParameters{}
			}
			if err := m.ForkParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecondsPerSlot", wireType)
			}
			m.SecondsPerSlot = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SecondsPerSlot |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlotsPerEpoch", wireType)
			}
			m.SlotsPerEpoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SlotsPerEpoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochsPerSyncCommitteePeriod", wireType)
			}
			m.EpochsPerSyncCommitteePeriod = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EpochsPerSyncCommitteePeriod |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IbcAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IbcAddress = append(m.IbcAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.IbcAddress == nil {
				m.IbcAddress = []byte{}
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IbcCommitmentsSlot", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IbcCommitmentsSlot = append(m.IbcCommitmentsSlot[:0], dAtA[iNdEx:postIndex]...)
			if m.IbcCommitmentsSlot == nil {
				m.IbcCommitmentsSlot = []byte{}
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TrustLevel", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TrustLevel == nil {
				m.TrustLevel = &Fraction{}
			}
			if err := m.TrustLevel.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TrustingPeriod", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_cosmos_gogoproto_types.StdDurationUnmarshal(&m.TrustingPeriod, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxClockDrift", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_cosmos_gogoproto_types.StdDurationUnmarshal(&m.MaxClockDrift, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatestSlot", wireType)
			}
			m.LatestSlot = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LatestSlot |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatestExecutionBlockNumber", wireType)
			}
			m.LatestExecutionBlockNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LatestExecutionBlockNumber |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FrozenHeight", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FrozenHeight == nil {
				m.FrozenHeight = &types.Height{}
			}
			if err := m.FrozenHeight.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEthereum(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEthereum
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConsensusState) 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 ErrIntOverflowEthereum
			}
			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: ConsensusState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConsensusState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType)
			}
			m.Slot = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Slot |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageRoot", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StorageRoot = append(m.StorageRoot[:0], dAtA[iNdEx:postIndex]...)
			if m.StorageRoot == nil {
				m.StorageRoot = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentSyncCommittee", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CurrentSyncCommittee = append(m.CurrentSyncCommittee[:0], dAtA[iNdEx:postIndex]...)
			if m.CurrentSyncCommittee == nil {
				m.CurrentSyncCommittee = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextSyncCommittee", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NextSyncCommittee = append(m.NextSyncCommittee[:0], dAtA[iNdEx:postIndex]...)
			if m.NextSyncCommittee == nil {
				m.NextSyncCommittee = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEthereum(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEthereum
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Header) 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 ErrIntOverflowEthereum
			}
			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: Header: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Header: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TrustedSyncCommittee", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TrustedSyncCommittee == nil {
				m.TrustedSyncCommittee = &TrustedSyncCommittee{}
			}
			if err := m.TrustedSyncCommittee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsensusUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ConsensusUpdate == nil {
				m.ConsensusUpdate = &LightClientUpdate{}
			}
			if err := m.ConsensusUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecutionUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ExecutionUpdate == nil {
				m.ExecutionUpdate = &ExecutionUpdate{}
			}
			if err := m.ExecutionUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AccountUpdate == nil {
				m.AccountUpdate = &AccountUpdate{}
			}
			if err := m.AccountUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.Timestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEthereum(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEthereum
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TrustedSyncCommittee) 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 ErrIntOverflowEthereum
			}
			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: TrustedSyncCommittee: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TrustedSyncCommittee: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TrustedHeight", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TrustedHeight == nil {
				m.TrustedHeight = &types.Height{}
			}
			if err := m.TrustedHeight.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SyncCommittee", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SyncCommittee == nil {
				m.SyncCommittee = &SyncCommittee{}
			}
			if err := m.SyncCommittee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsNext", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsNext = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipEthereum(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEthereum
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ForkParameters) 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 ErrIntOverflowEthereum
			}
			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: ForkParameters: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ForkParameters: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GenesisForkVersion", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GenesisForkVersion = append(m.GenesisForkVersion[:0], dAtA[iNdEx:postIndex]...)
			if m.GenesisForkVersion == nil {
				m.GenesisForkVersion = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Forks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Forks = append(m.Forks, &Fork{})
			if err := m.Forks[len(m.Forks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEthereum(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEthereum
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Fork) 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 ErrIntOverflowEthereum
			}
			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: Fork: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Fork: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = append(m.Version[:0], dAtA[iNdEx:postIndex]...)
			if m.Version == nil {
				m.Version = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			m.Epoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Epoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEthereum(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEthereum
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LightClientUpdate) 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 ErrIntOverflowEthereum
			}
			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: LightClientUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LightClientUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AttestedHeader", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AttestedHeader == nil {
				m.AttestedHeader = &BeaconBlockHeader{}
			}
			if err := m.AttestedHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextSyncCommittee", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NextSyncCommittee == nil {
				m.NextSyncCommittee = &SyncCommittee{}
			}
			if err := m.NextSyncCommittee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextSyncCommitteeBranch", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NextSyncCommitteeBranch = append(m.NextSyncCommitteeBranch, make([]byte, postIndex-iNdEx))
			copy(m.NextSyncCommitteeBranch[len(m.NextSyncCommitteeBranch)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FinalizedHeader", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FinalizedHeader == nil {
				m.FinalizedHeader = &BeaconBlockHeader{}
			}
			if err := m.FinalizedHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FinalizedHeaderBranch", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FinalizedHeaderBranch = append(m.FinalizedHeaderBranch, make([]byte, postIndex-iNdEx))
			copy(m.FinalizedHeaderBranch[len(m.FinalizedHeaderBranch)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FinalizedExecutionRoot", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FinalizedExecutionRoot = append(m.FinalizedExecutionRoot[:0], dAtA[iNdEx:postIndex]...)
			if m.FinalizedExecutionRoot == nil {
				m.FinalizedExecutionRoot = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FinalizedExecutionBranch", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FinalizedExecutionBranch = append(m.FinalizedExecutionBranch, make([]byte, postIndex-iNdEx))
			copy(m.FinalizedExecutionBranch[len(m.FinalizedExecutionBranch)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SyncAggregate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SyncAggregate == nil {
				m.SyncAggregate = &SyncAggregate{}
			}
			if err := m.SyncAggregate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignatureSlot", wireType)
			}
			m.SignatureSlot = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SignatureSlot |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEthereum(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEthereum
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SyncCommittee) 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 ErrIntOverflowEthereum
			}
			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: SyncCommittee: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SyncCommittee: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pubkeys", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Pubkeys = append(m.Pubkeys, make([]byte, postIndex-iNdEx))
			copy(m.Pubkeys[len(m.Pubkeys)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AggregatePubkey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AggregatePubkey = append(m.AggregatePubkey[:0], dAtA[iNdEx:postIndex]...)
			if m.AggregatePubkey == nil {
				m.AggregatePubkey = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEthereum(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEthereum
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SyncAggregate) 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 ErrIntOverflowEthereum
			}
			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: SyncAggregate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SyncAggregate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SyncCommitteeBits", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SyncCommitteeBits = append(m.SyncCommitteeBits[:0], dAtA[iNdEx:postIndex]...)
			if m.SyncCommitteeBits == nil {
				m.SyncCommitteeBits = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SyncCommitteeSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SyncCommitteeSignature = append(m.SyncCommitteeSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.SyncCommitteeSignature == nil {
				m.SyncCommitteeSignature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEthereum(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEthereum
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExecutionUpdate) 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 ErrIntOverflowEthereum
			}
			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: ExecutionUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExecutionUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StateRoot = append(m.StateRoot[:0], dAtA[iNdEx:postIndex]...)
			if m.StateRoot == nil {
				m.StateRoot = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StateRootBranch", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StateRootBranch = append(m.StateRootBranch, make([]byte, postIndex-iNdEx))
			copy(m.StateRootBranch[len(m.StateRootBranch)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType)
			}
			m.BlockNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockNumber |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockNumberBranch", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockNumberBranch = append(m.BlockNumberBranch, make([]byte, postIndex-iNdEx))
			copy(m.BlockNumberBranch[len(m.BlockNumberBranch)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEthereum(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEthereum
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AccountUpdate) 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 ErrIntOverflowEthereum
			}
			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: AccountUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AccountUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountProof", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccountProof = append(m.AccountProof[:0], dAtA[iNdEx:postIndex]...)
			if m.AccountProof == nil {
				m.AccountProof = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountStorageRoot", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccountStorageRoot = append(m.AccountStorageRoot[:0], dAtA[iNdEx:postIndex]...)
			if m.AccountStorageRoot == nil {
				m.AccountStorageRoot = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEthereum(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEthereum
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BeaconBlockHeader) 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 ErrIntOverflowEthereum
			}
			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: BeaconBlockHeader: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BeaconBlockHeader: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType)
			}
			m.Slot = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Slot |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProposerIndex", wireType)
			}
			m.ProposerIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProposerIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParentRoot", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ParentRoot = append(m.ParentRoot[:0], dAtA[iNdEx:postIndex]...)
			if m.ParentRoot == nil {
				m.ParentRoot = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StateRoot = append(m.StateRoot[:0], dAtA[iNdEx:postIndex]...)
			if m.StateRoot == nil {
				m.StateRoot = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BodyRoot", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEthereum
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEthereum
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEthereum
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BodyRoot = append(m.BodyRoot[:0], dAtA[iNdEx:postIndex]...)
			if m.BodyRoot == nil {
				m.BodyRoot = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEthereum(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEthereum
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipEthereum(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, ErrIntOverflowEthereum
			}
			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, ErrIntOverflowEthereum
				}
				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, ErrIntOverflowEthereum
				}
				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, ErrInvalidLengthEthereum
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupEthereum
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthEthereum
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthEthereum        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowEthereum          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupEthereum = fmt.Errorf("proto: unexpected end of group")
)