package types

import (
	context "context"
	fmt "fmt"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types "github.com/cosmos/cosmos-sdk/types"
	query "github.com/cosmos/cosmos-sdk/types/query"
	_ "github.com/gogo/protobuf/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/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"
)

var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

const _ = proto.GoGoProtoPackageIsVersion3 

type ParamsRequest struct {
}

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

var xxx_messageInfo_ParamsRequest proto.InternalMessageInfo

type ParamsResponse struct {
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
}

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

var xxx_messageInfo_ParamsResponse proto.InternalMessageInfo

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

type SignerSetTxRequest struct {
	SignerSetNonce uint64 `protobuf:"varint,1,opt,name=signer_set_nonce,json=signerSetNonce,proto3" json:"signer_set_nonce,omitempty"`
}

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

var xxx_messageInfo_SignerSetTxRequest proto.InternalMessageInfo

func (m *SignerSetTxRequest) GetSignerSetNonce() uint64 {
	if m != nil {
		return m.SignerSetNonce
	}
	return 0
}

type LatestSignerSetTxRequest struct {
}

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

var xxx_messageInfo_LatestSignerSetTxRequest proto.InternalMessageInfo

type SignerSetTxResponse struct {
	SignerSet *SignerSetTx `protobuf:"bytes,1,opt,name=signer_set,json=signerSet,proto3" json:"signer_set,omitempty"`
}

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

var xxx_messageInfo_SignerSetTxResponse proto.InternalMessageInfo

func (m *SignerSetTxResponse) GetSignerSet() *SignerSetTx {
	if m != nil {
		return m.SignerSet
	}
	return nil
}

type BatchTxRequest struct {
	TokenContract string `protobuf:"bytes,1,opt,name=token_contract,json=tokenContract,proto3" json:"token_contract,omitempty"`
	BatchNonce    uint64 `protobuf:"varint,2,opt,name=batch_nonce,json=batchNonce,proto3" json:"batch_nonce,omitempty"`
}

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

var xxx_messageInfo_BatchTxRequest proto.InternalMessageInfo

func (m *BatchTxRequest) GetTokenContract() string {
	if m != nil {
		return m.TokenContract
	}
	return ""
}

func (m *BatchTxRequest) GetBatchNonce() uint64 {
	if m != nil {
		return m.BatchNonce
	}
	return 0
}

type BatchTxResponse struct {
	Batch *BatchTx `protobuf:"bytes,1,opt,name=batch,proto3" json:"batch,omitempty"`
}

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

var xxx_messageInfo_BatchTxResponse proto.InternalMessageInfo

func (m *BatchTxResponse) GetBatch() *BatchTx {
	if m != nil {
		return m.Batch
	}
	return nil
}

type ContractCallTxRequest struct {
	InvalidationScope []byte `protobuf:"bytes,1,opt,name=invalidation_scope,json=invalidationScope,proto3" json:"invalidation_scope,omitempty"`
	InvalidationNonce uint64 `protobuf:"varint,2,opt,name=invalidation_nonce,json=invalidationNonce,proto3" json:"invalidation_nonce,omitempty"`
}

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

var xxx_messageInfo_ContractCallTxRequest proto.InternalMessageInfo

func (m *ContractCallTxRequest) GetInvalidationScope() []byte {
	if m != nil {
		return m.InvalidationScope
	}
	return nil
}

func (m *ContractCallTxRequest) GetInvalidationNonce() uint64 {
	if m != nil {
		return m.InvalidationNonce
	}
	return 0
}

type ContractCallTxResponse struct {
	LogicCall *ContractCallTx `protobuf:"bytes,1,opt,name=logic_call,json=logicCall,proto3" json:"logic_call,omitempty"`
}

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

var xxx_messageInfo_ContractCallTxResponse proto.InternalMessageInfo

func (m *ContractCallTxResponse) GetLogicCall() *ContractCallTx {
	if m != nil {
		return m.LogicCall
	}
	return nil
}

type SignerSetTxConfirmationsRequest struct {
	SignerSetNonce uint64 `protobuf:"varint,1,opt,name=signer_set_nonce,json=signerSetNonce,proto3" json:"signer_set_nonce,omitempty"`
}

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

var xxx_messageInfo_SignerSetTxConfirmationsRequest proto.InternalMessageInfo

func (m *SignerSetTxConfirmationsRequest) GetSignerSetNonce() uint64 {
	if m != nil {
		return m.SignerSetNonce
	}
	return 0
}

type SignerSetTxConfirmationsResponse struct {
	Signatures []*SignerSetTxConfirmation `protobuf:"bytes,1,rep,name=signatures,proto3" json:"signatures,omitempty"`
}

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

var xxx_messageInfo_SignerSetTxConfirmationsResponse proto.InternalMessageInfo

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

type SignerSetTxsRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_SignerSetTxsRequest proto.InternalMessageInfo

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

type SignerSetTxsResponse struct {
	SignerSets []*SignerSetTx      `protobuf:"bytes,1,rep,name=signer_sets,json=signerSets,proto3" json:"signer_sets,omitempty"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_SignerSetTxsResponse proto.InternalMessageInfo

func (m *SignerSetTxsResponse) GetSignerSets() []*SignerSetTx {
	if m != nil {
		return m.SignerSets
	}
	return nil
}

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

type BatchTxsRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_BatchTxsRequest proto.InternalMessageInfo

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

type BatchTxsResponse struct {
	Batches    []*BatchTx          `protobuf:"bytes,1,rep,name=batches,proto3" json:"batches,omitempty"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_BatchTxsResponse proto.InternalMessageInfo

func (m *BatchTxsResponse) GetBatches() []*BatchTx {
	if m != nil {
		return m.Batches
	}
	return nil
}

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

type ContractCallTxsRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_ContractCallTxsRequest proto.InternalMessageInfo

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

type ContractCallTxsResponse struct {
	Calls      []*ContractCallTx   `protobuf:"bytes,1,rep,name=calls,proto3" json:"calls,omitempty"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_ContractCallTxsResponse proto.InternalMessageInfo

func (m *ContractCallTxsResponse) GetCalls() []*ContractCallTx {
	if m != nil {
		return m.Calls
	}
	return nil
}

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

type UnsignedSignerSetTxsRequest struct {

	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_UnsignedSignerSetTxsRequest proto.InternalMessageInfo

func (m *UnsignedSignerSetTxsRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type UnsignedSignerSetTxsResponse struct {
	SignerSets []*SignerSetTx `protobuf:"bytes,1,rep,name=signer_sets,json=signerSets,proto3" json:"signer_sets,omitempty"`
}

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

var xxx_messageInfo_UnsignedSignerSetTxsResponse proto.InternalMessageInfo

func (m *UnsignedSignerSetTxsResponse) GetSignerSets() []*SignerSetTx {
	if m != nil {
		return m.SignerSets
	}
	return nil
}

type UnsignedBatchTxsRequest struct {

	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_UnsignedBatchTxsRequest proto.InternalMessageInfo

func (m *UnsignedBatchTxsRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type UnsignedBatchTxsResponse struct {

	Batches []*BatchTx `protobuf:"bytes,1,rep,name=batches,proto3" json:"batches,omitempty"`
}

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

var xxx_messageInfo_UnsignedBatchTxsResponse proto.InternalMessageInfo

func (m *UnsignedBatchTxsResponse) GetBatches() []*BatchTx {
	if m != nil {
		return m.Batches
	}
	return nil
}

type UnsignedContractCallTxsRequest struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_UnsignedContractCallTxsRequest proto.InternalMessageInfo

func (m *UnsignedContractCallTxsRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type UnsignedContractCallTxsResponse struct {
	Calls []*ContractCallTx `protobuf:"bytes,1,rep,name=calls,proto3" json:"calls,omitempty"`
}

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

var xxx_messageInfo_UnsignedContractCallTxsResponse proto.InternalMessageInfo

func (m *UnsignedContractCallTxsResponse) GetCalls() []*ContractCallTx {
	if m != nil {
		return m.Calls
	}
	return nil
}

type BatchTxFeesRequest struct {
}

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

var xxx_messageInfo_BatchTxFeesRequest proto.InternalMessageInfo

type BatchTxFeesResponse struct {
	Fees github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,1,rep,name=fees,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"fees"`
}

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

var xxx_messageInfo_BatchTxFeesResponse proto.InternalMessageInfo

func (m *BatchTxFeesResponse) GetFees() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.Fees
	}
	return nil
}

type ContractCallTxConfirmationsRequest struct {
	InvalidationScope []byte `protobuf:"bytes,1,opt,name=invalidation_scope,json=invalidationScope,proto3" json:"invalidation_scope,omitempty"`
	InvalidationNonce uint64 `protobuf:"varint,2,opt,name=invalidation_nonce,json=invalidationNonce,proto3" json:"invalidation_nonce,omitempty"`
}

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

var xxx_messageInfo_ContractCallTxConfirmationsRequest proto.InternalMessageInfo

func (m *ContractCallTxConfirmationsRequest) GetInvalidationScope() []byte {
	if m != nil {
		return m.InvalidationScope
	}
	return nil
}

func (m *ContractCallTxConfirmationsRequest) GetInvalidationNonce() uint64 {
	if m != nil {
		return m.InvalidationNonce
	}
	return 0
}

type ContractCallTxConfirmationsResponse struct {
	Signatures []*ContractCallTxConfirmation `protobuf:"bytes,1,rep,name=signatures,proto3" json:"signatures,omitempty"`
}

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

var xxx_messageInfo_ContractCallTxConfirmationsResponse proto.InternalMessageInfo

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

type BatchTxConfirmationsRequest struct {
	BatchNonce    uint64 `protobuf:"varint,1,opt,name=batch_nonce,json=batchNonce,proto3" json:"batch_nonce,omitempty"`
	TokenContract string `protobuf:"bytes,2,opt,name=token_contract,json=tokenContract,proto3" json:"token_contract,omitempty"`
}

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

var xxx_messageInfo_BatchTxConfirmationsRequest proto.InternalMessageInfo

func (m *BatchTxConfirmationsRequest) GetBatchNonce() uint64 {
	if m != nil {
		return m.BatchNonce
	}
	return 0
}

func (m *BatchTxConfirmationsRequest) GetTokenContract() string {
	if m != nil {
		return m.TokenContract
	}
	return ""
}

type BatchTxConfirmationsResponse struct {
	Signatures []*BatchTxConfirmation `protobuf:"bytes,1,rep,name=signatures,proto3" json:"signatures,omitempty"`
}

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

var xxx_messageInfo_BatchTxConfirmationsResponse proto.InternalMessageInfo

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

type LastSubmittedEthereumEventRequest struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_LastSubmittedEthereumEventRequest proto.InternalMessageInfo

func (m *LastSubmittedEthereumEventRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type LastSubmittedEthereumEventResponse struct {
	EventNonce uint64 `protobuf:"varint,1,opt,name=event_nonce,json=eventNonce,proto3" json:"event_nonce,omitempty"`
}

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

var xxx_messageInfo_LastSubmittedEthereumEventResponse proto.InternalMessageInfo

func (m *LastSubmittedEthereumEventResponse) GetEventNonce() uint64 {
	if m != nil {
		return m.EventNonce
	}
	return 0
}

type ERC20ToDenomRequest struct {
	Erc20 string `protobuf:"bytes,1,opt,name=erc20,proto3" json:"erc20,omitempty"`
}

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

var xxx_messageInfo_ERC20ToDenomRequest proto.InternalMessageInfo

func (m *ERC20ToDenomRequest) GetErc20() string {
	if m != nil {
		return m.Erc20
	}
	return ""
}

type ERC20ToDenomResponse struct {
	Denom            string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
	CosmosOriginated bool   `protobuf:"varint,2,opt,name=cosmos_originated,json=cosmosOriginated,proto3" json:"cosmos_originated,omitempty"`
}

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

var xxx_messageInfo_ERC20ToDenomResponse proto.InternalMessageInfo

func (m *ERC20ToDenomResponse) GetDenom() string {
	if m != nil {
		return m.Denom
	}
	return ""
}

func (m *ERC20ToDenomResponse) GetCosmosOriginated() bool {
	if m != nil {
		return m.CosmosOriginated
	}
	return false
}

type DenomToERC20ParamsRequest struct {
	Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
}

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

var xxx_messageInfo_DenomToERC20ParamsRequest proto.InternalMessageInfo

func (m *DenomToERC20ParamsRequest) GetDenom() string {
	if m != nil {
		return m.Denom
	}
	return ""
}

type DenomToERC20ParamsResponse struct {
	BaseDenom     string `protobuf:"bytes,1,opt,name=base_denom,json=baseDenom,proto3" json:"base_denom,omitempty"`
	Erc20Name     string `protobuf:"bytes,2,opt,name=erc20_name,json=erc20Name,proto3" json:"erc20_name,omitempty"`
	Erc20Symbol   string `protobuf:"bytes,3,opt,name=erc20_symbol,json=erc20Symbol,proto3" json:"erc20_symbol,omitempty"`
	Erc20Decimals uint64 `protobuf:"varint,4,opt,name=erc20_decimals,json=erc20Decimals,proto3" json:"erc20_decimals,omitempty"`
}

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

var xxx_messageInfo_DenomToERC20ParamsResponse proto.InternalMessageInfo

func (m *DenomToERC20ParamsResponse) GetBaseDenom() string {
	if m != nil {
		return m.BaseDenom
	}
	return ""
}

func (m *DenomToERC20ParamsResponse) GetErc20Name() string {
	if m != nil {
		return m.Erc20Name
	}
	return ""
}

func (m *DenomToERC20ParamsResponse) GetErc20Symbol() string {
	if m != nil {
		return m.Erc20Symbol
	}
	return ""
}

func (m *DenomToERC20ParamsResponse) GetErc20Decimals() uint64 {
	if m != nil {
		return m.Erc20Decimals
	}
	return 0
}

type DenomToERC20Request struct {
	Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
}

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

var xxx_messageInfo_DenomToERC20Request proto.InternalMessageInfo

func (m *DenomToERC20Request) GetDenom() string {
	if m != nil {
		return m.Denom
	}
	return ""
}

type DenomToERC20Response struct {
	Erc20            string `protobuf:"bytes,1,opt,name=erc20,proto3" json:"erc20,omitempty"`
	CosmosOriginated bool   `protobuf:"varint,2,opt,name=cosmos_originated,json=cosmosOriginated,proto3" json:"cosmos_originated,omitempty"`
}

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

var xxx_messageInfo_DenomToERC20Response proto.InternalMessageInfo

func (m *DenomToERC20Response) GetErc20() string {
	if m != nil {
		return m.Erc20
	}
	return ""
}

func (m *DenomToERC20Response) GetCosmosOriginated() bool {
	if m != nil {
		return m.CosmosOriginated
	}
	return false
}

type DelegateKeysByValidatorRequest struct {
	ValidatorAddress string `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
}

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

var xxx_messageInfo_DelegateKeysByValidatorRequest proto.InternalMessageInfo

func (m *DelegateKeysByValidatorRequest) GetValidatorAddress() string {
	if m != nil {
		return m.ValidatorAddress
	}
	return ""
}

type DelegateKeysByValidatorResponse struct {
	EthAddress          string `protobuf:"bytes,1,opt,name=eth_address,json=ethAddress,proto3" json:"eth_address,omitempty"`
	OrchestratorAddress string `protobuf:"bytes,2,opt,name=orchestrator_address,json=orchestratorAddress,proto3" json:"orchestrator_address,omitempty"`
}

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

var xxx_messageInfo_DelegateKeysByValidatorResponse proto.InternalMessageInfo

func (m *DelegateKeysByValidatorResponse) GetEthAddress() string {
	if m != nil {
		return m.EthAddress
	}
	return ""
}

func (m *DelegateKeysByValidatorResponse) GetOrchestratorAddress() string {
	if m != nil {
		return m.OrchestratorAddress
	}
	return ""
}

type DelegateKeysByEthereumSignerRequest struct {
	EthereumSigner string `protobuf:"bytes,1,opt,name=ethereum_signer,json=ethereumSigner,proto3" json:"ethereum_signer,omitempty"`
}

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

var xxx_messageInfo_DelegateKeysByEthereumSignerRequest proto.InternalMessageInfo

func (m *DelegateKeysByEthereumSignerRequest) GetEthereumSigner() string {
	if m != nil {
		return m.EthereumSigner
	}
	return ""
}

type DelegateKeysByEthereumSignerResponse struct {
	ValidatorAddress    string `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
	OrchestratorAddress string `protobuf:"bytes,2,opt,name=orchestrator_address,json=orchestratorAddress,proto3" json:"orchestrator_address,omitempty"`
}

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

var xxx_messageInfo_DelegateKeysByEthereumSignerResponse proto.InternalMessageInfo

func (m *DelegateKeysByEthereumSignerResponse) GetValidatorAddress() string {
	if m != nil {
		return m.ValidatorAddress
	}
	return ""
}

func (m *DelegateKeysByEthereumSignerResponse) GetOrchestratorAddress() string {
	if m != nil {
		return m.OrchestratorAddress
	}
	return ""
}

type DelegateKeysByOrchestratorRequest struct {
	OrchestratorAddress string `protobuf:"bytes,1,opt,name=orchestrator_address,json=orchestratorAddress,proto3" json:"orchestrator_address,omitempty"`
}

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

var xxx_messageInfo_DelegateKeysByOrchestratorRequest proto.InternalMessageInfo

func (m *DelegateKeysByOrchestratorRequest) GetOrchestratorAddress() string {
	if m != nil {
		return m.OrchestratorAddress
	}
	return ""
}

type DelegateKeysByOrchestratorResponse struct {
	ValidatorAddress string `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
	EthereumSigner   string `protobuf:"bytes,2,opt,name=ethereum_signer,json=ethereumSigner,proto3" json:"ethereum_signer,omitempty"`
}

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

var xxx_messageInfo_DelegateKeysByOrchestratorResponse proto.InternalMessageInfo

func (m *DelegateKeysByOrchestratorResponse) GetValidatorAddress() string {
	if m != nil {
		return m.ValidatorAddress
	}
	return ""
}

func (m *DelegateKeysByOrchestratorResponse) GetEthereumSigner() string {
	if m != nil {
		return m.EthereumSigner
	}
	return ""
}

type DelegateKeysRequest struct {
}

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

var xxx_messageInfo_DelegateKeysRequest proto.InternalMessageInfo

type DelegateKeysResponse struct {
	DelegateKeys []*MsgDelegateKeys `protobuf:"bytes,1,rep,name=delegate_keys,json=delegateKeys,proto3" json:"delegate_keys,omitempty"`
}

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

var xxx_messageInfo_DelegateKeysResponse proto.InternalMessageInfo

func (m *DelegateKeysResponse) GetDelegateKeys() []*MsgDelegateKeys {
	if m != nil {
		return m.DelegateKeys
	}
	return nil
}

type BatchedSendToEthereumsRequest struct {
	SenderAddress string `protobuf:"bytes,1,opt,name=sender_address,json=senderAddress,proto3" json:"sender_address,omitempty"`
}

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

var xxx_messageInfo_BatchedSendToEthereumsRequest proto.InternalMessageInfo

func (m *BatchedSendToEthereumsRequest) GetSenderAddress() string {
	if m != nil {
		return m.SenderAddress
	}
	return ""
}

type BatchedSendToEthereumsResponse struct {
	SendToEthereums []*SendToEthereum `protobuf:"bytes,1,rep,name=send_to_ethereums,json=sendToEthereums,proto3" json:"send_to_ethereums,omitempty"`
}

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

var xxx_messageInfo_BatchedSendToEthereumsResponse proto.InternalMessageInfo

func (m *BatchedSendToEthereumsResponse) GetSendToEthereums() []*SendToEthereum {
	if m != nil {
		return m.SendToEthereums
	}
	return nil
}

type UnbatchedSendToEthereumsRequest struct {
	SenderAddress string             `protobuf:"bytes,1,opt,name=sender_address,json=senderAddress,proto3" json:"sender_address,omitempty"`
	Pagination    *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_UnbatchedSendToEthereumsRequest proto.InternalMessageInfo

func (m *UnbatchedSendToEthereumsRequest) GetSenderAddress() string {
	if m != nil {
		return m.SenderAddress
	}
	return ""
}

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

type UnbatchedSendToEthereumsResponse struct {
	SendToEthereums []*SendToEthereum   `protobuf:"bytes,1,rep,name=send_to_ethereums,json=sendToEthereums,proto3" json:"send_to_ethereums,omitempty"`
	Pagination      *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_UnbatchedSendToEthereumsResponse proto.InternalMessageInfo

func (m *UnbatchedSendToEthereumsResponse) GetSendToEthereums() []*SendToEthereum {
	if m != nil {
		return m.SendToEthereums
	}
	return nil
}

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

func init() {
	proto.RegisterType((*ParamsRequest)(nil), "gravity.v1migration.ParamsRequest")
	proto.RegisterType((*ParamsResponse)(nil), "gravity.v1migration.ParamsResponse")
	proto.RegisterType((*SignerSetTxRequest)(nil), "gravity.v1migration.SignerSetTxRequest")
	proto.RegisterType((*LatestSignerSetTxRequest)(nil), "gravity.v1migration.LatestSignerSetTxRequest")
	proto.RegisterType((*SignerSetTxResponse)(nil), "gravity.v1migration.SignerSetTxResponse")
	proto.RegisterType((*BatchTxRequest)(nil), "gravity.v1migration.BatchTxRequest")
	proto.RegisterType((*BatchTxResponse)(nil), "gravity.v1migration.BatchTxResponse")
	proto.RegisterType((*ContractCallTxRequest)(nil), "gravity.v1migration.ContractCallTxRequest")
	proto.RegisterType((*ContractCallTxResponse)(nil), "gravity.v1migration.ContractCallTxResponse")
	proto.RegisterType((*SignerSetTxConfirmationsRequest)(nil), "gravity.v1migration.SignerSetTxConfirmationsRequest")
	proto.RegisterType((*SignerSetTxConfirmationsResponse)(nil), "gravity.v1migration.SignerSetTxConfirmationsResponse")
	proto.RegisterType((*SignerSetTxsRequest)(nil), "gravity.v1migration.SignerSetTxsRequest")
	proto.RegisterType((*SignerSetTxsResponse)(nil), "gravity.v1migration.SignerSetTxsResponse")
	proto.RegisterType((*BatchTxsRequest)(nil), "gravity.v1migration.BatchTxsRequest")
	proto.RegisterType((*BatchTxsResponse)(nil), "gravity.v1migration.BatchTxsResponse")
	proto.RegisterType((*ContractCallTxsRequest)(nil), "gravity.v1migration.ContractCallTxsRequest")
	proto.RegisterType((*ContractCallTxsResponse)(nil), "gravity.v1migration.ContractCallTxsResponse")
	proto.RegisterType((*UnsignedSignerSetTxsRequest)(nil), "gravity.v1migration.UnsignedSignerSetTxsRequest")
	proto.RegisterType((*UnsignedSignerSetTxsResponse)(nil), "gravity.v1migration.UnsignedSignerSetTxsResponse")
	proto.RegisterType((*UnsignedBatchTxsRequest)(nil), "gravity.v1migration.UnsignedBatchTxsRequest")
	proto.RegisterType((*UnsignedBatchTxsResponse)(nil), "gravity.v1migration.UnsignedBatchTxsResponse")
	proto.RegisterType((*UnsignedContractCallTxsRequest)(nil), "gravity.v1migration.UnsignedContractCallTxsRequest")
	proto.RegisterType((*UnsignedContractCallTxsResponse)(nil), "gravity.v1migration.UnsignedContractCallTxsResponse")
	proto.RegisterType((*BatchTxFeesRequest)(nil), "gravity.v1migration.BatchTxFeesRequest")
	proto.RegisterType((*BatchTxFeesResponse)(nil), "gravity.v1migration.BatchTxFeesResponse")
	proto.RegisterType((*ContractCallTxConfirmationsRequest)(nil), "gravity.v1migration.ContractCallTxConfirmationsRequest")
	proto.RegisterType((*ContractCallTxConfirmationsResponse)(nil), "gravity.v1migration.ContractCallTxConfirmationsResponse")
	proto.RegisterType((*BatchTxConfirmationsRequest)(nil), "gravity.v1migration.BatchTxConfirmationsRequest")
	proto.RegisterType((*BatchTxConfirmationsResponse)(nil), "gravity.v1migration.BatchTxConfirmationsResponse")
	proto.RegisterType((*LastSubmittedEthereumEventRequest)(nil), "gravity.v1migration.LastSubmittedEthereumEventRequest")
	proto.RegisterType((*LastSubmittedEthereumEventResponse)(nil), "gravity.v1migration.LastSubmittedEthereumEventResponse")
	proto.RegisterType((*ERC20ToDenomRequest)(nil), "gravity.v1migration.ERC20ToDenomRequest")
	proto.RegisterType((*ERC20ToDenomResponse)(nil), "gravity.v1migration.ERC20ToDenomResponse")
	proto.RegisterType((*DenomToERC20ParamsRequest)(nil), "gravity.v1migration.DenomToERC20ParamsRequest")
	proto.RegisterType((*DenomToERC20ParamsResponse)(nil), "gravity.v1migration.DenomToERC20ParamsResponse")
	proto.RegisterType((*DenomToERC20Request)(nil), "gravity.v1migration.DenomToERC20Request")
	proto.RegisterType((*DenomToERC20Response)(nil), "gravity.v1migration.DenomToERC20Response")
	proto.RegisterType((*DelegateKeysByValidatorRequest)(nil), "gravity.v1migration.DelegateKeysByValidatorRequest")
	proto.RegisterType((*DelegateKeysByValidatorResponse)(nil), "gravity.v1migration.DelegateKeysByValidatorResponse")
	proto.RegisterType((*DelegateKeysByEthereumSignerRequest)(nil), "gravity.v1migration.DelegateKeysByEthereumSignerRequest")
	proto.RegisterType((*DelegateKeysByEthereumSignerResponse)(nil), "gravity.v1migration.DelegateKeysByEthereumSignerResponse")
	proto.RegisterType((*DelegateKeysByOrchestratorRequest)(nil), "gravity.v1migration.DelegateKeysByOrchestratorRequest")
	proto.RegisterType((*DelegateKeysByOrchestratorResponse)(nil), "gravity.v1migration.DelegateKeysByOrchestratorResponse")
	proto.RegisterType((*DelegateKeysRequest)(nil), "gravity.v1migration.DelegateKeysRequest")
	proto.RegisterType((*DelegateKeysResponse)(nil), "gravity.v1migration.DelegateKeysResponse")
	proto.RegisterType((*BatchedSendToEthereumsRequest)(nil), "gravity.v1migration.BatchedSendToEthereumsRequest")
	proto.RegisterType((*BatchedSendToEthereumsResponse)(nil), "gravity.v1migration.BatchedSendToEthereumsResponse")
	proto.RegisterType((*UnbatchedSendToEthereumsRequest)(nil), "gravity.v1migration.UnbatchedSendToEthereumsRequest")
	proto.RegisterType((*UnbatchedSendToEthereumsResponse)(nil), "gravity.v1migration.UnbatchedSendToEthereumsResponse")
}

func init() { proto.RegisterFile("gravity/v1migration/query.proto", fileDescriptor_52ac3aa5b09dcaf2) }

var fileDescriptor_52ac3aa5b09dcaf2 = []byte{

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

var _ context.Context
var _ grpc.ClientConn

const _ = grpc.SupportPackageIsVersion4

type QueryClient interface {

	Params(ctx context.Context, in *ParamsRequest, opts ...grpc.CallOption) (*ParamsResponse, error)

	SignerSetTx(ctx context.Context, in *SignerSetTxRequest, opts ...grpc.CallOption) (*SignerSetTxResponse, error)
	LatestSignerSetTx(ctx context.Context, in *LatestSignerSetTxRequest, opts ...grpc.CallOption) (*SignerSetTxResponse, error)
	BatchTx(ctx context.Context, in *BatchTxRequest, opts ...grpc.CallOption) (*BatchTxResponse, error)
	ContractCallTx(ctx context.Context, in *ContractCallTxRequest, opts ...grpc.CallOption) (*ContractCallTxResponse, error)

	SignerSetTxs(ctx context.Context, in *SignerSetTxsRequest, opts ...grpc.CallOption) (*SignerSetTxsResponse, error)
	BatchTxs(ctx context.Context, in *BatchTxsRequest, opts ...grpc.CallOption) (*BatchTxsResponse, error)
	ContractCallTxs(ctx context.Context, in *ContractCallTxsRequest, opts ...grpc.CallOption) (*ContractCallTxsResponse, error)

	SignerSetTxConfirmations(ctx context.Context, in *SignerSetTxConfirmationsRequest, opts ...grpc.CallOption) (*SignerSetTxConfirmationsResponse, error)
	BatchTxConfirmations(ctx context.Context, in *BatchTxConfirmationsRequest, opts ...grpc.CallOption) (*BatchTxConfirmationsResponse, error)
	ContractCallTxConfirmations(ctx context.Context, in *ContractCallTxConfirmationsRequest, opts ...grpc.CallOption) (*ContractCallTxConfirmationsResponse, error)

	UnsignedSignerSetTxs(ctx context.Context, in *UnsignedSignerSetTxsRequest, opts ...grpc.CallOption) (*UnsignedSignerSetTxsResponse, error)
	UnsignedBatchTxs(ctx context.Context, in *UnsignedBatchTxsRequest, opts ...grpc.CallOption) (*UnsignedBatchTxsResponse, error)
	UnsignedContractCallTxs(ctx context.Context, in *UnsignedContractCallTxsRequest, opts ...grpc.CallOption) (*UnsignedContractCallTxsResponse, error)
	LastSubmittedEthereumEvent(ctx context.Context, in *LastSubmittedEthereumEventRequest, opts ...grpc.CallOption) (*LastSubmittedEthereumEventResponse, error)

	BatchTxFees(ctx context.Context, in *BatchTxFeesRequest, opts ...grpc.CallOption) (*BatchTxFeesResponse, error)

	ERC20ToDenom(ctx context.Context, in *ERC20ToDenomRequest, opts ...grpc.CallOption) (*ERC20ToDenomResponse, error)

	DenomToERC20Params(ctx context.Context, in *DenomToERC20ParamsRequest, opts ...grpc.CallOption) (*DenomToERC20ParamsResponse, error)

	DenomToERC20(ctx context.Context, in *DenomToERC20Request, opts ...grpc.CallOption) (*DenomToERC20Response, error)

	BatchedSendToEthereums(ctx context.Context, in *BatchedSendToEthereumsRequest, opts ...grpc.CallOption) (*BatchedSendToEthereumsResponse, error)

	UnbatchedSendToEthereums(ctx context.Context, in *UnbatchedSendToEthereumsRequest, opts ...grpc.CallOption) (*UnbatchedSendToEthereumsResponse, error)

	DelegateKeysByValidator(ctx context.Context, in *DelegateKeysByValidatorRequest, opts ...grpc.CallOption) (*DelegateKeysByValidatorResponse, error)
	DelegateKeysByEthereumSigner(ctx context.Context, in *DelegateKeysByEthereumSignerRequest, opts ...grpc.CallOption) (*DelegateKeysByEthereumSignerResponse, error)
	DelegateKeysByOrchestrator(ctx context.Context, in *DelegateKeysByOrchestratorRequest, opts ...grpc.CallOption) (*DelegateKeysByOrchestratorResponse, error)
	DelegateKeys(ctx context.Context, in *DelegateKeysRequest, opts ...grpc.CallOption) (*DelegateKeysResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

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

func (c *queryClient) Params(ctx context.Context, in *ParamsRequest, opts ...grpc.CallOption) (*ParamsResponse, error) {
	out := new(ParamsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/Params", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) SignerSetTx(ctx context.Context, in *SignerSetTxRequest, opts ...grpc.CallOption) (*SignerSetTxResponse, error) {
	out := new(SignerSetTxResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/SignerSetTx", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) LatestSignerSetTx(ctx context.Context, in *LatestSignerSetTxRequest, opts ...grpc.CallOption) (*SignerSetTxResponse, error) {
	out := new(SignerSetTxResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/LatestSignerSetTx", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) BatchTx(ctx context.Context, in *BatchTxRequest, opts ...grpc.CallOption) (*BatchTxResponse, error) {
	out := new(BatchTxResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/BatchTx", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ContractCallTx(ctx context.Context, in *ContractCallTxRequest, opts ...grpc.CallOption) (*ContractCallTxResponse, error) {
	out := new(ContractCallTxResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/ContractCallTx", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) SignerSetTxs(ctx context.Context, in *SignerSetTxsRequest, opts ...grpc.CallOption) (*SignerSetTxsResponse, error) {
	out := new(SignerSetTxsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/SignerSetTxs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) BatchTxs(ctx context.Context, in *BatchTxsRequest, opts ...grpc.CallOption) (*BatchTxsResponse, error) {
	out := new(BatchTxsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/BatchTxs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ContractCallTxs(ctx context.Context, in *ContractCallTxsRequest, opts ...grpc.CallOption) (*ContractCallTxsResponse, error) {
	out := new(ContractCallTxsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/ContractCallTxs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) SignerSetTxConfirmations(ctx context.Context, in *SignerSetTxConfirmationsRequest, opts ...grpc.CallOption) (*SignerSetTxConfirmationsResponse, error) {
	out := new(SignerSetTxConfirmationsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/SignerSetTxConfirmations", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) BatchTxConfirmations(ctx context.Context, in *BatchTxConfirmationsRequest, opts ...grpc.CallOption) (*BatchTxConfirmationsResponse, error) {
	out := new(BatchTxConfirmationsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/BatchTxConfirmations", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ContractCallTxConfirmations(ctx context.Context, in *ContractCallTxConfirmationsRequest, opts ...grpc.CallOption) (*ContractCallTxConfirmationsResponse, error) {
	out := new(ContractCallTxConfirmationsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/ContractCallTxConfirmations", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) UnsignedSignerSetTxs(ctx context.Context, in *UnsignedSignerSetTxsRequest, opts ...grpc.CallOption) (*UnsignedSignerSetTxsResponse, error) {
	out := new(UnsignedSignerSetTxsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/UnsignedSignerSetTxs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) UnsignedBatchTxs(ctx context.Context, in *UnsignedBatchTxsRequest, opts ...grpc.CallOption) (*UnsignedBatchTxsResponse, error) {
	out := new(UnsignedBatchTxsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/UnsignedBatchTxs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) UnsignedContractCallTxs(ctx context.Context, in *UnsignedContractCallTxsRequest, opts ...grpc.CallOption) (*UnsignedContractCallTxsResponse, error) {
	out := new(UnsignedContractCallTxsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/UnsignedContractCallTxs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) LastSubmittedEthereumEvent(ctx context.Context, in *LastSubmittedEthereumEventRequest, opts ...grpc.CallOption) (*LastSubmittedEthereumEventResponse, error) {
	out := new(LastSubmittedEthereumEventResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/LastSubmittedEthereumEvent", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) BatchTxFees(ctx context.Context, in *BatchTxFeesRequest, opts ...grpc.CallOption) (*BatchTxFeesResponse, error) {
	out := new(BatchTxFeesResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/BatchTxFees", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ERC20ToDenom(ctx context.Context, in *ERC20ToDenomRequest, opts ...grpc.CallOption) (*ERC20ToDenomResponse, error) {
	out := new(ERC20ToDenomResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/ERC20ToDenom", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) DenomToERC20Params(ctx context.Context, in *DenomToERC20ParamsRequest, opts ...grpc.CallOption) (*DenomToERC20ParamsResponse, error) {
	out := new(DenomToERC20ParamsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/DenomToERC20Params", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) DenomToERC20(ctx context.Context, in *DenomToERC20Request, opts ...grpc.CallOption) (*DenomToERC20Response, error) {
	out := new(DenomToERC20Response)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/DenomToERC20", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) BatchedSendToEthereums(ctx context.Context, in *BatchedSendToEthereumsRequest, opts ...grpc.CallOption) (*BatchedSendToEthereumsResponse, error) {
	out := new(BatchedSendToEthereumsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/BatchedSendToEthereums", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) UnbatchedSendToEthereums(ctx context.Context, in *UnbatchedSendToEthereumsRequest, opts ...grpc.CallOption) (*UnbatchedSendToEthereumsResponse, error) {
	out := new(UnbatchedSendToEthereumsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/UnbatchedSendToEthereums", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) DelegateKeysByValidator(ctx context.Context, in *DelegateKeysByValidatorRequest, opts ...grpc.CallOption) (*DelegateKeysByValidatorResponse, error) {
	out := new(DelegateKeysByValidatorResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/DelegateKeysByValidator", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) DelegateKeysByEthereumSigner(ctx context.Context, in *DelegateKeysByEthereumSignerRequest, opts ...grpc.CallOption) (*DelegateKeysByEthereumSignerResponse, error) {
	out := new(DelegateKeysByEthereumSignerResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/DelegateKeysByEthereumSigner", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) DelegateKeysByOrchestrator(ctx context.Context, in *DelegateKeysByOrchestratorRequest, opts ...grpc.CallOption) (*DelegateKeysByOrchestratorResponse, error) {
	out := new(DelegateKeysByOrchestratorResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/DelegateKeysByOrchestrator", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) DelegateKeys(ctx context.Context, in *DelegateKeysRequest, opts ...grpc.CallOption) (*DelegateKeysResponse, error) {
	out := new(DelegateKeysResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/DelegateKeys", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

type QueryServer interface {

	Params(context.Context, *ParamsRequest) (*ParamsResponse, error)

	SignerSetTx(context.Context, *SignerSetTxRequest) (*SignerSetTxResponse, error)
	LatestSignerSetTx(context.Context, *LatestSignerSetTxRequest) (*SignerSetTxResponse, error)
	BatchTx(context.Context, *BatchTxRequest) (*BatchTxResponse, error)
	ContractCallTx(context.Context, *ContractCallTxRequest) (*ContractCallTxResponse, error)

	SignerSetTxs(context.Context, *SignerSetTxsRequest) (*SignerSetTxsResponse, error)
	BatchTxs(context.Context, *BatchTxsRequest) (*BatchTxsResponse, error)
	ContractCallTxs(context.Context, *ContractCallTxsRequest) (*ContractCallTxsResponse, error)

	SignerSetTxConfirmations(context.Context, *SignerSetTxConfirmationsRequest) (*SignerSetTxConfirmationsResponse, error)
	BatchTxConfirmations(context.Context, *BatchTxConfirmationsRequest) (*BatchTxConfirmationsResponse, error)
	ContractCallTxConfirmations(context.Context, *ContractCallTxConfirmationsRequest) (*ContractCallTxConfirmationsResponse, error)

	UnsignedSignerSetTxs(context.Context, *UnsignedSignerSetTxsRequest) (*UnsignedSignerSetTxsResponse, error)
	UnsignedBatchTxs(context.Context, *UnsignedBatchTxsRequest) (*UnsignedBatchTxsResponse, error)
	UnsignedContractCallTxs(context.Context, *UnsignedContractCallTxsRequest) (*UnsignedContractCallTxsResponse, error)
	LastSubmittedEthereumEvent(context.Context, *LastSubmittedEthereumEventRequest) (*LastSubmittedEthereumEventResponse, error)

	BatchTxFees(context.Context, *BatchTxFeesRequest) (*BatchTxFeesResponse, error)

	ERC20ToDenom(context.Context, *ERC20ToDenomRequest) (*ERC20ToDenomResponse, error)

	DenomToERC20Params(context.Context, *DenomToERC20ParamsRequest) (*DenomToERC20ParamsResponse, error)

	DenomToERC20(context.Context, *DenomToERC20Request) (*DenomToERC20Response, error)

	BatchedSendToEthereums(context.Context, *BatchedSendToEthereumsRequest) (*BatchedSendToEthereumsResponse, error)

	UnbatchedSendToEthereums(context.Context, *UnbatchedSendToEthereumsRequest) (*UnbatchedSendToEthereumsResponse, error)

	DelegateKeysByValidator(context.Context, *DelegateKeysByValidatorRequest) (*DelegateKeysByValidatorResponse, error)
	DelegateKeysByEthereumSigner(context.Context, *DelegateKeysByEthereumSignerRequest) (*DelegateKeysByEthereumSignerResponse, error)
	DelegateKeysByOrchestrator(context.Context, *DelegateKeysByOrchestratorRequest) (*DelegateKeysByOrchestratorResponse, error)
	DelegateKeys(context.Context, *DelegateKeysRequest) (*DelegateKeysResponse, error)
}

type UnimplementedQueryServer struct {
}

func (*UnimplementedQueryServer) Params(ctx context.Context, req *ParamsRequest) (*ParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}
func (*UnimplementedQueryServer) SignerSetTx(ctx context.Context, req *SignerSetTxRequest) (*SignerSetTxResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SignerSetTx not implemented")
}
func (*UnimplementedQueryServer) LatestSignerSetTx(ctx context.Context, req *LatestSignerSetTxRequest) (*SignerSetTxResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LatestSignerSetTx not implemented")
}
func (*UnimplementedQueryServer) BatchTx(ctx context.Context, req *BatchTxRequest) (*BatchTxResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchTx not implemented")
}
func (*UnimplementedQueryServer) ContractCallTx(ctx context.Context, req *ContractCallTxRequest) (*ContractCallTxResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContractCallTx not implemented")
}
func (*UnimplementedQueryServer) SignerSetTxs(ctx context.Context, req *SignerSetTxsRequest) (*SignerSetTxsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SignerSetTxs not implemented")
}
func (*UnimplementedQueryServer) BatchTxs(ctx context.Context, req *BatchTxsRequest) (*BatchTxsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchTxs not implemented")
}
func (*UnimplementedQueryServer) ContractCallTxs(ctx context.Context, req *ContractCallTxsRequest) (*ContractCallTxsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContractCallTxs not implemented")
}
func (*UnimplementedQueryServer) SignerSetTxConfirmations(ctx context.Context, req *SignerSetTxConfirmationsRequest) (*SignerSetTxConfirmationsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SignerSetTxConfirmations not implemented")
}
func (*UnimplementedQueryServer) BatchTxConfirmations(ctx context.Context, req *BatchTxConfirmationsRequest) (*BatchTxConfirmationsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchTxConfirmations not implemented")
}
func (*UnimplementedQueryServer) ContractCallTxConfirmations(ctx context.Context, req *ContractCallTxConfirmationsRequest) (*ContractCallTxConfirmationsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContractCallTxConfirmations not implemented")
}
func (*UnimplementedQueryServer) UnsignedSignerSetTxs(ctx context.Context, req *UnsignedSignerSetTxsRequest) (*UnsignedSignerSetTxsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnsignedSignerSetTxs not implemented")
}
func (*UnimplementedQueryServer) UnsignedBatchTxs(ctx context.Context, req *UnsignedBatchTxsRequest) (*UnsignedBatchTxsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnsignedBatchTxs not implemented")
}
func (*UnimplementedQueryServer) UnsignedContractCallTxs(ctx context.Context, req *UnsignedContractCallTxsRequest) (*UnsignedContractCallTxsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnsignedContractCallTxs not implemented")
}
func (*UnimplementedQueryServer) LastSubmittedEthereumEvent(ctx context.Context, req *LastSubmittedEthereumEventRequest) (*LastSubmittedEthereumEventResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LastSubmittedEthereumEvent not implemented")
}
func (*UnimplementedQueryServer) BatchTxFees(ctx context.Context, req *BatchTxFeesRequest) (*BatchTxFeesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchTxFees not implemented")
}
func (*UnimplementedQueryServer) ERC20ToDenom(ctx context.Context, req *ERC20ToDenomRequest) (*ERC20ToDenomResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ERC20ToDenom not implemented")
}
func (*UnimplementedQueryServer) DenomToERC20Params(ctx context.Context, req *DenomToERC20ParamsRequest) (*DenomToERC20ParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DenomToERC20Params not implemented")
}
func (*UnimplementedQueryServer) DenomToERC20(ctx context.Context, req *DenomToERC20Request) (*DenomToERC20Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DenomToERC20 not implemented")
}
func (*UnimplementedQueryServer) BatchedSendToEthereums(ctx context.Context, req *BatchedSendToEthereumsRequest) (*BatchedSendToEthereumsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchedSendToEthereums not implemented")
}
func (*UnimplementedQueryServer) UnbatchedSendToEthereums(ctx context.Context, req *UnbatchedSendToEthereumsRequest) (*UnbatchedSendToEthereumsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnbatchedSendToEthereums not implemented")
}
func (*UnimplementedQueryServer) DelegateKeysByValidator(ctx context.Context, req *DelegateKeysByValidatorRequest) (*DelegateKeysByValidatorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DelegateKeysByValidator not implemented")
}
func (*UnimplementedQueryServer) DelegateKeysByEthereumSigner(ctx context.Context, req *DelegateKeysByEthereumSignerRequest) (*DelegateKeysByEthereumSignerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DelegateKeysByEthereumSigner not implemented")
}
func (*UnimplementedQueryServer) DelegateKeysByOrchestrator(ctx context.Context, req *DelegateKeysByOrchestratorRequest) (*DelegateKeysByOrchestratorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DelegateKeysByOrchestrator not implemented")
}
func (*UnimplementedQueryServer) DelegateKeys(ctx context.Context, req *DelegateKeysRequest) (*DelegateKeysResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DelegateKeys 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(ParamsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Params(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/Params",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Params(ctx, req.(*ParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_SignerSetTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignerSetTxRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).SignerSetTx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/SignerSetTx",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).SignerSetTx(ctx, req.(*SignerSetTxRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_LatestSignerSetTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LatestSignerSetTxRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).LatestSignerSetTx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/LatestSignerSetTx",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).LatestSignerSetTx(ctx, req.(*LatestSignerSetTxRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_BatchTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchTxRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).BatchTx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/BatchTx",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).BatchTx(ctx, req.(*BatchTxRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ContractCallTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContractCallTxRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ContractCallTx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/ContractCallTx",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ContractCallTx(ctx, req.(*ContractCallTxRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_SignerSetTxs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignerSetTxsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).SignerSetTxs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/SignerSetTxs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).SignerSetTxs(ctx, req.(*SignerSetTxsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_BatchTxs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchTxsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).BatchTxs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/BatchTxs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).BatchTxs(ctx, req.(*BatchTxsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ContractCallTxs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContractCallTxsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ContractCallTxs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/ContractCallTxs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ContractCallTxs(ctx, req.(*ContractCallTxsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_SignerSetTxConfirmations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignerSetTxConfirmationsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).SignerSetTxConfirmations(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/SignerSetTxConfirmations",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).SignerSetTxConfirmations(ctx, req.(*SignerSetTxConfirmationsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_BatchTxConfirmations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchTxConfirmationsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).BatchTxConfirmations(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/BatchTxConfirmations",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).BatchTxConfirmations(ctx, req.(*BatchTxConfirmationsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ContractCallTxConfirmations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContractCallTxConfirmationsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ContractCallTxConfirmations(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/ContractCallTxConfirmations",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ContractCallTxConfirmations(ctx, req.(*ContractCallTxConfirmationsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_UnsignedSignerSetTxs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnsignedSignerSetTxsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).UnsignedSignerSetTxs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/UnsignedSignerSetTxs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).UnsignedSignerSetTxs(ctx, req.(*UnsignedSignerSetTxsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_UnsignedBatchTxs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnsignedBatchTxsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).UnsignedBatchTxs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/UnsignedBatchTxs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).UnsignedBatchTxs(ctx, req.(*UnsignedBatchTxsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_UnsignedContractCallTxs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnsignedContractCallTxsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).UnsignedContractCallTxs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/UnsignedContractCallTxs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).UnsignedContractCallTxs(ctx, req.(*UnsignedContractCallTxsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_LastSubmittedEthereumEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LastSubmittedEthereumEventRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).LastSubmittedEthereumEvent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/LastSubmittedEthereumEvent",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).LastSubmittedEthereumEvent(ctx, req.(*LastSubmittedEthereumEventRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_BatchTxFees_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchTxFeesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).BatchTxFees(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/BatchTxFees",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).BatchTxFees(ctx, req.(*BatchTxFeesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ERC20ToDenom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ERC20ToDenomRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ERC20ToDenom(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/ERC20ToDenom",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ERC20ToDenom(ctx, req.(*ERC20ToDenomRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_DenomToERC20Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DenomToERC20ParamsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).DenomToERC20Params(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/DenomToERC20Params",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).DenomToERC20Params(ctx, req.(*DenomToERC20ParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_DenomToERC20_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DenomToERC20Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).DenomToERC20(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/DenomToERC20",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).DenomToERC20(ctx, req.(*DenomToERC20Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_BatchedSendToEthereums_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchedSendToEthereumsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).BatchedSendToEthereums(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/BatchedSendToEthereums",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).BatchedSendToEthereums(ctx, req.(*BatchedSendToEthereumsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_UnbatchedSendToEthereums_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnbatchedSendToEthereumsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).UnbatchedSendToEthereums(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/UnbatchedSendToEthereums",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).UnbatchedSendToEthereums(ctx, req.(*UnbatchedSendToEthereumsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_DelegateKeysByValidator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DelegateKeysByValidatorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).DelegateKeysByValidator(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/DelegateKeysByValidator",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).DelegateKeysByValidator(ctx, req.(*DelegateKeysByValidatorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_DelegateKeysByEthereumSigner_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DelegateKeysByEthereumSignerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).DelegateKeysByEthereumSigner(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/DelegateKeysByEthereumSigner",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).DelegateKeysByEthereumSigner(ctx, req.(*DelegateKeysByEthereumSignerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_DelegateKeysByOrchestrator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DelegateKeysByOrchestratorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).DelegateKeysByOrchestrator(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/DelegateKeysByOrchestrator",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).DelegateKeysByOrchestrator(ctx, req.(*DelegateKeysByOrchestratorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_DelegateKeys_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DelegateKeysRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).DelegateKeys(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/DelegateKeys",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).DelegateKeys(ctx, req.(*DelegateKeysRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "gravity.v1migration.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
		{
			MethodName: "SignerSetTx",
			Handler:    _Query_SignerSetTx_Handler,
		},
		{
			MethodName: "LatestSignerSetTx",
			Handler:    _Query_LatestSignerSetTx_Handler,
		},
		{
			MethodName: "BatchTx",
			Handler:    _Query_BatchTx_Handler,
		},
		{
			MethodName: "ContractCallTx",
			Handler:    _Query_ContractCallTx_Handler,
		},
		{
			MethodName: "SignerSetTxs",
			Handler:    _Query_SignerSetTxs_Handler,
		},
		{
			MethodName: "BatchTxs",
			Handler:    _Query_BatchTxs_Handler,
		},
		{
			MethodName: "ContractCallTxs",
			Handler:    _Query_ContractCallTxs_Handler,
		},
		{
			MethodName: "SignerSetTxConfirmations",
			Handler:    _Query_SignerSetTxConfirmations_Handler,
		},
		{
			MethodName: "BatchTxConfirmations",
			Handler:    _Query_BatchTxConfirmations_Handler,
		},
		{
			MethodName: "ContractCallTxConfirmations",
			Handler:    _Query_ContractCallTxConfirmations_Handler,
		},
		{
			MethodName: "UnsignedSignerSetTxs",
			Handler:    _Query_UnsignedSignerSetTxs_Handler,
		},
		{
			MethodName: "UnsignedBatchTxs",
			Handler:    _Query_UnsignedBatchTxs_Handler,
		},
		{
			MethodName: "UnsignedContractCallTxs",
			Handler:    _Query_UnsignedContractCallTxs_Handler,
		},
		{
			MethodName: "LastSubmittedEthereumEvent",
			Handler:    _Query_LastSubmittedEthereumEvent_Handler,
		},
		{
			MethodName: "BatchTxFees",
			Handler:    _Query_BatchTxFees_Handler,
		},
		{
			MethodName: "ERC20ToDenom",
			Handler:    _Query_ERC20ToDenom_Handler,
		},
		{
			MethodName: "DenomToERC20Params",
			Handler:    _Query_DenomToERC20Params_Handler,
		},
		{
			MethodName: "DenomToERC20",
			Handler:    _Query_DenomToERC20_Handler,
		},
		{
			MethodName: "BatchedSendToEthereums",
			Handler:    _Query_BatchedSendToEthereums_Handler,
		},
		{
			MethodName: "UnbatchedSendToEthereums",
			Handler:    _Query_UnbatchedSendToEthereums_Handler,
		},
		{
			MethodName: "DelegateKeysByValidator",
			Handler:    _Query_DelegateKeysByValidator_Handler,
		},
		{
			MethodName: "DelegateKeysByEthereumSigner",
			Handler:    _Query_DelegateKeysByEthereumSigner_Handler,
		},
		{
			MethodName: "DelegateKeysByOrchestrator",
			Handler:    _Query_DelegateKeysByOrchestrator_Handler,
		},
		{
			MethodName: "DelegateKeys",
			Handler:    _Query_DelegateKeys_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "gravity/v1migration/query.proto",
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *UnsignedSignerSetTxsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SignerSets) > 0 {
		for iNdEx := len(m.SignerSets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SignerSets[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 *UnsignedBatchTxsRequest) 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 *UnsignedBatchTxsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *UnsignedBatchTxsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Batches) > 0 {
		for iNdEx := len(m.Batches) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Batches[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 *UnsignedContractCallTxsRequest) 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 *UnsignedContractCallTxsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *UnsignedContractCallTxsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Calls) > 0 {
		for iNdEx := len(m.Calls) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Calls[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 *BatchTxFeesRequest) 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 *BatchTxFeesRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *BatchTxFeesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Fees) > 0 {
		for iNdEx := len(m.Fees) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Fees[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 *ContractCallTxConfirmationsRequest) 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 *ContractCallTxConfirmationsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *DenomToERC20ParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Erc20Decimals != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Erc20Decimals))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Erc20Symbol) > 0 {
		i -= len(m.Erc20Symbol)
		copy(dAtA[i:], m.Erc20Symbol)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Erc20Symbol)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Erc20Name) > 0 {
		i -= len(m.Erc20Name)
		copy(dAtA[i:], m.Erc20Name)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Erc20Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.BaseDenom) > 0 {
		i -= len(m.BaseDenom)
		copy(dAtA[i:], m.BaseDenom)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.BaseDenom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *DelegateKeysResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DelegateKeys) > 0 {
		for iNdEx := len(m.DelegateKeys) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DelegateKeys[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 *BatchedSendToEthereumsRequest) 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 *BatchedSendToEthereumsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *BatchedSendToEthereumsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SendToEthereums) > 0 {
		for iNdEx := len(m.SendToEthereums) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SendToEthereums[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 *UnbatchedSendToEthereumsRequest) 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 *UnbatchedSendToEthereumsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *UnbatchedSendToEthereumsResponse) 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.SendToEthereums) > 0 {
		for iNdEx := len(m.SendToEthereums) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SendToEthereums[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 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 *ParamsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *ParamsResponse) 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 *SignerSetTxRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SignerSetNonce != 0 {
		n += 1 + sovQuery(uint64(m.SignerSetNonce))
	}
	return n
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *DenomToERC20ParamsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BaseDenom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.Erc20Name)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.Erc20Symbol)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Erc20Decimals != 0 {
		n += 1 + sovQuery(uint64(m.Erc20Decimals))
	}
	return n
}

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

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

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

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

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

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

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

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

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

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

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

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

func (m *UnbatchedSendToEthereumsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SenderAddress)
	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 *UnbatchedSendToEthereumsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.SendToEthereums) > 0 {
		for _, e := range m.SendToEthereums {
			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 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 *ParamsRequest) 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: ParamsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ParamsRequest: 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 *ParamsResponse) 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: ParamsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ParamsResponse: 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 *SignerSetTxRequest) 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: SignerSetTxRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignerSetTxRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignerSetNonce", wireType)
			}
			m.SignerSetNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SignerSetNonce |= 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 *LatestSignerSetTxRequest) 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: LatestSignerSetTxRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LatestSignerSetTxRequest: 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 *SignerSetTxResponse) 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: SignerSetTxResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignerSetTxResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignerSet", 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.SignerSet == nil {
				m.SignerSet = &SignerSetTx{}
			}
			if err := m.SignerSet.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 *BatchTxRequest) 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: BatchTxRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchTxRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenContract", 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.TokenContract = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BatchNonce", wireType)
			}
			m.BatchNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BatchNonce |= 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 *BatchTxResponse) 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: BatchTxResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchTxResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Batch", 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.Batch == nil {
				m.Batch = &BatchTx{}
			}
			if err := m.Batch.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 *ContractCallTxRequest) 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: ContractCallTxRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContractCallTxRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InvalidationScope", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InvalidationScope = append(m.InvalidationScope[:0], dAtA[iNdEx:postIndex]...)
			if m.InvalidationScope == nil {
				m.InvalidationScope = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InvalidationNonce", wireType)
			}
			m.InvalidationNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InvalidationNonce |= 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 *ContractCallTxResponse) 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: ContractCallTxResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContractCallTxResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogicCall", 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.LogicCall == nil {
				m.LogicCall = &ContractCallTx{}
			}
			if err := m.LogicCall.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 *SignerSetTxConfirmationsRequest) 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: SignerSetTxConfirmationsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignerSetTxConfirmationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignerSetNonce", wireType)
			}
			m.SignerSetNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SignerSetNonce |= 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 *SignerSetTxConfirmationsResponse) 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: SignerSetTxConfirmationsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignerSetTxConfirmationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Signatures = append(m.Signatures, &SignerSetTxConfirmation{})
			if err := m.Signatures[len(m.Signatures)-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 *SignerSetTxsRequest) 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: SignerSetTxsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignerSetTxsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageRequest{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ContractCallTxsResponse) 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: ContractCallTxsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContractCallTxsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Calls", 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.Calls = append(m.Calls, &ContractCallTx{})
			if err := m.Calls[len(m.Calls)-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 *UnsignedSignerSetTxsRequest) 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: UnsignedSignerSetTxsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnsignedSignerSetTxsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *UnsignedSignerSetTxsResponse) 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: UnsignedSignerSetTxsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnsignedSignerSetTxsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignerSets", 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.SignerSets = append(m.SignerSets, &SignerSetTx{})
			if err := m.SignerSets[len(m.SignerSets)-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 *UnsignedBatchTxsRequest) 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: UnsignedBatchTxsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnsignedBatchTxsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *UnsignedBatchTxsResponse) 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: UnsignedBatchTxsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnsignedBatchTxsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Batches", 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.Batches = append(m.Batches, &BatchTx{})
			if err := m.Batches[len(m.Batches)-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 *UnsignedContractCallTxsRequest) 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: UnsignedContractCallTxsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnsignedContractCallTxsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *UnsignedContractCallTxsResponse) 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: UnsignedContractCallTxsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnsignedContractCallTxsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Calls", 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.Calls = append(m.Calls, &ContractCallTx{})
			if err := m.Calls[len(m.Calls)-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 *BatchTxFeesRequest) 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: BatchTxFeesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchTxFeesRequest: 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 *BatchTxFeesResponse) 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: BatchTxFeesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchTxFeesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fees", 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.Fees = append(m.Fees, types.Coin{})
			if err := m.Fees[len(m.Fees)-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 *ContractCallTxConfirmationsRequest) 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: ContractCallTxConfirmationsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContractCallTxConfirmationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InvalidationScope", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InvalidationScope = append(m.InvalidationScope[:0], dAtA[iNdEx:postIndex]...)
			if m.InvalidationScope == nil {
				m.InvalidationScope = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InvalidationNonce", wireType)
			}
			m.InvalidationNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InvalidationNonce |= 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 *ContractCallTxConfirmationsResponse) 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: ContractCallTxConfirmationsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContractCallTxConfirmationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Signatures = append(m.Signatures, &ContractCallTxConfirmation{})
			if err := m.Signatures[len(m.Signatures)-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 *BatchTxConfirmationsRequest) 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: BatchTxConfirmationsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchTxConfirmationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BatchNonce", wireType)
			}
			m.BatchNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BatchNonce |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenContract", 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.TokenContract = 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 *BatchTxConfirmationsResponse) 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: BatchTxConfirmationsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchTxConfirmationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Signatures = append(m.Signatures, &BatchTxConfirmation{})
			if err := m.Signatures[len(m.Signatures)-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 *LastSubmittedEthereumEventRequest) 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: LastSubmittedEthereumEventRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LastSubmittedEthereumEventRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *LastSubmittedEthereumEventResponse) 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: LastSubmittedEthereumEventResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LastSubmittedEthereumEventResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventNonce", wireType)
			}
			m.EventNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EventNonce |= 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 *ERC20ToDenomRequest) 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: ERC20ToDenomRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ERC20ToDenomRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Erc20", 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.Erc20 = 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 *ERC20ToDenomResponse) 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: ERC20ToDenomResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ERC20ToDenomResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", 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.Denom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CosmosOriginated", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CosmosOriginated = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DenomToERC20ParamsRequest) 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: DenomToERC20ParamsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DenomToERC20ParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", 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.Denom = 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 *DenomToERC20ParamsResponse) 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: DenomToERC20ParamsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DenomToERC20ParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BaseDenom", 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.BaseDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Erc20Name", 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.Erc20Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Erc20Symbol", 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.Erc20Symbol = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Erc20Decimals", wireType)
			}
			m.Erc20Decimals = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Erc20Decimals |= 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 *DenomToERC20Request) 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: DenomToERC20Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DenomToERC20Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", 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.Denom = 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 *DenomToERC20Response) 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: DenomToERC20Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DenomToERC20Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Erc20", 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.Erc20 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CosmosOriginated", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CosmosOriginated = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DelegateKeysByValidatorRequest) 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: DelegateKeysByValidatorRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateKeysByValidatorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", 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.ValidatorAddress = 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 *DelegateKeysByValidatorResponse) 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: DelegateKeysByValidatorResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateKeysByValidatorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EthAddress", 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.EthAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrchestratorAddress", 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.OrchestratorAddress = 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 *DelegateKeysByEthereumSignerRequest) 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: DelegateKeysByEthereumSignerRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateKeysByEthereumSignerRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EthereumSigner", 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.EthereumSigner = 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 *DelegateKeysByEthereumSignerResponse) 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: DelegateKeysByEthereumSignerResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateKeysByEthereumSignerResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", 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.ValidatorAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrchestratorAddress", 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.OrchestratorAddress = 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 *DelegateKeysByOrchestratorRequest) 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: DelegateKeysByOrchestratorRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateKeysByOrchestratorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrchestratorAddress", 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.OrchestratorAddress = 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 *DelegateKeysByOrchestratorResponse) 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: DelegateKeysByOrchestratorResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateKeysByOrchestratorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", 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.ValidatorAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EthereumSigner", 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.EthereumSigner = 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 *DelegateKeysRequest) 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: DelegateKeysRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateKeysRequest: 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 *DelegateKeysResponse) 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: DelegateKeysResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateKeysResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegateKeys", 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.DelegateKeys = append(m.DelegateKeys, &MsgDelegateKeys{})
			if err := m.DelegateKeys[len(m.DelegateKeys)-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 *BatchedSendToEthereumsRequest) 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: BatchedSendToEthereumsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchedSendToEthereumsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SenderAddress", 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.SenderAddress = 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 *BatchedSendToEthereumsResponse) 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: BatchedSendToEthereumsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchedSendToEthereumsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SendToEthereums", 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.SendToEthereums = append(m.SendToEthereums, &SendToEthereum{})
			if err := m.SendToEthereums[len(m.SendToEthereums)-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 *UnbatchedSendToEthereumsRequest) 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: UnbatchedSendToEthereumsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnbatchedSendToEthereumsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SenderAddress", 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.SenderAddress = 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 *UnbatchedSendToEthereumsResponse) 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: UnbatchedSendToEthereumsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnbatchedSendToEthereumsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SendToEthereums", 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.SendToEthereums = append(m.SendToEthereums, &SendToEthereum{})
			if err := m.SendToEthereums[len(m.SendToEthereums)-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 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")
)
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: gravity/v1migration/query.proto

package types

import (
	context "context"
	fmt "fmt"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types "github.com/cosmos/cosmos-sdk/types"
	query "github.com/cosmos/cosmos-sdk/types/query"
	_ "github.com/gogo/protobuf/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/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

//  rpc Params
type ParamsRequest struct {
}

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

var xxx_messageInfo_ParamsRequest proto.InternalMessageInfo

type ParamsResponse struct {
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
}

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

var xxx_messageInfo_ParamsResponse proto.InternalMessageInfo

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

//  rpc SignerSetTx
type SignerSetTxRequest struct {
	SignerSetNonce uint64 `protobuf:"varint,1,opt,name=signer_set_nonce,json=signerSetNonce,proto3" json:"signer_set_nonce,omitempty"`
}

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

var xxx_messageInfo_SignerSetTxRequest proto.InternalMessageInfo

func (m *SignerSetTxRequest) GetSignerSetNonce() uint64 {
	if m != nil {
		return m.SignerSetNonce
	}
	return 0
}

type LatestSignerSetTxRequest struct {
}

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

var xxx_messageInfo_LatestSignerSetTxRequest proto.InternalMessageInfo

type SignerSetTxResponse struct {
	SignerSet *SignerSetTx `protobuf:"bytes,1,opt,name=signer_set,json=signerSet,proto3" json:"signer_set,omitempty"`
}

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

var xxx_messageInfo_SignerSetTxResponse proto.InternalMessageInfo

func (m *SignerSetTxResponse) GetSignerSet() *SignerSetTx {
	if m != nil {
		return m.SignerSet
	}
	return nil
}

//  rpc BatchTx
type BatchTxRequest struct {
	TokenContract string `protobuf:"bytes,1,opt,name=token_contract,json=tokenContract,proto3" json:"token_contract,omitempty"`
	BatchNonce    uint64 `protobuf:"varint,2,opt,name=batch_nonce,json=batchNonce,proto3" json:"batch_nonce,omitempty"`
}

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

var xxx_messageInfo_BatchTxRequest proto.InternalMessageInfo

func (m *BatchTxRequest) GetTokenContract() string {
	if m != nil {
		return m.TokenContract
	}
	return ""
}

func (m *BatchTxRequest) GetBatchNonce() uint64 {
	if m != nil {
		return m.BatchNonce
	}
	return 0
}

type BatchTxResponse struct {
	Batch *BatchTx `protobuf:"bytes,1,opt,name=batch,proto3" json:"batch,omitempty"`
}

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

var xxx_messageInfo_BatchTxResponse proto.InternalMessageInfo

func (m *BatchTxResponse) GetBatch() *BatchTx {
	if m != nil {
		return m.Batch
	}
	return nil
}

//  rpc ContractCallTx
type ContractCallTxRequest struct {
	InvalidationScope []byte `protobuf:"bytes,1,opt,name=invalidation_scope,json=invalidationScope,proto3" json:"invalidation_scope,omitempty"`
	InvalidationNonce uint64 `protobuf:"varint,2,opt,name=invalidation_nonce,json=invalidationNonce,proto3" json:"invalidation_nonce,omitempty"`
}

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

var xxx_messageInfo_ContractCallTxRequest proto.InternalMessageInfo

func (m *ContractCallTxRequest) GetInvalidationScope() []byte {
	if m != nil {
		return m.InvalidationScope
	}
	return nil
}

func (m *ContractCallTxRequest) GetInvalidationNonce() uint64 {
	if m != nil {
		return m.InvalidationNonce
	}
	return 0
}

type ContractCallTxResponse struct {
	LogicCall *ContractCallTx `protobuf:"bytes,1,opt,name=logic_call,json=logicCall,proto3" json:"logic_call,omitempty"`
}

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

var xxx_messageInfo_ContractCallTxResponse proto.InternalMessageInfo

func (m *ContractCallTxResponse) GetLogicCall() *ContractCallTx {
	if m != nil {
		return m.LogicCall
	}
	return nil
}

// rpc SignerSetTxConfirmations
type SignerSetTxConfirmationsRequest struct {
	SignerSetNonce uint64 `protobuf:"varint,1,opt,name=signer_set_nonce,json=signerSetNonce,proto3" json:"signer_set_nonce,omitempty"`
}

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

var xxx_messageInfo_SignerSetTxConfirmationsRequest proto.InternalMessageInfo

func (m *SignerSetTxConfirmationsRequest) GetSignerSetNonce() uint64 {
	if m != nil {
		return m.SignerSetNonce
	}
	return 0
}

type SignerSetTxConfirmationsResponse struct {
	Signatures []*SignerSetTxConfirmation `protobuf:"bytes,1,rep,name=signatures,proto3" json:"signatures,omitempty"`
}

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

var xxx_messageInfo_SignerSetTxConfirmationsResponse proto.InternalMessageInfo

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

//  rpc SignerSetTxs
type SignerSetTxsRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_SignerSetTxsRequest proto.InternalMessageInfo

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

type SignerSetTxsResponse struct {
	SignerSets []*SignerSetTx      `protobuf:"bytes,1,rep,name=signer_sets,json=signerSets,proto3" json:"signer_sets,omitempty"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_SignerSetTxsResponse proto.InternalMessageInfo

func (m *SignerSetTxsResponse) GetSignerSets() []*SignerSetTx {
	if m != nil {
		return m.SignerSets
	}
	return nil
}

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

//  rpc BatchTxs
type BatchTxsRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_BatchTxsRequest proto.InternalMessageInfo

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

type BatchTxsResponse struct {
	Batches    []*BatchTx          `protobuf:"bytes,1,rep,name=batches,proto3" json:"batches,omitempty"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_BatchTxsResponse proto.InternalMessageInfo

func (m *BatchTxsResponse) GetBatches() []*BatchTx {
	if m != nil {
		return m.Batches
	}
	return nil
}

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

//  rpc ContractCallTxs
type ContractCallTxsRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_ContractCallTxsRequest proto.InternalMessageInfo

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

type ContractCallTxsResponse struct {
	Calls      []*ContractCallTx   `protobuf:"bytes,1,rep,name=calls,proto3" json:"calls,omitempty"`
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_ContractCallTxsResponse proto.InternalMessageInfo

func (m *ContractCallTxsResponse) GetCalls() []*ContractCallTx {
	if m != nil {
		return m.Calls
	}
	return nil
}

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

// rpc UnsignedSignerSetTxs
type UnsignedSignerSetTxsRequest struct {
	// NOTE: this is an sdk.AccAddress and can represent either the
	// orchestrator address or the corresponding validator address
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_UnsignedSignerSetTxsRequest proto.InternalMessageInfo

func (m *UnsignedSignerSetTxsRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type UnsignedSignerSetTxsResponse struct {
	SignerSets []*SignerSetTx `protobuf:"bytes,1,rep,name=signer_sets,json=signerSets,proto3" json:"signer_sets,omitempty"`
}

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

var xxx_messageInfo_UnsignedSignerSetTxsResponse proto.InternalMessageInfo

func (m *UnsignedSignerSetTxsResponse) GetSignerSets() []*SignerSetTx {
	if m != nil {
		return m.SignerSets
	}
	return nil
}

type UnsignedBatchTxsRequest struct {
	// NOTE: this is an sdk.AccAddress and can represent either the
	// orchestrator address or the corresponding validator address
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_UnsignedBatchTxsRequest proto.InternalMessageInfo

func (m *UnsignedBatchTxsRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type UnsignedBatchTxsResponse struct {
	// Note these are returned with the signature empty
	Batches []*BatchTx `protobuf:"bytes,1,rep,name=batches,proto3" json:"batches,omitempty"`
}

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

var xxx_messageInfo_UnsignedBatchTxsResponse proto.InternalMessageInfo

func (m *UnsignedBatchTxsResponse) GetBatches() []*BatchTx {
	if m != nil {
		return m.Batches
	}
	return nil
}

//  rpc UnsignedContractCallTxs
type UnsignedContractCallTxsRequest struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_UnsignedContractCallTxsRequest proto.InternalMessageInfo

func (m *UnsignedContractCallTxsRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type UnsignedContractCallTxsResponse struct {
	Calls []*ContractCallTx `protobuf:"bytes,1,rep,name=calls,proto3" json:"calls,omitempty"`
}

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

var xxx_messageInfo_UnsignedContractCallTxsResponse proto.InternalMessageInfo

func (m *UnsignedContractCallTxsResponse) GetCalls() []*ContractCallTx {
	if m != nil {
		return m.Calls
	}
	return nil
}

type BatchTxFeesRequest struct {
}

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

var xxx_messageInfo_BatchTxFeesRequest proto.InternalMessageInfo

type BatchTxFeesResponse struct {
	Fees github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,1,rep,name=fees,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"fees"`
}

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

var xxx_messageInfo_BatchTxFeesResponse proto.InternalMessageInfo

func (m *BatchTxFeesResponse) GetFees() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.Fees
	}
	return nil
}

