// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: band/base/oracle/v1/proof.proto

package proof

import (
	context "context"
	fmt "fmt"
	types "github.com/bandprotocol/chain/v3/x/oracle/types"
	github_com_cometbft_cometbft_libs_bytes "github.com/cometbft/cometbft/libs/bytes"
	_ "github.com/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	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

// ProofRequest is request type for the Service/Proof RPC method.
type ProofRequest struct {
	// RequestID is ID of an oracle request
	RequestId uint64 `protobuf:"varint,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	// height is block height
	Height int64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
}

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

var xxx_messageInfo_ProofRequest proto.InternalMessageInfo

func (m *ProofRequest) GetRequestId() uint64 {
	if m != nil {
		return m.RequestId
	}
	return 0
}

func (m *ProofRequest) GetHeight() int64 {
	if m != nil {
		return m.Height
	}
	return 0
}

// ProofResponse is response type for the Service/Proof RPC method.
type ProofResponse struct {
	// height is block height
	Height int64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	// result is the proof
	Result SingleProofResult `protobuf:"bytes,2,opt,name=result,proto3" json:"result"`
}

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

var xxx_messageInfo_ProofResponse proto.InternalMessageInfo

func (m *ProofResponse) GetHeight() int64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *ProofResponse) GetResult() SingleProofResult {
	if m != nil {
		return m.Result
	}
	return SingleProofResult{}
}

// MultiProofRequest is request type for the Service/MultiProof RPC method.
type MultiProofRequest struct {
	// request_ids is the list of request IDs
	RequestIds []uint64 `protobuf:"varint,1,rep,packed,name=request_ids,json=requestIds,proto3" json:"request_ids,omitempty"`
}

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

var xxx_messageInfo_MultiProofRequest proto.InternalMessageInfo

func (m *MultiProofRequest) GetRequestIds() []uint64 {
	if m != nil {
		return m.RequestIds
	}
	return nil
}

// MultiProofResponse is response type for the Service/MultiProof RPC method.
type MultiProofResponse struct {
	Height int64            `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	Result MultiProofResult `protobuf:"bytes,2,opt,name=result,proto3" json:"result"`
}

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

var xxx_messageInfo_MultiProofResponse proto.InternalMessageInfo

func (m *MultiProofResponse) GetHeight() int64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *MultiProofResponse) GetResult() MultiProofResult {
	if m != nil {
		return m.Result
	}
	return MultiProofResult{}
}

// RequestCountProofRequest is request type for the Service/RequestCountProof RPC method.
type RequestCountProofRequest struct {
}

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

var xxx_messageInfo_RequestCountProofRequest proto.InternalMessageInfo

// RequestCountProofResponse is response type for the Service/RequestCountProof RPC method.
type RequestCountProofResponse struct {
	Height int64            `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	Result CountProofResult `protobuf:"bytes,2,opt,name=result,proto3" json:"result"`
}

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

var xxx_messageInfo_RequestCountProofResponse proto.InternalMessageInfo

func (m *RequestCountProofResponse) GetHeight() int64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *RequestCountProofResponse) GetResult() CountProofResult {
	if m != nil {
		return m.Result
	}
	return CountProofResult{}
}

// SingleProofResponse is the data structure for response of single proof
type SingleProofResult struct {
	Proof         SingleProof                                      `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof"`
	EvmProofBytes github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,2,opt,name=evm_proof_bytes,json=evmProofBytes,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"evm_proof_bytes,omitempty"`
}

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

var xxx_messageInfo_SingleProofResult proto.InternalMessageInfo

func (m *SingleProofResult) GetProof() SingleProof {
	if m != nil {
		return m.Proof
	}
	return SingleProof{}
}

func (m *SingleProofResult) GetEvmProofBytes() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.EvmProofBytes
	}
	return nil
}

// MultiProofResult is the data structure for response of multi proof
type MultiProofResult struct {
	Proof         MultiProof                                       `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof"`
	EvmProofBytes github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,2,opt,name=evm_proof_bytes,json=evmProofBytes,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"evm_proof_bytes,omitempty"`
}

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

var xxx_messageInfo_MultiProofResult proto.InternalMessageInfo

func (m *MultiProofResult) GetProof() MultiProof {
	if m != nil {
		return m.Proof
	}
	return MultiProof{}
}

func (m *MultiProofResult) GetEvmProofBytes() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.EvmProofBytes
	}
	return nil
}

// CountProofResult is the data structure for response of count proof
type CountProofResult struct {
	Proof         CountProof                                       `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof"`
	EvmProofBytes github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,2,opt,name=evm_proof_bytes,json=evmProofBytes,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"evm_proof_bytes,omitempty"`
}

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

var xxx_messageInfo_CountProofResult proto.InternalMessageInfo

func (m *CountProofResult) GetProof() CountProof {
	if m != nil {
		return m.Proof
	}
	return CountProof{}
}

func (m *CountProofResult) GetEvmProofBytes() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.EvmProofBytes
	}
	return nil
}

// SingleProof contains block height, oracle data proof and block relay proof
type SingleProof struct {
	BlockHeight     uint64          `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	OracleDataProof OracleDataProof `protobuf:"bytes,2,opt,name=oracle_data_proof,json=oracleDataProof,proto3" json:"oracle_data_proof"`
	BlockRelayProof BlockRelayProof `protobuf:"bytes,3,opt,name=block_relay_proof,json=blockRelayProof,proto3" json:"block_relay_proof"`
}

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

var xxx_messageInfo_SingleProof proto.InternalMessageInfo

func (m *SingleProof) GetBlockHeight() uint64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *SingleProof) GetOracleDataProof() OracleDataProof {
	if m != nil {
		return m.OracleDataProof
	}
	return OracleDataProof{}
}

func (m *SingleProof) GetBlockRelayProof() BlockRelayProof {
	if m != nil {
		return m.BlockRelayProof
	}
	return BlockRelayProof{}
}

