query.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: axelar/tss/v1beta1/query.proto

package types

import (
	fmt "fmt"
	exported "github.com/axelarnetwork/axelar-core/x/tss/exported"
	github_com_axelarnetwork_axelar_core_x_tss_exported "github.com/axelarnetwork/axelar-core/x/tss/exported"
	tofnd "github.com/axelarnetwork/axelar-core/x/tss/tofnd"
	_ "github.com/cosmos/cosmos-sdk/crypto/keys/multisig"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	_ "google.golang.org/protobuf/types/known/timestamppb"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

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

// 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

type VoteStatus int32

const (
	Unspecified VoteStatus = 0
	NotFound    VoteStatus = 1
	Pending     VoteStatus = 2
	Decided     VoteStatus = 3
)

var VoteStatus_name = map[int32]string{
	0: "VOTE_STATUS_UNSPECIFIED",
	1: "VOTE_STATUS_NOT_FOUND",
	2: "VOTE_STATUS_PENDING",
	3: "VOTE_STATUS_DECIDED",
}

var VoteStatus_value = map[string]int32{
	"VOTE_STATUS_UNSPECIFIED": 0,
	"VOTE_STATUS_NOT_FOUND":   1,
	"VOTE_STATUS_PENDING":     2,
	"VOTE_STATUS_DECIDED":     3,
}

func (x VoteStatus) String() string {
	return proto.EnumName(VoteStatus_name, int32(x))
}

func (VoteStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ef30ba194f672ab8, []int{0}
}

type QuerySignatureResponse struct {
	// Types that are valid to be assigned to Sig:
	//	*QuerySignatureResponse_ThresholdSignature_
	//	*QuerySignatureResponse_MultisigSignature_
	Sig isQuerySignatureResponse_Sig `protobuf_oneof:"sig"`
}

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

var xxx_messageInfo_QuerySignatureResponse proto.InternalMessageInfo

type isQuerySignatureResponse_Sig interface {
	isQuerySignatureResponse_Sig()
	MarshalTo([]byte) (int, error)
	Size() int
}

type QuerySignatureResponse_ThresholdSignature_ struct {
	ThresholdSignature *QuerySignatureResponse_ThresholdSignature `protobuf:"bytes,1,opt,name=threshold_signature,json=thresholdSignature,proto3,oneof" json:"threshold_signature,omitempty"`
}
type QuerySignatureResponse_MultisigSignature_ struct {
	MultisigSignature *QuerySignatureResponse_MultisigSignature `protobuf:"bytes,2,opt,name=multisig_signature,json=multisigSignature,proto3,oneof" json:"multisig_signature,omitempty"`
}

func (*QuerySignatureResponse_ThresholdSignature_) isQuerySignatureResponse_Sig() {}
func (*QuerySignatureResponse_MultisigSignature_) isQuerySignatureResponse_Sig()  {}

func (m *QuerySignatureResponse) GetSig() isQuerySignatureResponse_Sig {
	if m != nil {
		return m.Sig
	}
	return nil
}

func (m *QuerySignatureResponse) GetThresholdSignature() *QuerySignatureResponse_ThresholdSignature {
	if x, ok := m.GetSig().(*QuerySignatureResponse_ThresholdSignature_); ok {
		return x.ThresholdSignature
	}
	return nil
}

func (m *QuerySignatureResponse) GetMultisigSignature() *QuerySignatureResponse_MultisigSignature {
	if x, ok := m.GetSig().(*QuerySignatureResponse_MultisigSignature_); ok {
		return x.MultisigSignature
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*QuerySignatureResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*QuerySignatureResponse_ThresholdSignature_)(nil),
		(*QuerySignatureResponse_MultisigSignature_)(nil),
	}
}

type QuerySignatureResponse_Signature struct {
	R string `protobuf:"bytes,1,opt,name=r,proto3" json:"r,omitempty"`
	S string `protobuf:"bytes,2,opt,name=s,proto3" json:"s,omitempty"`
}

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

var xxx_messageInfo_QuerySignatureResponse_Signature proto.InternalMessageInfo

