query.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: dydxprotocol/clob/query.proto

package types

import (
	context "context"
	encoding_binary "encoding/binary"
	fmt "fmt"
	query "github.com/cosmos/cosmos-sdk/types/query"
	_ "github.com/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	types "github.com/dydxprotocol/v4-chain/protocol/x/subaccounts/types"
	_ "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

// QueryGetClobPairRequest is request type for the ClobPair method.
type QueryGetClobPairRequest struct {
	Id uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
}

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

var xxx_messageInfo_QueryGetClobPairRequest proto.InternalMessageInfo

func (m *QueryGetClobPairRequest) GetId() uint32 {
	if m != nil {
		return m.Id
	}
	return 0
}

// QueryClobPairResponse is response type for the ClobPair method.
type QueryClobPairResponse struct {
	ClobPair ClobPair `protobuf:"bytes,1,opt,name=clob_pair,json=clobPair,proto3" json:"clob_pair"`
}

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

var xxx_messageInfo_QueryClobPairResponse proto.InternalMessageInfo

func (m *QueryClobPairResponse) GetClobPair() ClobPair {
	if m != nil {
		return m.ClobPair
	}
	return ClobPair{}
}

// QueryAllClobPairRequest is request type for the ClobPairAll method.
type QueryAllClobPairRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllClobPairRequest proto.InternalMessageInfo

func (m *QueryAllClobPairRequest) GetPagination() *query.PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QueryClobPairAllResponse is response type for the ClobPairAll method.
type QueryClobPairAllResponse struct {
	ClobPair   []ClobPair          `protobuf:"bytes,1,rep,name=clob_pair,json=clobPair,proto3" json:"clob_pair"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryClobPairAllResponse proto.InternalMessageInfo

func (m *QueryClobPairAllResponse) GetClobPair() []ClobPair {
	if m != nil {
		return m.ClobPair
	}
	return nil
}

func (m *QueryClobPairAllResponse) GetPagination() *query.PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// AreSubaccountsLiquidatableRequest is a request message used to check whether
// the given subaccounts are liquidatable.
// The subaccount ids should not contain duplicates.
type AreSubaccountsLiquidatableRequest struct {
	SubaccountIds []types.SubaccountId `protobuf:"bytes,1,rep,name=subaccount_ids,json=subaccountIds,proto3" json:"subaccount_ids"`
}

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

var xxx_messageInfo_AreSubaccountsLiquidatableRequest proto.InternalMessageInfo

func (m *AreSubaccountsLiquidatableRequest) GetSubaccountIds() []types.SubaccountId {
	if m != nil {
		return m.SubaccountIds
	}
	return nil
}

// AreSubaccountsLiquidatableResponse is a response message that contains the
// liquidation status for each subaccount.
type AreSubaccountsLiquidatableResponse struct {
	Results []AreSubaccountsLiquidatableResponse_Result `protobuf:"bytes,1,rep,name=results,proto3" json:"results"`
}

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

var xxx_messageInfo_AreSubaccountsLiquidatableResponse proto.InternalMessageInfo

func (m *AreSubaccountsLiquidatableResponse) GetResults() []AreSubaccountsLiquidatableResponse_Result {
	if m != nil {
		return m.Results
	}
	return nil
}

// Result returns whether a subaccount should be liquidated.
type AreSubaccountsLiquidatableResponse_Result struct {
	SubaccountId   types.SubaccountId `protobuf:"bytes,1,opt,name=subaccount_id,json=subaccountId,proto3" json:"subaccount_id"`
	IsLiquidatable bool               `protobuf:"varint,2,opt,name=is_liquidatable,json=isLiquidatable,proto3" json:"is_liquidatable,omitempty"`
}

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

var xxx_messageInfo_AreSubaccountsLiquidatableResponse_Result proto.InternalMessageInfo

func (m *AreSubaccountsLiquidatableResponse_Result) GetSubaccountId() types.SubaccountId {
	if m != nil {
		return m.SubaccountId
	}
	return types.SubaccountId{}
}

func (m *AreSubaccountsLiquidatableResponse_Result) GetIsLiquidatable() bool {
	if m != nil {
		return m.IsLiquidatable
	}
	return false
}

// MevNodeToNodeCalculationRequest is a request message used to run the
// MEV node <> node calculation.
type MevNodeToNodeCalculationRequest struct {
	// Represents the matches on the "block proposer". Note that this field
	// does not need to be the actual block proposer's matches for a block, since
	// the MEV calculation logic is run with this nodes matches as the "block
	// proposer" matches.
	BlockProposerMatches *ValidatorMevMatches `protobuf:"bytes,1,opt,name=block_proposer_matches,json=blockProposerMatches,proto3" json:"block_proposer_matches,omitempty"`
	// Represents the matches and mid-prices on the validator.
	ValidatorMevMetrics *MevNodeToNodeMetrics `protobuf:"bytes,2,opt,name=validator_mev_metrics,json=validatorMevMetrics,proto3" json:"validator_mev_metrics,omitempty"`
}

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

var xxx_messageInfo_MevNodeToNodeCalculationRequest proto.InternalMessageInfo

func (m *MevNodeToNodeCalculationRequest) GetBlockProposerMatches() *ValidatorMevMatches {
	if m != nil {
		return m.BlockProposerMatches
	}
	return nil
}

func (m *MevNodeToNodeCalculationRequest) GetValidatorMevMetrics() *MevNodeToNodeMetrics {
	if m != nil {
		return m.ValidatorMevMetrics
	}
	return nil
}

// MevNodeToNodeCalculationResponse is a response message that contains the
// MEV node <> node calculation result.
type MevNodeToNodeCalculationResponse struct {
	Results []MevNodeToNodeCalculationResponse_MevAndVolumePerClob `protobuf:"bytes,1,rep,name=results,proto3" json:"results"`
}

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

var xxx_messageInfo_MevNodeToNodeCalculationResponse proto.InternalMessageInfo

func (m *MevNodeToNodeCalculationResponse) GetResults() []MevNodeToNodeCalculationResponse_MevAndVolumePerClob {
	if m != nil {
		return m.Results
	}
	return nil
}

// MevAndVolumePerClob contains information about the MEV and volume per CLOB.
type MevNodeToNodeCalculationResponse_MevAndVolumePerClob struct {
	ClobPairId uint32  `protobuf:"varint,1,opt,name=clob_pair_id,json=clobPairId,proto3" json:"clob_pair_id,omitempty"`
	Mev        float32 `protobuf:"fixed32,2,opt,name=mev,proto3" json:"mev,omitempty"`
	Volume     uint64  `protobuf:"varint,3,opt,name=volume,proto3" json:"volume,omitempty"`
}

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

var xxx_messageInfo_MevNodeToNodeCalculationResponse_MevAndVolumePerClob proto.InternalMessageInfo

func (m *MevNodeToNodeCalculationResponse_MevAndVolumePerClob) GetClobPairId() uint32 {
	if m != nil {
		return m.ClobPairId
	}
	return 0
}

func (m *MevNodeToNodeCalculationResponse_MevAndVolumePerClob) GetMev() float32 {
	if m != nil {
		return m.Mev
	}
	return 0
}

func (m *MevNodeToNodeCalculationResponse_MevAndVolumePerClob) GetVolume() uint64 {
	if m != nil {
		return m.Volume
	}
	return 0
}

// QueryEquityTierLimitConfigurationRequest is a request message for
// EquityTierLimitConfiguration.
type QueryEquityTierLimitConfigurationRequest struct {
}

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

var xxx_messageInfo_QueryEquityTierLimitConfigurationRequest proto.InternalMessageInfo

// QueryEquityTierLimitConfigurationResponse is a response message that contains
// the EquityTierLimitConfiguration.
type QueryEquityTierLimitConfigurationResponse struct {
	EquityTierLimitConfig EquityTierLimitConfiguration `protobuf:"bytes,1,opt,name=equity_tier_limit_config,json=equityTierLimitConfig,proto3" json:"equity_tier_limit_config"`
}

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

var xxx_messageInfo_QueryEquityTierLimitConfigurationResponse proto.InternalMessageInfo

func (m *QueryEquityTierLimitConfigurationResponse) GetEquityTierLimitConfig() EquityTierLimitConfiguration {
	if m != nil {
		return m.EquityTierLimitConfig
	}
	return EquityTierLimitConfiguration{}
}

func init() {
	proto.RegisterType((*QueryGetClobPairRequest)(nil), "dydxprotocol.clob.QueryGetClobPairRequest")
	proto.RegisterType((*QueryClobPairResponse)(nil), "dydxprotocol.clob.QueryClobPairResponse")
	proto.RegisterType((*QueryAllClobPairRequest)(nil), "dydxprotocol.clob.QueryAllClobPairRequest")
	proto.RegisterType((*QueryClobPairAllResponse)(nil), "dydxprotocol.clob.QueryClobPairAllResponse")
	proto.RegisterType((*AreSubaccountsLiquidatableRequest)(nil), "dydxprotocol.clob.AreSubaccountsLiquidatableRequest")
	proto.RegisterType((*AreSubaccountsLiquidatableResponse)(nil), "dydxprotocol.clob.AreSubaccountsLiquidatableResponse")
	proto.RegisterType((*AreSubaccountsLiquidatableResponse_Result)(nil), "dydxprotocol.clob.AreSubaccountsLiquidatableResponse.Result")
	proto.RegisterType((*MevNodeToNodeCalculationRequest)(nil), "dydxprotocol.clob.MevNodeToNodeCalculationRequest")
	proto.RegisterType((*MevNodeToNodeCalculationResponse)(nil), "dydxprotocol.clob.MevNodeToNodeCalculationResponse")
	proto.RegisterType((*MevNodeToNodeCalculationResponse_MevAndVolumePerClob)(nil), "dydxprotocol.clob.MevNodeToNodeCalculationResponse.MevAndVolumePerClob")
	proto.RegisterType((*QueryEquityTierLimitConfigurationRequest)(nil), "dydxprotocol.clob.QueryEquityTierLimitConfigurationRequest")
	proto.RegisterType((*QueryEquityTierLimitConfigurationResponse)(nil), "dydxprotocol.clob.QueryEquityTierLimitConfigurationResponse")
}

func init() { proto.RegisterFile("dydxprotocol/clob/query.proto", fileDescriptor_3365c195b25c5bc0) }

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

// QueryClient is the client API for Query service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryClient interface {
	// Queries a ClobPair by id.
	ClobPair(ctx context.Context, in *QueryGetClobPairRequest, opts ...grpc.CallOption) (*QueryClobPairResponse, error)
	// Queries a list of ClobPair items.
	ClobPairAll(ctx context.Context, in *QueryAllClobPairRequest, opts ...grpc.CallOption) (*QueryClobPairAllResponse, error)
	// Returns whether a subaccount is liquidatable.
	AreSubaccountsLiquidatable(ctx context.Context, in *AreSubaccountsLiquidatableRequest, opts ...grpc.CallOption) (*AreSubaccountsLiquidatableResponse, error)
	// Runs the MEV node <> node calculation with the provided parameters.
	MevNodeToNodeCalculation(ctx context.Context, in *MevNodeToNodeCalculationRequest, opts ...grpc.CallOption) (*MevNodeToNodeCalculationResponse, error)
	// Queries EquityTierLimitConfiguration.
	EquityTierLimitConfiguration(ctx context.Context, in *QueryEquityTierLimitConfigurationRequest, opts ...grpc.CallOption) (*QueryEquityTierLimitConfigurationResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

func NewQueryClient(cc grpc1.ClientConn) QueryClient {
	return &queryClient{cc}
}

func (c *queryClient) ClobPair(ctx context.Context, in *QueryGetClobPairRequest, opts ...grpc.CallOption) (*QueryClobPairResponse, error) {
	out := new(QueryClobPairResponse)
	err := c.cc.Invoke(ctx, "/dydxprotocol.clob.Query/ClobPair", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ClobPairAll(ctx context.Context, in *QueryAllClobPairRequest, opts ...grpc.CallOption) (*QueryClobPairAllResponse, error) {
	out := new(QueryClobPairAllResponse)
	err := c.cc.Invoke(ctx, "/dydxprotocol.clob.Query/ClobPairAll", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) AreSubaccountsLiquidatable(ctx context.Context, in *AreSubaccountsLiquidatableRequest, opts ...grpc.CallOption) (*AreSubaccountsLiquidatableResponse, error) {
	out := new(AreSubaccountsLiquidatableResponse)
	err := c.cc.Invoke(ctx, "/dydxprotocol.clob.Query/AreSubaccountsLiquidatable", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) MevNodeToNodeCalculation(ctx context.Context, in *MevNodeToNodeCalculationRequest, opts ...grpc.CallOption) (*MevNodeToNodeCalculationResponse, error) {
	out := new(MevNodeToNodeCalculationResponse)
	err := c.cc.Invoke(ctx, "/dydxprotocol.clob.Query/MevNodeToNodeCalculation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) EquityTierLimitConfiguration(ctx context.Context, in *QueryEquityTierLimitConfigurationRequest, opts ...grpc.CallOption) (*QueryEquityTierLimitConfigurationResponse, error) {
	out := new(QueryEquityTierLimitConfigurationResponse)
	err := c.cc.Invoke(ctx, "/dydxprotocol.clob.Query/EquityTierLimitConfiguration", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// Queries a ClobPair by id.
	ClobPair(context.Context, *QueryGetClobPairRequest) (*QueryClobPairResponse, error)
	// Queries a list of ClobPair items.
	ClobPairAll(context.Context, *QueryAllClobPairRequest) (*QueryClobPairAllResponse, error)
	// Returns whether a subaccount is liquidatable.
	AreSubaccountsLiquidatable(context.Context, *AreSubaccountsLiquidatableRequest) (*AreSubaccountsLiquidatableResponse, error)
	// Runs the MEV node <> node calculation with the provided parameters.
	MevNodeToNodeCalculation(context.Context, *MevNodeToNodeCalculationRequest) (*MevNodeToNodeCalculationResponse, error)
	// Queries EquityTierLimitConfiguration.
	EquityTierLimitConfiguration(context.Context, *QueryEquityTierLimitConfigurationRequest) (*QueryEquityTierLimitConfigurationResponse, error)
}

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

func (*UnimplementedQueryServer) ClobPair(ctx context.Context, req *QueryGetClobPairRequest) (*QueryClobPairResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ClobPair not implemented")
}
func (*UnimplementedQueryServer) ClobPairAll(ctx context.Context, req *QueryAllClobPairRequest) (*QueryClobPairAllResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ClobPairAll not implemented")
}
func (*UnimplementedQueryServer) AreSubaccountsLiquidatable(ctx context.Context, req *AreSubaccountsLiquidatableRequest) (*AreSubaccountsLiquidatableResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AreSubaccountsLiquidatable not implemented")
}
func (*UnimplementedQueryServer) MevNodeToNodeCalculation(ctx context.Context, req *MevNodeToNodeCalculationRequest) (*MevNodeToNodeCalculationResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MevNodeToNodeCalculation not implemented")
}
func (*UnimplementedQueryServer) EquityTierLimitConfiguration(ctx context.Context, req *QueryEquityTierLimitConfigurationRequest) (*QueryEquityTierLimitConfigurationResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EquityTierLimitConfiguration not implemented")
}

func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
	s.RegisterService(&_Query_serviceDesc, srv)
}

func _Query_ClobPair_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGetClobPairRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ClobPair(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dydxprotocol.clob.Query/ClobPair",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ClobPair(ctx, req.(*QueryGetClobPairRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ClobPairAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAllClobPairRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ClobPairAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dydxprotocol.clob.Query/ClobPairAll",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ClobPairAll(ctx, req.(*QueryAllClobPairRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_AreSubaccountsLiquidatable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AreSubaccountsLiquidatableRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).AreSubaccountsLiquidatable(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dydxprotocol.clob.Query/AreSubaccountsLiquidatable",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).AreSubaccountsLiquidatable(ctx, req.(*AreSubaccountsLiquidatableRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_MevNodeToNodeCalculation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MevNodeToNodeCalculationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).MevNodeToNodeCalculation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dydxprotocol.clob.Query/MevNodeToNodeCalculation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).MevNodeToNodeCalculation(ctx, req.(*MevNodeToNodeCalculationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_EquityTierLimitConfiguration_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryEquityTierLimitConfigurationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).EquityTierLimitConfiguration(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dydxprotocol.clob.Query/EquityTierLimitConfiguration",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).EquityTierLimitConfiguration(ctx, req.(*QueryEquityTierLimitConfigurationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "dydxprotocol.clob.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ClobPair",
			Handler:    _Query_ClobPair_Handler,
		},
		{
			MethodName: "ClobPairAll",
			Handler:    _Query_ClobPairAll_Handler,
		},
		{
			MethodName: "AreSubaccountsLiquidatable",
			Handler:    _Query_AreSubaccountsLiquidatable_Handler,
		},
		{
			MethodName: "MevNodeToNodeCalculation",
			Handler:    _Query_MevNodeToNodeCalculation_Handler,
		},
		{
			MethodName: "EquityTierLimitConfiguration",
			Handler:    _Query_EquityTierLimitConfiguration_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "dydxprotocol/clob/query.proto",
}

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

func (m *QueryGetClobPairRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Id != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

func (m *AreSubaccountsLiquidatableResponse_Result) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsLiquidatable {
		i--
		if m.IsLiquidatable {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.SubaccountId.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *MevNodeToNodeCalculationResponse_MevAndVolumePerClob) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Volume != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Volume))
		i--
		dAtA[i] = 0x18
	}
	if m.Mev != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Mev))))
		i--
		dAtA[i] = 0x15
	}
	if m.ClobPairId != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.ClobPairId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *QueryClobPairResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ClobPair.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *QueryAllClobPairRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryClobPairAllResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ClobPair) > 0 {
		for _, e := range m.ClobPair {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

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

func (m *AreSubaccountsLiquidatableResponse_Result) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.SubaccountId.Size()
	n += 1 + l + sovQuery(uint64(l))
	if m.IsLiquidatable {
		n += 2
	}
	return n
}

func (m *MevNodeToNodeCalculationRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockProposerMatches != nil {
		l = m.BlockProposerMatches.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.ValidatorMevMetrics != nil {
		l = m.ValidatorMevMetrics.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

func (m *MevNodeToNodeCalculationResponse_MevAndVolumePerClob) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ClobPairId != 0 {
		n += 1 + sovQuery(uint64(m.ClobPairId))
	}
	if m.Mev != 0 {
		n += 5
	}
	if m.Volume != 0 {
		n += 1 + sovQuery(uint64(m.Volume))
	}
	return n
}

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

func (m *QueryEquityTierLimitConfigurationResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.EquityTierLimitConfig.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

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

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

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

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MevNodeToNodeCalculationResponse_MevAndVolumePerClob) 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 ErrIntOverflowQuery
			}
			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: MevAndVolumePerClob: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MevAndVolumePerClob: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClobPairId", wireType)
			}
			m.ClobPairId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ClobPairId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mev", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Mev = float32(math.Float32frombits(v))
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Volume", wireType)
			}
			m.Volume = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Volume |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

var (
	ErrInvalidLengthQuery        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowQuery          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group")
)