type ContractCallTxConfirmationsRequest struct {
	InvalidationScope []byte `protobuf:"bytes,1,opt,name=invalidation_scope,json=invalidationScope,proto3" json:"invalidation_scope,omitempty"`
	InvalidationNonce uint64 `protobuf:"varint,2,opt,name=invalidation_nonce,json=invalidationNonce,proto3" json:"invalidation_nonce,omitempty"`
}

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

var xxx_messageInfo_ContractCallTxConfirmationsRequest proto.InternalMessageInfo

func (m *ContractCallTxConfirmationsRequest) GetInvalidationScope() []byte {
	if m != nil {
		return m.InvalidationScope
	}
	return nil
}

func (m *ContractCallTxConfirmationsRequest) GetInvalidationNonce() uint64 {
	if m != nil {
		return m.InvalidationNonce
	}
	return 0
}

type ContractCallTxConfirmationsResponse struct {
	Signatures []*ContractCallTxConfirmation `protobuf:"bytes,1,rep,name=signatures,proto3" json:"signatures,omitempty"`
}

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

var xxx_messageInfo_ContractCallTxConfirmationsResponse proto.InternalMessageInfo

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

type BatchTxConfirmationsRequest struct {
	BatchNonce    uint64 `protobuf:"varint,1,opt,name=batch_nonce,json=batchNonce,proto3" json:"batch_nonce,omitempty"`
	TokenContract string `protobuf:"bytes,2,opt,name=token_contract,json=tokenContract,proto3" json:"token_contract,omitempty"`
}

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