// MultiProof contains block height, list of oracle data proof and block relay proof
type MultiProof struct {
	BlockHeight          uint64            `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	OracleDataMultiProof []OracleDataProof `protobuf:"bytes,2,rep,name=oracle_data_multi_proof,json=oracleDataMultiProof,proto3" json:"oracle_data_multi_proof"`
	BlockRelayProof      BlockRelayProof   `protobuf:"bytes,3,opt,name=block_relay_proof,json=blockRelayProof,proto3" json:"block_relay_proof"`
}

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

var xxx_messageInfo_MultiProof proto.InternalMessageInfo

func (m *MultiProof) GetBlockHeight() uint64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *MultiProof) GetOracleDataMultiProof() []OracleDataProof {
	if m != nil {
		return m.OracleDataMultiProof
	}
	return nil
}

func (m *MultiProof) GetBlockRelayProof() BlockRelayProof {
	if m != nil {
		return m.BlockRelayProof
	}
	return BlockRelayProof{}
}

// CountProof contains block height, count proof and block relay proof
type CountProof struct {
	BlockHeight     uint64             `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	CountProof      RequestsCountProof `protobuf:"bytes,2,opt,name=count_proof,json=countProof,proto3" json:"count_proof"`
	BlockRelayProof BlockRelayProof    `protobuf:"bytes,3,opt,name=block_relay_proof,json=blockRelayProof,proto3" json:"block_relay_proof"`
}

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

var xxx_messageInfo_CountProof proto.InternalMessageInfo

func (m *CountProof) GetBlockHeight() uint64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *CountProof) GetCountProof() RequestsCountProof {
	if m != nil {
		return m.CountProof
	}
	return RequestsCountProof{}
}

func (m *CountProof) GetBlockRelayProof() BlockRelayProof {
	if m != nil {
		return m.BlockRelayProof
	}
	return BlockRelayProof{}
}

// OracleDataProof contains result, version and merkle paths
type OracleDataProof struct {
	Result      types.Result     `protobuf:"bytes,1,opt,name=result,proto3" json:"result"`
	Version     uint64           `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"`
	MerklePaths []IAVLMerklePath `protobuf:"bytes,3,rep,name=merkle_paths,json=merklePaths,proto3" json:"merkle_paths"`
}

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

var xxx_messageInfo_OracleDataProof proto.InternalMessageInfo

func (m *OracleDataProof) GetResult() types.Result {
	if m != nil {
		return m.Result
	}
	return types.Result{}
}

func (m *OracleDataProof) GetVersion() uint64 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *OracleDataProof) GetMerklePaths() []IAVLMerklePath {
	if m != nil {
		return m.MerklePaths
	}
	return nil
}