type QuerySignatureResponse_ThresholdSignature struct {
	VoteStatus VoteStatus                        `protobuf:"varint,1,opt,name=vote_status,json=voteStatus,proto3,enum=axelar.tss.v1beta1.VoteStatus" json:"vote_status,omitempty"`
	Signature  *QuerySignatureResponse_Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
}

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

var xxx_messageInfo_QuerySignatureResponse_ThresholdSignature proto.InternalMessageInfo

type QuerySignatureResponse_MultisigSignature struct {
	SigStatus  exported.SigStatus                 `protobuf:"varint,1,opt,name=sig_status,json=sigStatus,proto3,enum=axelar.tss.exported.v1beta1.SigStatus" json:"sig_status,omitempty"`
	Signatures []QuerySignatureResponse_Signature `protobuf:"bytes,2,rep,name=signatures,proto3" json:"signatures"`
}

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

var xxx_messageInfo_QuerySignatureResponse_MultisigSignature proto.InternalMessageInfo

type QueryKeyResponse struct {
	// Types that are valid to be assigned to PublicKey:
	//	*QueryKeyResponse_ECDSAKey_
	//	*QueryKeyResponse_MultisigKey_
	PublicKey isQueryKeyResponse_PublicKey `protobuf_oneof:"public_key"`
	Role      exported.KeyRole             `protobuf:"varint,3,opt,name=role,proto3,enum=axelar.tss.exported.v1beta1.KeyRole" json:"role,omitempty"`
	RotatedAt *time.Time                   `protobuf:"bytes,4,opt,name=rotated_at,json=rotatedAt,proto3,stdtime" json:"rotated_at,omitempty"`
}

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

var xxx_messageInfo_QueryKeyResponse proto.InternalMessageInfo

type isQueryKeyResponse_PublicKey interface {
	isQueryKeyResponse_PublicKey()
	MarshalTo([]byte) (int, error)
	Size() int
}

type QueryKeyResponse_ECDSAKey_ struct {
	ECDSAKey *QueryKeyResponse_ECDSAKey `protobuf:"bytes,1,opt,name=ecdsa_key,json=ecdsaKey,proto3,oneof" json:"ecdsa_key,omitempty"`
}
type QueryKeyResponse_MultisigKey_ struct {
	MultisigKey *QueryKeyResponse_MultisigKey `protobuf:"bytes,2,opt,name=multisig_key,json=multisigKey,proto3,oneof" json:"multisig_key,omitempty"`
}

func (*QueryKeyResponse_ECDSAKey_) isQueryKeyResponse_PublicKey()    {}
func (*QueryKeyResponse_MultisigKey_) isQueryKeyResponse_PublicKey() {}

func (m *QueryKeyResponse) GetPublicKey() isQueryKeyResponse_PublicKey {
	if m != nil {
		return m.PublicKey
	}
	return nil
}

func (m *QueryKeyResponse) GetECDSAKey() *QueryKeyResponse_ECDSAKey {
	if x, ok := m.GetPublicKey().(*QueryKeyResponse_ECDSAKey_); ok {
		return x.ECDSAKey
	}
	return nil
}

func (m *QueryKeyResponse) GetMultisigKey() *QueryKeyResponse_MultisigKey {
	if x, ok := m.GetPublicKey().(*QueryKeyResponse_MultisigKey_); ok {
		return x.MultisigKey
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*QueryKeyResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*QueryKeyResponse_ECDSAKey_)(nil),
		(*QueryKeyResponse_MultisigKey_)(nil),
	}
}

type QueryKeyResponse_Key struct {
	X string `protobuf:"bytes,1,opt,name=x,proto3" json:"x,omitempty"`
	Y string `protobuf:"bytes,2,opt,name=y,proto3" json:"y,omitempty"`
}

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

var xxx_messageInfo_QueryKeyResponse_Key proto.InternalMessageInfo

type QueryKeyResponse_ECDSAKey struct {
	VoteStatus VoteStatus           `protobuf:"varint,1,opt,name=vote_status,json=voteStatus,proto3,enum=axelar.tss.v1beta1.VoteStatus" json:"vote_status,omitempty"`
	Key        QueryKeyResponse_Key `protobuf:"bytes,2,opt,name=key,proto3" json:"key"`
}

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

var xxx_messageInfo_QueryKeyResponse_ECDSAKey proto.InternalMessageInfo