var xxx_messageInfo_BatchTxConfirmationsRequest proto.InternalMessageInfo

func (m *BatchTxConfirmationsRequest) GetBatchNonce() uint64 {
	if m != nil {
		return m.BatchNonce
	}
	return 0
}

func (m *BatchTxConfirmationsRequest) GetTokenContract() string {
	if m != nil {
		return m.TokenContract
	}
	return ""
}

type BatchTxConfirmationsResponse struct {
	Signatures []*BatchTxConfirmation `protobuf:"bytes,1,rep,name=signatures,proto3" json:"signatures,omitempty"`
}

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

var xxx_messageInfo_BatchTxConfirmationsResponse proto.InternalMessageInfo

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

type LastSubmittedEthereumEventRequest struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_LastSubmittedEthereumEventRequest proto.InternalMessageInfo

func (m *LastSubmittedEthereumEventRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type LastSubmittedEthereumEventResponse struct {
	EventNonce uint64 `protobuf:"varint,1,opt,name=event_nonce,json=eventNonce,proto3" json:"event_nonce,omitempty"`
}

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

var xxx_messageInfo_LastSubmittedEthereumEventResponse proto.InternalMessageInfo

func (m *LastSubmittedEthereumEventResponse) GetEventNonce() uint64 {
	if m != nil {
		return m.EventNonce
	}
	return 0
}

type ERC20ToDenomRequest struct {
	Erc20 string `protobuf:"bytes,1,opt,name=erc20,proto3" json:"erc20,omitempty"`
}

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

var xxx_messageInfo_ERC20ToDenomRequest proto.InternalMessageInfo

func (m *ERC20ToDenomRequest) GetErc20() string {
	if m != nil {
		return m.Erc20
	}
	return ""
}

type ERC20ToDenomResponse struct {
	Denom            string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
	CosmosOriginated bool   `protobuf:"varint,2,opt,name=cosmos_originated,json=cosmosOriginated,proto3" json:"cosmos_originated,omitempty"`
}

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

var xxx_messageInfo_ERC20ToDenomResponse proto.InternalMessageInfo

func (m *ERC20ToDenomResponse) GetDenom() string {
	if m != nil {
		return m.Denom
	}
	return ""
}

func (m *ERC20ToDenomResponse) GetCosmosOriginated() bool {
	if m != nil {
		return m.CosmosOriginated
	}
	return false
}

type DenomToERC20ParamsRequest struct {
	Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
}

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

var xxx_messageInfo_DenomToERC20ParamsRequest proto.InternalMessageInfo

func (m *DenomToERC20ParamsRequest) GetDenom() string {
	if m != nil {
		return m.Denom
	}
	return ""
}

type DenomToERC20ParamsResponse struct {
	BaseDenom     string `protobuf:"bytes,1,opt,name=base_denom,json=baseDenom,proto3" json:"base_denom,omitempty"`
	Erc20Name     string `protobuf:"bytes,2,opt,name=erc20_name,json=erc20Name,proto3" json:"erc20_name,omitempty"`
	Erc20Symbol   string `protobuf:"bytes,3,opt,name=erc20_symbol,json=erc20Symbol,proto3" json:"erc20_symbol,omitempty"`
	Erc20Decimals uint64 `protobuf:"varint,4,opt,name=erc20_decimals,json=erc20Decimals,proto3" json:"erc20_decimals,omitempty"`
}

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

var xxx_messageInfo_DenomToERC20ParamsResponse proto.InternalMessageInfo

func (m *DenomToERC20ParamsResponse) GetBaseDenom() string {
	if m != nil {
		return m.BaseDenom
	}
	return ""
}

func (m *DenomToERC20ParamsResponse) GetErc20Name() string {
	if m != nil {
		return m.Erc20Name
	}
	return ""
}

func (m *DenomToERC20ParamsResponse) GetErc20Symbol() string {
	if m != nil {
		return m.Erc20Symbol
	}
	return ""
}

func (m *DenomToERC20ParamsResponse) GetErc20Decimals() uint64 {
	if m != nil {
		return m.Erc20Decimals
	}
	return 0
}

type DenomToERC20Request struct {
	Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
}

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

var xxx_messageInfo_DenomToERC20Request proto.InternalMessageInfo

func (m *DenomToERC20Request) GetDenom() string {
	if m != nil {
		return m.Denom
	}
	return ""
}

type DenomToERC20Response struct {
	Erc20            string `protobuf:"bytes,1,opt,name=erc20,proto3" json:"erc20,omitempty"`
	CosmosOriginated bool   `protobuf:"varint,2,opt,name=cosmos_originated,json=cosmosOriginated,proto3" json:"cosmos_originated,omitempty"`
}

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

var xxx_messageInfo_DenomToERC20Response proto.InternalMessageInfo

func (m *DenomToERC20Response) GetErc20() string {
	if m != nil {
		return m.Erc20
	}
	return ""
}

func (m *DenomToERC20Response) GetCosmosOriginated() bool {
	if m != nil {
		return m.CosmosOriginated
	}
	return false
}

type DelegateKeysByValidatorRequest struct {
	ValidatorAddress string `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
}

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

var xxx_messageInfo_DelegateKeysByValidatorRequest proto.InternalMessageInfo

func (m *DelegateKeysByValidatorRequest) GetValidatorAddress() string {
	if m != nil {
		return m.ValidatorAddress
	}
	return ""
}

type DelegateKeysByValidatorResponse struct {
	EthAddress          string `protobuf:"bytes,1,opt,name=eth_address,json=ethAddress,proto3" json:"eth_address,omitempty"`
	OrchestratorAddress string `protobuf:"bytes,2,opt,name=orchestrator_address,json=orchestratorAddress,proto3" json:"orchestrator_address,omitempty"`
}

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

var xxx_messageInfo_DelegateKeysByValidatorResponse proto.InternalMessageInfo

func (m *DelegateKeysByValidatorResponse) GetEthAddress() string {
	if m != nil {
		return m.EthAddress
	}
	return ""
}

func (m *DelegateKeysByValidatorResponse) GetOrchestratorAddress() string {
	if m != nil {
		return m.OrchestratorAddress
	}
	return ""
}

type DelegateKeysByEthereumSignerRequest struct {
	EthereumSigner string `protobuf:"bytes,1,opt,name=ethereum_signer,json=ethereumSigner,proto3" json:"ethereum_signer,omitempty"`
}

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

var xxx_messageInfo_DelegateKeysByEthereumSignerRequest proto.InternalMessageInfo

func (m *DelegateKeysByEthereumSignerRequest) GetEthereumSigner() string {
	if m != nil {
		return m.EthereumSigner
	}
	return ""
}

type DelegateKeysByEthereumSignerResponse struct {
	ValidatorAddress    string `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
	OrchestratorAddress string `protobuf:"bytes,2,opt,name=orchestrator_address,json=orchestratorAddress,proto3" json:"orchestrator_address,omitempty"`
}

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

var xxx_messageInfo_DelegateKeysByEthereumSignerResponse proto.InternalMessageInfo

func (m *DelegateKeysByEthereumSignerResponse) GetValidatorAddress() string {
	if m != nil {
		return m.ValidatorAddress
	}
	return ""
}

func (m *DelegateKeysByEthereumSignerResponse) GetOrchestratorAddress() string {
	if m != nil {
		return m.OrchestratorAddress
	}
	return ""
}

type DelegateKeysByOrchestratorRequest struct {
	OrchestratorAddress string `protobuf:"bytes,1,opt,name=orchestrator_address,json=orchestratorAddress,proto3" json:"orchestrator_address,omitempty"`
}

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

var xxx_messageInfo_DelegateKeysByOrchestratorRequest proto.InternalMessageInfo

func (m *DelegateKeysByOrchestratorRequest) GetOrchestratorAddress() string {
	if m != nil {
		return m.OrchestratorAddress
	}
	return ""
}

type DelegateKeysByOrchestratorResponse struct {
	ValidatorAddress string `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
	EthereumSigner   string `protobuf:"bytes,2,opt,name=ethereum_signer,json=ethereumSigner,proto3" json:"ethereum_signer,omitempty"`
}

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

var xxx_messageInfo_DelegateKeysByOrchestratorResponse proto.InternalMessageInfo

func (m *DelegateKeysByOrchestratorResponse) GetValidatorAddress() string {
	if m != nil {
		return m.ValidatorAddress
	}
	return ""
}

func (m *DelegateKeysByOrchestratorResponse) GetEthereumSigner() string {
	if m != nil {
		return m.EthereumSigner
	}
	return ""
}

type DelegateKeysRequest struct {
}

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

var xxx_messageInfo_DelegateKeysRequest proto.InternalMessageInfo

type DelegateKeysResponse struct {
	DelegateKeys []*MsgDelegateKeys `protobuf:"bytes,1,rep,name=delegate_keys,json=delegateKeys,proto3" json:"delegate_keys,omitempty"`
}

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

var xxx_messageInfo_DelegateKeysResponse proto.InternalMessageInfo

func (m *DelegateKeysResponse) GetDelegateKeys() []*MsgDelegateKeys {
	if m != nil {
		return m.DelegateKeys
	}
	return nil
}

// NOTE: if there is no sender address, return all
type BatchedSendToEthereumsRequest struct {
	SenderAddress string `protobuf:"bytes,1,opt,name=sender_address,json=senderAddress,proto3" json:"sender_address,omitempty"`
}

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

var xxx_messageInfo_BatchedSendToEthereumsRequest proto.InternalMessageInfo

func (m *BatchedSendToEthereumsRequest) GetSenderAddress() string {
	if m != nil {
		return m.SenderAddress
	}
	return ""
}

type BatchedSendToEthereumsResponse struct {
	SendToEthereums []*SendToEthereum `protobuf:"bytes,1,rep,name=send_to_ethereums,json=sendToEthereums,proto3" json:"send_to_ethereums,omitempty"`
}

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

var xxx_messageInfo_BatchedSendToEthereumsResponse proto.InternalMessageInfo

func (m *BatchedSendToEthereumsResponse) GetSendToEthereums() []*SendToEthereum {
	if m != nil {
		return m.SendToEthereums
	}
	return nil
}

type UnbatchedSendToEthereumsRequest struct {
	SenderAddress string             `protobuf:"bytes,1,opt,name=sender_address,json=senderAddress,proto3" json:"sender_address,omitempty"`
	Pagination    *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_UnbatchedSendToEthereumsRequest proto.InternalMessageInfo

func (m *UnbatchedSendToEthereumsRequest) GetSenderAddress() string {
	if m != nil {
		return m.SenderAddress
	}
	return ""
}

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

type UnbatchedSendToEthereumsResponse struct {
	SendToEthereums []*SendToEthereum   `protobuf:"bytes,1,rep,name=send_to_ethereums,json=sendToEthereums,proto3" json:"send_to_ethereums,omitempty"`
	Pagination      *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_UnbatchedSendToEthereumsResponse proto.InternalMessageInfo

func (m *UnbatchedSendToEthereumsResponse) GetSendToEthereums() []*SendToEthereum {
	if m != nil {
		return m.SendToEthereums
	}
	return nil
}

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

func init() {
	proto.RegisterType((*ParamsRequest)(nil), "gravity.v1migration.ParamsRequest")
	proto.RegisterType((*ParamsResponse)(nil), "gravity.v1migration.ParamsResponse")
	proto.RegisterType((*SignerSetTxRequest)(nil), "gravity.v1migration.SignerSetTxRequest")
	proto.RegisterType((*LatestSignerSetTxRequest)(nil), "gravity.v1migration.LatestSignerSetTxRequest")
	proto.RegisterType((*SignerSetTxResponse)(nil), "gravity.v1migration.SignerSetTxResponse")
	proto.RegisterType((*BatchTxRequest)(nil), "gravity.v1migration.BatchTxRequest")
	proto.RegisterType((*BatchTxResponse)(nil), "gravity.v1migration.BatchTxResponse")
	proto.RegisterType((*ContractCallTxRequest)(nil), "gravity.v1migration.ContractCallTxRequest")
	proto.RegisterType((*ContractCallTxResponse)(nil), "gravity.v1migration.ContractCallTxResponse")
	proto.RegisterType((*SignerSetTxConfirmationsRequest)(nil), "gravity.v1migration.SignerSetTxConfirmationsRequest")
	proto.RegisterType((*SignerSetTxConfirmationsResponse)(nil), "gravity.v1migration.SignerSetTxConfirmationsResponse")
	proto.RegisterType((*SignerSetTxsRequest)(nil), "gravity.v1migration.SignerSetTxsRequest")
	proto.RegisterType((*SignerSetTxsResponse)(nil), "gravity.v1migration.SignerSetTxsResponse")
	proto.RegisterType((*BatchTxsRequest)(nil), "gravity.v1migration.BatchTxsRequest")
	proto.RegisterType((*BatchTxsResponse)(nil), "gravity.v1migration.BatchTxsResponse")
	proto.RegisterType((*ContractCallTxsRequest)(nil), "gravity.v1migration.ContractCallTxsRequest")
	proto.RegisterType((*ContractCallTxsResponse)(nil), "gravity.v1migration.ContractCallTxsResponse")
	proto.RegisterType((*UnsignedSignerSetTxsRequest)(nil), "gravity.v1migration.UnsignedSignerSetTxsRequest")
	proto.RegisterType((*UnsignedSignerSetTxsResponse)(nil), "gravity.v1migration.UnsignedSignerSetTxsResponse")
	proto.RegisterType((*UnsignedBatchTxsRequest)(nil), "gravity.v1migration.UnsignedBatchTxsRequest")
	proto.RegisterType((*UnsignedBatchTxsResponse)(nil), "gravity.v1migration.UnsignedBatchTxsResponse")
	proto.RegisterType((*UnsignedContractCallTxsRequest)(nil), "gravity.v1migration.UnsignedContractCallTxsRequest")
	proto.RegisterType((*UnsignedContractCallTxsResponse)(nil), "gravity.v1migration.UnsignedContractCallTxsResponse")
	proto.RegisterType((*BatchTxFeesRequest)(nil), "gravity.v1migration.BatchTxFeesRequest")
	proto.RegisterType((*BatchTxFeesResponse)(nil), "gravity.v1migration.BatchTxFeesResponse")
	proto.RegisterType((*ContractCallTxConfirmationsRequest)(nil), "gravity.v1migration.ContractCallTxConfirmationsRequest")
	proto.RegisterType((*ContractCallTxConfirmationsResponse)(nil), "gravity.v1migration.ContractCallTxConfirmationsResponse")
	proto.RegisterType((*BatchTxConfirmationsRequest)(nil), "gravity.v1migration.BatchTxConfirmationsRequest")
	proto.RegisterType((*BatchTxConfirmationsResponse)(nil), "gravity.v1migration.BatchTxConfirmationsResponse")
	proto.RegisterType((*LastSubmittedEthereumEventRequest)(nil), "gravity.v1migration.LastSubmittedEthereumEventRequest")
	proto.RegisterType((*LastSubmittedEthereumEventResponse)(nil), "gravity.v1migration.LastSubmittedEthereumEventResponse")
	proto.RegisterType((*ERC20ToDenomRequest)(nil), "gravity.v1migration.ERC20ToDenomRequest")
	proto.RegisterType((*ERC20ToDenomResponse)(nil), "gravity.v1migration.ERC20ToDenomResponse")
	proto.RegisterType((*DenomToERC20ParamsRequest)(nil), "gravity.v1migration.DenomToERC20ParamsRequest")
	proto.RegisterType((*DenomToERC20ParamsResponse)(nil), "gravity.v1migration.DenomToERC20ParamsResponse")
	proto.RegisterType((*DenomToERC20Request)(nil), "gravity.v1migration.DenomToERC20Request")
	proto.RegisterType((*DenomToERC20Response)(nil), "gravity.v1migration.DenomToERC20Response")
	proto.RegisterType((*DelegateKeysByValidatorRequest)(nil), "gravity.v1migration.DelegateKeysByValidatorRequest")
	proto.RegisterType((*DelegateKeysByValidatorResponse)(nil), "gravity.v1migration.DelegateKeysByValidatorResponse")
	proto.RegisterType((*DelegateKeysByEthereumSignerRequest)(nil), "gravity.v1migration.DelegateKeysByEthereumSignerRequest")
	proto.RegisterType((*DelegateKeysByEthereumSignerResponse)(nil), "gravity.v1migration.DelegateKeysByEthereumSignerResponse")
	proto.RegisterType((*DelegateKeysByOrchestratorRequest)(nil), "gravity.v1migration.DelegateKeysByOrchestratorRequest")
	proto.RegisterType((*DelegateKeysByOrchestratorResponse)(nil), "gravity.v1migration.DelegateKeysByOrchestratorResponse")
	proto.RegisterType((*DelegateKeysRequest)(nil), "gravity.v1migration.DelegateKeysRequest")
	proto.RegisterType((*DelegateKeysResponse)(nil), "gravity.v1migration.DelegateKeysResponse")
	proto.RegisterType((*BatchedSendToEthereumsRequest)(nil), "gravity.v1migration.BatchedSendToEthereumsRequest")
	proto.RegisterType((*BatchedSendToEthereumsResponse)(nil), "gravity.v1migration.BatchedSendToEthereumsResponse")
	proto.RegisterType((*UnbatchedSendToEthereumsRequest)(nil), "gravity.v1migration.UnbatchedSendToEthereumsRequest")
	proto.RegisterType((*UnbatchedSendToEthereumsResponse)(nil), "gravity.v1migration.UnbatchedSendToEthereumsResponse")
}

func init() { proto.RegisterFile("gravity/v1migration/query.proto", fileDescriptor_52ac3aa5b09dcaf2) }

var fileDescriptor_52ac3aa5b09dcaf2 = []byte{
	// 1797 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x59, 0x4b, 0x6f, 0xdb, 0xc6,
	0x13, 0x17, 0x1d, 0x3b, 0x89, 0xc7, 0xef, 0xb5, 0x92, 0x38, 0xb2, 0x23, 0xd9, 0xeb, 0xe4, 0x1f,
	0xff, 0xe3, 0x58, 0xb4, 0xe5, 0x34, 0x8f, 0x02, 0x6d, 0x11, 0x3b, 0x4e, 0x1b, 0xe4, 0x59, 0xd9,
	0x35, 0xea, 0x22, 0x85, 0x4a, 0x89, 0x1b, 0x9a, 0xb5, 0x44, 0xca, 0x24, 0xa5, 0x46, 0x05, 0x7a,
	0x69, 0x81, 0x00, 0x3d, 0x35, 0x68, 0xd1, 0x63, 0x2f, 0x45, 0x4f, 0xed, 0x57, 0xe8, 0x07, 0xc8,
	0x31, 0xc7, 0x9e, 0xda, 0x22, 0xf9, 0x22, 0x05, 0x97, 0x4b, 0x8a, 0x94, 0x76, 0x29, 0xc9, 0x51,
	0x4e, 0x36, 0x67, 0x67, 0x7e, 0xf3, 0xd8, 0xd9, 0xd9, 0x99, 0x15, 0x64, 0x34, 0x4b, 0xa9, 0xeb,
	0x4e, 0x43, 0xae, 0xaf, 0x55, 0x74, 0xcd, 0x52, 0x1c, 0xdd, 0x34, 0xe4, 0xc3, 0x1a, 0xb1, 0x1a,
	0xd9, 0xaa, 0x65, 0x3a, 0x26, 0x9a, 0x66, 0x0c, 0xd9, 0x10, 0x43, 0xea, 0x52, 0xc9, 0xb4, 0x2b,
	0xa6, 0x2d, 0x17, 0x15, 0x9b, 0x78, 0xdc, 0x72, 0x7d, 0xad, 0x48, 0x1c, 0x65, 0x4d, 0xae, 0x2a,
	0x9a, 0x6e, 0x50, 0x2e, 0x0f, 0x20, 0x95, 0x0e, 0xf3, 0xfa, 0x5c, 0x25, 0x53, 0xf7, 0xd7, 0x93,
	0x9a, 0xa9, 0x99, 0xf4, 0x5f, 0xd9, 0xfd, 0x8f, 0x51, 0xe7, 0x34, 0xd3, 0xd4, 0xca, 0x44, 0x56,
	0xaa, 0xba, 0xac, 0x18, 0x86, 0xe9, 0x50, 0x48, 0x9b, 0xad, 0x2e, 0xf0, 0xac, 0xd6, 0x88, 0x41,
	0x6c, 0x3d, 0x9e, 0x85, 0xf9, 0xc2, 0x2c, 0xe3, 0xb1, 0x54, 0x6c, 0x8d, 0x41, 0xe0, 0x09, 0x18,
	0x7b, 0xa4, 0x58, 0x4a, 0xc5, 0xce, 0x93, 0xc3, 0x1a, 0xb1, 0x1d, 0x7c, 0x17, 0xc6, 0x7d, 0x82,
	0x5d, 0x35, 0x0d, 0x9b, 0xa0, 0x1b, 0x70, 0xbc, 0x4a, 0x29, 0x33, 0xd2, 0xbc, 0xb4, 0x34, 0x92,
	0x9b, 0xcd, 0x72, 0xc2, 0x95, 0xf5, 0x84, 0x36, 0x06, 0x5f, 0xfc, 0x9d, 0x49, 0xe4, 0x99, 0x00,
	0x7e, 0x1f, 0xd0, 0xb6, 0xae, 0x19, 0xc4, 0xda, 0x26, 0xce, 0xce, 0x53, 0xa6, 0x02, 0x2d, 0xc1,
	0xa4, 0x4d, 0xa9, 0x05, 0x9b, 0x38, 0x05, 0xc3, 0x34, 0x4a, 0x84, 0x42, 0x0f, 0xe6, 0xc7, 0x6d,
	0x9f, 0xfb, 0x81, 0x4b, 0xc5, 0x29, 0x98, 0xb9, 0xa7, 0x38, 0xc4, 0x76, 0xda, 0x51, 0xf0, 0x2e,
	0x4c, 0x47, 0xa8, 0xcc, 0xda, 0x0f, 0x00, 0x9a, 0xe0, 0xcc, 0xe2, 0x79, 0xae, 0xc5, 0x61, 0xe9,
	0xe1, 0x40, 0x31, 0xfe, 0x14, 0xc6, 0x37, 0x14, 0xa7, 0xb4, 0xdf, 0xb4, 0xf7, 0x02, 0x8c, 0x3b,
	0xe6, 0x01, 0x31, 0x0a, 0x25, 0xd3, 0x70, 0x2c, 0xa5, 0xe4, 0xc1, 0x0e, 0xe7, 0xc7, 0x28, 0x75,
	0x93, 0x11, 0x51, 0x06, 0x46, 0x8a, 0xae, 0x20, 0xf3, 0x68, 0x80, 0x7a, 0x04, 0x94, 0xe4, 0x79,
	0xb3, 0x05, 0x13, 0x01, 0x32, 0xb3, 0x36, 0x07, 0x43, 0x94, 0x81, 0x19, 0x3a, 0xc7, 0x35, 0xd4,
	0x17, 0xf2, 0x58, 0x71, 0x0d, 0x4e, 0xf9, 0x3a, 0x37, 0x95, 0x72, 0xb9, 0x69, 0xe7, 0x0a, 0x20,
	0xdd, 0xa8, 0x2b, 0x65, 0x5d, 0xa5, 0x72, 0x05, 0xbb, 0x64, 0x56, 0xbd, 0xc8, 0x8e, 0xe6, 0xa7,
	0xc2, 0x2b, 0xdb, 0xee, 0x42, 0x1b, 0x7b, 0xd8, 0xec, 0x08, 0xbb, 0x67, 0xfd, 0x63, 0x38, 0xdd,
	0xaa, 0x96, 0x39, 0xb1, 0x01, 0x50, 0x36, 0x35, 0xbd, 0x54, 0x28, 0x29, 0xe5, 0x32, 0xf3, 0x64,
	0x91, 0xeb, 0x49, 0x0b, 0xc0, 0x30, 0x15, 0x73, 0x3f, 0xf0, 0x5d, 0xc8, 0x84, 0xf6, 0x63, 0xd3,
	0x34, 0x9e, 0xe8, 0x56, 0xc5, 0x3b, 0x0f, 0xbd, 0xa7, 0x4d, 0x15, 0xe6, 0xc5, 0x60, 0xcc, 0xe8,
	0x7b, 0x5e, 0x9e, 0x28, 0x4e, 0xcd, 0x22, 0x6e, 0x66, 0x1f, 0x5b, 0x1a, 0xc9, 0x5d, 0xee, 0x94,
	0x27, 0x61, 0xa8, 0x7c, 0x48, 0x1e, 0x7f, 0x1e, 0x49, 0xc6, 0xc0, 0xe4, 0xdb, 0x00, 0xcd, 0x5a,
	0xc1, 0x22, 0xf3, 0xbf, 0xac, 0x57, 0x2c, 0xb2, 0x6e, 0xb1, 0xc8, 0x7a, 0x65, 0x88, 0x95, 0x8c,
	0xec, 0x23, 0x45, 0x23, 0x4c, 0x36, 0x1f, 0x92, 0xc4, 0xbf, 0x4a, 0x90, 0x8c, 0xe2, 0x33, 0x2f,
	0x6e, 0xc2, 0x48, 0x33, 0x26, 0xbe, 0x1b, 0x9d, 0xd3, 0x1d, 0x82, 0x80, 0xd9, 0xe8, 0xc3, 0x88,
	0x8d, 0x03, 0xd4, 0xc6, 0x8b, 0x1d, 0x6d, 0xf4, 0xf4, 0x47, 0x8c, 0xdc, 0x0b, 0xd2, 0xbb, 0xef,
	0xfe, 0xff, 0x24, 0xc1, 0x64, 0x13, 0x9b, 0xf9, 0x7e, 0x15, 0x4e, 0xd0, 0x03, 0x11, 0x6c, 0x5f,
	0xfc, 0xe9, 0xf1, 0x99, 0xfb, 0xe7, 0xf0, 0x17, 0xad, 0x27, 0xa2, 0xef, 0x7e, 0xff, 0x22, 0xc1,
	0x99, 0x36, 0x15, 0x41, 0x59, 0x1e, 0x72, 0xcf, 0x9b, 0xef, 0x7c, 0x57, 0x07, 0xce, 0x93, 0xe8,
	0x5f, 0x04, 0xae, 0xc1, 0xec, 0x27, 0x06, 0xcd, 0x25, 0x95, 0x97, 0xfe, 0x33, 0x70, 0x42, 0x51,
	0x55, 0x8b, 0xd8, 0x36, 0xab, 0x98, 0xfe, 0x27, 0x56, 0x60, 0x8e, 0x2f, 0xd8, 0xb7, 0xbc, 0xc6,
	0xeb, 0x70, 0xc6, 0x57, 0xd1, 0x9a, 0x96, 0x62, 0xbb, 0xf2, 0x30, 0xd3, 0x2e, 0xf4, 0x66, 0xf9,
	0x86, 0xdf, 0x85, 0xb4, 0x8f, 0x29, 0x48, 0x17, 0xb1, 0x3d, 0x8f, 0x21, 0x23, 0x94, 0x7d, 0xe3,
	0x3c, 0xc0, 0x49, 0x40, 0xcc, 0xda, 0xdb, 0x84, 0x04, 0x1d, 0x40, 0x1d, 0xa6, 0x23, 0x54, 0xa6,
	0xa7, 0x00, 0x83, 0x4f, 0x48, 0xe0, 0xfb, 0xd9, 0x48, 0xba, 0xf8, 0x89, 0xb2, 0x69, 0xea, 0xc6,
	0xc6, 0xaa, 0xdb, 0x02, 0xfc, 0xfe, 0x4f, 0x66, 0x49, 0xd3, 0x9d, 0xfd, 0x5a, 0x31, 0x5b, 0x32,
	0x2b, 0x32, 0xeb, 0x8f, 0xbc, 0x3f, 0x2b, 0xb6, 0x7a, 0x20, 0x3b, 0x8d, 0x2a, 0xb1, 0xa9, 0x80,
	0x9d, 0xa7, 0xc0, 0xf8, 0x5b, 0x09, 0x70, 0xd4, 0x4e, 0xee, 0x35, 0xf0, 0x76, 0x6f, 0xb9, 0x3a,
	0x2c, 0xc6, 0xda, 0xc0, 0x82, 0xf1, 0x90, 0x73, 0x7b, 0xc8, 0x5d, 0x44, 0x5e, 0x78, 0x81, 0x10,
	0x98, 0x65, 0x41, 0xe7, 0x3a, 0xdd, 0xd2, 0x5b, 0x48, 0xad, 0xbd, 0x05, 0xa7, 0x47, 0x19, 0xe0,
	0xf4, 0x28, 0x78, 0x1f, 0xe6, 0xf8, 0x6a, 0x98, 0x5f, 0x1f, 0x71, 0xfc, 0x5a, 0x8a, 0x4b, 0x73,
	0xa1, 0x43, 0xef, 0xc1, 0xc2, 0x3d, 0xc5, 0x76, 0xb6, 0x6b, 0xc5, 0x8a, 0xee, 0x38, 0x44, 0xdd,
	0x72, 0xf6, 0x89, 0x45, 0x6a, 0x95, 0xad, 0x3a, 0x31, 0x9c, 0xce, 0x89, 0xbf, 0x05, 0x38, 0x4e,
	0x9c, 0x99, 0x9b, 0x81, 0x11, 0xe2, 0x12, 0xa2, 0x61, 0xa1, 0x24, 0x6f, 0x3b, 0x97, 0x61, 0x7a,
	0x2b, 0xbf, 0x99, 0x5b, 0xdd, 0x31, 0x6f, 0x11, 0xc3, 0xac, 0xf8, 0x7a, 0x93, 0x30, 0x44, 0xac,
	0x52, 0x6e, 0x95, 0x69, 0xf5, 0x3e, 0xf0, 0x1e, 0x24, 0xa3, 0xcc, 0x4c, 0x4b, 0x12, 0x86, 0x54,
	0x97, 0xe0, 0x73, 0xd3, 0x0f, 0xb4, 0x0c, 0x53, 0x5e, 0x3a, 0x17, 0x4c, 0x4b, 0xa7, 0x15, 0x91,
	0xa8, 0x34, 0xe8, 0x27, 0xf3, 0x93, 0xde, 0xc2, 0xc3, 0x80, 0x8e, 0xd7, 0xe0, 0x2c, 0xc5, 0xdc,
	0x31, 0xa9, 0x86, 0x48, 0xcb, 0xcd, 0xc7, 0xc7, 0xbf, 0x49, 0x90, 0xe2, 0xc9, 0x30, 0xa3, 0xce,
	0x01, 0xb8, 0x47, 0xaf, 0x10, 0x96, 0x1c, 0x76, 0x29, 0x54, 0xc6, 0x5d, 0xa6, 0x4e, 0x15, 0x0c,
	0xa5, 0x42, 0x58, 0x2e, 0x0c, 0x53, 0xca, 0x03, 0xa5, 0x42, 0xd0, 0x02, 0x8c, 0x7a, 0xcb, 0x76,
	0xa3, 0x52, 0x34, 0xcb, 0x33, 0xc7, 0x28, 0xc3, 0x08, 0xa5, 0x6d, 0x53, 0x92, 0x9b, 0x51, 0x1e,
	0x8b, 0x4a, 0x4a, 0x7a, 0x45, 0x29, 0xdb, 0x33, 0x83, 0x34, 0xbc, 0x63, 0x94, 0x7a, 0x8b, 0x11,
	0xdd, 0x08, 0x87, 0xad, 0x8c, 0xf7, 0x69, 0x0f, 0x92, 0x51, 0xe6, 0x66, 0x84, 0xdb, 0xf7, 0xa3,
	0xb7, 0x08, 0xdf, 0x87, 0xf4, 0x2d, 0x52, 0x26, 0x9a, 0xe2, 0x90, 0xbb, 0xa4, 0x61, 0x6f, 0x34,
	0x76, 0xbd, 0x93, 0x6d, 0x5a, 0xbe, 0x49, 0xcb, 0x30, 0x55, 0xf7, 0x69, 0x85, 0x68, 0xda, 0x4d,
	0x06, 0x0b, 0x37, 0x59, 0xfe, 0xd5, 0x20, 0x23, 0x84, 0x0b, 0x25, 0x9f, 0xb3, 0xdf, 0x82, 0x04,
	0xc4, 0xd9, 0x67, 0x18, 0x68, 0x0d, 0x92, 0xa6, 0xe5, 0x5e, 0x01, 0x8e, 0x15, 0xd1, 0xe9, 0xed,
	0xc6, 0x74, 0x78, 0xcd, 0x57, 0xfb, 0x00, 0x16, 0xa3, 0x6a, 0xfd, 0xbc, 0xf7, 0x6e, 0x39, 0xdf,
	0x95, 0x8b, 0x30, 0x41, 0xd8, 0x42, 0xc1, 0xbb, 0xf2, 0x98, 0xfa, 0x71, 0x12, 0xe1, 0xc7, 0xcf,
	0x24, 0x38, 0x1f, 0x0f, 0xc8, 0x9c, 0xe9, 0x25, 0x38, 0x47, 0x71, 0x6c, 0x17, 0x16, 0xa2, 0x76,
	0x3c, 0x0c, 0x31, 0xf9, 0x6e, 0x89, 0x70, 0x25, 0x31, 0xee, 0xd7, 0x80, 0xe3, 0x70, 0x8f, 0xe2,
	0x1d, 0x27, 0xb8, 0x03, 0xdc, 0xe0, 0x9e, 0x72, 0x53, 0xbf, 0xa9, 0xdb, 0xbf, 0x3f, 0x15, 0x37,
	0xc9, 0xc3, 0x64, 0x66, 0xc4, 0x1d, 0x18, 0x53, 0x19, 0xbd, 0x70, 0x40, 0x1a, 0x7e, 0x79, 0x3d,
	0xcf, 0x2d, 0xaf, 0xf7, 0x6d, 0x2d, 0x02, 0x32, 0xaa, 0x86, 0xbe, 0xf0, 0x6d, 0x38, 0x47, 0xeb,
	0x2f, 0x51, 0xb7, 0x89, 0xa1, 0xee, 0x98, 0xfe, 0xa6, 0xda, 0xa1, 0x91, 0xd5, 0x26, 0x86, 0x4a,
	0x5a, 0xbd, 0x1d, 0xf3, 0xa8, 0x7e, 0xf4, 0x0e, 0x21, 0x2d, 0xc2, 0x09, 0x2e, 0xba, 0x29, 0x57,
	0xa4, 0xe0, 0x98, 0x05, 0xdf, 0xfb, 0xf8, 0x4e, 0x23, 0x0a, 0x94, 0x9f, 0xb0, 0xa3, 0xc0, 0xf8,
	0xb9, 0xe4, 0xb6, 0x34, 0xc5, 0x3e, 0x58, 0xdf, 0xd2, 0x65, 0x0f, 0x1c, 0xb9, 0xcb, 0xfe, 0x53,
	0x82, 0x79, 0xb1, 0x49, 0x6f, 0x29, 0x10, 0x7d, 0x6b, 0xc2, 0x73, 0x7f, 0x9c, 0x81, 0xa1, 0x8f,
	0x5d, 0x56, 0xb4, 0x0d, 0xc7, 0xbd, 0x5b, 0x02, 0xe1, 0x98, 0x37, 0x1a, 0x16, 0x82, 0xd4, 0x62,
	0x2c, 0x8f, 0xa7, 0x08, 0x27, 0x50, 0x11, 0x46, 0x42, 0x2d, 0x36, 0xba, 0xd8, 0xb1, 0x09, 0x67,
	0xf0, 0x4b, 0x9d, 0x19, 0x03, 0x1d, 0x06, 0x4c, 0xb5, 0xbd, 0xf3, 0xa0, 0x15, 0x2e, 0x80, 0xe8,
	0x3d, 0xa8, 0x27, 0x7d, 0xbb, 0x70, 0x82, 0xf5, 0x2f, 0x68, 0x31, 0xb6, 0x89, 0x67, 0xd8, 0xe7,
	0xe3, 0x99, 0x02, 0xdc, 0x03, 0x18, 0x8f, 0xf6, 0x7b, 0xe8, 0x52, 0x37, 0xed, 0x38, 0xd3, 0xb2,
	0xdc, 0x15, 0x6f, 0xa0, 0x8c, 0xc0, 0x68, 0x78, 0x76, 0x42, 0x1d, 0x03, 0x10, 0xec, 0xfc, 0xff,
	0xbb, 0xe0, 0x0c, 0xd4, 0xec, 0xc1, 0x49, 0x7f, 0x14, 0x42, 0xb1, 0x71, 0x08, 0xe0, 0x2f, 0x74,
	0xe0, 0x0a, 0x6d, 0xfb, 0x44, 0xcb, 0x54, 0x83, 0xba, 0x89, 0x41, 0xa0, 0xe8, 0x72, 0x77, 0xcc,
	0x81, 0xbe, 0xef, 0x25, 0x98, 0x11, 0x3d, 0x0c, 0xa1, 0x2b, 0xbd, 0x3c, 0xfe, 0x04, 0x26, 0xbc,
	0xd3, 0xa3, 0x54, 0x60, 0xcb, 0x37, 0x90, 0xe4, 0x75, 0xe2, 0x68, 0xb5, 0xdb, 0x6e, 0x3b, 0x30,
	0x61, 0xad, 0x07, 0x89, 0x40, 0xfd, 0x8f, 0x12, 0xcc, 0xc6, 0x0c, 0x3a, 0xe8, 0x5a, 0x8f, 0xc3,
	0x4c, 0x60, 0xcd, 0xf5, 0xde, 0x05, 0xc3, 0x31, 0xe1, 0xbd, 0x0a, 0x08, 0x62, 0x12, 0xf3, 0xf2,
	0x20, 0x88, 0x49, 0xdc, 0x93, 0x03, 0x4e, 0xa0, 0x43, 0x98, 0x6c, 0x1d, 0xfe, 0xd1, 0xe5, 0x58,
	0xa0, 0xd6, 0xcc, 0x5f, 0xe9, 0x92, 0x3b, 0x50, 0xf9, 0x4c, 0x6a, 0xbe, 0x52, 0xb4, 0x1e, 0x85,
	0xf5, 0x58, 0x30, 0xc1, 0x91, 0xb8, 0xd2, 0x9b, 0x50, 0x60, 0xc8, 0x0f, 0x12, 0xa4, 0xc4, 0x03,
	0x17, 0xba, 0x2a, 0xa8, 0xc5, 0x1d, 0x06, 0xbc, 0xd4, 0xb5, 0x9e, 0xe5, 0xc2, 0xf7, 0x4e, 0xe8,
	0x19, 0x42, 0x70, 0xef, 0xb4, 0x3f, 0x5f, 0xa4, 0x96, 0x3a, 0x33, 0x86, 0x4b, 0x68, 0x78, 0xe2,
	0x13, 0x94, 0x50, 0xce, 0x04, 0x29, 0x28, 0xa1, 0xbc, 0xf1, 0x11, 0x27, 0xd0, 0x57, 0x80, 0xda,
	0x27, 0x39, 0x94, 0xe5, 0x42, 0x08, 0xc7, 0xc4, 0x94, 0xdc, 0x35, 0x7f, 0xd8, 0xbf, 0xf0, 0xba,
	0xc0, 0x3f, 0xce, 0xfc, 0x26, 0xf0, 0x8f, 0x37, 0xbc, 0xe1, 0x04, 0xfa, 0x4e, 0x82, 0xd3, 0xfc,
	0x3e, 0x12, 0xe5, 0xc4, 0xbb, 0x21, 0x6a, 0xff, 0x52, 0xeb, 0x3d, 0xc9, 0x44, 0xaa, 0xbb, 0xa8,
	0x8d, 0x43, 0xa2, 0x73, 0x11, 0xdb, 0x88, 0x0a, 0xaa, 0x7b, 0xa7, 0x5e, 0x91, 0x9d, 0x6b, 0xc1,
	0xfc, 0x28, 0x38, 0xd7, 0xf1, 0xc3, 0xab, 0xe0, 0x5c, 0x77, 0x18, 0x51, 0x71, 0x02, 0xfd, 0x2c,
	0xc1, 0x5c, 0xdc, 0x00, 0x88, 0xae, 0x77, 0x01, 0xcc, 0x1d, 0x42, 0x53, 0x37, 0x8e, 0x20, 0x19,
	0xa9, 0x37, 0xe2, 0xc1, 0x4d, 0x50, 0x6f, 0x3a, 0x4e, 0x90, 0x82, 0x7a, 0xd3, 0x79, 0x42, 0xf4,
	0xcf, 0x4a, 0x93, 0x4f, 0x78, 0x56, 0xda, 0x06, 0x3e, 0xe1, 0x59, 0x69, 0x9f, 0x01, 0x71, 0x62,
	0xa3, 0xf4, 0xe2, 0x55, 0x5a, 0x7a, 0xf9, 0x2a, 0x2d, 0xfd, 0xfb, 0x2a, 0x2d, 0x3d, 0x7f, 0x9d,
	0x4e, 0xbc, 0x7c, 0x9d, 0x4e, 0xfc, 0xf5, 0x3a, 0x9d, 0xf8, 0xec, 0x4e, 0xe8, 0xbd, 0xb4, 0x4a,
	0x34, 0xad, 0xf1, 0x65, 0xdd, 0xff, 0x31, 0x77, 0xa5, 0x68, 0xe9, 0xaa, 0x46, 0xe4, 0x8a, 0xa9,
	0xd6, 0xca, 0x44, 0xae, 0xe7, 0xe4, 0xa7, 0xfe, 0x92, 0x1c, 0x68, 0xb4, 0xe5, 0xfa, 0x9a, 0xf7,
	0xac, 0x5a, 0x3c, 0x4e, 0x7f, 0xdc, 0x5d, 0xff, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xa2, 0x1e, 0x35,
	0x25, 0xfa, 0x1e, 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 {
	// Module parameters query
	Params(ctx context.Context, in *ParamsRequest, opts ...grpc.CallOption) (*ParamsResponse, error)
	// get info on individual outgoing data
	SignerSetTx(ctx context.Context, in *SignerSetTxRequest, opts ...grpc.CallOption) (*SignerSetTxResponse, error)
	LatestSignerSetTx(ctx context.Context, in *LatestSignerSetTxRequest, opts ...grpc.CallOption) (*SignerSetTxResponse, error)
	BatchTx(ctx context.Context, in *BatchTxRequest, opts ...grpc.CallOption) (*BatchTxResponse, error)
	ContractCallTx(ctx context.Context, in *ContractCallTxRequest, opts ...grpc.CallOption) (*ContractCallTxResponse, error)
	// get collections of outgoing traffic from the bridge
	SignerSetTxs(ctx context.Context, in *SignerSetTxsRequest, opts ...grpc.CallOption) (*SignerSetTxsResponse, error)
	BatchTxs(ctx context.Context, in *BatchTxsRequest, opts ...grpc.CallOption) (*BatchTxsResponse, error)
	ContractCallTxs(ctx context.Context, in *ContractCallTxsRequest, opts ...grpc.CallOption) (*ContractCallTxsResponse, error)
	// TODO: can/should we group these into one endpoint?
	SignerSetTxConfirmations(ctx context.Context, in *SignerSetTxConfirmationsRequest, opts ...grpc.CallOption) (*SignerSetTxConfirmationsResponse, error)
	BatchTxConfirmations(ctx context.Context, in *BatchTxConfirmationsRequest, opts ...grpc.CallOption) (*BatchTxConfirmationsResponse, error)
	ContractCallTxConfirmations(ctx context.Context, in *ContractCallTxConfirmationsRequest, opts ...grpc.CallOption) (*ContractCallTxConfirmationsResponse, error)
	// pending ethereum signature queries for orchestrators to figure out which
	// signatures they are missing
	// TODO: can/should we group this into one endpoint?
	UnsignedSignerSetTxs(ctx context.Context, in *UnsignedSignerSetTxsRequest, opts ...grpc.CallOption) (*UnsignedSignerSetTxsResponse, error)
	UnsignedBatchTxs(ctx context.Context, in *UnsignedBatchTxsRequest, opts ...grpc.CallOption) (*UnsignedBatchTxsResponse, error)
	UnsignedContractCallTxs(ctx context.Context, in *UnsignedContractCallTxsRequest, opts ...grpc.CallOption) (*UnsignedContractCallTxsResponse, error)
	LastSubmittedEthereumEvent(ctx context.Context, in *LastSubmittedEthereumEventRequest, opts ...grpc.CallOption) (*LastSubmittedEthereumEventResponse, error)
	// Queries the fees for all pending batches, results are returned in sdk.Coin
	// (fee_amount_int)(contract_address) style
	BatchTxFees(ctx context.Context, in *BatchTxFeesRequest, opts ...grpc.CallOption) (*BatchTxFeesResponse, error)
	// Query for info about denoms tracked by gravity
	ERC20ToDenom(ctx context.Context, in *ERC20ToDenomRequest, opts ...grpc.CallOption) (*ERC20ToDenomResponse, error)
	// DenomToERC20Params implements a query that allows ERC-20 parameter
	// information to be retrieved by a Cosmos base denomination.
	DenomToERC20Params(ctx context.Context, in *DenomToERC20ParamsRequest, opts ...grpc.CallOption) (*DenomToERC20ParamsResponse, error)
	// Query for info about denoms tracked by gravity
	DenomToERC20(ctx context.Context, in *DenomToERC20Request, opts ...grpc.CallOption) (*DenomToERC20Response, error)
	// Query for batch send to ethereums
	BatchedSendToEthereums(ctx context.Context, in *BatchedSendToEthereumsRequest, opts ...grpc.CallOption) (*BatchedSendToEthereumsResponse, error)
	// Query for unbatched send to ethereums
	UnbatchedSendToEthereums(ctx context.Context, in *UnbatchedSendToEthereumsRequest, opts ...grpc.CallOption) (*UnbatchedSendToEthereumsResponse, error)
	// delegate keys
	DelegateKeysByValidator(ctx context.Context, in *DelegateKeysByValidatorRequest, opts ...grpc.CallOption) (*DelegateKeysByValidatorResponse, error)
	DelegateKeysByEthereumSigner(ctx context.Context, in *DelegateKeysByEthereumSignerRequest, opts ...grpc.CallOption) (*DelegateKeysByEthereumSignerResponse, error)
	DelegateKeysByOrchestrator(ctx context.Context, in *DelegateKeysByOrchestratorRequest, opts ...grpc.CallOption) (*DelegateKeysByOrchestratorResponse, error)
	DelegateKeys(ctx context.Context, in *DelegateKeysRequest, opts ...grpc.CallOption) (*DelegateKeysResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

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

func (c *queryClient) Params(ctx context.Context, in *ParamsRequest, opts ...grpc.CallOption) (*ParamsResponse, error) {
	out := new(ParamsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/Params", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) SignerSetTx(ctx context.Context, in *SignerSetTxRequest, opts ...grpc.CallOption) (*SignerSetTxResponse, error) {
	out := new(SignerSetTxResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/SignerSetTx", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) LatestSignerSetTx(ctx context.Context, in *LatestSignerSetTxRequest, opts ...grpc.CallOption) (*SignerSetTxResponse, error) {
	out := new(SignerSetTxResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/LatestSignerSetTx", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) BatchTx(ctx context.Context, in *BatchTxRequest, opts ...grpc.CallOption) (*BatchTxResponse, error) {
	out := new(BatchTxResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/BatchTx", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ContractCallTx(ctx context.Context, in *ContractCallTxRequest, opts ...grpc.CallOption) (*ContractCallTxResponse, error) {
	out := new(ContractCallTxResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/ContractCallTx", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) SignerSetTxs(ctx context.Context, in *SignerSetTxsRequest, opts ...grpc.CallOption) (*SignerSetTxsResponse, error) {
	out := new(SignerSetTxsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/SignerSetTxs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) BatchTxs(ctx context.Context, in *BatchTxsRequest, opts ...grpc.CallOption) (*BatchTxsResponse, error) {
	out := new(BatchTxsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/BatchTxs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ContractCallTxs(ctx context.Context, in *ContractCallTxsRequest, opts ...grpc.CallOption) (*ContractCallTxsResponse, error) {
	out := new(ContractCallTxsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/ContractCallTxs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) SignerSetTxConfirmations(ctx context.Context, in *SignerSetTxConfirmationsRequest, opts ...grpc.CallOption) (*SignerSetTxConfirmationsResponse, error) {
	out := new(SignerSetTxConfirmationsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/SignerSetTxConfirmations", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) BatchTxConfirmations(ctx context.Context, in *BatchTxConfirmationsRequest, opts ...grpc.CallOption) (*BatchTxConfirmationsResponse, error) {
	out := new(BatchTxConfirmationsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/BatchTxConfirmations", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ContractCallTxConfirmations(ctx context.Context, in *ContractCallTxConfirmationsRequest, opts ...grpc.CallOption) (*ContractCallTxConfirmationsResponse, error) {
	out := new(ContractCallTxConfirmationsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/ContractCallTxConfirmations", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) UnsignedSignerSetTxs(ctx context.Context, in *UnsignedSignerSetTxsRequest, opts ...grpc.CallOption) (*UnsignedSignerSetTxsResponse, error) {
	out := new(UnsignedSignerSetTxsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/UnsignedSignerSetTxs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) UnsignedBatchTxs(ctx context.Context, in *UnsignedBatchTxsRequest, opts ...grpc.CallOption) (*UnsignedBatchTxsResponse, error) {
	out := new(UnsignedBatchTxsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/UnsignedBatchTxs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) UnsignedContractCallTxs(ctx context.Context, in *UnsignedContractCallTxsRequest, opts ...grpc.CallOption) (*UnsignedContractCallTxsResponse, error) {
	out := new(UnsignedContractCallTxsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/UnsignedContractCallTxs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) LastSubmittedEthereumEvent(ctx context.Context, in *LastSubmittedEthereumEventRequest, opts ...grpc.CallOption) (*LastSubmittedEthereumEventResponse, error) {
	out := new(LastSubmittedEthereumEventResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/LastSubmittedEthereumEvent", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) BatchTxFees(ctx context.Context, in *BatchTxFeesRequest, opts ...grpc.CallOption) (*BatchTxFeesResponse, error) {
	out := new(BatchTxFeesResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/BatchTxFees", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ERC20ToDenom(ctx context.Context, in *ERC20ToDenomRequest, opts ...grpc.CallOption) (*ERC20ToDenomResponse, error) {
	out := new(ERC20ToDenomResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/ERC20ToDenom", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) DenomToERC20Params(ctx context.Context, in *DenomToERC20ParamsRequest, opts ...grpc.CallOption) (*DenomToERC20ParamsResponse, error) {
	out := new(DenomToERC20ParamsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/DenomToERC20Params", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) DenomToERC20(ctx context.Context, in *DenomToERC20Request, opts ...grpc.CallOption) (*DenomToERC20Response, error) {
	out := new(DenomToERC20Response)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/DenomToERC20", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) BatchedSendToEthereums(ctx context.Context, in *BatchedSendToEthereumsRequest, opts ...grpc.CallOption) (*BatchedSendToEthereumsResponse, error) {
	out := new(BatchedSendToEthereumsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/BatchedSendToEthereums", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) UnbatchedSendToEthereums(ctx context.Context, in *UnbatchedSendToEthereumsRequest, opts ...grpc.CallOption) (*UnbatchedSendToEthereumsResponse, error) {
	out := new(UnbatchedSendToEthereumsResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/UnbatchedSendToEthereums", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) DelegateKeysByValidator(ctx context.Context, in *DelegateKeysByValidatorRequest, opts ...grpc.CallOption) (*DelegateKeysByValidatorResponse, error) {
	out := new(DelegateKeysByValidatorResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/DelegateKeysByValidator", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) DelegateKeysByEthereumSigner(ctx context.Context, in *DelegateKeysByEthereumSignerRequest, opts ...grpc.CallOption) (*DelegateKeysByEthereumSignerResponse, error) {
	out := new(DelegateKeysByEthereumSignerResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/DelegateKeysByEthereumSigner", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) DelegateKeysByOrchestrator(ctx context.Context, in *DelegateKeysByOrchestratorRequest, opts ...grpc.CallOption) (*DelegateKeysByOrchestratorResponse, error) {
	out := new(DelegateKeysByOrchestratorResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/DelegateKeysByOrchestrator", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) DelegateKeys(ctx context.Context, in *DelegateKeysRequest, opts ...grpc.CallOption) (*DelegateKeysResponse, error) {
	out := new(DelegateKeysResponse)
	err := c.cc.Invoke(ctx, "/gravity.v1migration.Query/DelegateKeys", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// Module parameters query
	Params(context.Context, *ParamsRequest) (*ParamsResponse, error)
	// get info on individual outgoing data
	SignerSetTx(context.Context, *SignerSetTxRequest) (*SignerSetTxResponse, error)
	LatestSignerSetTx(context.Context, *LatestSignerSetTxRequest) (*SignerSetTxResponse, error)
	BatchTx(context.Context, *BatchTxRequest) (*BatchTxResponse, error)
	ContractCallTx(context.Context, *ContractCallTxRequest) (*ContractCallTxResponse, error)
	// get collections of outgoing traffic from the bridge
	SignerSetTxs(context.Context, *SignerSetTxsRequest) (*SignerSetTxsResponse, error)
	BatchTxs(context.Context, *BatchTxsRequest) (*BatchTxsResponse, error)
	ContractCallTxs(context.Context, *ContractCallTxsRequest) (*ContractCallTxsResponse, error)
	// TODO: can/should we group these into one endpoint?
	SignerSetTxConfirmations(context.Context, *SignerSetTxConfirmationsRequest) (*SignerSetTxConfirmationsResponse, error)
	BatchTxConfirmations(context.Context, *BatchTxConfirmationsRequest) (*BatchTxConfirmationsResponse, error)
	ContractCallTxConfirmations(context.Context, *ContractCallTxConfirmationsRequest) (*ContractCallTxConfirmationsResponse, error)
	// pending ethereum signature queries for orchestrators to figure out which
	// signatures they are missing
	// TODO: can/should we group this into one endpoint?
	UnsignedSignerSetTxs(context.Context, *UnsignedSignerSetTxsRequest) (*UnsignedSignerSetTxsResponse, error)
	UnsignedBatchTxs(context.Context, *UnsignedBatchTxsRequest) (*UnsignedBatchTxsResponse, error)
	UnsignedContractCallTxs(context.Context, *UnsignedContractCallTxsRequest) (*UnsignedContractCallTxsResponse, error)
	LastSubmittedEthereumEvent(context.Context, *LastSubmittedEthereumEventRequest) (*LastSubmittedEthereumEventResponse, error)
	// Queries the fees for all pending batches, results are returned in sdk.Coin
	// (fee_amount_int)(contract_address) style
	BatchTxFees(context.Context, *BatchTxFeesRequest) (*BatchTxFeesResponse, error)
	// Query for info about denoms tracked by gravity
	ERC20ToDenom(context.Context, *ERC20ToDenomRequest) (*ERC20ToDenomResponse, error)
	// DenomToERC20Params implements a query that allows ERC-20 parameter
	// information to be retrieved by a Cosmos base denomination.
	DenomToERC20Params(context.Context, *DenomToERC20ParamsRequest) (*DenomToERC20ParamsResponse, error)
	// Query for info about denoms tracked by gravity
	DenomToERC20(context.Context, *DenomToERC20Request) (*DenomToERC20Response, error)
	// Query for batch send to ethereums
	BatchedSendToEthereums(context.Context, *BatchedSendToEthereumsRequest) (*BatchedSendToEthereumsResponse, error)
	// Query for unbatched send to ethereums
	UnbatchedSendToEthereums(context.Context, *UnbatchedSendToEthereumsRequest) (*UnbatchedSendToEthereumsResponse, error)
	// delegate keys
	DelegateKeysByValidator(context.Context, *DelegateKeysByValidatorRequest) (*DelegateKeysByValidatorResponse, error)
	DelegateKeysByEthereumSigner(context.Context, *DelegateKeysByEthereumSignerRequest) (*DelegateKeysByEthereumSignerResponse, error)
	DelegateKeysByOrchestrator(context.Context, *DelegateKeysByOrchestratorRequest) (*DelegateKeysByOrchestratorResponse, error)
	DelegateKeys(context.Context, *DelegateKeysRequest) (*DelegateKeysResponse, error)
}

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

func (*UnimplementedQueryServer) Params(ctx context.Context, req *ParamsRequest) (*ParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}
func (*UnimplementedQueryServer) SignerSetTx(ctx context.Context, req *SignerSetTxRequest) (*SignerSetTxResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SignerSetTx not implemented")
}
func (*UnimplementedQueryServer) LatestSignerSetTx(ctx context.Context, req *LatestSignerSetTxRequest) (*SignerSetTxResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LatestSignerSetTx not implemented")
}
func (*UnimplementedQueryServer) BatchTx(ctx context.Context, req *BatchTxRequest) (*BatchTxResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchTx not implemented")
}
func (*UnimplementedQueryServer) ContractCallTx(ctx context.Context, req *ContractCallTxRequest) (*ContractCallTxResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContractCallTx not implemented")
}
func (*UnimplementedQueryServer) SignerSetTxs(ctx context.Context, req *SignerSetTxsRequest) (*SignerSetTxsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SignerSetTxs not implemented")
}
func (*UnimplementedQueryServer) BatchTxs(ctx context.Context, req *BatchTxsRequest) (*BatchTxsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchTxs not implemented")
}
func (*UnimplementedQueryServer) ContractCallTxs(ctx context.Context, req *ContractCallTxsRequest) (*ContractCallTxsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContractCallTxs not implemented")
}
func (*UnimplementedQueryServer) SignerSetTxConfirmations(ctx context.Context, req *SignerSetTxConfirmationsRequest) (*SignerSetTxConfirmationsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SignerSetTxConfirmations not implemented")
}
func (*UnimplementedQueryServer) BatchTxConfirmations(ctx context.Context, req *BatchTxConfirmationsRequest) (*BatchTxConfirmationsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchTxConfirmations not implemented")
}
func (*UnimplementedQueryServer) ContractCallTxConfirmations(ctx context.Context, req *ContractCallTxConfirmationsRequest) (*ContractCallTxConfirmationsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContractCallTxConfirmations not implemented")
}
func (*UnimplementedQueryServer) UnsignedSignerSetTxs(ctx context.Context, req *UnsignedSignerSetTxsRequest) (*UnsignedSignerSetTxsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnsignedSignerSetTxs not implemented")
}
func (*UnimplementedQueryServer) UnsignedBatchTxs(ctx context.Context, req *UnsignedBatchTxsRequest) (*UnsignedBatchTxsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnsignedBatchTxs not implemented")
}
func (*UnimplementedQueryServer) UnsignedContractCallTxs(ctx context.Context, req *UnsignedContractCallTxsRequest) (*UnsignedContractCallTxsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnsignedContractCallTxs not implemented")
}
func (*UnimplementedQueryServer) LastSubmittedEthereumEvent(ctx context.Context, req *LastSubmittedEthereumEventRequest) (*LastSubmittedEthereumEventResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LastSubmittedEthereumEvent not implemented")
}
func (*UnimplementedQueryServer) BatchTxFees(ctx context.Context, req *BatchTxFeesRequest) (*BatchTxFeesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchTxFees not implemented")
}
func (*UnimplementedQueryServer) ERC20ToDenom(ctx context.Context, req *ERC20ToDenomRequest) (*ERC20ToDenomResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ERC20ToDenom not implemented")
}
func (*UnimplementedQueryServer) DenomToERC20Params(ctx context.Context, req *DenomToERC20ParamsRequest) (*DenomToERC20ParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DenomToERC20Params not implemented")
}
func (*UnimplementedQueryServer) DenomToERC20(ctx context.Context, req *DenomToERC20Request) (*DenomToERC20Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DenomToERC20 not implemented")
}
func (*UnimplementedQueryServer) BatchedSendToEthereums(ctx context.Context, req *BatchedSendToEthereumsRequest) (*BatchedSendToEthereumsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchedSendToEthereums not implemented")
}
func (*UnimplementedQueryServer) UnbatchedSendToEthereums(ctx context.Context, req *UnbatchedSendToEthereumsRequest) (*UnbatchedSendToEthereumsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnbatchedSendToEthereums not implemented")
}
func (*UnimplementedQueryServer) DelegateKeysByValidator(ctx context.Context, req *DelegateKeysByValidatorRequest) (*DelegateKeysByValidatorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DelegateKeysByValidator not implemented")
}
func (*UnimplementedQueryServer) DelegateKeysByEthereumSigner(ctx context.Context, req *DelegateKeysByEthereumSignerRequest) (*DelegateKeysByEthereumSignerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DelegateKeysByEthereumSigner not implemented")
}
func (*UnimplementedQueryServer) DelegateKeysByOrchestrator(ctx context.Context, req *DelegateKeysByOrchestratorRequest) (*DelegateKeysByOrchestratorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DelegateKeysByOrchestrator not implemented")
}
func (*UnimplementedQueryServer) DelegateKeys(ctx context.Context, req *DelegateKeysRequest) (*DelegateKeysResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DelegateKeys 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(ParamsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Params(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/Params",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Params(ctx, req.(*ParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_SignerSetTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignerSetTxRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).SignerSetTx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/SignerSetTx",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).SignerSetTx(ctx, req.(*SignerSetTxRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_LatestSignerSetTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LatestSignerSetTxRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).LatestSignerSetTx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/LatestSignerSetTx",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).LatestSignerSetTx(ctx, req.(*LatestSignerSetTxRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_BatchTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchTxRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).BatchTx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/BatchTx",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).BatchTx(ctx, req.(*BatchTxRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ContractCallTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContractCallTxRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ContractCallTx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/ContractCallTx",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ContractCallTx(ctx, req.(*ContractCallTxRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_SignerSetTxs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignerSetTxsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).SignerSetTxs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/SignerSetTxs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).SignerSetTxs(ctx, req.(*SignerSetTxsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_BatchTxs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchTxsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).BatchTxs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/BatchTxs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).BatchTxs(ctx, req.(*BatchTxsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ContractCallTxs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContractCallTxsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ContractCallTxs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/ContractCallTxs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ContractCallTxs(ctx, req.(*ContractCallTxsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_SignerSetTxConfirmations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignerSetTxConfirmationsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).SignerSetTxConfirmations(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/SignerSetTxConfirmations",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).SignerSetTxConfirmations(ctx, req.(*SignerSetTxConfirmationsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_BatchTxConfirmations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchTxConfirmationsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).BatchTxConfirmations(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/BatchTxConfirmations",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).BatchTxConfirmations(ctx, req.(*BatchTxConfirmationsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ContractCallTxConfirmations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContractCallTxConfirmationsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ContractCallTxConfirmations(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/ContractCallTxConfirmations",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ContractCallTxConfirmations(ctx, req.(*ContractCallTxConfirmationsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_UnsignedSignerSetTxs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnsignedSignerSetTxsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).UnsignedSignerSetTxs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/UnsignedSignerSetTxs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).UnsignedSignerSetTxs(ctx, req.(*UnsignedSignerSetTxsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_UnsignedBatchTxs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnsignedBatchTxsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).UnsignedBatchTxs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/UnsignedBatchTxs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).UnsignedBatchTxs(ctx, req.(*UnsignedBatchTxsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_UnsignedContractCallTxs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnsignedContractCallTxsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).UnsignedContractCallTxs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/UnsignedContractCallTxs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).UnsignedContractCallTxs(ctx, req.(*UnsignedContractCallTxsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_LastSubmittedEthereumEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LastSubmittedEthereumEventRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).LastSubmittedEthereumEvent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/LastSubmittedEthereumEvent",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).LastSubmittedEthereumEvent(ctx, req.(*LastSubmittedEthereumEventRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_BatchTxFees_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchTxFeesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).BatchTxFees(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/BatchTxFees",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).BatchTxFees(ctx, req.(*BatchTxFeesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ERC20ToDenom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ERC20ToDenomRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ERC20ToDenom(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/ERC20ToDenom",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ERC20ToDenom(ctx, req.(*ERC20ToDenomRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_DenomToERC20Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DenomToERC20ParamsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).DenomToERC20Params(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/DenomToERC20Params",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).DenomToERC20Params(ctx, req.(*DenomToERC20ParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_DenomToERC20_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DenomToERC20Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).DenomToERC20(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/DenomToERC20",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).DenomToERC20(ctx, req.(*DenomToERC20Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_BatchedSendToEthereums_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchedSendToEthereumsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).BatchedSendToEthereums(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/BatchedSendToEthereums",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).BatchedSendToEthereums(ctx, req.(*BatchedSendToEthereumsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_UnbatchedSendToEthereums_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnbatchedSendToEthereumsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).UnbatchedSendToEthereums(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/UnbatchedSendToEthereums",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).UnbatchedSendToEthereums(ctx, req.(*UnbatchedSendToEthereumsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_DelegateKeysByValidator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DelegateKeysByValidatorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).DelegateKeysByValidator(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/DelegateKeysByValidator",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).DelegateKeysByValidator(ctx, req.(*DelegateKeysByValidatorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_DelegateKeysByEthereumSigner_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DelegateKeysByEthereumSignerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).DelegateKeysByEthereumSigner(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/DelegateKeysByEthereumSigner",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).DelegateKeysByEthereumSigner(ctx, req.(*DelegateKeysByEthereumSignerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_DelegateKeysByOrchestrator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DelegateKeysByOrchestratorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).DelegateKeysByOrchestrator(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/DelegateKeysByOrchestrator",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).DelegateKeysByOrchestrator(ctx, req.(*DelegateKeysByOrchestratorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_DelegateKeys_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DelegateKeysRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).DelegateKeys(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gravity.v1migration.Query/DelegateKeys",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).DelegateKeys(ctx, req.(*DelegateKeysRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "gravity.v1migration.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
		{
			MethodName: "SignerSetTx",
			Handler:    _Query_SignerSetTx_Handler,
		},
		{
			MethodName: "LatestSignerSetTx",
			Handler:    _Query_LatestSignerSetTx_Handler,
		},
		{
			MethodName: "BatchTx",
			Handler:    _Query_BatchTx_Handler,
		},
		{
			MethodName: "ContractCallTx",
			Handler:    _Query_ContractCallTx_Handler,
		},
		{
			MethodName: "SignerSetTxs",
			Handler:    _Query_SignerSetTxs_Handler,
		},
		{
			MethodName: "BatchTxs",
			Handler:    _Query_BatchTxs_Handler,
		},
		{
			MethodName: "ContractCallTxs",
			Handler:    _Query_ContractCallTxs_Handler,
		},
		{
			MethodName: "SignerSetTxConfirmations",
			Handler:    _Query_SignerSetTxConfirmations_Handler,
		},
		{
			MethodName: "BatchTxConfirmations",
			Handler:    _Query_BatchTxConfirmations_Handler,
		},
		{
			MethodName: "ContractCallTxConfirmations",
			Handler:    _Query_ContractCallTxConfirmations_Handler,
		},
		{
			MethodName: "UnsignedSignerSetTxs",
			Handler:    _Query_UnsignedSignerSetTxs_Handler,
		},
		{
			MethodName: "UnsignedBatchTxs",
			Handler:    _Query_UnsignedBatchTxs_Handler,
		},
		{
			MethodName: "UnsignedContractCallTxs",
			Handler:    _Query_UnsignedContractCallTxs_Handler,
		},
		{
			MethodName: "LastSubmittedEthereumEvent",
			Handler:    _Query_LastSubmittedEthereumEvent_Handler,
		},
		{
			MethodName: "BatchTxFees",
			Handler:    _Query_BatchTxFees_Handler,
		},
		{
			MethodName: "ERC20ToDenom",
			Handler:    _Query_ERC20ToDenom_Handler,
		},
		{
			MethodName: "DenomToERC20Params",
			Handler:    _Query_DenomToERC20Params_Handler,
		},
		{
			MethodName: "DenomToERC20",
			Handler:    _Query_DenomToERC20_Handler,
		},
		{
			MethodName: "BatchedSendToEthereums",
			Handler:    _Query_BatchedSendToEthereums_Handler,
		},
		{
			MethodName: "UnbatchedSendToEthereums",
			Handler:    _Query_UnbatchedSendToEthereums_Handler,
		},
		{
			MethodName: "DelegateKeysByValidator",
			Handler:    _Query_DelegateKeysByValidator_Handler,
		},
		{
			MethodName: "DelegateKeysByEthereumSigner",
			Handler:    _Query_DelegateKeysByEthereumSigner_Handler,
		},
		{
			MethodName: "DelegateKeysByOrchestrator",
			Handler:    _Query_DelegateKeysByOrchestrator_Handler,
		},
		{
			MethodName: "DelegateKeys",
			Handler:    _Query_DelegateKeys_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "gravity/v1migration/query.proto",
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *UnsignedSignerSetTxsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SignerSets) > 0 {
		for iNdEx := len(m.SignerSets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SignerSets[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 *UnsignedBatchTxsRequest) 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 *UnsignedBatchTxsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *UnsignedBatchTxsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Batches) > 0 {
		for iNdEx := len(m.Batches) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Batches[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 *UnsignedContractCallTxsRequest) 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 *UnsignedContractCallTxsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *UnsignedContractCallTxsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Calls) > 0 {
		for iNdEx := len(m.Calls) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Calls[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 *BatchTxFeesRequest) 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 *BatchTxFeesRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *BatchTxFeesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Fees) > 0 {
		for iNdEx := len(m.Fees) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Fees[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 *ContractCallTxConfirmationsRequest) 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 *ContractCallTxConfirmationsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *DenomToERC20ParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Erc20Decimals != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Erc20Decimals))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Erc20Symbol) > 0 {
		i -= len(m.Erc20Symbol)
		copy(dAtA[i:], m.Erc20Symbol)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Erc20Symbol)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Erc20Name) > 0 {
		i -= len(m.Erc20Name)
		copy(dAtA[i:], m.Erc20Name)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Erc20Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.BaseDenom) > 0 {
		i -= len(m.BaseDenom)
		copy(dAtA[i:], m.BaseDenom)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.BaseDenom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *DelegateKeysResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DelegateKeys) > 0 {
		for iNdEx := len(m.DelegateKeys) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DelegateKeys[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 *BatchedSendToEthereumsRequest) 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 *BatchedSendToEthereumsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *BatchedSendToEthereumsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SendToEthereums) > 0 {
		for iNdEx := len(m.SendToEthereums) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SendToEthereums[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 *UnbatchedSendToEthereumsRequest) 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 *UnbatchedSendToEthereumsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *UnbatchedSendToEthereumsResponse) 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.SendToEthereums) > 0 {
		for iNdEx := len(m.SendToEthereums) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SendToEthereums[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 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 *ParamsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *ParamsResponse) 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 *SignerSetTxRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SignerSetNonce != 0 {
		n += 1 + sovQuery(uint64(m.SignerSetNonce))
	}
	return n
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *DenomToERC20ParamsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BaseDenom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.Erc20Name)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.Erc20Symbol)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Erc20Decimals != 0 {
		n += 1 + sovQuery(uint64(m.Erc20Decimals))
	}
	return n
}

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

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

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

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

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

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

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

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

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

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

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

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

func (m *UnbatchedSendToEthereumsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SenderAddress)
	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 *UnbatchedSendToEthereumsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.SendToEthereums) > 0 {
		for _, e := range m.SendToEthereums {
			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 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 *ParamsRequest) 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: ParamsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ParamsRequest: 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 *ParamsResponse) 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: ParamsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ParamsResponse: 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 *SignerSetTxRequest) 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: SignerSetTxRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignerSetTxRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignerSetNonce", wireType)
			}
			m.SignerSetNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SignerSetNonce |= 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 *LatestSignerSetTxRequest) 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: LatestSignerSetTxRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LatestSignerSetTxRequest: 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 *SignerSetTxResponse) 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: SignerSetTxResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignerSetTxResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignerSet", 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.SignerSet == nil {
				m.SignerSet = &SignerSetTx{}
			}
			if err := m.SignerSet.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 *BatchTxRequest) 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: BatchTxRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchTxRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenContract", 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.TokenContract = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BatchNonce", wireType)
			}
			m.BatchNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BatchNonce |= 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 *BatchTxResponse) 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: BatchTxResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchTxResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Batch", 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.Batch == nil {
				m.Batch = &BatchTx{}
			}
			if err := m.Batch.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 *ContractCallTxRequest) 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: ContractCallTxRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContractCallTxRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InvalidationScope", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InvalidationScope = append(m.InvalidationScope[:0], dAtA[iNdEx:postIndex]...)
			if m.InvalidationScope == nil {
				m.InvalidationScope = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InvalidationNonce", wireType)
			}
			m.InvalidationNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InvalidationNonce |= 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 *ContractCallTxResponse) 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: ContractCallTxResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContractCallTxResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogicCall", 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.LogicCall == nil {
				m.LogicCall = &ContractCallTx{}
			}
			if err := m.LogicCall.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 *SignerSetTxConfirmationsRequest) 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: SignerSetTxConfirmationsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignerSetTxConfirmationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignerSetNonce", wireType)
			}
			m.SignerSetNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SignerSetNonce |= 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 *SignerSetTxConfirmationsResponse) 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: SignerSetTxConfirmationsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignerSetTxConfirmationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Signatures = append(m.Signatures, &SignerSetTxConfirmation{})
			if err := m.Signatures[len(m.Signatures)-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 *SignerSetTxsRequest) 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: SignerSetTxsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignerSetTxsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pagination == nil {
				m.Pagination = &query.PageRequest{}
			}
			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ContractCallTxsResponse) 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: ContractCallTxsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContractCallTxsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Calls", 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.Calls = append(m.Calls, &ContractCallTx{})
			if err := m.Calls[len(m.Calls)-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 *UnsignedSignerSetTxsRequest) 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: UnsignedSignerSetTxsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnsignedSignerSetTxsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *UnsignedSignerSetTxsResponse) 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: UnsignedSignerSetTxsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnsignedSignerSetTxsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignerSets", 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.SignerSets = append(m.SignerSets, &SignerSetTx{})
			if err := m.SignerSets[len(m.SignerSets)-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 *UnsignedBatchTxsRequest) 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: UnsignedBatchTxsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnsignedBatchTxsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *UnsignedBatchTxsResponse) 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: UnsignedBatchTxsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnsignedBatchTxsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Batches", 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.Batches = append(m.Batches, &BatchTx{})
			if err := m.Batches[len(m.Batches)-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 *UnsignedContractCallTxsRequest) 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: UnsignedContractCallTxsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnsignedContractCallTxsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *UnsignedContractCallTxsResponse) 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: UnsignedContractCallTxsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnsignedContractCallTxsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Calls", 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.Calls = append(m.Calls, &ContractCallTx{})
			if err := m.Calls[len(m.Calls)-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 *BatchTxFeesRequest) 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: BatchTxFeesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchTxFeesRequest: 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 *BatchTxFeesResponse) 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: BatchTxFeesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchTxFeesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fees", 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.Fees = append(m.Fees, types.Coin{})
			if err := m.Fees[len(m.Fees)-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 *ContractCallTxConfirmationsRequest) 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: ContractCallTxConfirmationsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContractCallTxConfirmationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InvalidationScope", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InvalidationScope = append(m.InvalidationScope[:0], dAtA[iNdEx:postIndex]...)
			if m.InvalidationScope == nil {
				m.InvalidationScope = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InvalidationNonce", wireType)
			}
			m.InvalidationNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InvalidationNonce |= 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 *ContractCallTxConfirmationsResponse) 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: ContractCallTxConfirmationsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContractCallTxConfirmationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Signatures = append(m.Signatures, &ContractCallTxConfirmation{})
			if err := m.Signatures[len(m.Signatures)-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 *BatchTxConfirmationsRequest) 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: BatchTxConfirmationsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchTxConfirmationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BatchNonce", wireType)
			}
			m.BatchNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BatchNonce |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenContract", 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.TokenContract = 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 *BatchTxConfirmationsResponse) 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: BatchTxConfirmationsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchTxConfirmationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Signatures = append(m.Signatures, &BatchTxConfirmation{})
			if err := m.Signatures[len(m.Signatures)-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 *LastSubmittedEthereumEventRequest) 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: LastSubmittedEthereumEventRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LastSubmittedEthereumEventRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *LastSubmittedEthereumEventResponse) 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: LastSubmittedEthereumEventResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LastSubmittedEthereumEventResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventNonce", wireType)
			}
			m.EventNonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EventNonce |= 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 *ERC20ToDenomRequest) 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: ERC20ToDenomRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ERC20ToDenomRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Erc20", 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.Erc20 = 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 *ERC20ToDenomResponse) 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: ERC20ToDenomResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ERC20ToDenomResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", 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.Denom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CosmosOriginated", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CosmosOriginated = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DenomToERC20ParamsRequest) 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: DenomToERC20ParamsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DenomToERC20ParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", 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.Denom = 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 *DenomToERC20ParamsResponse) 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: DenomToERC20ParamsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DenomToERC20ParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BaseDenom", 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.BaseDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Erc20Name", 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.Erc20Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Erc20Symbol", 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.Erc20Symbol = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Erc20Decimals", wireType)
			}
			m.Erc20Decimals = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Erc20Decimals |= 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 *DenomToERC20Request) 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: DenomToERC20Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DenomToERC20Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", 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.Denom = 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 *DenomToERC20Response) 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: DenomToERC20Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DenomToERC20Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Erc20", 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.Erc20 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CosmosOriginated", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CosmosOriginated = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DelegateKeysByValidatorRequest) 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: DelegateKeysByValidatorRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateKeysByValidatorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", 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.ValidatorAddress = 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 *DelegateKeysByValidatorResponse) 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: DelegateKeysByValidatorResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateKeysByValidatorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EthAddress", 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.EthAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrchestratorAddress", 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.OrchestratorAddress = 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 *DelegateKeysByEthereumSignerRequest) 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: DelegateKeysByEthereumSignerRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateKeysByEthereumSignerRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EthereumSigner", 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.EthereumSigner = 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 *DelegateKeysByEthereumSignerResponse) 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: DelegateKeysByEthereumSignerResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateKeysByEthereumSignerResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", 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.ValidatorAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrchestratorAddress", 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.OrchestratorAddress = 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 *DelegateKeysByOrchestratorRequest) 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: DelegateKeysByOrchestratorRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateKeysByOrchestratorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrchestratorAddress", 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.OrchestratorAddress = 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 *DelegateKeysByOrchestratorResponse) 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: DelegateKeysByOrchestratorResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateKeysByOrchestratorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", 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.ValidatorAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EthereumSigner", 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.EthereumSigner = 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 *DelegateKeysRequest) 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: DelegateKeysRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateKeysRequest: 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 *DelegateKeysResponse) 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: DelegateKeysResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegateKeysResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegateKeys", 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.DelegateKeys = append(m.DelegateKeys, &MsgDelegateKeys{})
			if err := m.DelegateKeys[len(m.DelegateKeys)-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 *BatchedSendToEthereumsRequest) 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: BatchedSendToEthereumsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchedSendToEthereumsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SenderAddress", 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.SenderAddress = 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 *BatchedSendToEthereumsResponse) 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: BatchedSendToEthereumsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchedSendToEthereumsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SendToEthereums", 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.SendToEthereums = append(m.SendToEthereums, &SendToEthereum{})
			if err := m.SendToEthereums[len(m.SendToEthereums)-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 *UnbatchedSendToEthereumsRequest) 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: UnbatchedSendToEthereumsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnbatchedSendToEthereumsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SenderAddress", 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.SenderAddress = 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 *UnbatchedSendToEthereumsResponse) 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: UnbatchedSendToEthereumsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnbatchedSendToEthereumsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SendToEthereums", 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.SendToEthereums = append(m.SendToEthereums, &SendToEthereum{})
			if err := m.SendToEthereums[len(m.SendToEthereums)-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 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")
)