// IAVLMerklePath represents a Merkle step to a leaf data node in an iAVL tree.
type IAVLMerklePath struct {
	IsDataOnRight  bool                                             `protobuf:"varint,1,opt,name=is_data_on_right,json=isDataOnRight,proto3" json:"is_data_on_right,omitempty"`
	SubtreeHeight  uint32                                           `protobuf:"varint,2,opt,name=subtree_height,json=subtreeHeight,proto3" json:"subtree_height,omitempty"`
	SubtreeSize    uint64                                           `protobuf:"varint,3,opt,name=subtree_size,json=subtreeSize,proto3" json:"subtree_size,omitempty"`
	SubtreeVersion uint64                                           `protobuf:"varint,4,opt,name=subtree_version,json=subtreeVersion,proto3" json:"subtree_version,omitempty"`
	SiblingHash    github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,5,opt,name=sibling_hash,json=siblingHash,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"sibling_hash,omitempty"`
}

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

var xxx_messageInfo_IAVLMerklePath proto.InternalMessageInfo

func (m *IAVLMerklePath) GetIsDataOnRight() bool {
	if m != nil {
		return m.IsDataOnRight
	}
	return false
}

func (m *IAVLMerklePath) GetSubtreeHeight() uint32 {
	if m != nil {
		return m.SubtreeHeight
	}
	return 0
}

func (m *IAVLMerklePath) GetSubtreeSize() uint64 {
	if m != nil {
		return m.SubtreeSize
	}
	return 0
}

func (m *IAVLMerklePath) GetSubtreeVersion() uint64 {
	if m != nil {
		return m.SubtreeVersion
	}
	return 0
}

func (m *IAVLMerklePath) GetSiblingHash() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.SiblingHash
	}
	return nil
}

// BlockRelayProof contains multi store proof, block header merkle parts, common encoded part and signatures
type BlockRelayProof struct {
	MultiStoreProof        MultiStoreProof        `protobuf:"bytes,1,opt,name=multi_store_proof,json=multiStoreProof,proto3" json:"multi_store_proof"`
	BlockHeaderMerkleParts BlockHeaderMerkleParts `protobuf:"bytes,2,opt,name=block_header_merkle_parts,json=blockHeaderMerkleParts,proto3" json:"block_header_merkle_parts"`
	CommonEncodedVotePart  CommonEncodedVotePart  `protobuf:"bytes,3,opt,name=common_encoded_vote_part,json=commonEncodedVotePart,proto3" json:"common_encoded_vote_part"`
	Signatures             []TMSignature          `protobuf:"bytes,4,rep,name=signatures,proto3" json:"signatures"`
}

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

var xxx_messageInfo_BlockRelayProof proto.InternalMessageInfo

func (m *BlockRelayProof) GetMultiStoreProof() MultiStoreProof {
	if m != nil {
		return m.MultiStoreProof
	}
	return MultiStoreProof{}
}

func (m *BlockRelayProof) GetBlockHeaderMerkleParts() BlockHeaderMerkleParts {
	if m != nil {
		return m.BlockHeaderMerkleParts
	}
	return BlockHeaderMerkleParts{}
}

func (m *BlockRelayProof) GetCommonEncodedVotePart() CommonEncodedVotePart {
	if m != nil {
		return m.CommonEncodedVotePart
	}
	return CommonEncodedVotePart{}
}

func (m *BlockRelayProof) GetSignatures() []TMSignature {
	if m != nil {
		return m.Signatures
	}
	return nil
}

// MultiStoreProof stores a compact of other Cosmos-SDK modules' storage hash in multistore to
// compute (in combination with oracle store hash) Tendermint's application state hash at a given block.
//
//	                                 __________________________[AppHash]__________________________
//	                                /                                                             \
//	                  ___________[N24]____________                                    ___________[N25]________
//	                 /                            \                                  /                        \
//	          _____[N20]_____                 ____[N21]______                   ____[N22]______              _[N23]_
//	         /               \               /               \                 /               \            /       \
//	     _[N12]_          _[N13]_          _[N14]_          _[N15]_          _[N16]_          _[N17]_     [N18]     [Q]
//	    /       \        /       \        /       \        /       \        /       \        /       \    /   \
//	  [N0]     [N1]    [N2]     [N3]    [N4]     [N5]    [N6]     [N7]    [N8]     [N9]   [N10]    [N11] [O] [P]
//	 /   \    /   \    /  \    /   \   /   \    /   \   /   \    /   \   /   \    /   \   /   \    /   \
//	[0] [1]  [2] [3] [4] [5]  [6] [7] [8] [9]  [A] [B] [C] [D]  [E] [F] [G] [H]  [I] [J] [K] [L]  [M] [N]
//
// [0] - acc (auth) [1] - authz         [2] - bandtss       [3] - bank        [4] - capability [5] - consensus
// [6] - crisis     [7] - distribution  [8] - evidence      [9] - feeds       [A] - feegrant   [B] - feeibc
// [C] - globalfee  [D] - gov           [E] - ibc           [F] - icahost     [G] - mint       [H] - oracle
// [I] - params     [J] - restake       [K] - rollingseed   [L] - slashing    [M] - staking    [N] - transfer
// [O] - tss        [P] - tunnel        [Q] - upgrade
//
// Notice that NOT all leaves of the Merkle tree are needed in order to compute the Merkle
// root hash, since we only want to validate the correctness of [H] In fact, only
// [G], [N9], [N17], [N23], and [N24] are needed in order to compute [AppHash].
type MultiStoreProof struct {
	OracleIAVLStateHash                   github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,1,opt,name=oracle_iavl_state_hash,json=oracleIavlStateHash,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"oracle_iavl_state_hash,omitempty"`
	MintStoreMerkleHash                   github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,2,opt,name=mint_store_merkle_hash,json=mintStoreMerkleHash,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"mint_store_merkle_hash,omitempty"`
	ParamsToRestakeStoresMerkleHash       github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,3,opt,name=params_to_restake_stores_merkle_hash,json=paramsToRestakeStoresMerkleHash,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"params_to_restake_stores_merkle_hash,omitempty"`
	RollingseedToTransferStoresMerkleHash github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,4,opt,name=rollingseed_to_transfer_stores_merkle_hash,json=rollingseedToTransferStoresMerkleHash,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"rollingseed_to_transfer_stores_merkle_hash,omitempty"`
	TSSToUpgradeStoresMerkleHash          github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,5,opt,name=tss_to_upgrade_stores_merkle_hash,json=tssToUpgradeStoresMerkleHash,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"tss_to_upgrade_stores_merkle_hash,omitempty"`
	AuthToIcahostStoresMerkleHash         github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,6,opt,name=auth_to_icahost_stores_merkle_hash,json=authToIcahostStoresMerkleHash,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"auth_to_icahost_stores_merkle_hash,omitempty"`
}

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

var xxx_messageInfo_MultiStoreProof proto.InternalMessageInfo

func (m *MultiStoreProof) GetOracleIAVLStateHash() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.OracleIAVLStateHash
	}
	return nil
}

func (m *MultiStoreProof) GetMintStoreMerkleHash() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.MintStoreMerkleHash
	}
	return nil
}

func (m *MultiStoreProof) GetParamsToRestakeStoresMerkleHash() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.ParamsToRestakeStoresMerkleHash
	}
	return nil
}

func (m *MultiStoreProof) GetRollingseedToTransferStoresMerkleHash() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.RollingseedToTransferStoresMerkleHash
	}
	return nil
}

func (m *MultiStoreProof) GetTSSToUpgradeStoresMerkleHash() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.TSSToUpgradeStoresMerkleHash
	}
	return nil
}

func (m *MultiStoreProof) GetAuthToIcahostStoresMerkleHash() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.AuthToIcahostStoresMerkleHash
	}
	return nil
}

// BlockHeaderMerkleParts stores a group of hashes using for computing Tendermint's block
// header hash from app hash, and height.
//
// In Tendermint, a block header hash is the Merkle hash of a binary tree with 14 leaf nodes.
// Each node encodes a data piece of the blockchain. The notable data leaves are: [A] app_hash,
// [2] height. All data pieces are combined into one 32-byte hash to be signed
// by block validators. The structure of the Merkle tree is shown below.
//
//	                                 [BlockHeader]
//	                              /                \
//	                 [3A]                                    [3B]
//	               /      \                                /      \
//	       [2A]                [2B]                [2C]                [2D]
//	      /    \              /    \              /    \              /    \
//	  [1A]      [1B]      [1C]      [1D]      [1E]      [1F]        [C]    [D]
//	  /  \      /  \      /  \      /  \      /  \      /  \
//	[0]  [1]  [2]  [3]  [4]  [5]  [6]  [7]  [8]  [9]  [A]  [B]
//
//	[0] - version               [1] - chain_id            [2] - height        [3] - time
//	[4] - last_block_id         [5] - last_commit_hash    [6] - data_hash     [7] - validators_hash
//	[8] - next_validators_hash  [9] - consensus_hash      [A] - app_hash      [B] - last_results_hash
//	[C] - evidence_hash         [D] - proposer_address
//
// Notice that NOT all leaves of the Merkle tree are needed in order to compute the Merkle
// root hash, since we only want to validate the correctness of [2], [3], and [A]. In fact, only
// [1A], [2B], [1E], [B], and [2D] are needed in order to compute [BlockHeader].
type BlockHeaderMerkleParts struct {
	VersionAndChainIdHash             github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,1,opt,name=version_and_chain_id_hash,json=versionAndChainIdHash,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"version_and_chain_id_hash,omitempty"`
	Height                            uint64                                           `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
	TimeSecond                        uint64                                           `protobuf:"varint,3,opt,name=time_second,json=timeSecond,proto3" json:"time_second,omitempty"`
	TimeNanoSecond                    uint32                                           `protobuf:"varint,4,opt,name=time_nano_second,json=timeNanoSecond,proto3" json:"time_nano_second,omitempty"`
	LastBlockIdAndOther               github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,5,opt,name=last_block_id_and_other,json=lastBlockIdAndOther,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"last_block_id_and_other,omitempty"`
	NextValidatorHashAndConsensusHash github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,6,opt,name=next_validator_hash_and_consensus_hash,json=nextValidatorHashAndConsensusHash,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"next_validator_hash_and_consensus_hash,omitempty"`
	LastResultsHash                   github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,7,opt,name=last_results_hash,json=lastResultsHash,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"last_results_hash,omitempty"`
	EvidenceAndProposerHash           github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,8,opt,name=evidence_and_proposer_hash,json=evidenceAndProposerHash,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"evidence_and_proposer_hash,omitempty"`
}

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

var xxx_messageInfo_BlockHeaderMerkleParts proto.InternalMessageInfo

func (m *BlockHeaderMerkleParts) GetVersionAndChainIdHash() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.VersionAndChainIdHash
	}
	return nil
}

func (m *BlockHeaderMerkleParts) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *BlockHeaderMerkleParts) GetTimeSecond() uint64 {
	if m != nil {
		return m.TimeSecond
	}
	return 0
}

func (m *BlockHeaderMerkleParts) GetTimeNanoSecond() uint32 {
	if m != nil {
		return m.TimeNanoSecond
	}
	return 0
}

func (m *BlockHeaderMerkleParts) GetLastBlockIdAndOther() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.LastBlockIdAndOther
	}
	return nil
}

func (m *BlockHeaderMerkleParts) GetNextValidatorHashAndConsensusHash() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.NextValidatorHashAndConsensusHash
	}
	return nil
}

func (m *BlockHeaderMerkleParts) GetLastResultsHash() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.LastResultsHash
	}
	return nil
}

func (m *BlockHeaderMerkleParts) GetEvidenceAndProposerHash() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.EvidenceAndProposerHash
	}
	return nil
}

// CommonEncodedVotePart represents the common part of encoded vote
type CommonEncodedVotePart struct {
	SignedDataPrefix github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,1,opt,name=signed_data_prefix,json=signedDataPrefix,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"signed_data_prefix,omitempty"`
	SignedDataSuffix github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,2,opt,name=signed_data_suffix,json=signedDataSuffix,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"signed_data_suffix,omitempty"`
}

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

var xxx_messageInfo_CommonEncodedVotePart proto.InternalMessageInfo

func (m *CommonEncodedVotePart) GetSignedDataPrefix() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.SignedDataPrefix
	}
	return nil
}

func (m *CommonEncodedVotePart) GetSignedDataSuffix() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.SignedDataSuffix
	}
	return nil
}

// TMSignature contains all details of validator signature for performing signer recovery for ECDSA
// secp256k1 signature. Note that this struct is written specifically for signature signed on
// Tendermint's precommit data, which includes the block hash and some additional information prepended
// and appended to the block hash. The prepended part (prefix) and the appended part (suffix) are
// different for each signer (including signature size, machine clock, validator index, etc).
type TMSignature struct {
	R                github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,1,opt,name=r,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"r,omitempty"`
	S                github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,2,opt,name=s,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"s,omitempty"`
	V                uint32                                           `protobuf:"varint,3,opt,name=v,proto3" json:"v,omitempty"`
	EncodedTimestamp github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,4,opt,name=encoded_timestamp,json=encodedTimestamp,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"encoded_timestamp,omitempty"`
}

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