type QueryKeyResponse_MultisigKey struct {
	Threshold int64                  `protobuf:"varint,1,opt,name=threshold,proto3" json:"threshold,omitempty"`
	Key       []QueryKeyResponse_Key `protobuf:"bytes,2,rep,name=key,proto3" json:"key"`
}

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

var xxx_messageInfo_QueryKeyResponse_MultisigKey proto.InternalMessageInfo

type QueryRecoveryResponse struct {
	PartyUids        []string            `protobuf:"bytes,1,rep,name=party_uids,json=partyUids,proto3" json:"party_uids,omitempty"`
	PartyShareCounts []uint32            `protobuf:"varint,2,rep,packed,name=party_share_counts,json=partyShareCounts,proto3" json:"party_share_counts,omitempty"`
	Threshold        uint32              `protobuf:"varint,3,opt,name=threshold,proto3" json:"threshold,omitempty"`
	KeygenOutput     *tofnd.KeygenOutput `protobuf:"bytes,4,opt,name=keygen_output,json=keygenOutput,proto3" json:"keygen_output,omitempty"`
}

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

var xxx_messageInfo_QueryRecoveryResponse proto.InternalMessageInfo

type QueryKeyShareResponse struct {
	ShareInfos []QueryKeyShareResponse_ShareInfo `protobuf:"bytes,1,rep,name=share_infos,json=shareInfos,proto3" json:"share_infos"`
}

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

var xxx_messageInfo_QueryKeyShareResponse proto.InternalMessageInfo

