lightclientd.pb.go

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

package types

import (
	context "context"
	fmt "fmt"
	types2 "github.com/cosmos/cosmos-sdk/codec/types"
	types "github.com/cosmos/ibc-go/modules/core/02-client/types"
	types3 "github.com/cosmos/ibc-go/modules/core/03-connection/types"
	types4 "github.com/cosmos/ibc-go/modules/core/04-channel/types"
	types1 "github.com/cosmos/ibc-go/modules/core/23-commitment/types"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

// State
type State struct {
	ClientState    *ClientState    `protobuf:"bytes,1,opt,name=client_state,json=clientState,proto3" json:"client_state,omitempty"`
	ConsensusState *ConsensusState `protobuf:"bytes,2,opt,name=consensus_state,json=consensusState,proto3" json:"consensus_state,omitempty"`
}

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

var xxx_messageInfo_State proto.InternalMessageInfo

func (m *State) GetClientState() *ClientState {
	if m != nil {
		return m.ClientState
	}
	return nil
}

func (m *State) GetConsensusState() *ConsensusState {
	if m != nil {
		return m.ConsensusState
	}
	return nil
}

// rpc VerifyClientState
type VerifyClientStateRequest struct {
	State                        *State               `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
	Height                       *types.Height        `protobuf:"bytes,2,opt,name=height,proto3" json:"height,omitempty"`
	Prefix                       *types1.MerklePrefix `protobuf:"bytes,3,opt,name=prefix,proto3" json:"prefix,omitempty"`
	CounterpartyClientIdentifier string               `protobuf:"bytes,4,opt,name=counterparty_client_identifier,json=counterpartyClientIdentifier,proto3" json:"counterparty_client_identifier,omitempty"`
	Proof                        []byte               `protobuf:"bytes,5,opt,name=proof,proto3" json:"proof,omitempty"`
	ClientState                  *types2.Any          `protobuf:"bytes,6,opt,name=client_state,json=clientState,proto3" json:"client_state,omitempty"`
}

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

var xxx_messageInfo_VerifyClientStateRequest proto.InternalMessageInfo

func (m *VerifyClientStateRequest) GetState() *State {
	if m != nil {
		return m.State
	}
	return nil
}

func (m *VerifyClientStateRequest) GetHeight() *types.Height {
	if m != nil {
		return m.Height
	}
	return nil
}

func (m *VerifyClientStateRequest) GetPrefix() *types1.MerklePrefix {
	if m != nil {
		return m.Prefix
	}
	return nil
}

func (m *VerifyClientStateRequest) GetCounterpartyClientIdentifier() string {
	if m != nil {
		return m.CounterpartyClientIdentifier
	}
	return ""
}

func (m *VerifyClientStateRequest) GetProof() []byte {
	if m != nil {
		return m.Proof
	}
	return nil
}

func (m *VerifyClientStateRequest) GetClientState() *types2.Any {
	if m != nil {
		return m.ClientState
	}
	return nil
}

// rpc VerifyClientConsensusState
type VerifyClientConsensusStateRequest struct {
	State                        *State               `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
	Height                       *types.Height        `protobuf:"bytes,2,opt,name=height,proto3" json:"height,omitempty"`
	CounterpartyClientIdentifier string               `protobuf:"bytes,3,opt,name=counterparty_client_identifier,json=counterpartyClientIdentifier,proto3" json:"counterparty_client_identifier,omitempty"`
	ConsensusHeight              *types.Height        `protobuf:"bytes,4,opt,name=consensus_height,json=consensusHeight,proto3" json:"consensus_height,omitempty"`
	Prefix                       *types1.MerklePrefix `protobuf:"bytes,5,opt,name=prefix,proto3" json:"prefix,omitempty"`
	Proof                        []byte               `protobuf:"bytes,6,opt,name=proof,proto3" json:"proof,omitempty"`
	ConsensusState               *types2.Any          `protobuf:"bytes,7,opt,name=consensus_state,json=consensusState,proto3" json:"consensus_state,omitempty"`
}

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

var xxx_messageInfo_VerifyClientConsensusStateRequest proto.InternalMessageInfo

func (m *VerifyClientConsensusStateRequest) GetState() *State {
	if m != nil {
		return m.State
	}
	return nil
}

func (m *VerifyClientConsensusStateRequest) GetHeight() *types.Height {
	if m != nil {
		return m.Height
	}
	return nil
}

func (m *VerifyClientConsensusStateRequest) GetCounterpartyClientIdentifier() string {
	if m != nil {
		return m.CounterpartyClientIdentifier
	}
	return ""
}

func (m *VerifyClientConsensusStateRequest) GetConsensusHeight() *types.Height {
	if m != nil {
		return m.ConsensusHeight
	}
	return nil
}

func (m *VerifyClientConsensusStateRequest) GetPrefix() *types1.MerklePrefix {
	if m != nil {
		return m.Prefix
	}
	return nil
}

func (m *VerifyClientConsensusStateRequest) GetProof() []byte {
	if m != nil {
		return m.Proof
	}
	return nil
}

func (m *VerifyClientConsensusStateRequest) GetConsensusState() *types2.Any {
	if m != nil {
		return m.ConsensusState
	}
	return nil
}

// rpc VerifyConnectionState
type VerifyConnectionStateRequest struct {
	State         *State                `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
	Height        *types.Height         `protobuf:"bytes,2,opt,name=height,proto3" json:"height,omitempty"`
	Prefix        *types1.MerklePrefix  `protobuf:"bytes,3,opt,name=prefix,proto3" json:"prefix,omitempty"`
	Proof         []byte                `protobuf:"bytes,4,opt,name=proof,proto3" json:"proof,omitempty"`
	ConnectionId  string                `protobuf:"bytes,5,opt,name=connection_id,json=connectionId,proto3" json:"connection_id,omitempty"`
	ConnectionEnd *types3.ConnectionEnd `protobuf:"bytes,6,opt,name=connection_end,json=connectionEnd,proto3" json:"connection_end,omitempty"`
}

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

var xxx_messageInfo_VerifyConnectionStateRequest proto.InternalMessageInfo

func (m *VerifyConnectionStateRequest) GetState() *State {
	if m != nil {
		return m.State
	}
	return nil
}

func (m *VerifyConnectionStateRequest) GetHeight() *types.Height {
	if m != nil {
		return m.Height
	}
	return nil
}

func (m *VerifyConnectionStateRequest) GetPrefix() *types1.MerklePrefix {
	if m != nil {
		return m.Prefix
	}
	return nil
}

func (m *VerifyConnectionStateRequest) GetProof() []byte {
	if m != nil {
		return m.Proof
	}
	return nil
}

func (m *VerifyConnectionStateRequest) GetConnectionId() string {
	if m != nil {
		return m.ConnectionId
	}
	return ""
}

func (m *VerifyConnectionStateRequest) GetConnectionEnd() *types3.ConnectionEnd {
	if m != nil {
		return m.ConnectionEnd
	}
	return nil
}

// rpc VerifyChannelState
type VerifyChannelStateRequest struct {
	State     *State               `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
	Height    *types.Height        `protobuf:"bytes,2,opt,name=height,proto3" json:"height,omitempty"`
	Prefix    *types1.MerklePrefix `protobuf:"bytes,3,opt,name=prefix,proto3" json:"prefix,omitempty"`
	Proof     []byte               `protobuf:"bytes,4,opt,name=proof,proto3" json:"proof,omitempty"`
	PortId    string               `protobuf:"bytes,5,opt,name=port_id,json=portId,proto3" json:"port_id,omitempty"`
	ChannelId string               `protobuf:"bytes,6,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	Channel   *types4.Channel      `protobuf:"bytes,7,opt,name=channel,proto3" json:"channel,omitempty"`
}

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

var xxx_messageInfo_VerifyChannelStateRequest proto.InternalMessageInfo

func (m *VerifyChannelStateRequest) GetState() *State {
	if m != nil {
		return m.State
	}
	return nil
}

func (m *VerifyChannelStateRequest) GetHeight() *types.Height {
	if m != nil {
		return m.Height
	}
	return nil
}

func (m *VerifyChannelStateRequest) GetPrefix() *types1.MerklePrefix {
	if m != nil {
		return m.Prefix
	}
	return nil
}

func (m *VerifyChannelStateRequest) GetProof() []byte {
	if m != nil {
		return m.Proof
	}
	return nil
}

func (m *VerifyChannelStateRequest) GetPortId() string {
	if m != nil {
		return m.PortId
	}
	return ""
}

func (m *VerifyChannelStateRequest) GetChannelId() string {
	if m != nil {
		return m.ChannelId
	}
	return ""
}

func (m *VerifyChannelStateRequest) GetChannel() *types4.Channel {
	if m != nil {
		return m.Channel
	}
	return nil
}

// rpc VerifyPacketCommitment
type VerifyPacketCommitmentRequest struct {
	State            *State               `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
	Height           *types.Height        `protobuf:"bytes,2,opt,name=height,proto3" json:"height,omitempty"`
	DelayTimePeriod  uint64               `protobuf:"varint,3,opt,name=delay_time_period,json=delayTimePeriod,proto3" json:"delay_time_period,omitempty"`
	DelayBlockPeriod uint64               `protobuf:"varint,4,opt,name=delay_block_period,json=delayBlockPeriod,proto3" json:"delay_block_period,omitempty"`
	Prefix           *types1.MerklePrefix `protobuf:"bytes,5,opt,name=prefix,proto3" json:"prefix,omitempty"`
	Proof            []byte               `protobuf:"bytes,6,opt,name=proof,proto3" json:"proof,omitempty"`
	PortId           string               `protobuf:"bytes,7,opt,name=port_id,json=portId,proto3" json:"port_id,omitempty"`
	ChannelId        string               `protobuf:"bytes,8,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	Sequence         uint64               `protobuf:"varint,9,opt,name=sequence,proto3" json:"sequence,omitempty"`
	CommitmentBytes  []byte               `protobuf:"bytes,10,opt,name=commitment_bytes,json=commitmentBytes,proto3" json:"commitment_bytes,omitempty"`
}

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

var xxx_messageInfo_VerifyPacketCommitmentRequest proto.InternalMessageInfo

func (m *VerifyPacketCommitmentRequest) GetState() *State {
	if m != nil {
		return m.State
	}
	return nil
}

func (m *VerifyPacketCommitmentRequest) GetHeight() *types.Height {
	if m != nil {
		return m.Height
	}
	return nil
}

func (m *VerifyPacketCommitmentRequest) GetDelayTimePeriod() uint64 {
	if m != nil {
		return m.DelayTimePeriod
	}
	return 0
}

func (m *VerifyPacketCommitmentRequest) GetDelayBlockPeriod() uint64 {
	if m != nil {
		return m.DelayBlockPeriod
	}
	return 0
}

func (m *VerifyPacketCommitmentRequest) GetPrefix() *types1.MerklePrefix {
	if m != nil {
		return m.Prefix
	}
	return nil
}

func (m *VerifyPacketCommitmentRequest) GetProof() []byte {
	if m != nil {
		return m.Proof
	}
	return nil
}

func (m *VerifyPacketCommitmentRequest) GetPortId() string {
	if m != nil {
		return m.PortId
	}
	return ""
}

func (m *VerifyPacketCommitmentRequest) GetChannelId() string {
	if m != nil {
		return m.ChannelId
	}
	return ""
}

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

func (m *VerifyPacketCommitmentRequest) GetCommitmentBytes() []byte {
	if m != nil {
		return m.CommitmentBytes
	}
	return nil
}

// rpc VerifyPacketAcknowledgement
type VerifyPacketAcknowledgementRequest struct {
	State            *State               `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
	Height           *types.Height        `protobuf:"bytes,2,opt,name=height,proto3" json:"height,omitempty"`
	DelayTimePeriod  uint64               `protobuf:"varint,3,opt,name=delay_time_period,json=delayTimePeriod,proto3" json:"delay_time_period,omitempty"`
	DelayBlockPeriod uint64               `protobuf:"varint,4,opt,name=delay_block_period,json=delayBlockPeriod,proto3" json:"delay_block_period,omitempty"`
	Prefix           *types1.MerklePrefix `protobuf:"bytes,5,opt,name=prefix,proto3" json:"prefix,omitempty"`
	Proof            []byte               `protobuf:"bytes,6,opt,name=proof,proto3" json:"proof,omitempty"`
	PortId           string               `protobuf:"bytes,7,opt,name=port_id,json=portId,proto3" json:"port_id,omitempty"`
	ChannelId        string               `protobuf:"bytes,8,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	Sequence         uint64               `protobuf:"varint,9,opt,name=sequence,proto3" json:"sequence,omitempty"`
	Acknowledgement  []byte               `protobuf:"bytes,10,opt,name=acknowledgement,proto3" json:"acknowledgement,omitempty"`
}

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

var xxx_messageInfo_VerifyPacketAcknowledgementRequest proto.InternalMessageInfo

func (m *VerifyPacketAcknowledgementRequest) GetState() *State {
	if m != nil {
		return m.State
	}
	return nil
}

func (m *VerifyPacketAcknowledgementRequest) GetHeight() *types.Height {
	if m != nil {
		return m.Height
	}
	return nil
}

func (m *VerifyPacketAcknowledgementRequest) GetDelayTimePeriod() uint64 {
	if m != nil {
		return m.DelayTimePeriod
	}
	return 0
}

func (m *VerifyPacketAcknowledgementRequest) GetDelayBlockPeriod() uint64 {
	if m != nil {
		return m.DelayBlockPeriod
	}
	return 0
}

func (m *VerifyPacketAcknowledgementRequest) GetPrefix() *types1.MerklePrefix {
	if m != nil {
		return m.Prefix
	}
	return nil
}

func (m *VerifyPacketAcknowledgementRequest) GetProof() []byte {
	if m != nil {
		return m.Proof
	}
	return nil
}

func (m *VerifyPacketAcknowledgementRequest) GetPortId() string {
	if m != nil {
		return m.PortId
	}
	return ""
}

func (m *VerifyPacketAcknowledgementRequest) GetChannelId() string {
	if m != nil {
		return m.ChannelId
	}
	return ""
}

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

func (m *VerifyPacketAcknowledgementRequest) GetAcknowledgement() []byte {
	if m != nil {
		return m.Acknowledgement
	}
	return nil
}

// rpc VerifyPacketReceiptAbsence
type VerifyPacketReceiptAbsenceRequest struct {
	State            *State               `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
	Height           *types.Height        `protobuf:"bytes,2,opt,name=height,proto3" json:"height,omitempty"`
	DelayTimePeriod  uint64               `protobuf:"varint,3,opt,name=delay_time_period,json=delayTimePeriod,proto3" json:"delay_time_period,omitempty"`
	DelayBlockPeriod uint64               `protobuf:"varint,4,opt,name=delay_block_period,json=delayBlockPeriod,proto3" json:"delay_block_period,omitempty"`
	Prefix           *types1.MerklePrefix `protobuf:"bytes,5,opt,name=prefix,proto3" json:"prefix,omitempty"`
	Proof            []byte               `protobuf:"bytes,6,opt,name=proof,proto3" json:"proof,omitempty"`
	PortId           string               `protobuf:"bytes,7,opt,name=port_id,json=portId,proto3" json:"port_id,omitempty"`
	ChannelId        string               `protobuf:"bytes,8,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	Sequence         uint64               `protobuf:"varint,9,opt,name=sequence,proto3" json:"sequence,omitempty"`
}

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

var xxx_messageInfo_VerifyPacketReceiptAbsenceRequest proto.InternalMessageInfo

func (m *VerifyPacketReceiptAbsenceRequest) GetState() *State {
	if m != nil {
		return m.State
	}
	return nil
}

func (m *VerifyPacketReceiptAbsenceRequest) GetHeight() *types.Height {
	if m != nil {
		return m.Height
	}
	return nil
}

func (m *VerifyPacketReceiptAbsenceRequest) GetDelayTimePeriod() uint64 {
	if m != nil {
		return m.DelayTimePeriod
	}
	return 0
}

func (m *VerifyPacketReceiptAbsenceRequest) GetDelayBlockPeriod() uint64 {
	if m != nil {
		return m.DelayBlockPeriod
	}
	return 0
}

func (m *VerifyPacketReceiptAbsenceRequest) GetPrefix() *types1.MerklePrefix {
	if m != nil {
		return m.Prefix
	}
	return nil
}

func (m *VerifyPacketReceiptAbsenceRequest) GetProof() []byte {
	if m != nil {
		return m.Proof
	}
	return nil
}

func (m *VerifyPacketReceiptAbsenceRequest) GetPortId() string {
	if m != nil {
		return m.PortId
	}
	return ""
}

func (m *VerifyPacketReceiptAbsenceRequest) GetChannelId() string {
	if m != nil {
		return m.ChannelId
	}
	return ""
}

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

// rpc VerifyNextSequenceRecv
type VerifyNextSequenceRecvRequest struct {
	State            *State               `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
	Height           *types.Height        `protobuf:"bytes,2,opt,name=height,proto3" json:"height,omitempty"`
	DelayTimePeriod  uint64               `protobuf:"varint,3,opt,name=delay_time_period,json=delayTimePeriod,proto3" json:"delay_time_period,omitempty"`
	DelayBlockPeriod uint64               `protobuf:"varint,4,opt,name=delay_block_period,json=delayBlockPeriod,proto3" json:"delay_block_period,omitempty"`
	Prefix           *types1.MerklePrefix `protobuf:"bytes,5,opt,name=prefix,proto3" json:"prefix,omitempty"`
	Proof            []byte               `protobuf:"bytes,6,opt,name=proof,proto3" json:"proof,omitempty"`
	PortId           string               `protobuf:"bytes,7,opt,name=port_id,json=portId,proto3" json:"port_id,omitempty"`
	ChannelId        string               `protobuf:"bytes,8,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	NextSequenceRecv uint64               `protobuf:"varint,9,opt,name=next_sequence_recv,json=nextSequenceRecv,proto3" json:"next_sequence_recv,omitempty"`
}

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

var xxx_messageInfo_VerifyNextSequenceRecvRequest proto.InternalMessageInfo

func (m *VerifyNextSequenceRecvRequest) GetState() *State {
	if m != nil {
		return m.State
	}
	return nil
}

func (m *VerifyNextSequenceRecvRequest) GetHeight() *types.Height {
	if m != nil {
		return m.Height
	}
	return nil
}

func (m *VerifyNextSequenceRecvRequest) GetDelayTimePeriod() uint64 {
	if m != nil {
		return m.DelayTimePeriod
	}
	return 0
}

func (m *VerifyNextSequenceRecvRequest) GetDelayBlockPeriod() uint64 {
	if m != nil {
		return m.DelayBlockPeriod
	}
	return 0
}

func (m *VerifyNextSequenceRecvRequest) GetPrefix() *types1.MerklePrefix {
	if m != nil {
		return m.Prefix
	}
	return nil
}

func (m *VerifyNextSequenceRecvRequest) GetProof() []byte {
	if m != nil {
		return m.Proof
	}
	return nil
}

func (m *VerifyNextSequenceRecvRequest) GetPortId() string {
	if m != nil {
		return m.PortId
	}
	return ""
}

func (m *VerifyNextSequenceRecvRequest) GetChannelId() string {
	if m != nil {
		return m.ChannelId
	}
	return ""
}

func (m *VerifyNextSequenceRecvRequest) GetNextSequenceRecv() uint64 {
	if m != nil {
		return m.NextSequenceRecv
	}
	return 0
}

func init() {
	proto.RegisterType((*State)(nil), "ibc.lightclientd.corda.v1.State")
	proto.RegisterType((*VerifyClientStateRequest)(nil), "ibc.lightclientd.corda.v1.VerifyClientStateRequest")
	proto.RegisterType((*VerifyClientConsensusStateRequest)(nil), "ibc.lightclientd.corda.v1.VerifyClientConsensusStateRequest")
	proto.RegisterType((*VerifyConnectionStateRequest)(nil), "ibc.lightclientd.corda.v1.VerifyConnectionStateRequest")
	proto.RegisterType((*VerifyChannelStateRequest)(nil), "ibc.lightclientd.corda.v1.VerifyChannelStateRequest")
	proto.RegisterType((*VerifyPacketCommitmentRequest)(nil), "ibc.lightclientd.corda.v1.VerifyPacketCommitmentRequest")
	proto.RegisterType((*VerifyPacketAcknowledgementRequest)(nil), "ibc.lightclientd.corda.v1.VerifyPacketAcknowledgementRequest")
	proto.RegisterType((*VerifyPacketReceiptAbsenceRequest)(nil), "ibc.lightclientd.corda.v1.VerifyPacketReceiptAbsenceRequest")
	proto.RegisterType((*VerifyNextSequenceRecvRequest)(nil), "ibc.lightclientd.corda.v1.VerifyNextSequenceRecvRequest")
}

func init() {
	proto.RegisterFile("ibc/lightclientd/corda/v1/lightclientd.proto", fileDescriptor_98dd8860a0897f8c)
}

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// LightClientClient is the client API for LightClient service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type LightClientClient interface {
	VerifyClientState(ctx context.Context, in *VerifyClientStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	VerifyClientConsensusState(ctx context.Context, in *VerifyClientConsensusStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	VerifyConnectionState(ctx context.Context, in *VerifyConnectionStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	VerifyChannelState(ctx context.Context, in *VerifyChannelStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	VerifyPacketCommitment(ctx context.Context, in *VerifyPacketCommitmentRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	VerifyPacketAcknowledgement(ctx context.Context, in *VerifyPacketAcknowledgementRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	VerifyPacketReceiptAbsence(ctx context.Context, in *VerifyPacketReceiptAbsenceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	VerifyNextSequenceRecv(ctx context.Context, in *VerifyNextSequenceRecvRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type lightClientClient struct {
	cc grpc1.ClientConn
}

func NewLightClientClient(cc grpc1.ClientConn) LightClientClient {
	return &lightClientClient{cc}
}

func (c *lightClientClient) VerifyClientState(ctx context.Context, in *VerifyClientStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/ibc.lightclientd.corda.v1.LightClient/VerifyClientState", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *lightClientClient) VerifyClientConsensusState(ctx context.Context, in *VerifyClientConsensusStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/ibc.lightclientd.corda.v1.LightClient/VerifyClientConsensusState", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *lightClientClient) VerifyConnectionState(ctx context.Context, in *VerifyConnectionStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/ibc.lightclientd.corda.v1.LightClient/VerifyConnectionState", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *lightClientClient) VerifyChannelState(ctx context.Context, in *VerifyChannelStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/ibc.lightclientd.corda.v1.LightClient/VerifyChannelState", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *lightClientClient) VerifyPacketCommitment(ctx context.Context, in *VerifyPacketCommitmentRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/ibc.lightclientd.corda.v1.LightClient/VerifyPacketCommitment", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *lightClientClient) VerifyPacketAcknowledgement(ctx context.Context, in *VerifyPacketAcknowledgementRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/ibc.lightclientd.corda.v1.LightClient/VerifyPacketAcknowledgement", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *lightClientClient) VerifyPacketReceiptAbsence(ctx context.Context, in *VerifyPacketReceiptAbsenceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/ibc.lightclientd.corda.v1.LightClient/VerifyPacketReceiptAbsence", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *lightClientClient) VerifyNextSequenceRecv(ctx context.Context, in *VerifyNextSequenceRecvRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/ibc.lightclientd.corda.v1.LightClient/VerifyNextSequenceRecv", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// LightClientServer is the server API for LightClient service.
type LightClientServer interface {
	VerifyClientState(context.Context, *VerifyClientStateRequest) (*emptypb.Empty, error)
	VerifyClientConsensusState(context.Context, *VerifyClientConsensusStateRequest) (*emptypb.Empty, error)
	VerifyConnectionState(context.Context, *VerifyConnectionStateRequest) (*emptypb.Empty, error)
	VerifyChannelState(context.Context, *VerifyChannelStateRequest) (*emptypb.Empty, error)
	VerifyPacketCommitment(context.Context, *VerifyPacketCommitmentRequest) (*emptypb.Empty, error)
	VerifyPacketAcknowledgement(context.Context, *VerifyPacketAcknowledgementRequest) (*emptypb.Empty, error)
	VerifyPacketReceiptAbsence(context.Context, *VerifyPacketReceiptAbsenceRequest) (*emptypb.Empty, error)
	VerifyNextSequenceRecv(context.Context, *VerifyNextSequenceRecvRequest) (*emptypb.Empty, error)
}

// UnimplementedLightClientServer can be embedded to have forward compatible implementations.
type UnimplementedLightClientServer struct {
}

func (*UnimplementedLightClientServer) VerifyClientState(ctx context.Context, req *VerifyClientStateRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VerifyClientState not implemented")
}
func (*UnimplementedLightClientServer) VerifyClientConsensusState(ctx context.Context, req *VerifyClientConsensusStateRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VerifyClientConsensusState not implemented")
}
func (*UnimplementedLightClientServer) VerifyConnectionState(ctx context.Context, req *VerifyConnectionStateRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VerifyConnectionState not implemented")
}
func (*UnimplementedLightClientServer) VerifyChannelState(ctx context.Context, req *VerifyChannelStateRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VerifyChannelState not implemented")
}
func (*UnimplementedLightClientServer) VerifyPacketCommitment(ctx context.Context, req *VerifyPacketCommitmentRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VerifyPacketCommitment not implemented")
}
func (*UnimplementedLightClientServer) VerifyPacketAcknowledgement(ctx context.Context, req *VerifyPacketAcknowledgementRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VerifyPacketAcknowledgement not implemented")
}
func (*UnimplementedLightClientServer) VerifyPacketReceiptAbsence(ctx context.Context, req *VerifyPacketReceiptAbsenceRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VerifyPacketReceiptAbsence not implemented")
}
func (*UnimplementedLightClientServer) VerifyNextSequenceRecv(ctx context.Context, req *VerifyNextSequenceRecvRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VerifyNextSequenceRecv not implemented")
}

func RegisterLightClientServer(s grpc1.Server, srv LightClientServer) {
	s.RegisterService(&_LightClient_serviceDesc, srv)
}

func _LightClient_VerifyClientState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VerifyClientStateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LightClientServer).VerifyClientState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ibc.lightclientd.corda.v1.LightClient/VerifyClientState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LightClientServer).VerifyClientState(ctx, req.(*VerifyClientStateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LightClient_VerifyClientConsensusState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VerifyClientConsensusStateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LightClientServer).VerifyClientConsensusState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ibc.lightclientd.corda.v1.LightClient/VerifyClientConsensusState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LightClientServer).VerifyClientConsensusState(ctx, req.(*VerifyClientConsensusStateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LightClient_VerifyConnectionState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VerifyConnectionStateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LightClientServer).VerifyConnectionState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ibc.lightclientd.corda.v1.LightClient/VerifyConnectionState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LightClientServer).VerifyConnectionState(ctx, req.(*VerifyConnectionStateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LightClient_VerifyChannelState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VerifyChannelStateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LightClientServer).VerifyChannelState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ibc.lightclientd.corda.v1.LightClient/VerifyChannelState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LightClientServer).VerifyChannelState(ctx, req.(*VerifyChannelStateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LightClient_VerifyPacketCommitment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VerifyPacketCommitmentRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LightClientServer).VerifyPacketCommitment(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ibc.lightclientd.corda.v1.LightClient/VerifyPacketCommitment",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LightClientServer).VerifyPacketCommitment(ctx, req.(*VerifyPacketCommitmentRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LightClient_VerifyPacketAcknowledgement_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VerifyPacketAcknowledgementRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LightClientServer).VerifyPacketAcknowledgement(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ibc.lightclientd.corda.v1.LightClient/VerifyPacketAcknowledgement",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LightClientServer).VerifyPacketAcknowledgement(ctx, req.(*VerifyPacketAcknowledgementRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LightClient_VerifyPacketReceiptAbsence_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VerifyPacketReceiptAbsenceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LightClientServer).VerifyPacketReceiptAbsence(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ibc.lightclientd.corda.v1.LightClient/VerifyPacketReceiptAbsence",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LightClientServer).VerifyPacketReceiptAbsence(ctx, req.(*VerifyPacketReceiptAbsenceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LightClient_VerifyNextSequenceRecv_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VerifyNextSequenceRecvRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LightClientServer).VerifyNextSequenceRecv(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ibc.lightclientd.corda.v1.LightClient/VerifyNextSequenceRecv",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LightClientServer).VerifyNextSequenceRecv(ctx, req.(*VerifyNextSequenceRecvRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _LightClient_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ibc.lightclientd.corda.v1.LightClient",
	HandlerType: (*LightClientServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "VerifyClientState",
			Handler:    _LightClient_VerifyClientState_Handler,
		},
		{
			MethodName: "VerifyClientConsensusState",
			Handler:    _LightClient_VerifyClientConsensusState_Handler,
		},
		{
			MethodName: "VerifyConnectionState",
			Handler:    _LightClient_VerifyConnectionState_Handler,
		},
		{
			MethodName: "VerifyChannelState",
			Handler:    _LightClient_VerifyChannelState_Handler,
		},
		{
			MethodName: "VerifyPacketCommitment",
			Handler:    _LightClient_VerifyPacketCommitment_Handler,
		},
		{
			MethodName: "VerifyPacketAcknowledgement",
			Handler:    _LightClient_VerifyPacketAcknowledgement_Handler,
		},
		{
			MethodName: "VerifyPacketReceiptAbsence",
			Handler:    _LightClient_VerifyPacketReceiptAbsence_Handler,
		},
		{
			MethodName: "VerifyNextSequenceRecv",
			Handler:    _LightClient_VerifyNextSequenceRecv_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "ibc/lightclientd/corda/v1/lightclientd.proto",
}

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

func (m *State) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ConsensusState != nil {
		{
			size, err := m.ConsensusState.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ClientState != nil {
		{
			size, err := m.ClientState.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *VerifyClientStateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ClientState != nil {
		{
			size, err := m.ClientState.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.Proof) > 0 {
		i -= len(m.Proof)
		copy(dAtA[i:], m.Proof)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.Proof)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.CounterpartyClientIdentifier) > 0 {
		i -= len(m.CounterpartyClientIdentifier)
		copy(dAtA[i:], m.CounterpartyClientIdentifier)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.CounterpartyClientIdentifier)))
		i--
		dAtA[i] = 0x22
	}
	if m.Prefix != nil {
		{
			size, err := m.Prefix.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Height != nil {
		{
			size, err := m.Height.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.State != nil {
		{
			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *VerifyClientConsensusStateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ConsensusState != nil {
		{
			size, err := m.ConsensusState.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Proof) > 0 {
		i -= len(m.Proof)
		copy(dAtA[i:], m.Proof)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.Proof)))
		i--
		dAtA[i] = 0x32
	}
	if m.Prefix != nil {
		{
			size, err := m.Prefix.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.ConsensusHeight != nil {
		{
			size, err := m.ConsensusHeight.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.CounterpartyClientIdentifier) > 0 {
		i -= len(m.CounterpartyClientIdentifier)
		copy(dAtA[i:], m.CounterpartyClientIdentifier)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.CounterpartyClientIdentifier)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Height != nil {
		{
			size, err := m.Height.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.State != nil {
		{
			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *VerifyConnectionStateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ConnectionEnd != nil {
		{
			size, err := m.ConnectionEnd.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.ConnectionId) > 0 {
		i -= len(m.ConnectionId)
		copy(dAtA[i:], m.ConnectionId)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.ConnectionId)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Proof) > 0 {
		i -= len(m.Proof)
		copy(dAtA[i:], m.Proof)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.Proof)))
		i--
		dAtA[i] = 0x22
	}
	if m.Prefix != nil {
		{
			size, err := m.Prefix.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Height != nil {
		{
			size, err := m.Height.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.State != nil {
		{
			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *VerifyChannelStateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Channel != nil {
		{
			size, err := m.Channel.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if len(m.ChannelId) > 0 {
		i -= len(m.ChannelId)
		copy(dAtA[i:], m.ChannelId)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.ChannelId)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.PortId) > 0 {
		i -= len(m.PortId)
		copy(dAtA[i:], m.PortId)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.PortId)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Proof) > 0 {
		i -= len(m.Proof)
		copy(dAtA[i:], m.Proof)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.Proof)))
		i--
		dAtA[i] = 0x22
	}
	if m.Prefix != nil {
		{
			size, err := m.Prefix.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Height != nil {
		{
			size, err := m.Height.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.State != nil {
		{
			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *VerifyPacketCommitmentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CommitmentBytes) > 0 {
		i -= len(m.CommitmentBytes)
		copy(dAtA[i:], m.CommitmentBytes)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.CommitmentBytes)))
		i--
		dAtA[i] = 0x52
	}
	if m.Sequence != 0 {
		i = encodeVarintLightclientd(dAtA, i, uint64(m.Sequence))
		i--
		dAtA[i] = 0x48
	}
	if len(m.ChannelId) > 0 {
		i -= len(m.ChannelId)
		copy(dAtA[i:], m.ChannelId)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.ChannelId)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.PortId) > 0 {
		i -= len(m.PortId)
		copy(dAtA[i:], m.PortId)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.PortId)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Proof) > 0 {
		i -= len(m.Proof)
		copy(dAtA[i:], m.Proof)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.Proof)))
		i--
		dAtA[i] = 0x32
	}
	if m.Prefix != nil {
		{
			size, err := m.Prefix.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.DelayBlockPeriod != 0 {
		i = encodeVarintLightclientd(dAtA, i, uint64(m.DelayBlockPeriod))
		i--
		dAtA[i] = 0x20
	}
	if m.DelayTimePeriod != 0 {
		i = encodeVarintLightclientd(dAtA, i, uint64(m.DelayTimePeriod))
		i--
		dAtA[i] = 0x18
	}
	if m.Height != nil {
		{
			size, err := m.Height.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.State != nil {
		{
			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *VerifyPacketAcknowledgementRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Acknowledgement) > 0 {
		i -= len(m.Acknowledgement)
		copy(dAtA[i:], m.Acknowledgement)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.Acknowledgement)))
		i--
		dAtA[i] = 0x52
	}
	if m.Sequence != 0 {
		i = encodeVarintLightclientd(dAtA, i, uint64(m.Sequence))
		i--
		dAtA[i] = 0x48
	}
	if len(m.ChannelId) > 0 {
		i -= len(m.ChannelId)
		copy(dAtA[i:], m.ChannelId)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.ChannelId)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.PortId) > 0 {
		i -= len(m.PortId)
		copy(dAtA[i:], m.PortId)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.PortId)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Proof) > 0 {
		i -= len(m.Proof)
		copy(dAtA[i:], m.Proof)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.Proof)))
		i--
		dAtA[i] = 0x32
	}
	if m.Prefix != nil {
		{
			size, err := m.Prefix.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.DelayBlockPeriod != 0 {
		i = encodeVarintLightclientd(dAtA, i, uint64(m.DelayBlockPeriod))
		i--
		dAtA[i] = 0x20
	}
	if m.DelayTimePeriod != 0 {
		i = encodeVarintLightclientd(dAtA, i, uint64(m.DelayTimePeriod))
		i--
		dAtA[i] = 0x18
	}
	if m.Height != nil {
		{
			size, err := m.Height.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.State != nil {
		{
			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *VerifyPacketReceiptAbsenceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Sequence != 0 {
		i = encodeVarintLightclientd(dAtA, i, uint64(m.Sequence))
		i--
		dAtA[i] = 0x48
	}
	if len(m.ChannelId) > 0 {
		i -= len(m.ChannelId)
		copy(dAtA[i:], m.ChannelId)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.ChannelId)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.PortId) > 0 {
		i -= len(m.PortId)
		copy(dAtA[i:], m.PortId)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.PortId)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Proof) > 0 {
		i -= len(m.Proof)
		copy(dAtA[i:], m.Proof)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.Proof)))
		i--
		dAtA[i] = 0x32
	}
	if m.Prefix != nil {
		{
			size, err := m.Prefix.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.DelayBlockPeriod != 0 {
		i = encodeVarintLightclientd(dAtA, i, uint64(m.DelayBlockPeriod))
		i--
		dAtA[i] = 0x20
	}
	if m.DelayTimePeriod != 0 {
		i = encodeVarintLightclientd(dAtA, i, uint64(m.DelayTimePeriod))
		i--
		dAtA[i] = 0x18
	}
	if m.Height != nil {
		{
			size, err := m.Height.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.State != nil {
		{
			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *VerifyNextSequenceRecvRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NextSequenceRecv != 0 {
		i = encodeVarintLightclientd(dAtA, i, uint64(m.NextSequenceRecv))
		i--
		dAtA[i] = 0x48
	}
	if len(m.ChannelId) > 0 {
		i -= len(m.ChannelId)
		copy(dAtA[i:], m.ChannelId)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.ChannelId)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.PortId) > 0 {
		i -= len(m.PortId)
		copy(dAtA[i:], m.PortId)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.PortId)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Proof) > 0 {
		i -= len(m.Proof)
		copy(dAtA[i:], m.Proof)
		i = encodeVarintLightclientd(dAtA, i, uint64(len(m.Proof)))
		i--
		dAtA[i] = 0x32
	}
	if m.Prefix != nil {
		{
			size, err := m.Prefix.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.DelayBlockPeriod != 0 {
		i = encodeVarintLightclientd(dAtA, i, uint64(m.DelayBlockPeriod))
		i--
		dAtA[i] = 0x20
	}
	if m.DelayTimePeriod != 0 {
		i = encodeVarintLightclientd(dAtA, i, uint64(m.DelayTimePeriod))
		i--
		dAtA[i] = 0x18
	}
	if m.Height != nil {
		{
			size, err := m.Height.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.State != nil {
		{
			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLightclientd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintLightclientd(dAtA []byte, offset int, v uint64) int {
	offset -= sovLightclientd(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *State) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ClientState != nil {
		l = m.ClientState.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.ConsensusState != nil {
		l = m.ConsensusState.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	return n
}

func (m *VerifyClientStateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.State != nil {
		l = m.State.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.Height != nil {
		l = m.Height.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.Prefix != nil {
		l = m.Prefix.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.CounterpartyClientIdentifier)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.Proof)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.ClientState != nil {
		l = m.ClientState.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	return n
}

func (m *VerifyClientConsensusStateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.State != nil {
		l = m.State.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.Height != nil {
		l = m.Height.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.CounterpartyClientIdentifier)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.ConsensusHeight != nil {
		l = m.ConsensusHeight.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.Prefix != nil {
		l = m.Prefix.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.Proof)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.ConsensusState != nil {
		l = m.ConsensusState.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	return n
}

func (m *VerifyConnectionStateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.State != nil {
		l = m.State.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.Height != nil {
		l = m.Height.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.Prefix != nil {
		l = m.Prefix.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.Proof)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.ConnectionId)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.ConnectionEnd != nil {
		l = m.ConnectionEnd.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	return n
}

func (m *VerifyChannelStateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.State != nil {
		l = m.State.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.Height != nil {
		l = m.Height.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.Prefix != nil {
		l = m.Prefix.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.Proof)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.PortId)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.ChannelId)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.Channel != nil {
		l = m.Channel.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	return n
}

func (m *VerifyPacketCommitmentRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.State != nil {
		l = m.State.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.Height != nil {
		l = m.Height.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.DelayTimePeriod != 0 {
		n += 1 + sovLightclientd(uint64(m.DelayTimePeriod))
	}
	if m.DelayBlockPeriod != 0 {
		n += 1 + sovLightclientd(uint64(m.DelayBlockPeriod))
	}
	if m.Prefix != nil {
		l = m.Prefix.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.Proof)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.PortId)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.ChannelId)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.Sequence != 0 {
		n += 1 + sovLightclientd(uint64(m.Sequence))
	}
	l = len(m.CommitmentBytes)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	return n
}

func (m *VerifyPacketAcknowledgementRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.State != nil {
		l = m.State.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.Height != nil {
		l = m.Height.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.DelayTimePeriod != 0 {
		n += 1 + sovLightclientd(uint64(m.DelayTimePeriod))
	}
	if m.DelayBlockPeriod != 0 {
		n += 1 + sovLightclientd(uint64(m.DelayBlockPeriod))
	}
	if m.Prefix != nil {
		l = m.Prefix.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.Proof)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.PortId)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.ChannelId)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.Sequence != 0 {
		n += 1 + sovLightclientd(uint64(m.Sequence))
	}
	l = len(m.Acknowledgement)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	return n
}

func (m *VerifyPacketReceiptAbsenceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.State != nil {
		l = m.State.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.Height != nil {
		l = m.Height.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.DelayTimePeriod != 0 {
		n += 1 + sovLightclientd(uint64(m.DelayTimePeriod))
	}
	if m.DelayBlockPeriod != 0 {
		n += 1 + sovLightclientd(uint64(m.DelayBlockPeriod))
	}
	if m.Prefix != nil {
		l = m.Prefix.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.Proof)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.PortId)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.ChannelId)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.Sequence != 0 {
		n += 1 + sovLightclientd(uint64(m.Sequence))
	}
	return n
}

func (m *VerifyNextSequenceRecvRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.State != nil {
		l = m.State.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.Height != nil {
		l = m.Height.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.DelayTimePeriod != 0 {
		n += 1 + sovLightclientd(uint64(m.DelayTimePeriod))
	}
	if m.DelayBlockPeriod != 0 {
		n += 1 + sovLightclientd(uint64(m.DelayBlockPeriod))
	}
	if m.Prefix != nil {
		l = m.Prefix.Size()
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.Proof)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.PortId)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	l = len(m.ChannelId)
	if l > 0 {
		n += 1 + l + sovLightclientd(uint64(l))
	}
	if m.NextSequenceRecv != 0 {
		n += 1 + sovLightclientd(uint64(m.NextSequenceRecv))
	}
	return n
}

func sovLightclientd(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozLightclientd(x uint64) (n int) {
	return sovLightclientd(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *State) 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 ErrIntOverflowLightclientd
			}
			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: State: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: State: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ClientState == nil {
				m.ClientState = &ClientState{}
			}
			if err := m.ClientState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsensusState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ConsensusState == nil {
				m.ConsensusState = &ConsensusState{}
			}
			if err := m.ConsensusState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLightclientd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLightclientd
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLightclientd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VerifyClientStateRequest) 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 ErrIntOverflowLightclientd
			}
			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: VerifyClientStateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VerifyClientStateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.State == nil {
				m.State = &State{}
			}
			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Height == nil {
				m.Height = &types.Height{}
			}
			if err := m.Height.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Prefix == nil {
				m.Prefix = &types1.MerklePrefix{}
			}
			if err := m.Prefix.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CounterpartyClientIdentifier", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				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 ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CounterpartyClientIdentifier = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...)
			if m.Proof == nil {
				m.Proof = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ClientState == nil {
				m.ClientState = &types2.Any{}
			}
			if err := m.ClientState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLightclientd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLightclientd
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLightclientd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VerifyClientConsensusStateRequest) 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 ErrIntOverflowLightclientd
			}
			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: VerifyClientConsensusStateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VerifyClientConsensusStateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.State == nil {
				m.State = &State{}
			}
			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Height == nil {
				m.Height = &types.Height{}
			}
			if err := m.Height.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CounterpartyClientIdentifier", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				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 ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CounterpartyClientIdentifier = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsensusHeight", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ConsensusHeight == nil {
				m.ConsensusHeight = &types.Height{}
			}
			if err := m.ConsensusHeight.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Prefix == nil {
				m.Prefix = &types1.MerklePrefix{}
			}
			if err := m.Prefix.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...)
			if m.Proof == nil {
				m.Proof = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsensusState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ConsensusState == nil {
				m.ConsensusState = &types2.Any{}
			}
			if err := m.ConsensusState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLightclientd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLightclientd
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLightclientd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VerifyConnectionStateRequest) 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 ErrIntOverflowLightclientd
			}
			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: VerifyConnectionStateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VerifyConnectionStateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.State == nil {
				m.State = &State{}
			}
			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Height == nil {
				m.Height = &types.Height{}
			}
			if err := m.Height.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Prefix == nil {
				m.Prefix = &types1.MerklePrefix{}
			}
			if err := m.Prefix.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...)
			if m.Proof == nil {
				m.Proof = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConnectionId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				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 ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConnectionId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConnectionEnd", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ConnectionEnd == nil {
				m.ConnectionEnd = &types3.ConnectionEnd{}
			}
			if err := m.ConnectionEnd.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLightclientd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLightclientd
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLightclientd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VerifyChannelStateRequest) 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 ErrIntOverflowLightclientd
			}
			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: VerifyChannelStateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VerifyChannelStateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.State == nil {
				m.State = &State{}
			}
			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Height == nil {
				m.Height = &types.Height{}
			}
			if err := m.Height.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Prefix == nil {
				m.Prefix = &types1.MerklePrefix{}
			}
			if err := m.Prefix.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...)
			if m.Proof == nil {
				m.Proof = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PortId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				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 ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PortId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				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 ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChannelId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Channel", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Channel == nil {
				m.Channel = &types4.Channel{}
			}
			if err := m.Channel.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLightclientd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLightclientd
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLightclientd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VerifyPacketCommitmentRequest) 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 ErrIntOverflowLightclientd
			}
			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: VerifyPacketCommitmentRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VerifyPacketCommitmentRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.State == nil {
				m.State = &State{}
			}
			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Height == nil {
				m.Height = &types.Height{}
			}
			if err := m.Height.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelayTimePeriod", wireType)
			}
			m.DelayTimePeriod = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DelayTimePeriod |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelayBlockPeriod", wireType)
			}
			m.DelayBlockPeriod = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DelayBlockPeriod |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Prefix == nil {
				m.Prefix = &types1.MerklePrefix{}
			}
			if err := m.Prefix.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...)
			if m.Proof == nil {
				m.Proof = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PortId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				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 ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PortId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				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 ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChannelId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
			}
			m.Sequence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sequence |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitmentBytes", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CommitmentBytes = append(m.CommitmentBytes[:0], dAtA[iNdEx:postIndex]...)
			if m.CommitmentBytes == nil {
				m.CommitmentBytes = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLightclientd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLightclientd
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLightclientd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VerifyPacketAcknowledgementRequest) 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 ErrIntOverflowLightclientd
			}
			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: VerifyPacketAcknowledgementRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VerifyPacketAcknowledgementRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.State == nil {
				m.State = &State{}
			}
			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Height == nil {
				m.Height = &types.Height{}
			}
			if err := m.Height.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelayTimePeriod", wireType)
			}
			m.DelayTimePeriod = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DelayTimePeriod |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelayBlockPeriod", wireType)
			}
			m.DelayBlockPeriod = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DelayBlockPeriod |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Prefix == nil {
				m.Prefix = &types1.MerklePrefix{}
			}
			if err := m.Prefix.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...)
			if m.Proof == nil {
				m.Proof = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PortId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				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 ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PortId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				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 ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChannelId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
			}
			m.Sequence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sequence |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Acknowledgement", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Acknowledgement = append(m.Acknowledgement[:0], dAtA[iNdEx:postIndex]...)
			if m.Acknowledgement == nil {
				m.Acknowledgement = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLightclientd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLightclientd
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLightclientd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VerifyPacketReceiptAbsenceRequest) 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 ErrIntOverflowLightclientd
			}
			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: VerifyPacketReceiptAbsenceRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VerifyPacketReceiptAbsenceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.State == nil {
				m.State = &State{}
			}
			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Height == nil {
				m.Height = &types.Height{}
			}
			if err := m.Height.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelayTimePeriod", wireType)
			}
			m.DelayTimePeriod = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DelayTimePeriod |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelayBlockPeriod", wireType)
			}
			m.DelayBlockPeriod = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DelayBlockPeriod |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Prefix == nil {
				m.Prefix = &types1.MerklePrefix{}
			}
			if err := m.Prefix.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...)
			if m.Proof == nil {
				m.Proof = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PortId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				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 ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PortId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				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 ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChannelId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
			}
			m.Sequence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sequence |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipLightclientd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLightclientd
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLightclientd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VerifyNextSequenceRecvRequest) 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 ErrIntOverflowLightclientd
			}
			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: VerifyNextSequenceRecvRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VerifyNextSequenceRecvRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.State == nil {
				m.State = &State{}
			}
			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Height == nil {
				m.Height = &types.Height{}
			}
			if err := m.Height.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelayTimePeriod", wireType)
			}
			m.DelayTimePeriod = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DelayTimePeriod |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelayBlockPeriod", wireType)
			}
			m.DelayBlockPeriod = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DelayBlockPeriod |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Prefix == nil {
				m.Prefix = &types1.MerklePrefix{}
			}
			if err := m.Prefix.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...)
			if m.Proof == nil {
				m.Proof = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PortId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				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 ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PortId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				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 ErrInvalidLengthLightclientd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLightclientd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChannelId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextSequenceRecv", wireType)
			}
			m.NextSequenceRecv = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLightclientd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NextSequenceRecv |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipLightclientd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLightclientd
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLightclientd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthLightclientd        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowLightclientd          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupLightclientd = fmt.Errorf("proto: unexpected end of group")
)