var xxx_messageInfo_TMSignature proto.InternalMessageInfo

func (m *TMSignature) GetR() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.R
	}
	return nil
}

func (m *TMSignature) GetS() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.S
	}
	return nil
}

func (m *TMSignature) GetV() uint32 {
	if m != nil {
		return m.V
	}
	return 0
}

func (m *TMSignature) GetEncodedTimestamp() github_com_cometbft_cometbft_libs_bytes.HexBytes {
	if m != nil {
		return m.EncodedTimestamp
	}
	return nil
}

// RequestsCountProof contains count, version and merkle paths
type RequestsCountProof struct {
	Count       uint64           `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
	Version     uint64           `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"`
	MerklePaths []IAVLMerklePath `protobuf:"bytes,3,rep,name=merkle_paths,json=merklePaths,proto3" json:"merkle_paths"`
}

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

var xxx_messageInfo_RequestsCountProof proto.InternalMessageInfo

func (m *RequestsCountProof) GetCount() uint64 {
	if m != nil {
		return m.Count
	}
	return 0
}

func (m *RequestsCountProof) GetVersion() uint64 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *RequestsCountProof) GetMerklePaths() []IAVLMerklePath {
	if m != nil {
		return m.MerklePaths
	}
	return nil
}

func init() {
	proto.RegisterType((*ProofRequest)(nil), "band.base.oracle.v1.ProofRequest")
	proto.RegisterType((*ProofResponse)(nil), "band.base.oracle.v1.ProofResponse")
	proto.RegisterType((*MultiProofRequest)(nil), "band.base.oracle.v1.MultiProofRequest")
	proto.RegisterType((*MultiProofResponse)(nil), "band.base.oracle.v1.MultiProofResponse")
	proto.RegisterType((*RequestCountProofRequest)(nil), "band.base.oracle.v1.RequestCountProofRequest")
	proto.RegisterType((*RequestCountProofResponse)(nil), "band.base.oracle.v1.RequestCountProofResponse")
	proto.RegisterType((*SingleProofResult)(nil), "band.base.oracle.v1.SingleProofResult")
	proto.RegisterType((*MultiProofResult)(nil), "band.base.oracle.v1.MultiProofResult")
	proto.RegisterType((*CountProofResult)(nil), "band.base.oracle.v1.CountProofResult")
	proto.RegisterType((*SingleProof)(nil), "band.base.oracle.v1.SingleProof")
	proto.RegisterType((*MultiProof)(nil), "band.base.oracle.v1.MultiProof")
	proto.RegisterType((*CountProof)(nil), "band.base.oracle.v1.CountProof")
	proto.RegisterType((*OracleDataProof)(nil), "band.base.oracle.v1.OracleDataProof")
	proto.RegisterType((*IAVLMerklePath)(nil), "band.base.oracle.v1.IAVLMerklePath")
	proto.RegisterType((*BlockRelayProof)(nil), "band.base.oracle.v1.BlockRelayProof")
	proto.RegisterType((*MultiStoreProof)(nil), "band.base.oracle.v1.MultiStoreProof")
	proto.RegisterType((*BlockHeaderMerkleParts)(nil), "band.base.oracle.v1.BlockHeaderMerkleParts")
	proto.RegisterType((*CommonEncodedVotePart)(nil), "band.base.oracle.v1.CommonEncodedVotePart")
	proto.RegisterType((*TMSignature)(nil), "band.base.oracle.v1.TMSignature")
	proto.RegisterType((*RequestsCountProof)(nil), "band.base.oracle.v1.RequestsCountProof")
}