type QueryKeyShareResponse_ShareInfo struct {
	KeyID               github_com_axelarnetwork_axelar_core_x_tss_exported.KeyID `protobuf:"bytes,1,opt,name=key_id,json=keyId,proto3,casttype=github.com/axelarnetwork/axelar-core/x/tss/exported.KeyID" json:"key_id,omitempty"`
	KeyChain            string                                                    `protobuf:"bytes,2,opt,name=key_chain,json=keyChain,proto3" json:"key_chain,omitempty"`
	KeyRole             string                                                    `protobuf:"bytes,3,opt,name=key_role,json=keyRole,proto3" json:"key_role,omitempty"`
	SnapshotBlockNumber int64                                                     `protobuf:"varint,4,opt,name=snapshot_block_number,json=snapshotBlockNumber,proto3" json:"snapshot_block_number,omitempty"`
	ValidatorAddress    string                                                    `protobuf:"bytes,5,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
	NumValidatorShares  int64                                                     `protobuf:"varint,6,opt,name=num_validator_shares,json=numValidatorShares,proto3" json:"num_validator_shares,omitempty"`
	NumTotalShares      int64                                                     `protobuf:"varint,7,opt,name=num_total_shares,json=numTotalShares,proto3" json:"num_total_shares,omitempty"`
}

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

var xxx_messageInfo_QueryKeyShareResponse_ShareInfo proto.InternalMessageInfo

type QueryDeactivatedOperatorsResponse struct {
	OperatorAddresses []string `protobuf:"bytes,1,rep,name=operator_addresses,json=operatorAddresses,proto3" json:"operator_addresses,omitempty"`
}

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

var xxx_messageInfo_QueryDeactivatedOperatorsResponse proto.InternalMessageInfo

type QueryActiveOldKeysValidatorResponse struct {
	KeysInfo []QueryActiveOldKeysValidatorResponse_KeyInfo `protobuf:"bytes,1,rep,name=keys_info,json=keysInfo,proto3" json:"keys_info"`
}

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

var xxx_messageInfo_QueryActiveOldKeysValidatorResponse proto.InternalMessageInfo

type QueryActiveOldKeysValidatorResponse_KeyInfo struct {
	ID    github_com_axelarnetwork_axelar_core_x_tss_exported.KeyID   `protobuf:"bytes,1,opt,name=id,proto3,casttype=github.com/axelarnetwork/axelar-core/x/tss/exported.KeyID" json:"id,omitempty"`
	Chain string                                                      `protobuf:"bytes,2,opt,name=chain,proto3" json:"chain,omitempty"`
	Role  github_com_axelarnetwork_axelar_core_x_tss_exported.KeyRole `protobuf:"varint,3,opt,name=role,proto3,casttype=github.com/axelarnetwork/axelar-core/x/tss/exported.KeyRole" json:"role,omitempty"`
}

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

var xxx_messageInfo_QueryActiveOldKeysValidatorResponse_KeyInfo proto.InternalMessageInfo

type QueryActiveOldKeysResponse struct {
	KeyIDs []github_com_axelarnetwork_axelar_core_x_tss_exported.KeyID `protobuf:"bytes,1,rep,name=key_ids,json=keyIds,proto3,casttype=github.com/axelarnetwork/axelar-core/x/tss/exported.KeyID" json:"key_ids,omitempty"`
}

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

var xxx_messageInfo_QueryActiveOldKeysResponse proto.InternalMessageInfo

type QueryExternalKeyIDResponse struct {
	KeyIDs []github_com_axelarnetwork_axelar_core_x_tss_exported.KeyID `protobuf:"bytes,1,rep,name=key_ids,json=keyIds,proto3,casttype=github.com/axelarnetwork/axelar-core/x/tss/exported.KeyID" json:"key_ids,omitempty"`
}

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

var xxx_messageInfo_QueryExternalKeyIDResponse proto.InternalMessageInfo

type NextKeyIDRequest struct {
	Chain   string           `protobuf:"bytes,1,opt,name=chain,proto3" json:"chain,omitempty"`
	KeyRole exported.KeyRole `protobuf:"varint,2,opt,name=key_role,json=keyRole,proto3,enum=axelar.tss.exported.v1beta1.KeyRole" json:"key_role,omitempty"`
}

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

var xxx_messageInfo_NextKeyIDRequest proto.InternalMessageInfo

type NextKeyIDResponse struct {
	KeyID github_com_axelarnetwork_axelar_core_x_tss_exported.KeyID `protobuf:"bytes,1,opt,name=key_id,json=keyId,proto3,casttype=github.com/axelarnetwork/axelar-core/x/tss/exported.KeyID" json:"key_id,omitempty"`
}

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

var xxx_messageInfo_NextKeyIDResponse proto.InternalMessageInfo

type AssignableKeyRequest struct {
	Chain   string           `protobuf:"bytes,1,opt,name=chain,proto3" json:"chain,omitempty"`
	KeyRole exported.KeyRole `protobuf:"varint,2,opt,name=key_role,json=keyRole,proto3,enum=axelar.tss.exported.v1beta1.KeyRole" json:"key_role,omitempty"`
}

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

var xxx_messageInfo_AssignableKeyRequest proto.InternalMessageInfo

type AssignableKeyResponse struct {
	Assignable bool `protobuf:"varint,1,opt,name=assignable,proto3" json:"assignable,omitempty"`
}

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

var xxx_messageInfo_AssignableKeyResponse proto.InternalMessageInfo

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

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

var xxx_messageInfo_ValidatorMultisigKeysRequest proto.InternalMessageInfo

type ValidatorMultisigKeysResponse struct {
	Keys map[string]*ValidatorMultisigKeysResponse_Keys `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_ValidatorMultisigKeysResponse proto.InternalMessageInfo

type ValidatorMultisigKeysResponse_Keys struct {
	Keys [][]byte `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"`
}

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

var xxx_messageInfo_ValidatorMultisigKeysResponse_Keys proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("axelar.tss.v1beta1.VoteStatus", VoteStatus_name, VoteStatus_value)
	proto.RegisterType((*QuerySignatureResponse)(nil), "axelar.tss.v1beta1.QuerySignatureResponse")
	proto.RegisterType((*QuerySignatureResponse_Signature)(nil), "axelar.tss.v1beta1.QuerySignatureResponse.Signature")
	proto.RegisterType((*QuerySignatureResponse_ThresholdSignature)(nil), "axelar.tss.v1beta1.QuerySignatureResponse.ThresholdSignature")
	proto.RegisterType((*QuerySignatureResponse_MultisigSignature)(nil), "axelar.tss.v1beta1.QuerySignatureResponse.MultisigSignature")
	proto.RegisterType((*QueryKeyResponse)(nil), "axelar.tss.v1beta1.QueryKeyResponse")
	proto.RegisterType((*QueryKeyResponse_Key)(nil), "axelar.tss.v1beta1.QueryKeyResponse.Key")
	proto.RegisterType((*QueryKeyResponse_ECDSAKey)(nil), "axelar.tss.v1beta1.QueryKeyResponse.ECDSAKey")
	proto.RegisterType((*QueryKeyResponse_MultisigKey)(nil), "axelar.tss.v1beta1.QueryKeyResponse.MultisigKey")
	proto.RegisterType((*QueryRecoveryResponse)(nil), "axelar.tss.v1beta1.QueryRecoveryResponse")
	proto.RegisterType((*QueryKeyShareResponse)(nil), "axelar.tss.v1beta1.QueryKeyShareResponse")
	proto.RegisterType((*QueryKeyShareResponse_ShareInfo)(nil), "axelar.tss.v1beta1.QueryKeyShareResponse.ShareInfo")
	proto.RegisterType((*QueryDeactivatedOperatorsResponse)(nil), "axelar.tss.v1beta1.QueryDeactivatedOperatorsResponse")
	proto.RegisterType((*QueryActiveOldKeysValidatorResponse)(nil), "axelar.tss.v1beta1.QueryActiveOldKeysValidatorResponse")
	proto.RegisterType((*QueryActiveOldKeysValidatorResponse_KeyInfo)(nil), "axelar.tss.v1beta1.QueryActiveOldKeysValidatorResponse.KeyInfo")
	proto.RegisterType((*QueryActiveOldKeysResponse)(nil), "axelar.tss.v1beta1.QueryActiveOldKeysResponse")
	proto.RegisterType((*QueryExternalKeyIDResponse)(nil), "axelar.tss.v1beta1.QueryExternalKeyIDResponse")
	proto.RegisterType((*NextKeyIDRequest)(nil), "axelar.tss.v1beta1.NextKeyIDRequest")
	proto.RegisterType((*NextKeyIDResponse)(nil), "axelar.tss.v1beta1.NextKeyIDResponse")
	proto.RegisterType((*AssignableKeyRequest)(nil), "axelar.tss.v1beta1.AssignableKeyRequest")
	proto.RegisterType((*AssignableKeyResponse)(nil), "axelar.tss.v1beta1.AssignableKeyResponse")
	proto.RegisterType((*ValidatorMultisigKeysRequest)(nil), "axelar.tss.v1beta1.ValidatorMultisigKeysRequest")
	proto.RegisterType((*ValidatorMultisigKeysResponse)(nil), "axelar.tss.v1beta1.ValidatorMultisigKeysResponse")
	proto.RegisterMapType((map[string]*ValidatorMultisigKeysResponse_Keys)(nil), "axelar.tss.v1beta1.ValidatorMultisigKeysResponse.KeysEntry")
	proto.RegisterType((*ValidatorMultisigKeysResponse_Keys)(nil), "axelar.tss.v1beta1.ValidatorMultisigKeysResponse.Keys")
}

