// DONTCOVER
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: archway/rewards/v1/query.proto

package types

import (
	context "context"
	fmt "fmt"
	types "github.com/cosmos/cosmos-sdk/types"
	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"
	_ "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

// QueryParamsRequest is the request for Query.Params.
type QueryParamsRequest struct {
}

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

var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo

// QueryParamsResponse is the response for Query.Params.
type QueryParamsResponse struct {
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
}

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

var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo

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

// QueryContractMetadataRequest is the request for Query.ContractMetadata.
type QueryContractMetadataRequest struct {
	// contract_address is the contract address (bech32 encoded).
	ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"`
}

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

var xxx_messageInfo_QueryContractMetadataRequest proto.InternalMessageInfo

func (m *QueryContractMetadataRequest) GetContractAddress() string {
	if m != nil {
		return m.ContractAddress
	}
	return ""
}

// QueryContractMetadataResponse is the response for Query.ContractMetadata.
type QueryContractMetadataResponse struct {
	Metadata ContractMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata"`
}

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

var xxx_messageInfo_QueryContractMetadataResponse proto.InternalMessageInfo

func (m *QueryContractMetadataResponse) GetMetadata() ContractMetadata {
	if m != nil {
		return m.Metadata
	}
	return ContractMetadata{}
}

// QueryBlockRewardsTrackingRequest is the request for
// Query.BlockRewardsTracking.
type QueryBlockRewardsTrackingRequest struct {
}

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

var xxx_messageInfo_QueryBlockRewardsTrackingRequest proto.InternalMessageInfo

// QueryBlockRewardsTrackingResponse is the response for
// Query.BlockRewardsTracking.
type QueryBlockRewardsTrackingResponse struct {
	Block BlockTracking `protobuf:"bytes,1,opt,name=block,proto3" json:"block"`
}

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

var xxx_messageInfo_QueryBlockRewardsTrackingResponse proto.InternalMessageInfo

func (m *QueryBlockRewardsTrackingResponse) GetBlock() BlockTracking {
	if m != nil {
		return m.Block
	}
	return BlockTracking{}
}

// QueryRewardsPoolRequest is the request for Query.RewardsPool.
type QueryRewardsPoolRequest struct {
}

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

var xxx_messageInfo_QueryRewardsPoolRequest proto.InternalMessageInfo

// QueryRewardsPoolResponse is the response for Query.RewardsPool.
type QueryRewardsPoolResponse struct {
	// undistributed_funds are undistributed yet tokens (ready for withdrawal).
	UndistributedFunds []types.Coin `protobuf:"bytes,1,rep,name=undistributed_funds,json=undistributedFunds,proto3" json:"undistributed_funds"`
	// treasury_funds are treasury tokens available (no mechanism is available to
	// withdraw ATM). Treasury tokens are collected on a block basis. Those tokens
	// are unused block rewards.
	TreasuryFunds []types.Coin `protobuf:"bytes,2,rep,name=treasury_funds,json=treasuryFunds,proto3" json:"treasury_funds"`
}

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

var xxx_messageInfo_QueryRewardsPoolResponse proto.InternalMessageInfo

func (m *QueryRewardsPoolResponse) GetUndistributedFunds() []types.Coin {
	if m != nil {
		return m.UndistributedFunds
	}
	return nil
}

func (m *QueryRewardsPoolResponse) GetTreasuryFunds() []types.Coin {
	if m != nil {
		return m.TreasuryFunds
	}
	return nil
}

// QueryEstimateTxFeesRequest is the request for Query.EstimateTxFees.
type QueryEstimateTxFeesRequest struct {
	// gas_limit is the transaction gas limit.
	GasLimit uint64 `protobuf:"varint,1,opt,name=gas_limit,json=gasLimit,proto3" json:"gas_limit,omitempty"`
	// contract_address whose flat fee is considered when estimating tx fees.
	ContractAddress string `protobuf:"bytes,2,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"`
}

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

var xxx_messageInfo_QueryEstimateTxFeesRequest proto.InternalMessageInfo

func (m *QueryEstimateTxFeesRequest) GetGasLimit() uint64 {
	if m != nil {
		return m.GasLimit
	}
	return 0
}

func (m *QueryEstimateTxFeesRequest) GetContractAddress() string {
	if m != nil {
		return m.ContractAddress
	}
	return ""
}

// QueryEstimateTxFeesResponse is the response for Query.EstimateTxFees.
type QueryEstimateTxFeesResponse struct {
	// gas_unit_price defines the minimum transaction fee per gas unit.
	GasUnitPrice types.DecCoin `protobuf:"bytes,1,opt,name=gas_unit_price,json=gasUnitPrice,proto3" json:"gas_unit_price"`
	// estimated_fee is the estimated transaction fee for a given gas limit.
	EstimatedFee []types.Coin `protobuf:"bytes,2,rep,name=estimated_fee,json=estimatedFee,proto3" json:"estimated_fee"`
}

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

var xxx_messageInfo_QueryEstimateTxFeesResponse proto.InternalMessageInfo

func (m *QueryEstimateTxFeesResponse) GetGasUnitPrice() types.DecCoin {
	if m != nil {
		return m.GasUnitPrice
	}
	return types.DecCoin{}
}

func (m *QueryEstimateTxFeesResponse) GetEstimatedFee() []types.Coin {
	if m != nil {
		return m.EstimatedFee
	}
	return nil
}

// BlockTracking is the tracking information for a block.
type BlockTracking struct {
	// inflation_rewards defines the inflation rewards for the block.
	InflationRewards BlockRewards `protobuf:"bytes,1,opt,name=inflation_rewards,json=inflationRewards,proto3" json:"inflation_rewards"`
	// tx_rewards defines the transaction rewards for the block.
	TxRewards []TxRewards `protobuf:"bytes,2,rep,name=tx_rewards,json=txRewards,proto3" json:"tx_rewards"`
}

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

var xxx_messageInfo_BlockTracking proto.InternalMessageInfo

func (m *BlockTracking) GetInflationRewards() BlockRewards {
	if m != nil {
		return m.InflationRewards
	}
	return BlockRewards{}
}

func (m *BlockTracking) GetTxRewards() []TxRewards {
	if m != nil {
		return m.TxRewards
	}
	return nil
}

// QueryRewardsRecordsRequest is the request for Query.RewardsRecords.
type QueryRewardsRecordsRequest struct {
	// rewards_address is the target address to query records for (bech32
	// encoded).
	RewardsAddress string `protobuf:"bytes,1,opt,name=rewards_address,json=rewardsAddress,proto3" json:"rewards_address,omitempty"`
	// pagination is an optional pagination options for the request.
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryRewardsRecordsRequest proto.InternalMessageInfo

func (m *QueryRewardsRecordsRequest) GetRewardsAddress() string {
	if m != nil {
		return m.RewardsAddress
	}
	return ""
}

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

// QueryRewardsRecordsResponse is the response for Query.RewardsRecords.
type QueryRewardsRecordsResponse struct {
	// records is the list of rewards records.
	Records []RewardsRecord `protobuf:"bytes,1,rep,name=records,proto3" json:"records"`
	// pagination is the pagination details in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryRewardsRecordsResponse proto.InternalMessageInfo

func (m *QueryRewardsRecordsResponse) GetRecords() []RewardsRecord {
	if m != nil {
		return m.Records
	}
	return nil
}

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

// QueryOutstandingRewardsRequest is the request for Query.OutstandingRewards.
type QueryOutstandingRewardsRequest struct {
	// rewards_address is the target address to query calculated rewards for
	// (bech32 encoded).
	RewardsAddress string `protobuf:"bytes,1,opt,name=rewards_address,json=rewardsAddress,proto3" json:"rewards_address,omitempty"`
}

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

var xxx_messageInfo_QueryOutstandingRewardsRequest proto.InternalMessageInfo

func (m *QueryOutstandingRewardsRequest) GetRewardsAddress() string {
	if m != nil {
		return m.RewardsAddress
	}
	return ""
}

// QueryOutstandingRewardsResponse is the response for Query.OutstandingRewards.
type QueryOutstandingRewardsResponse struct {
	// total_rewards is the total rewards credited to the rewards_address.
	TotalRewards []types.Coin `protobuf:"bytes,1,rep,name=total_rewards,json=totalRewards,proto3" json:"total_rewards"`
	// records_num is the total number of RewardsRecord objects stored for the
	// rewards_address.
	RecordsNum uint64 `protobuf:"varint,2,opt,name=records_num,json=recordsNum,proto3" json:"records_num,omitempty"`
}

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

var xxx_messageInfo_QueryOutstandingRewardsResponse proto.InternalMessageInfo

func (m *QueryOutstandingRewardsResponse) GetTotalRewards() []types.Coin {
	if m != nil {
		return m.TotalRewards
	}
	return nil
}

func (m *QueryOutstandingRewardsResponse) GetRecordsNum() uint64 {
	if m != nil {
		return m.RecordsNum
	}
	return 0
}

// QueryFlatFeeRequest is the request for Query.FlatFeet
type QueryFlatFeeRequest struct {
	// contract_address is the contract address (bech32 encoded).
	ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"`
}

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

var xxx_messageInfo_QueryFlatFeeRequest proto.InternalMessageInfo

func (m *QueryFlatFeeRequest) GetContractAddress() string {
	if m != nil {
		return m.ContractAddress
	}
	return ""
}

// QueryFlatFeeResponse is the response for Query.FlatFee
type QueryFlatFeeResponse struct {
	// flat_fee_amount defines the minimum flat fee set by the contract_owner per
	// contract execution.
	FlatFeeAmount types.Coin `protobuf:"bytes,1,opt,name=flat_fee_amount,json=flatFeeAmount,proto3" json:"flat_fee_amount"`
}

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

var xxx_messageInfo_QueryFlatFeeResponse proto.InternalMessageInfo

func (m *QueryFlatFeeResponse) GetFlatFeeAmount() types.Coin {
	if m != nil {
		return m.FlatFeeAmount
	}
	return types.Coin{}
}

func init() {
	proto.RegisterType((*QueryParamsRequest)(nil), "archway.rewards.v1.QueryParamsRequest")
	proto.RegisterType((*QueryParamsResponse)(nil), "archway.rewards.v1.QueryParamsResponse")
	proto.RegisterType((*QueryContractMetadataRequest)(nil), "archway.rewards.v1.QueryContractMetadataRequest")
	proto.RegisterType((*QueryContractMetadataResponse)(nil), "archway.rewards.v1.QueryContractMetadataResponse")
	proto.RegisterType((*QueryBlockRewardsTrackingRequest)(nil), "archway.rewards.v1.QueryBlockRewardsTrackingRequest")
	proto.RegisterType((*QueryBlockRewardsTrackingResponse)(nil), "archway.rewards.v1.QueryBlockRewardsTrackingResponse")
	proto.RegisterType((*QueryRewardsPoolRequest)(nil), "archway.rewards.v1.QueryRewardsPoolRequest")
	proto.RegisterType((*QueryRewardsPoolResponse)(nil), "archway.rewards.v1.QueryRewardsPoolResponse")
	proto.RegisterType((*QueryEstimateTxFeesRequest)(nil), "archway.rewards.v1.QueryEstimateTxFeesRequest")
	proto.RegisterType((*QueryEstimateTxFeesResponse)(nil), "archway.rewards.v1.QueryEstimateTxFeesResponse")
	proto.RegisterType((*BlockTracking)(nil), "archway.rewards.v1.BlockTracking")
	proto.RegisterType((*QueryRewardsRecordsRequest)(nil), "archway.rewards.v1.QueryRewardsRecordsRequest")
	proto.RegisterType((*QueryRewardsRecordsResponse)(nil), "archway.rewards.v1.QueryRewardsRecordsResponse")
	proto.RegisterType((*QueryOutstandingRewardsRequest)(nil), "archway.rewards.v1.QueryOutstandingRewardsRequest")
	proto.RegisterType((*QueryOutstandingRewardsResponse)(nil), "archway.rewards.v1.QueryOutstandingRewardsResponse")
	proto.RegisterType((*QueryFlatFeeRequest)(nil), "archway.rewards.v1.QueryFlatFeeRequest")
	proto.RegisterType((*QueryFlatFeeResponse)(nil), "archway.rewards.v1.QueryFlatFeeResponse")
}

func init() { proto.RegisterFile("archway/rewards/v1/query.proto", fileDescriptor_5094c979ac5beea0) }

var fileDescriptor_5094c979ac5beea0 = []byte{
	// 1094 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x97, 0xcf, 0x6f, 0xdc, 0x44,
	0x14, 0xc7, 0xe3, 0x90, 0xa6, 0xcd, 0x4b, 0xf3, 0x83, 0x69, 0x24, 0x5a, 0x37, 0x75, 0x52, 0x93,
	0x26, 0x69, 0x9b, 0xda, 0x64, 0x0b, 0x12, 0x17, 0x24, 0x92, 0x86, 0x2d, 0x95, 0x0a, 0x0d, 0x4b,
	0xb8, 0x70, 0xb1, 0x66, 0xed, 0x89, 0x6b, 0x65, 0xd7, 0xb3, 0xb5, 0xc7, 0xf9, 0x71, 0xe0, 0xd2,
	0x13, 0x17, 0x24, 0x04, 0x77, 0xb8, 0x21, 0x38, 0xc0, 0x09, 0x89, 0x7f, 0xa1, 0xc7, 0x4a, 0x5c,
	0x38, 0x21, 0x94, 0xf0, 0x3f, 0x70, 0x45, 0x1e, 0xbf, 0xd9, 0xae, 0xb3, 0xe3, 0xcd, 0xa6, 0xa7,
	0x64, 0xdf, 0xcc, 0x7b, 0xdf, 0xcf, 0xbc, 0x79, 0xf3, 0xde, 0x2e, 0x58, 0x34, 0xf1, 0x9f, 0x1e,
	0xd0, 0x23, 0x37, 0x61, 0x07, 0x34, 0x09, 0x52, 0x77, 0x7f, 0xdd, 0x7d, 0x96, 0xb1, 0xe4, 0xc8,
	0xe9, 0x24, 0x5c, 0x70, 0x42, 0x70, 0xdd, 0xc1, 0x75, 0x67, 0x7f, 0xdd, 0x9c, 0x0b, 0x79, 0xc8,
	0xe5, 0xb2, 0x9b, 0xff, 0x57, 0xec, 0x34, 0xe7, 0x43, 0xce, 0xc3, 0x16, 0x73, 0x69, 0x27, 0x72,
	0x69, 0x1c, 0x73, 0x41, 0x45, 0xc4, 0xe3, 0x14, 0x57, 0x2d, 0x9f, 0xa7, 0x6d, 0x9e, 0xba, 0x4d,
	0x9a, 0x32, 0x77, 0x7f, 0xbd, 0xc9, 0x04, 0x5d, 0x77, 0x7d, 0x1e, 0xc5, 0xb8, 0x7e, 0xa7, 0x77,
	0x5d, 0x02, 0x74, 0x77, 0x75, 0x68, 0x18, 0xc5, 0x32, 0x18, 0xee, 0x5d, 0xd4, 0x30, 0x2b, 0x3c,
	0xb9, 0xc3, 0x9e, 0x03, 0xf2, 0x59, 0x1e, 0x63, 0x9b, 0x26, 0xb4, 0x9d, 0x36, 0xd8, 0xb3, 0x8c,
	0xa5, 0xc2, 0x7e, 0x02, 0x57, 0x4a, 0xd6, 0xb4, 0xc3, 0xe3, 0x94, 0x91, 0xf7, 0x61, 0xbc, 0x23,
	0x2d, 0x57, 0x8d, 0x45, 0x63, 0x75, 0xb2, 0x66, 0x3a, 0xfd, 0x67, 0x76, 0x0a, 0x9f, 0xcd, 0xb1,
	0x17, 0x7f, 0x2f, 0x8c, 0x34, 0x70, 0xbf, 0xfd, 0x08, 0xe6, 0x65, 0xc0, 0x07, 0x3c, 0x16, 0x09,
	0xf5, 0xc5, 0x27, 0x4c, 0xd0, 0x80, 0x0a, 0x8a, 0x82, 0xe4, 0x36, 0xcc, 0xfa, 0xb8, 0xe4, 0xd1,
	0x20, 0x48, 0x58, 0x5a, 0x68, 0x4c, 0x34, 0x66, 0x94, 0x7d, 0xa3, 0x30, 0xdb, 0x21, 0xdc, 0xa8,
	0x08, 0x85, 0x94, 0x75, 0xb8, 0xd4, 0x46, 0x1b, 0x72, 0x2e, 0xe9, 0x38, 0x4f, 0xfb, 0x23, 0x71,
	0xd7, 0xd7, 0xb6, 0x61, 0x51, 0x0a, 0x6d, 0xb6, 0xb8, 0xbf, 0xd7, 0x28, 0x1c, 0x77, 0x12, 0xea,
	0xef, 0x45, 0x71, 0xa8, 0x12, 0xd5, 0x84, 0x9b, 0x03, 0xf6, 0x20, 0xd0, 0x07, 0x70, 0xa1, 0x99,
	0xaf, 0x23, 0xcd, 0x4d, 0x1d, 0x8d, 0x0c, 0xa0, 0x3c, 0x11, 0xa5, 0xf0, 0xb2, 0xaf, 0xc1, 0x5b,
	0x52, 0x03, 0xc3, 0x6f, 0x73, 0xde, 0x52, 0xf2, 0xbf, 0x1b, 0x70, 0xb5, 0x7f, 0x0d, 0x65, 0xb7,
	0xe1, 0x4a, 0x16, 0x07, 0x51, 0x2a, 0x92, 0xa8, 0x99, 0x09, 0x16, 0x78, 0xbb, 0x59, 0x1c, 0xe4,
	0x69, 0x7d, 0x63, 0x75, 0xb2, 0x76, 0xcd, 0x29, 0xca, 0xc8, 0xc9, 0xcb, 0xc8, 0xc1, 0x02, 0x72,
	0x1e, 0xf0, 0x28, 0x46, 0x71, 0x52, 0xf2, 0xad, 0xe7, 0xae, 0xa4, 0x0e, 0xd3, 0x22, 0x61, 0x34,
	0xcd, 0x92, 0x23, 0x0c, 0x36, 0x3a, 0x5c, 0xb0, 0x29, 0xe5, 0x26, 0xe3, 0xd8, 0x01, 0x98, 0x92,
	0xfa, 0xa3, 0x54, 0x44, 0x6d, 0x2a, 0xd8, 0xce, 0x61, 0x9d, 0x31, 0x55, 0x7c, 0xe4, 0x3a, 0x4c,
	0x84, 0x34, 0xf5, 0x5a, 0x51, 0x3b, 0x12, 0x32, 0x65, 0x63, 0x8d, 0x4b, 0x21, 0x4d, 0x1f, 0xe7,
	0x9f, 0xb5, 0x85, 0x32, 0xaa, 0x2f, 0x94, 0x5f, 0x0d, 0xb8, 0xae, 0x95, 0xc1, 0xfc, 0x7c, 0x0c,
	0xd3, 0xb9, 0x4e, 0x16, 0x47, 0xc2, 0xeb, 0x24, 0x91, 0xcf, 0xf0, 0x7e, 0xe6, 0xb5, 0xa7, 0xd9,
	0x62, 0x7e, 0xcf, 0x81, 0x2e, 0x87, 0x34, 0xfd, 0x22, 0x8e, 0xc4, 0x76, 0xee, 0x47, 0xb6, 0x60,
	0x8a, 0xa1, 0x46, 0xe0, 0xed, 0x32, 0x36, 0x6c, 0x5a, 0x2e, 0x77, 0xbd, 0xea, 0x8c, 0xd9, 0x3f,
	0x1b, 0x30, 0x55, 0x2a, 0x03, 0xf2, 0x39, 0xbc, 0x19, 0xc5, 0xbb, 0x2d, 0xf9, 0xa2, 0x3d, 0x2c,
	0x16, 0x84, 0x5c, 0xac, 0x2c, 0x22, 0x2c, 0x05, 0x94, 0x98, 0xed, 0x06, 0x40, 0x3b, 0xd9, 0x04,
	0x10, 0x87, 0xdd, 0x68, 0x05, 0xe9, 0x0d, 0x5d, 0xb4, 0x9d, 0xc3, 0x72, 0xa8, 0x09, 0xa1, 0x0c,
	0xf6, 0x37, 0x06, 0xde, 0x20, 0x1a, 0x1a, 0xcc, 0xe7, 0xf2, 0x4f, 0x71, 0x83, 0x2b, 0x30, 0x83,
	0x71, 0x4e, 0x3d, 0xe6, 0x69, 0x34, 0xe3, 0x15, 0x91, 0x3a, 0xc0, 0xab, 0x9e, 0x25, 0xef, 0x71,
	0xb2, 0xb6, 0x5c, 0xca, 0x5a, 0xd1, 0x61, 0x55, 0xee, 0xb6, 0x69, 0xc8, 0x50, 0xa4, 0xd1, 0xe3,
	0x69, 0xff, 0xa2, 0xae, 0xfa, 0x34, 0x0f, 0x5e, 0xf5, 0x06, 0x5c, 0x4c, 0x0a, 0x13, 0x96, 0xbf,
	0xf6, 0x0d, 0x96, 0x9c, 0xf1, 0xd0, 0xca, 0x8f, 0x3c, 0xd4, 0xa0, 0xae, 0x9c, 0x89, 0x5a, 0xe8,
	0x97, 0x58, 0x1f, 0x81, 0x25, 0x51, 0x9f, 0x64, 0x22, 0x15, 0x34, 0x0e, 0x64, 0xa7, 0x40, 0xe1,
	0xf3, 0xa5, 0xcf, 0xfe, 0xda, 0x80, 0x85, 0xca, 0x58, 0x78, 0xf4, 0x2d, 0x98, 0x12, 0x5c, 0xd0,
	0x56, 0x4f, 0xfd, 0x0c, 0x57, 0x9b, 0xd2, 0x4b, 0x15, 0xcd, 0x02, 0x4c, 0x62, 0x22, 0xbc, 0x38,
	0x6b, 0xcb, 0xe3, 0x8f, 0x35, 0x00, 0x4d, 0x9f, 0x66, 0x6d, 0xfb, 0x43, 0x9c, 0x18, 0xf5, 0x16,
	0x15, 0x75, 0xc6, 0x5e, 0xa3, 0xaf, 0x7b, 0x30, 0x57, 0x8e, 0x80, 0x07, 0x78, 0x08, 0x33, 0x79,
	0x05, 0xe7, 0xef, 0xca, 0xa3, 0x6d, 0x9e, 0xc5, 0x02, 0x9f, 0xc0, 0xd9, 0x5d, 0x67, 0xb7, 0x08,
	0xb5, 0x21, 0xbd, 0x6a, 0xff, 0x4d, 0xc0, 0x05, 0xa9, 0x40, 0xbe, 0x82, 0xf1, 0x62, 0x4a, 0x91,
	0x65, 0x5d, 0x1d, 0xf4, 0x0f, 0x44, 0x73, 0xe5, 0xcc, 0x7d, 0x05, 0xad, 0x6d, 0x3f, 0xff, 0xf3,
	0xdf, 0xef, 0x47, 0xe7, 0x89, 0xe9, 0x6a, 0x46, 0x6f, 0x31, 0x0c, 0xc9, 0x4f, 0x06, 0xcc, 0x9e,
	0x9e, 0x3e, 0xe4, 0x9d, 0x4a, 0x85, 0x8a, 0x99, 0x69, 0xae, 0x9f, 0xc3, 0x03, 0xe9, 0xee, 0x49,
	0xba, 0x15, 0x72, 0x4b, 0x47, 0xd7, 0xbd, 0x28, 0x35, 0x01, 0xc9, 0x1f, 0x06, 0xcc, 0xe9, 0x26,
	0x1b, 0x79, 0xb7, 0x52, 0x7a, 0xc0, 0xb0, 0x34, 0xdf, 0x3b, 0xa7, 0x17, 0x42, 0xd7, 0x24, 0xf4,
	0x1a, 0xb9, 0xa3, 0x83, 0x96, 0x23, 0x52, 0xd5, 0xb6, 0x27, 0x14, 0xe0, 0x77, 0x06, 0x4c, 0xf6,
	0xcc, 0x44, 0x72, 0xb7, 0x52, 0xba, 0x7f, 0xaa, 0x9a, 0x6b, 0xc3, 0x6d, 0x46, 0xbc, 0x55, 0x89,
	0x67, 0x93, 0x45, 0xb7, 0xfa, 0xcb, 0x96, 0xd7, 0xc9, 0x21, 0x7e, 0x34, 0x60, 0xba, 0x3c, 0x8b,
	0x88, 0x53, 0x29, 0xa5, 0x9d, 0x8d, 0xa6, 0x3b, 0xf4, 0x7e, 0xa4, 0x5b, 0x93, 0x74, 0xcb, 0x64,
	0x49, 0x47, 0xa7, 0xc6, 0x8f, 0x27, 0x0e, 0xf3, 0xe7, 0x95, 0x92, 0x1f, 0x0c, 0x98, 0x2e, 0xb7,
	0xd0, 0x01, 0x84, 0xda, 0xde, 0x3f, 0x80, 0x50, 0xdf, 0x9b, 0xed, 0xbb, 0x92, 0xf0, 0x16, 0x79,
	0x7b, 0x50, 0xfe, 0x54, 0x17, 0xfe, 0xcd, 0x00, 0xd2, 0xdf, 0xec, 0x48, 0xad, 0x52, 0xb4, 0xb2,
	0xcb, 0x9a, 0xf7, 0xcf, 0xe5, 0x83, 0xb0, 0xae, 0x84, 0xbd, 0x4d, 0x56, 0x74, 0xb0, 0xfc, 0x95,
	0x9f, 0xaa, 0x48, 0xf2, 0xdc, 0x80, 0x8b, 0xd8, 0xd1, 0x48, 0x75, 0x13, 0x29, 0x77, 0x4d, 0x73,
	0xf5, 0xec, 0x8d, 0xc8, 0xb3, 0x24, 0x79, 0x2c, 0x32, 0xaf, 0xe3, 0x51, 0x6d, 0x73, 0xf3, 0xf1,
	0x8b, 0x63, 0xcb, 0x78, 0x79, 0x6c, 0x19, 0xff, 0x1c, 0x5b, 0xc6, 0xb7, 0x27, 0xd6, 0xc8, 0xcb,
	0x13, 0x6b, 0xe4, 0xaf, 0x13, 0x6b, 0xe4, 0xcb, 0x5a, 0x18, 0x89, 0xa7, 0x59, 0xd3, 0xf1, 0x79,
	0x5b, 0x45, 0xb8, 0x17, 0x33, 0x71, 0xc0, 0x93, 0xbd, 0x6e, 0xc4, 0xc3, 0x6e, 0x4c, 0x71, 0xd4,
	0x61, 0x69, 0x73, 0x5c, 0xfe, 0x72, 0xb8, 0xff, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x04, 0xb5,
	0xff, 0xe4, 0x11, 0x0d, 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 {
	// Params returns module parameters.
	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
	// ContractMetadata returns the contract rewards parameters (metadata).
	ContractMetadata(ctx context.Context, in *QueryContractMetadataRequest, opts ...grpc.CallOption) (*QueryContractMetadataResponse, error)
	// BlockRewardsTracking returns block rewards tracking for the current block.
	BlockRewardsTracking(ctx context.Context, in *QueryBlockRewardsTrackingRequest, opts ...grpc.CallOption) (*QueryBlockRewardsTrackingResponse, error)
	// RewardsPool returns the current undistributed rewards pool funds.
	RewardsPool(ctx context.Context, in *QueryRewardsPoolRequest, opts ...grpc.CallOption) (*QueryRewardsPoolResponse, error)
	// EstimateTxFees returns the estimated transaction fees for the given
	// transaction gas limit using the minimum consensus fee value for the current
	// block.
	EstimateTxFees(ctx context.Context, in *QueryEstimateTxFeesRequest, opts ...grpc.CallOption) (*QueryEstimateTxFeesResponse, error)
	// RewardsRecords returns the paginated list of RewardsRecord objects stored
	// for the provided rewards_address.
	RewardsRecords(ctx context.Context, in *QueryRewardsRecordsRequest, opts ...grpc.CallOption) (*QueryRewardsRecordsResponse, error)
	// OutstandingRewards returns total rewards credited from different contracts
	// for the provided rewards_address.
	OutstandingRewards(ctx context.Context, in *QueryOutstandingRewardsRequest, opts ...grpc.CallOption) (*QueryOutstandingRewardsResponse, error)
	// FlatFee returns the flat fee set by the contract owner for the provided
	// contract_address
	FlatFee(ctx context.Context, in *QueryFlatFeeRequest, opts ...grpc.CallOption) (*QueryFlatFeeResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

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

func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) {
	out := new(QueryParamsResponse)
	err := c.cc.Invoke(ctx, "/archway.rewards.v1.Query/Params", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ContractMetadata(ctx context.Context, in *QueryContractMetadataRequest, opts ...grpc.CallOption) (*QueryContractMetadataResponse, error) {
	out := new(QueryContractMetadataResponse)
	err := c.cc.Invoke(ctx, "/archway.rewards.v1.Query/ContractMetadata", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) BlockRewardsTracking(ctx context.Context, in *QueryBlockRewardsTrackingRequest, opts ...grpc.CallOption) (*QueryBlockRewardsTrackingResponse, error) {
	out := new(QueryBlockRewardsTrackingResponse)
	err := c.cc.Invoke(ctx, "/archway.rewards.v1.Query/BlockRewardsTracking", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) RewardsPool(ctx context.Context, in *QueryRewardsPoolRequest, opts ...grpc.CallOption) (*QueryRewardsPoolResponse, error) {
	out := new(QueryRewardsPoolResponse)
	err := c.cc.Invoke(ctx, "/archway.rewards.v1.Query/RewardsPool", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) EstimateTxFees(ctx context.Context, in *QueryEstimateTxFeesRequest, opts ...grpc.CallOption) (*QueryEstimateTxFeesResponse, error) {
	out := new(QueryEstimateTxFeesResponse)
	err := c.cc.Invoke(ctx, "/archway.rewards.v1.Query/EstimateTxFees", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) RewardsRecords(ctx context.Context, in *QueryRewardsRecordsRequest, opts ...grpc.CallOption) (*QueryRewardsRecordsResponse, error) {
	out := new(QueryRewardsRecordsResponse)
	err := c.cc.Invoke(ctx, "/archway.rewards.v1.Query/RewardsRecords", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) OutstandingRewards(ctx context.Context, in *QueryOutstandingRewardsRequest, opts ...grpc.CallOption) (*QueryOutstandingRewardsResponse, error) {
	out := new(QueryOutstandingRewardsResponse)
	err := c.cc.Invoke(ctx, "/archway.rewards.v1.Query/OutstandingRewards", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) FlatFee(ctx context.Context, in *QueryFlatFeeRequest, opts ...grpc.CallOption) (*QueryFlatFeeResponse, error) {
	out := new(QueryFlatFeeResponse)
	err := c.cc.Invoke(ctx, "/archway.rewards.v1.Query/FlatFee", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// Params returns module parameters.
	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
	// ContractMetadata returns the contract rewards parameters (metadata).
	ContractMetadata(context.Context, *QueryContractMetadataRequest) (*QueryContractMetadataResponse, error)
	// BlockRewardsTracking returns block rewards tracking for the current block.
	BlockRewardsTracking(context.Context, *QueryBlockRewardsTrackingRequest) (*QueryBlockRewardsTrackingResponse, error)
	// RewardsPool returns the current undistributed rewards pool funds.
	RewardsPool(context.Context, *QueryRewardsPoolRequest) (*QueryRewardsPoolResponse, error)
	// EstimateTxFees returns the estimated transaction fees for the given
	// transaction gas limit using the minimum consensus fee value for the current
	// block.
	EstimateTxFees(context.Context, *QueryEstimateTxFeesRequest) (*QueryEstimateTxFeesResponse, error)
	// RewardsRecords returns the paginated list of RewardsRecord objects stored
	// for the provided rewards_address.
	RewardsRecords(context.Context, *QueryRewardsRecordsRequest) (*QueryRewardsRecordsResponse, error)
	// OutstandingRewards returns total rewards credited from different contracts
	// for the provided rewards_address.
	OutstandingRewards(context.Context, *QueryOutstandingRewardsRequest) (*QueryOutstandingRewardsResponse, error)
	// FlatFee returns the flat fee set by the contract owner for the provided
	// contract_address
	FlatFee(context.Context, *QueryFlatFeeRequest) (*QueryFlatFeeResponse, error)
}

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

func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}
func (*UnimplementedQueryServer) ContractMetadata(ctx context.Context, req *QueryContractMetadataRequest) (*QueryContractMetadataResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContractMetadata not implemented")
}
func (*UnimplementedQueryServer) BlockRewardsTracking(ctx context.Context, req *QueryBlockRewardsTrackingRequest) (*QueryBlockRewardsTrackingResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BlockRewardsTracking not implemented")
}
func (*UnimplementedQueryServer) RewardsPool(ctx context.Context, req *QueryRewardsPoolRequest) (*QueryRewardsPoolResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RewardsPool not implemented")
}
func (*UnimplementedQueryServer) EstimateTxFees(ctx context.Context, req *QueryEstimateTxFeesRequest) (*QueryEstimateTxFeesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EstimateTxFees not implemented")
}
func (*UnimplementedQueryServer) RewardsRecords(ctx context.Context, req *QueryRewardsRecordsRequest) (*QueryRewardsRecordsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RewardsRecords not implemented")
}
func (*UnimplementedQueryServer) OutstandingRewards(ctx context.Context, req *QueryOutstandingRewardsRequest) (*QueryOutstandingRewardsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OutstandingRewards not implemented")
}
func (*UnimplementedQueryServer) FlatFee(ctx context.Context, req *QueryFlatFeeRequest) (*QueryFlatFeeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FlatFee not implemented")
}

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

func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryParamsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Params(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/archway.rewards.v1.Query/Params",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ContractMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryContractMetadataRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ContractMetadata(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/archway.rewards.v1.Query/ContractMetadata",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ContractMetadata(ctx, req.(*QueryContractMetadataRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_BlockRewardsTracking_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryBlockRewardsTrackingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).BlockRewardsTracking(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/archway.rewards.v1.Query/BlockRewardsTracking",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).BlockRewardsTracking(ctx, req.(*QueryBlockRewardsTrackingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_RewardsPool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryRewardsPoolRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).RewardsPool(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/archway.rewards.v1.Query/RewardsPool",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).RewardsPool(ctx, req.(*QueryRewardsPoolRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_EstimateTxFees_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryEstimateTxFeesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).EstimateTxFees(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/archway.rewards.v1.Query/EstimateTxFees",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).EstimateTxFees(ctx, req.(*QueryEstimateTxFeesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_RewardsRecords_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryRewardsRecordsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).RewardsRecords(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/archway.rewards.v1.Query/RewardsRecords",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).RewardsRecords(ctx, req.(*QueryRewardsRecordsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_OutstandingRewards_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryOutstandingRewardsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).OutstandingRewards(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/archway.rewards.v1.Query/OutstandingRewards",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).OutstandingRewards(ctx, req.(*QueryOutstandingRewardsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_FlatFee_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryFlatFeeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).FlatFee(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/archway.rewards.v1.Query/FlatFee",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).FlatFee(ctx, req.(*QueryFlatFeeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "archway.rewards.v1.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
		{
			MethodName: "ContractMetadata",
			Handler:    _Query_ContractMetadata_Handler,
		},
		{
			MethodName: "BlockRewardsTracking",
			Handler:    _Query_BlockRewardsTracking_Handler,
		},
		{
			MethodName: "RewardsPool",
			Handler:    _Query_RewardsPool_Handler,
		},
		{
			MethodName: "EstimateTxFees",
			Handler:    _Query_EstimateTxFees_Handler,
		},
		{
			MethodName: "RewardsRecords",
			Handler:    _Query_RewardsRecords_Handler,
		},
		{
			MethodName: "OutstandingRewards",
			Handler:    _Query_OutstandingRewards_Handler,
		},
		{
			MethodName: "FlatFee",
			Handler:    _Query_FlatFee_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "archway/rewards/v1/query.proto",
}

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

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

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

func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Params.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 *QueryContractMetadataRequest) 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 *QueryContractMetadataRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryContractMetadataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Metadata.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 *QueryBlockRewardsTrackingRequest) 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 *QueryBlockRewardsTrackingRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryBlockRewardsTrackingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Block.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 *QueryRewardsPoolRequest) 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 *QueryRewardsPoolRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryRewardsPoolResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TreasuryFunds) > 0 {
		for iNdEx := len(m.TreasuryFunds) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TreasuryFunds[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.UndistributedFunds) > 0 {
		for iNdEx := len(m.UndistributedFunds) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.UndistributedFunds[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 *QueryEstimateTxFeesRequest) 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 *QueryEstimateTxFeesRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryEstimateTxFeesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.EstimatedFee) > 0 {
		for iNdEx := len(m.EstimatedFee) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.EstimatedFee[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	{
		size, err := m.GasUnitPrice.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 *BlockTracking) 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 *BlockTracking) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockTracking) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TxRewards) > 0 {
		for iNdEx := len(m.TxRewards) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TxRewards[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	{
		size, err := m.InflationRewards.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 *QueryRewardsRecordsRequest) 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 *QueryRewardsRecordsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryRewardsRecordsRequest) 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.RewardsAddress) > 0 {
		i -= len(m.RewardsAddress)
		copy(dAtA[i:], m.RewardsAddress)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.RewardsAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryRewardsRecordsResponse) 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.Records) > 0 {
		for iNdEx := len(m.Records) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Records[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 *QueryOutstandingRewardsRequest) 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 *QueryOutstandingRewardsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryOutstandingRewardsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RecordsNum != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.RecordsNum))
		i--
		dAtA[i] = 0x10
	}
	if len(m.TotalRewards) > 0 {
		for iNdEx := len(m.TotalRewards) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TotalRewards[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 *QueryFlatFeeRequest) 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 *QueryFlatFeeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryFlatFeeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.FlatFeeAmount.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 *QueryParamsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

func (m *QueryContractMetadataRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContractAddress)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

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

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

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

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

func (m *QueryEstimateTxFeesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GasLimit != 0 {
		n += 1 + sovQuery(uint64(m.GasLimit))
	}
	l = len(m.ContractAddress)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

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

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

func (m *QueryRewardsRecordsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Records) > 0 {
		for _, e := range m.Records {
			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 *QueryOutstandingRewardsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RewardsAddress)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

func (m *QueryFlatFeeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContractAddress)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryFlatFeeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.FlatFeeAmount.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 *QueryParamsRequest) 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: QueryParamsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParamsRequest: 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 *QueryParamsResponse) 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: QueryParamsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Params.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 *QueryContractMetadataRequest) 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: QueryContractMetadataRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryContractMetadataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractAddress = string(dAtA[iNdEx:postIndex])
			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 *QueryContractMetadataResponse) 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: QueryContractMetadataResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryContractMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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.Metadata.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 *QueryBlockRewardsTrackingRequest) 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: QueryBlockRewardsTrackingRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryBlockRewardsTrackingRequest: 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 *QueryBlockRewardsTrackingResponse) 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: QueryBlockRewardsTrackingResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryBlockRewardsTrackingResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Block", 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.Block.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 *QueryRewardsPoolRequest) 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: QueryRewardsPoolRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryRewardsPoolRequest: 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 *QueryRewardsPoolResponse) 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: QueryRewardsPoolResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryRewardsPoolResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UndistributedFunds", 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.UndistributedFunds = append(m.UndistributedFunds, types.Coin{})
			if err := m.UndistributedFunds[len(m.UndistributedFunds)-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 TreasuryFunds", 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.TreasuryFunds = append(m.TreasuryFunds, types.Coin{})
			if err := m.TreasuryFunds[len(m.TreasuryFunds)-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 *QueryEstimateTxFeesRequest) 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: QueryEstimateTxFeesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryEstimateTxFeesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType)
			}
			m.GasLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GasLimit |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractAddress = string(dAtA[iNdEx:postIndex])
			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 *QueryEstimateTxFeesResponse) 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: QueryEstimateTxFeesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryEstimateTxFeesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GasUnitPrice", 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.GasUnitPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EstimatedFee", 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.EstimatedFee = append(m.EstimatedFee, types.Coin{})
			if err := m.EstimatedFee[len(m.EstimatedFee)-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 *BlockTracking) 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: BlockTracking: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockTracking: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InflationRewards", 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.InflationRewards.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxRewards", 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.TxRewards = append(m.TxRewards, TxRewards{})
			if err := m.TxRewards[len(m.TxRewards)-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 *QueryRewardsRecordsRequest) 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: QueryRewardsRecordsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryRewardsRecordsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RewardsAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RewardsAddress = string(dAtA[iNdEx:postIndex])
			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.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 *QueryRewardsRecordsResponse) 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: QueryRewardsRecordsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryRewardsRecordsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Records", 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.Records = append(m.Records, RewardsRecord{})
			if err := m.Records[len(m.Records)-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 *QueryOutstandingRewardsRequest) 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: QueryOutstandingRewardsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryOutstandingRewardsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RewardsAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RewardsAddress = string(dAtA[iNdEx:postIndex])
			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 *QueryOutstandingRewardsResponse) 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: QueryOutstandingRewardsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryOutstandingRewardsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalRewards", 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.TotalRewards = append(m.TotalRewards, types.Coin{})
			if err := m.TotalRewards[len(m.TotalRewards)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordsNum", wireType)
			}
			m.RecordsNum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RecordsNum |= 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 *QueryFlatFeeRequest) 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: QueryFlatFeeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryFlatFeeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractAddress = string(dAtA[iNdEx:postIndex])
			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 *QueryFlatFeeResponse) 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: QueryFlatFeeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryFlatFeeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FlatFeeAmount", 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.FlatFeeAmount.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")
)