func init() { proto.RegisterFile("band/base/oracle/v1/proof.proto", fileDescriptor_9deb752797273b09) }

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

// ServiceClient is the client API for Service service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ServiceClient interface {
	// Proof queries the proof for given request ID
	Proof(ctx context.Context, in *ProofRequest, opts ...grpc.CallOption) (*ProofResponse, error)
	// MultiProof queries multiple proofs for given list of request IDs
	MultiProof(ctx context.Context, in *MultiProofRequest, opts ...grpc.CallOption) (*MultiProofResponse, error)
	// RequestCountProof queries the count proof
	RequestCountProof(ctx context.Context, in *RequestCountProofRequest, opts ...grpc.CallOption) (*RequestCountProofResponse, error)
}

type serviceClient struct {
	cc grpc1.ClientConn
}

func NewServiceClient(cc grpc1.ClientConn) ServiceClient {
	return &serviceClient{cc}
}

func (c *serviceClient) Proof(ctx context.Context, in *ProofRequest, opts ...grpc.CallOption) (*ProofResponse, error) {
	out := new(ProofResponse)
	err := c.cc.Invoke(ctx, "/band.base.oracle.v1.Service/Proof", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serviceClient) MultiProof(ctx context.Context, in *MultiProofRequest, opts ...grpc.CallOption) (*MultiProofResponse, error) {
	out := new(MultiProofResponse)
	err := c.cc.Invoke(ctx, "/band.base.oracle.v1.Service/MultiProof", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serviceClient) RequestCountProof(ctx context.Context, in *RequestCountProofRequest, opts ...grpc.CallOption) (*RequestCountProofResponse, error) {
	out := new(RequestCountProofResponse)
	err := c.cc.Invoke(ctx, "/band.base.oracle.v1.Service/RequestCountProof", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ServiceServer is the server API for Service service.
type ServiceServer interface {
	// Proof queries the proof for given request ID
	Proof(context.Context, *ProofRequest) (*ProofResponse, error)
	// MultiProof queries multiple proofs for given list of request IDs
	MultiProof(context.Context, *MultiProofRequest) (*MultiProofResponse, error)
	// RequestCountProof queries the count proof
	RequestCountProof(context.Context, *RequestCountProofRequest) (*RequestCountProofResponse, error)
}

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

func (*UnimplementedServiceServer) Proof(ctx context.Context, req *ProofRequest) (*ProofResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Proof not implemented")
}
func (*UnimplementedServiceServer) MultiProof(ctx context.Context, req *MultiProofRequest) (*MultiProofResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MultiProof not implemented")
}
func (*UnimplementedServiceServer) RequestCountProof(ctx context.Context, req *RequestCountProofRequest) (*RequestCountProofResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RequestCountProof not implemented")
}

func RegisterServiceServer(s grpc1.Server, srv ServiceServer) {
	s.RegisterService(&_Service_serviceDesc, srv)
}

func _Service_Proof_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ProofRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).Proof(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.base.oracle.v1.Service/Proof",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).Proof(ctx, req.(*ProofRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Service_MultiProof_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MultiProofRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).MultiProof(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.base.oracle.v1.Service/MultiProof",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).MultiProof(ctx, req.(*MultiProofRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Service_RequestCountProof_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestCountProofRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).RequestCountProof(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.base.oracle.v1.Service/RequestCountProof",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).RequestCountProof(ctx, req.(*RequestCountProofRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Service_serviceDesc = grpc.ServiceDesc{
	ServiceName: "band.base.oracle.v1.Service",
	HandlerType: (*ServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Proof",
			Handler:    _Service_Proof_Handler,
		},
		{
			MethodName: "MultiProof",
			Handler:    _Service_MultiProof_Handler,
		},
		{
			MethodName: "RequestCountProof",
			Handler:    _Service_RequestCountProof_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "band/base/oracle/v1/proof.proto",
}

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

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

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

func (m *ProofResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProof(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.Height != 0 {
		i = encodeVarintProof(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *MultiProofRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RequestIds) > 0 {
		dAtA3 := make([]byte, len(m.RequestIds)*10)
		var j2 int
		for _, num := range m.RequestIds {
			for num >= 1<<7 {
				dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j2++
			}
			dAtA3[j2] = uint8(num)
			j2++
		}
		i -= j2
		copy(dAtA[i:], dAtA3[:j2])
		i = encodeVarintProof(dAtA, i, uint64(j2))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MultiProofResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProof(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.Height != 0 {
		i = encodeVarintProof(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *RequestCountProofRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *RequestCountProofResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProof(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.Height != 0 {
		i = encodeVarintProof(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *SingleProof) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.BlockRelayProof.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProof(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.OracleDataProof.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProof(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.BlockHeight != 0 {
		i = encodeVarintProof(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *MultiProof) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.BlockRelayProof.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProof(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.OracleDataMultiProof) > 0 {
		for iNdEx := len(m.OracleDataMultiProof) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OracleDataMultiProof[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintProof(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.BlockHeight != 0 {
		i = encodeVarintProof(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *CountProof) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.BlockRelayProof.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProof(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.CountProof.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProof(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.BlockHeight != 0 {
		i = encodeVarintProof(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *OracleDataProof) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MerklePaths) > 0 {
		for iNdEx := len(m.MerklePaths) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MerklePaths[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintProof(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Version != 0 {
		i = encodeVarintProof(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProof(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *IAVLMerklePath) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SiblingHash) > 0 {
		i -= len(m.SiblingHash)
		copy(dAtA[i:], m.SiblingHash)
		i = encodeVarintProof(dAtA, i, uint64(len(m.SiblingHash)))
		i--
		dAtA[i] = 0x2a
	}
	if m.SubtreeVersion != 0 {
		i = encodeVarintProof(dAtA, i, uint64(m.SubtreeVersion))
		i--
		dAtA[i] = 0x20
	}
	if m.SubtreeSize != 0 {
		i = encodeVarintProof(dAtA, i, uint64(m.SubtreeSize))
		i--
		dAtA[i] = 0x18
	}
	if m.SubtreeHeight != 0 {
		i = encodeVarintProof(dAtA, i, uint64(m.SubtreeHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.IsDataOnRight {
		i--
		if m.IsDataOnRight {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *BlockRelayProof) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Signatures) > 0 {
		for iNdEx := len(m.Signatures) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Signatures[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintProof(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	{
		size, err := m.CommonEncodedVotePart.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProof(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.BlockHeaderMerkleParts.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProof(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.MultiStoreProof.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProof(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *MultiStoreProof) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AuthToIcahostStoresMerkleHash) > 0 {
		i -= len(m.AuthToIcahostStoresMerkleHash)
		copy(dAtA[i:], m.AuthToIcahostStoresMerkleHash)
		i = encodeVarintProof(dAtA, i, uint64(len(m.AuthToIcahostStoresMerkleHash)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.TSSToUpgradeStoresMerkleHash) > 0 {
		i -= len(m.TSSToUpgradeStoresMerkleHash)
		copy(dAtA[i:], m.TSSToUpgradeStoresMerkleHash)
		i = encodeVarintProof(dAtA, i, uint64(len(m.TSSToUpgradeStoresMerkleHash)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.RollingseedToTransferStoresMerkleHash) > 0 {
		i -= len(m.RollingseedToTransferStoresMerkleHash)
		copy(dAtA[i:], m.RollingseedToTransferStoresMerkleHash)
		i = encodeVarintProof(dAtA, i, uint64(len(m.RollingseedToTransferStoresMerkleHash)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ParamsToRestakeStoresMerkleHash) > 0 {
		i -= len(m.ParamsToRestakeStoresMerkleHash)
		copy(dAtA[i:], m.ParamsToRestakeStoresMerkleHash)
		i = encodeVarintProof(dAtA, i, uint64(len(m.ParamsToRestakeStoresMerkleHash)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.MintStoreMerkleHash) > 0 {
		i -= len(m.MintStoreMerkleHash)
		copy(dAtA[i:], m.MintStoreMerkleHash)
		i = encodeVarintProof(dAtA, i, uint64(len(m.MintStoreMerkleHash)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.OracleIAVLStateHash) > 0 {
		i -= len(m.OracleIAVLStateHash)
		copy(dAtA[i:], m.OracleIAVLStateHash)
		i = encodeVarintProof(dAtA, i, uint64(len(m.OracleIAVLStateHash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *BlockHeaderMerkleParts) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.EvidenceAndProposerHash) > 0 {
		i -= len(m.EvidenceAndProposerHash)
		copy(dAtA[i:], m.EvidenceAndProposerHash)
		i = encodeVarintProof(dAtA, i, uint64(len(m.EvidenceAndProposerHash)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.LastResultsHash) > 0 {
		i -= len(m.LastResultsHash)
		copy(dAtA[i:], m.LastResultsHash)
		i = encodeVarintProof(dAtA, i, uint64(len(m.LastResultsHash)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.NextValidatorHashAndConsensusHash) > 0 {
		i -= len(m.NextValidatorHashAndConsensusHash)
		copy(dAtA[i:], m.NextValidatorHashAndConsensusHash)
		i = encodeVarintProof(dAtA, i, uint64(len(m.NextValidatorHashAndConsensusHash)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.LastBlockIdAndOther) > 0 {
		i -= len(m.LastBlockIdAndOther)
		copy(dAtA[i:], m.LastBlockIdAndOther)
		i = encodeVarintProof(dAtA, i, uint64(len(m.LastBlockIdAndOther)))
		i--
		dAtA[i] = 0x2a
	}
	if m.TimeNanoSecond != 0 {
		i = encodeVarintProof(dAtA, i, uint64(m.TimeNanoSecond))
		i--
		dAtA[i] = 0x20
	}
	if m.TimeSecond != 0 {
		i = encodeVarintProof(dAtA, i, uint64(m.TimeSecond))
		i--
		dAtA[i] = 0x18
	}
	if m.Height != 0 {
		i = encodeVarintProof(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x10
	}
	if len(m.VersionAndChainIdHash) > 0 {
		i -= len(m.VersionAndChainIdHash)
		copy(dAtA[i:], m.VersionAndChainIdHash)
		i = encodeVarintProof(dAtA, i, uint64(len(m.VersionAndChainIdHash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *TMSignature) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.EncodedTimestamp) > 0 {
		i -= len(m.EncodedTimestamp)
		copy(dAtA[i:], m.EncodedTimestamp)
		i = encodeVarintProof(dAtA, i, uint64(len(m.EncodedTimestamp)))
		i--
		dAtA[i] = 0x22
	}
	if m.V != 0 {
		i = encodeVarintProof(dAtA, i, uint64(m.V))
		i--
		dAtA[i] = 0x18
	}
	if len(m.S) > 0 {
		i -= len(m.S)
		copy(dAtA[i:], m.S)
		i = encodeVarintProof(dAtA, i, uint64(len(m.S)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.R) > 0 {
		i -= len(m.R)
		copy(dAtA[i:], m.R)
		i = encodeVarintProof(dAtA, i, uint64(len(m.R)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *RequestsCountProof) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MerklePaths) > 0 {
		for iNdEx := len(m.MerklePaths) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MerklePaths[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintProof(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Version != 0 {
		i = encodeVarintProof(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x10
	}
	if m.Count != 0 {
		i = encodeVarintProof(dAtA, i, uint64(m.Count))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ProofResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovProof(uint64(m.Height))
	}
	l = m.Result.Size()
	n += 1 + l + sovProof(uint64(l))
	return n
}

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

func (m *MultiProofResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovProof(uint64(m.Height))
	}
	l = m.Result.Size()
	n += 1 + l + sovProof(uint64(l))
	return n
}

func (m *RequestCountProofRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RequestCountProofResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovProof(uint64(m.Height))
	}
	l = m.Result.Size()
	n += 1 + l + sovProof(uint64(l))
	return n
}

func (m *SingleProofResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Proof.Size()
	n += 1 + l + sovProof(uint64(l))
	l = len(m.EvmProofBytes)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	return n
}

func (m *MultiProofResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Proof.Size()
	n += 1 + l + sovProof(uint64(l))
	l = len(m.EvmProofBytes)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	return n
}

func (m *CountProofResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Proof.Size()
	n += 1 + l + sovProof(uint64(l))
	l = len(m.EvmProofBytes)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	return n
}

func (m *SingleProof) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockHeight != 0 {
		n += 1 + sovProof(uint64(m.BlockHeight))
	}
	l = m.OracleDataProof.Size()
	n += 1 + l + sovProof(uint64(l))
	l = m.BlockRelayProof.Size()
	n += 1 + l + sovProof(uint64(l))
	return n
}

func (m *MultiProof) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockHeight != 0 {
		n += 1 + sovProof(uint64(m.BlockHeight))
	}
	if len(m.OracleDataMultiProof) > 0 {
		for _, e := range m.OracleDataMultiProof {
			l = e.Size()
			n += 1 + l + sovProof(uint64(l))
		}
	}
	l = m.BlockRelayProof.Size()
	n += 1 + l + sovProof(uint64(l))
	return n
}

func (m *CountProof) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockHeight != 0 {
		n += 1 + sovProof(uint64(m.BlockHeight))
	}
	l = m.CountProof.Size()
	n += 1 + l + sovProof(uint64(l))
	l = m.BlockRelayProof.Size()
	n += 1 + l + sovProof(uint64(l))
	return n
}

func (m *OracleDataProof) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Result.Size()
	n += 1 + l + sovProof(uint64(l))
	if m.Version != 0 {
		n += 1 + sovProof(uint64(m.Version))
	}
	if len(m.MerklePaths) > 0 {
		for _, e := range m.MerklePaths {
			l = e.Size()
			n += 1 + l + sovProof(uint64(l))
		}
	}
	return n
}

func (m *IAVLMerklePath) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IsDataOnRight {
		n += 2
	}
	if m.SubtreeHeight != 0 {
		n += 1 + sovProof(uint64(m.SubtreeHeight))
	}
	if m.SubtreeSize != 0 {
		n += 1 + sovProof(uint64(m.SubtreeSize))
	}
	if m.SubtreeVersion != 0 {
		n += 1 + sovProof(uint64(m.SubtreeVersion))
	}
	l = len(m.SiblingHash)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	return n
}

func (m *BlockRelayProof) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.MultiStoreProof.Size()
	n += 1 + l + sovProof(uint64(l))
	l = m.BlockHeaderMerkleParts.Size()
	n += 1 + l + sovProof(uint64(l))
	l = m.CommonEncodedVotePart.Size()
	n += 1 + l + sovProof(uint64(l))
	if len(m.Signatures) > 0 {
		for _, e := range m.Signatures {
			l = e.Size()
			n += 1 + l + sovProof(uint64(l))
		}
	}
	return n
}

func (m *MultiStoreProof) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OracleIAVLStateHash)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	l = len(m.MintStoreMerkleHash)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	l = len(m.ParamsToRestakeStoresMerkleHash)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	l = len(m.RollingseedToTransferStoresMerkleHash)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	l = len(m.TSSToUpgradeStoresMerkleHash)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	l = len(m.AuthToIcahostStoresMerkleHash)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	return n
}

func (m *BlockHeaderMerkleParts) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.VersionAndChainIdHash)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	if m.Height != 0 {
		n += 1 + sovProof(uint64(m.Height))
	}
	if m.TimeSecond != 0 {
		n += 1 + sovProof(uint64(m.TimeSecond))
	}
	if m.TimeNanoSecond != 0 {
		n += 1 + sovProof(uint64(m.TimeNanoSecond))
	}
	l = len(m.LastBlockIdAndOther)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	l = len(m.NextValidatorHashAndConsensusHash)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	l = len(m.LastResultsHash)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	l = len(m.EvidenceAndProposerHash)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	return n
}

func (m *CommonEncodedVotePart) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SignedDataPrefix)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	l = len(m.SignedDataSuffix)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	return n
}

func (m *TMSignature) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.R)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	l = len(m.S)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	if m.V != 0 {
		n += 1 + sovProof(uint64(m.V))
	}
	l = len(m.EncodedTimestamp)
	if l > 0 {
		n += 1 + l + sovProof(uint64(l))
	}
	return n
}

func (m *RequestsCountProof) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Count != 0 {
		n += 1 + sovProof(uint64(m.Count))
	}
	if m.Version != 0 {
		n += 1 + sovProof(uint64(m.Version))
	}
	if len(m.MerklePaths) > 0 {
		for _, e := range m.MerklePaths {
			l = e.Size()
			n += 1 + l + sovProof(uint64(l))
		}
	}
	return n
}

func sovProof(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozProof(x uint64) (n int) {
	return sovProof(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ProofRequest) 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 ErrIntOverflowProof
			}
			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: ProofRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProofRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)
			}
			m.RequestId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipProof(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProof
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MultiProofRequest) 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 ErrIntOverflowProof
			}
			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: MultiProofRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MultiProofRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProof
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RequestIds = append(m.RequestIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProof
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthProof
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthProof
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RequestIds) == 0 {
					m.RequestIds = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowProof
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RequestIds = append(m.RequestIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestIds", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipProof(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProof
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RequestCountProofRequest) 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 ErrIntOverflowProof
			}
			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: RequestCountProofRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RequestCountProofRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipProof(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProof
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MultiProof) 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 ErrIntOverflowProof
			}
			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: MultiProof: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MultiProof: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OracleDataMultiProof", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProof
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProof
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OracleDataMultiProof = append(m.OracleDataMultiProof, OracleDataProof{})
			if err := m.OracleDataMultiProof[len(m.OracleDataMultiProof)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockRelayProof", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProof
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProof
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.BlockRelayProof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProof(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProof
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IAVLMerklePath) 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 ErrIntOverflowProof
			}
			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: IAVLMerklePath: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IAVLMerklePath: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsDataOnRight", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsDataOnRight = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubtreeHeight", wireType)
			}
			m.SubtreeHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SubtreeHeight |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubtreeSize", wireType)
			}
			m.SubtreeSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SubtreeSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubtreeVersion", wireType)
			}
			m.SubtreeVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SubtreeVersion |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SiblingHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProof
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProof
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SiblingHash = append(m.SiblingHash[:0], dAtA[iNdEx:postIndex]...)
			if m.SiblingHash == nil {
				m.SiblingHash = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProof(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProof
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockRelayProof) 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 ErrIntOverflowProof
			}
			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: BlockRelayProof: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockRelayProof: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MultiStoreProof", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProof
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProof
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MultiStoreProof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeaderMerkleParts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProof
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProof
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.BlockHeaderMerkleParts.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommonEncodedVotePart", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProof
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProof
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CommonEncodedVotePart.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProof
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProof
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signatures = append(m.Signatures, TMSignature{})
			if err := m.Signatures[len(m.Signatures)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProof(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProof
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MultiStoreProof) 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 ErrIntOverflowProof
			}
			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: MultiStoreProof: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MultiStoreProof: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OracleIAVLStateHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProof
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProof
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OracleIAVLStateHash = append(m.OracleIAVLStateHash[:0], dAtA[iNdEx:postIndex]...)
			if m.OracleIAVLStateHash == nil {
				m.OracleIAVLStateHash = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MintStoreMerkleHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProof
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProof
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MintStoreMerkleHash = append(m.MintStoreMerkleHash[:0], dAtA[iNdEx:postIndex]...)
			if m.MintStoreMerkleHash == nil {
				m.MintStoreMerkleHash = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParamsToRestakeStoresMerkleHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProof
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProof
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ParamsToRestakeStoresMerkleHash = append(m.ParamsToRestakeStoresMerkleHash[:0], dAtA[iNdEx:postIndex]...)
			if m.ParamsToRestakeStoresMerkleHash == nil {
				m.ParamsToRestakeStoresMerkleHash = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RollingseedToTransferStoresMerkleHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProof
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProof
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RollingseedToTransferStoresMerkleHash = append(m.RollingseedToTransferStoresMerkleHash[:0], dAtA[iNdEx:postIndex]...)
			if m.RollingseedToTransferStoresMerkleHash == nil {
				m.RollingseedToTransferStoresMerkleHash = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TSSToUpgradeStoresMerkleHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProof
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProof
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TSSToUpgradeStoresMerkleHash = append(m.TSSToUpgradeStoresMerkleHash[:0], dAtA[iNdEx:postIndex]...)
			if m.TSSToUpgradeStoresMerkleHash == nil {
				m.TSSToUpgradeStoresMerkleHash = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AuthToIcahostStoresMerkleHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProof
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProof
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AuthToIcahostStoresMerkleHash = append(m.AuthToIcahostStoresMerkleHash[:0], dAtA[iNdEx:postIndex]...)
			if m.AuthToIcahostStoresMerkleHash == nil {
				m.AuthToIcahostStoresMerkleHash = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProof(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProof
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockHeaderMerkleParts) 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 ErrIntOverflowProof
			}
			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: BlockHeaderMerkleParts: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockHeaderMerkleParts: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VersionAndChainIdHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProof
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProof
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VersionAndChainIdHash = append(m.VersionAndChainIdHash[:0], dAtA[iNdEx:postIndex]...)
			if m.VersionAndChainIdHash == nil {
				m.VersionAndChainIdHash = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeSecond", wireType)
			}
			m.TimeSecond = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimeSecond |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeNanoSecond", wireType)
			}
			m.TimeNanoSecond = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimeNanoSecond |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastBlockIdAndOther", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProof
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProof
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LastBlockIdAndOther = append(m.LastBlockIdAndOther[:0], dAtA[iNdEx:postIndex]...)
			if m.LastBlockIdAndOther == nil {
				m.LastBlockIdAndOther = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextValidatorHashAndConsensusHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProof
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProof
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NextValidatorHashAndConsensusHash = append(m.NextValidatorHashAndConsensusHash[:0], dAtA[iNdEx:postIndex]...)
			if m.NextValidatorHashAndConsensusHash == nil {
				m.NextValidatorHashAndConsensusHash = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastResultsHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProof
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProof
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LastResultsHash = append(m.LastResultsHash[:0], dAtA[iNdEx:postIndex]...)
			if m.LastResultsHash == nil {
				m.LastResultsHash = []byte{}
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EvidenceAndProposerHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProof
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProof
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProof
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EvidenceAndProposerHash = append(m.EvidenceAndProposerHash[:0], dAtA[iNdEx:postIndex]...)
			if m.EvidenceAndProposerHash == nil {
				m.EvidenceAndProposerHash = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProof(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProof
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

var (
	ErrInvalidLengthProof        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowProof          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupProof = fmt.Errorf("proto: unexpected end of group")
)