func init() { proto.RegisterFile("axelar/tss/v1beta1/query.proto", fileDescriptor_ef30ba194f672ab8) }

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

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

func (m *QuerySignatureResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Sig != nil {
		{
			size := m.Sig.Size()
			i -= size
			if _, err := m.Sig.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *QuerySignatureResponse_ThresholdSignature_) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *QuerySignatureResponse_MultisigSignature_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.MultisigSignature != nil {
		{
			size, err := m.MultisigSignature.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *QuerySignatureResponse_Signature) 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 *QuerySignatureResponse_Signature) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

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

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

func (m *QuerySignatureResponse_MultisigSignature) 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] = 0x12
		}
	}
	if m.SigStatus != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.SigStatus))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryKeyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RotatedAt != nil {
		n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.RotatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.RotatedAt):])
		if err4 != nil {
			return 0, err4
		}
		i -= n4
		i = encodeVarintQuery(dAtA, i, uint64(n4))
		i--
		dAtA[i] = 0x22
	}
	if m.Role != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Role))
		i--
		dAtA[i] = 0x18
	}
	if m.PublicKey != nil {
		{
			size := m.PublicKey.Size()
			i -= size
			if _, err := m.PublicKey.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *QueryKeyResponse_ECDSAKey_) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *QueryKeyResponse_MultisigKey_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.MultisigKey != nil {
		{
			size, err := m.MultisigKey.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *QueryKeyResponse_Key) 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 *QueryKeyResponse_Key) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

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

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

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

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

func (m *QueryRecoveryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.KeygenOutput != nil {
		{
			size, err := m.KeygenOutput.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Threshold != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Threshold))
		i--
		dAtA[i] = 0x18
	}
	if len(m.PartyShareCounts) > 0 {
		dAtA10 := make([]byte, len(m.PartyShareCounts)*10)
		var j9 int
		for _, num := range m.PartyShareCounts {
			for num >= 1<<7 {
				dAtA10[j9] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j9++
			}
			dAtA10[j9] = uint8(num)
			j9++
		}
		i -= j9
		copy(dAtA[i:], dAtA10[:j9])
		i = encodeVarintQuery(dAtA, i, uint64(j9))
		i--
		dAtA[i] = 0x12
	}
	if len(m.PartyUids) > 0 {
		for iNdEx := len(m.PartyUids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PartyUids[iNdEx])
			copy(dAtA[i:], m.PartyUids[iNdEx])
			i = encodeVarintQuery(dAtA, i, uint64(len(m.PartyUids[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *QueryKeyShareResponse_ShareInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NumTotalShares != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.NumTotalShares))
		i--
		dAtA[i] = 0x38
	}
	if m.NumValidatorShares != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.NumValidatorShares))
		i--
		dAtA[i] = 0x30
	}
	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] = 0x2a
	}
	if m.SnapshotBlockNumber != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.SnapshotBlockNumber))
		i--
		dAtA[i] = 0x20
	}
	if len(m.KeyRole) > 0 {
		i -= len(m.KeyRole)
		copy(dAtA[i:], m.KeyRole)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.KeyRole)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.KeyChain) > 0 {
		i -= len(m.KeyChain)
		copy(dAtA[i:], m.KeyChain)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.KeyChain)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.KeyID) > 0 {
		i -= len(m.KeyID)
		copy(dAtA[i:], m.KeyID)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.KeyID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

func (m *QueryActiveOldKeysValidatorResponse_KeyInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Role != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Role))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Chain) > 0 {
		i -= len(m.Chain)
		copy(dAtA[i:], m.Chain)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Chain)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

func (m *AssignableKeyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Assignable {
		i--
		if m.Assignable {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ValidatorMultisigKeysResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Keys) > 0 {
		for k := range m.Keys {
			v := m.Keys[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintQuery(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintQuery(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintQuery(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *ValidatorMultisigKeysResponse_Keys) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Keys) > 0 {
		for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Keys[iNdEx])
			copy(dAtA[i:], m.Keys[iNdEx])
			i = encodeVarintQuery(dAtA, i, uint64(len(m.Keys[iNdEx])))
			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 *QuerySignatureResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Sig != nil {
		n += m.Sig.Size()
	}
	return n
}

func (m *QuerySignatureResponse_ThresholdSignature_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ThresholdSignature != nil {
		l = m.ThresholdSignature.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}
func (m *QuerySignatureResponse_MultisigSignature_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MultisigSignature != nil {
		l = m.MultisigSignature.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}
func (m *QuerySignatureResponse_Signature) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.R)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.S)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

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

func (m *QueryKeyResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PublicKey != nil {
		n += m.PublicKey.Size()
	}
	if m.Role != 0 {
		n += 1 + sovQuery(uint64(m.Role))
	}
	if m.RotatedAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.RotatedAt)
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryKeyResponse_ECDSAKey_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ECDSAKey != nil {
		l = m.ECDSAKey.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}
func (m *QueryKeyResponse_MultisigKey_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MultisigKey != nil {
		l = m.MultisigKey.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}
func (m *QueryKeyResponse_Key) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.X)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.Y)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

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

func (m *QueryRecoveryResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.PartyUids) > 0 {
		for _, s := range m.PartyUids {
			l = len(s)
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	if len(m.PartyShareCounts) > 0 {
		l = 0
		for _, e := range m.PartyShareCounts {
			l += sovQuery(uint64(e))
		}
		n += 1 + sovQuery(uint64(l)) + l
	}
	if m.Threshold != 0 {
		n += 1 + sovQuery(uint64(m.Threshold))
	}
	if m.KeygenOutput != nil {
		l = m.KeygenOutput.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

func (m *QueryKeyShareResponse_ShareInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.KeyID)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.KeyChain)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.KeyRole)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.SnapshotBlockNumber != 0 {
		n += 1 + sovQuery(uint64(m.SnapshotBlockNumber))
	}
	l = len(m.ValidatorAddress)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.NumValidatorShares != 0 {
		n += 1 + sovQuery(uint64(m.NumValidatorShares))
	}
	if m.NumTotalShares != 0 {
		n += 1 + sovQuery(uint64(m.NumTotalShares))
	}
	return n
}

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

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

func (m *QueryActiveOldKeysValidatorResponse_KeyInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.Chain)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Role != 0 {
		n += 1 + sovQuery(uint64(m.Role))
	}
	return n
}

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

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

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

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

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

func (m *AssignableKeyResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Assignable {
		n += 2
	}
	return n
}

func (m *ValidatorMultisigKeysRequest) 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 *ValidatorMultisigKeysResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Keys) > 0 {
		for k, v := range m.Keys {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovQuery(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovQuery(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovQuery(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *ValidatorMultisigKeysResponse_Keys) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Keys) > 0 {
		for _, b := range m.Keys {
			l = len(b)
			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 *QuerySignatureResponse) 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: QuerySignatureResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySignatureResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ThresholdSignature", 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
			}
			v := &QuerySignatureResponse_ThresholdSignature{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Sig = &QuerySignatureResponse_ThresholdSignature_{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MultisigSignature", 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
			}
			v := &QuerySignatureResponse_MultisigSignature{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Sig = &QuerySignatureResponse_MultisigSignature_{v}
			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 *QuerySignatureResponse_Signature) 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: Signature: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Signature: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field R", wireType)
			}
			var 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.R = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field S", 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.S = 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 *QuerySignatureResponse_ThresholdSignature) 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: ThresholdSignature: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ThresholdSignature: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VoteStatus", wireType)
			}
			m.VoteStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VoteStatus |= VoteStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", 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.Signature == nil {
				m.Signature = &QuerySignatureResponse_Signature{}
			}
			if err := m.Signature.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 *QuerySignatureResponse_MultisigSignature) 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: MultisigSignature: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MultisigSignature: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SigStatus", wireType)
			}
			m.SigStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SigStatus |= exported.SigStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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, QuerySignatureResponse_Signature{})
			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 *QueryKeyResponse) 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: QueryKeyResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryKeyResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ECDSAKey", 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
			}
			v := &QueryKeyResponse_ECDSAKey{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.PublicKey = &QueryKeyResponse_ECDSAKey_{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MultisigKey", 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
			}
			v := &QueryKeyResponse_MultisigKey{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.PublicKey = &QueryKeyResponse_MultisigKey_{v}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
			}
			m.Role = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Role |= exported.KeyRole(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RotatedAt", 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.RotatedAt == nil {
				m.RotatedAt = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.RotatedAt, 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 *QueryKeyResponse_Key) 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: Key: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Key: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field X", 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.X = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Y", 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.Y = 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 *QueryKeyResponse_ECDSAKey) 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: ECDSAKey: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ECDSAKey: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VoteStatus", wireType)
			}
			m.VoteStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VoteStatus |= VoteStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", 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.Key.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 *QueryKeyResponse_MultisigKey) 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: MultisigKey: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MultisigKey: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Threshold", wireType)
			}
			m.Threshold = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Threshold |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", 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.Key = append(m.Key, QueryKeyResponse_Key{})
			if err := m.Key[len(m.Key)-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 *QueryRecoveryResponse) 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: QueryRecoveryResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryRecoveryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PartyUids", 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.PartyUids = append(m.PartyUids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQuery
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.PartyShareCounts = append(m.PartyShareCounts, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQuery
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthQuery
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthQuery
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.PartyShareCounts) == 0 {
					m.PartyShareCounts = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowQuery
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.PartyShareCounts = append(m.PartyShareCounts, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PartyShareCounts", wireType)
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Threshold", wireType)
			}
			m.Threshold = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Threshold |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeygenOutput", 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.KeygenOutput == nil {
				m.KeygenOutput = &tofnd.KeygenOutput{}
			}
			if err := m.KeygenOutput.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 *QueryKeyShareResponse) 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: QueryKeyShareResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryKeyShareResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShareInfos", 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.ShareInfos = append(m.ShareInfos, QueryKeyShareResponse_ShareInfo{})
			if err := m.ShareInfos[len(m.ShareInfos)-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 *QueryKeyShareResponse_ShareInfo) 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: ShareInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShareInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyID", 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.KeyID = github_com_axelarnetwork_axelar_core_x_tss_exported.KeyID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyChain", 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.KeyChain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyRole", 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.KeyRole = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SnapshotBlockNumber", wireType)
			}
			m.SnapshotBlockNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SnapshotBlockNumber |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumValidatorShares", wireType)
			}
			m.NumValidatorShares = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumValidatorShares |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumTotalShares", wireType)
			}
			m.NumTotalShares = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumTotalShares |= int64(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 *QueryDeactivatedOperatorsResponse) 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: QueryDeactivatedOperatorsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryDeactivatedOperatorsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OperatorAddresses", 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.OperatorAddresses = append(m.OperatorAddresses, 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 *QueryActiveOldKeysValidatorResponse) 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: QueryActiveOldKeysValidatorResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryActiveOldKeysValidatorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeysInfo", 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.KeysInfo = append(m.KeysInfo, QueryActiveOldKeysValidatorResponse_KeyInfo{})
			if err := m.KeysInfo[len(m.KeysInfo)-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 *QueryActiveOldKeysValidatorResponse_KeyInfo) 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: KeyInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KeyInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", 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.ID = github_com_axelarnetwork_axelar_core_x_tss_exported.KeyID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chain", 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.Chain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
			}
			m.Role = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Role |= github_com_axelarnetwork_axelar_core_x_tss_exported.KeyRole(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 *QueryActiveOldKeysResponse) 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: QueryActiveOldKeysResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryActiveOldKeysResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyIDs", 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.KeyIDs = append(m.KeyIDs, github_com_axelarnetwork_axelar_core_x_tss_exported.KeyID(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 *QueryExternalKeyIDResponse) 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: QueryExternalKeyIDResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryExternalKeyIDResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyIDs", 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.KeyIDs = append(m.KeyIDs, github_com_axelarnetwork_axelar_core_x_tss_exported.KeyID(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 *NextKeyIDRequest) 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: NextKeyIDRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NextKeyIDRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chain", 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.Chain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyRole", wireType)
			}
			m.KeyRole = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.KeyRole |= exported.KeyRole(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 *NextKeyIDResponse) 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: NextKeyIDResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NextKeyIDResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyID", 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.KeyID = github_com_axelarnetwork_axelar_core_x_tss_exported.KeyID(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 *AssignableKeyRequest) 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: AssignableKeyRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AssignableKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chain", 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.Chain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyRole", wireType)
			}
			m.KeyRole = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.KeyRole |= exported.KeyRole(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 *AssignableKeyResponse) 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: AssignableKeyResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AssignableKeyResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Assignable", 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.Assignable = 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 *ValidatorMultisigKeysRequest) 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: ValidatorMultisigKeysRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorMultisigKeysRequest: 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 *ValidatorMultisigKeysResponse) 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: ValidatorMultisigKeysResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorMultisigKeysResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Keys", 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.Keys == nil {
				m.Keys = make(map[string]*ValidatorMultisigKeysResponse_Keys)
			}
			var mapkey string
			var mapvalue *ValidatorMultisigKeysResponse_Keys
			for iNdEx < postIndex {
				entryPreIndex := 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)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowQuery
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthQuery
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQuery
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowQuery
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthQuery
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthQuery
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &ValidatorMultisigKeysResponse_Keys{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQuery(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQuery
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Keys[mapkey] = mapvalue
			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 *ValidatorMultisigKeysResponse_Keys) 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: Keys: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Keys: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Keys", 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.Keys = append(m.Keys, make([]byte, postIndex-iNdEx))
			copy(m.Keys[len(m.Keys)-1], 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 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")
)