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

package types

import (
	context "context"
	fmt "fmt"
	github_com_bandprotocol_chain_v3_pkg_tss "github.com/bandprotocol/chain/v3/pkg/tss"
	_ "github.com/cosmos/cosmos-proto"
	_ "github.com/cosmos/cosmos-sdk/types/msgservice"
	_ "github.com/cosmos/cosmos-sdk/types/tx/amino"
	_ "github.com/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// MsgSubmitDKGRound1 is the Msg/MsgSubmitDKGRound1 request type.
type MsgSubmitDKGRound1 struct {
	// group_id is ID of the group.
	GroupID github_com_bandprotocol_chain_v3_pkg_tss.GroupID `protobuf:"varint,1,opt,name=group_id,json=groupId,proto3,casttype=github.com/bandprotocol/chain/v3/pkg/tss.GroupID" json:"group_id,omitempty"`
	// round1_info is all data that require to handle round 1.
	Round1Info Round1Info `protobuf:"bytes,2,opt,name=round1_info,json=round1Info,proto3" json:"round1_info"`
	// sender is the user address that submits the group creation information;
	// must be a member of this group.
	Sender string `protobuf:"bytes,3,opt,name=sender,proto3" json:"sender,omitempty"`
}

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

var xxx_messageInfo_MsgSubmitDKGRound1 proto.InternalMessageInfo

func (m *MsgSubmitDKGRound1) GetGroupID() github_com_bandprotocol_chain_v3_pkg_tss.GroupID {
	if m != nil {
		return m.GroupID
	}
	return 0
}

func (m *MsgSubmitDKGRound1) GetRound1Info() Round1Info {
	if m != nil {
		return m.Round1Info
	}
	return Round1Info{}
}

func (m *MsgSubmitDKGRound1) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

// MsgSubmitDKGRound1Response is the Msg/SubmitDKGRound1 response type.
type MsgSubmitDKGRound1Response struct {
}

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

var xxx_messageInfo_MsgSubmitDKGRound1Response proto.InternalMessageInfo

// MsgSubmitDKGRound2 is the Msg/SubmitDKGRound2 request type.
type MsgSubmitDKGRound2 struct {
	// group_id is ID of the group.
	GroupID github_com_bandprotocol_chain_v3_pkg_tss.GroupID `protobuf:"varint,1,opt,name=group_id,json=groupId,proto3,casttype=github.com/bandprotocol/chain/v3/pkg/tss.GroupID" json:"group_id,omitempty"`
	// round2_info is all data that is required to handle round 2.
	Round2Info Round2Info `protobuf:"bytes,2,opt,name=round2_info,json=round2Info,proto3" json:"round2_info"`
	// sender is the user address that submits the group creation information;
	// must be a member of this group.
	Sender string `protobuf:"bytes,3,opt,name=sender,proto3" json:"sender,omitempty"`
}

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

var xxx_messageInfo_MsgSubmitDKGRound2 proto.InternalMessageInfo

func (m *MsgSubmitDKGRound2) GetGroupID() github_com_bandprotocol_chain_v3_pkg_tss.GroupID {
	if m != nil {
		return m.GroupID
	}
	return 0
}

func (m *MsgSubmitDKGRound2) GetRound2Info() Round2Info {
	if m != nil {
		return m.Round2Info
	}
	return Round2Info{}
}

func (m *MsgSubmitDKGRound2) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

// MsgSubmitDKGRound2Response is response data for MsgSubmitDKGRound2 message
type MsgSubmitDKGRound2Response struct {
}

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

var xxx_messageInfo_MsgSubmitDKGRound2Response proto.InternalMessageInfo

// MsgComplain is a message used to complain about malicious actors in the group.
type MsgComplain struct {
	// group_id is ID of the group.
	GroupID github_com_bandprotocol_chain_v3_pkg_tss.GroupID `protobuf:"varint,1,opt,name=group_id,json=groupId,proto3,casttype=github.com/bandprotocol/chain/v3/pkg/tss.GroupID" json:"group_id,omitempty"`
	// complaints is a list of complaints.
	Complaints []Complaint `protobuf:"bytes,2,rep,name=complaints,proto3" json:"complaints"`
	// sender is the user address that submits the group creation information;
	// must be a member of this group.
	Sender string `protobuf:"bytes,3,opt,name=sender,proto3" json:"sender,omitempty"`
}

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

var xxx_messageInfo_MsgComplain proto.InternalMessageInfo

func (m *MsgComplain) GetGroupID() github_com_bandprotocol_chain_v3_pkg_tss.GroupID {
	if m != nil {
		return m.GroupID
	}
	return 0
}

func (m *MsgComplain) GetComplaints() []Complaint {
	if m != nil {
		return m.Complaints
	}
	return nil
}

func (m *MsgComplain) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

// MsgComplainResponse is response data for MsgComplain message
type MsgComplainResponse struct {
}

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

var xxx_messageInfo_MsgComplainResponse proto.InternalMessageInfo

// MsgConfirm is a message used to confirm own public key.
type MsgConfirm struct {
	// group_id is ID of the group.
	GroupID github_com_bandprotocol_chain_v3_pkg_tss.GroupID `protobuf:"varint,1,opt,name=group_id,json=groupId,proto3,casttype=github.com/bandprotocol/chain/v3/pkg/tss.GroupID" json:"group_id,omitempty"`
	// member_id is ID of the sender.
	MemberID github_com_bandprotocol_chain_v3_pkg_tss.MemberID `protobuf:"varint,2,opt,name=member_id,json=memberId,proto3,casttype=github.com/bandprotocol/chain/v3/pkg/tss.MemberID" json:"member_id,omitempty"`
	// own_pub_key_sig is a signature of the member_i on its own PubKey to confirm
	// that the address is able to derive the PubKey.
	OwnPubKeySig github_com_bandprotocol_chain_v3_pkg_tss.Signature `protobuf:"bytes,3,opt,name=own_pub_key_sig,json=ownPubKeySig,proto3,casttype=github.com/bandprotocol/chain/v3/pkg/tss.Signature" json:"own_pub_key_sig,omitempty"`
	// sender is the user address that submits the group creation information;
	// must be a member of this group.
	Sender string `protobuf:"bytes,4,opt,name=sender,proto3" json:"sender,omitempty"`
}

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

var xxx_messageInfo_MsgConfirm proto.InternalMessageInfo

func (m *MsgConfirm) GetGroupID() github_com_bandprotocol_chain_v3_pkg_tss.GroupID {
	if m != nil {
		return m.GroupID
	}
	return 0
}

func (m *MsgConfirm) GetMemberID() github_com_bandprotocol_chain_v3_pkg_tss.MemberID {
	if m != nil {
		return m.MemberID
	}
	return 0
}

func (m *MsgConfirm) GetOwnPubKeySig() github_com_bandprotocol_chain_v3_pkg_tss.Signature {
	if m != nil {
		return m.OwnPubKeySig
	}
	return nil
}

func (m *MsgConfirm) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

// MsgConfirmResponse is response data for MsgConfirm message
type MsgConfirmResponse struct {
}

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

var xxx_messageInfo_MsgConfirmResponse proto.InternalMessageInfo

// MsgSubmitDEs is a message used to submit a list of DEs.
type MsgSubmitDEs struct {
	// des is a list of DE objects.
	DEs []DE `protobuf:"bytes,1,rep,name=des,proto3" json:"des"`
	// sender is the user address that submits DE objects.
	Sender string `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty"`
}

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

var xxx_messageInfo_MsgSubmitDEs proto.InternalMessageInfo

func (m *MsgSubmitDEs) GetDEs() []DE {
	if m != nil {
		return m.DEs
	}
	return nil
}

func (m *MsgSubmitDEs) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

// MsgSubmitDEsResponse is response data for MsgSubmitDEs message
type MsgSubmitDEsResponse struct {
}

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

var xxx_messageInfo_MsgSubmitDEsResponse proto.InternalMessageInfo

// MsgResetDE is a message used to reset the DEs that being stored on chain.
type MsgResetDE struct {
	// sender is the user address that request for resetting DEs.
	Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
}

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

var xxx_messageInfo_MsgResetDE proto.InternalMessageInfo

func (m *MsgResetDE) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

// MsgResetDEResponse is response data for MsgResetDE message
type MsgResetDEResponse struct {
}

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

var xxx_messageInfo_MsgResetDEResponse proto.InternalMessageInfo

// MsgSubmitSignature is a message used to submitting signature data.
type MsgSubmitSignature struct {
	// signing_id is the unique identifier of the signing process.
	SigningID github_com_bandprotocol_chain_v3_pkg_tss.SigningID `protobuf:"varint,1,opt,name=signing_id,json=signingId,proto3,casttype=github.com/bandprotocol/chain/v3/pkg/tss.SigningID" json:"signing_id,omitempty"`
	// member_id is the unique identifier of the signer in the group.
	MemberID github_com_bandprotocol_chain_v3_pkg_tss.MemberID `protobuf:"varint,2,opt,name=member_id,json=memberId,proto3,casttype=github.com/bandprotocol/chain/v3/pkg/tss.MemberID" json:"member_id,omitempty"`
	// signature is the signature produced by the signer.
	Signature github_com_bandprotocol_chain_v3_pkg_tss.Signature `protobuf:"bytes,3,opt,name=signature,proto3,casttype=github.com/bandprotocol/chain/v3/pkg/tss.Signature" json:"signature,omitempty"`
	// signer is the address who signs a message; must be a member of the group.
	Signer string `protobuf:"bytes,4,opt,name=signer,proto3" json:"signer,omitempty"`
}

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

var xxx_messageInfo_MsgSubmitSignature proto.InternalMessageInfo

func (m *MsgSubmitSignature) GetSigningID() github_com_bandprotocol_chain_v3_pkg_tss.SigningID {
	if m != nil {
		return m.SigningID
	}
	return 0
}

func (m *MsgSubmitSignature) GetMemberID() github_com_bandprotocol_chain_v3_pkg_tss.MemberID {
	if m != nil {
		return m.MemberID
	}
	return 0
}

func (m *MsgSubmitSignature) GetSignature() github_com_bandprotocol_chain_v3_pkg_tss.Signature {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *MsgSubmitSignature) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

// MsgSubmitSignatureResponse is response data for MsgSubmitSignature message
type MsgSubmitSignatureResponse struct {
}

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

var xxx_messageInfo_MsgSubmitSignatureResponse proto.InternalMessageInfo

// MsgUpdateParams is the Msg/UpdateParams request type.
type MsgUpdateParams struct {
	// params defines the x/tss parameters to update.
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
	// authority is the address of the governance account.
	Authority string `protobuf:"bytes,2,opt,name=authority,proto3" json:"authority,omitempty"`
}

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

var xxx_messageInfo_MsgUpdateParams proto.InternalMessageInfo

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

func (m *MsgUpdateParams) GetAuthority() string {
	if m != nil {
		return m.Authority
	}
	return ""
}

// MsgUpdateParamsResponse defines the response structure for executing a
// MsgUpdateParams message.
type MsgUpdateParamsResponse struct {
}

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

var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*MsgSubmitDKGRound1)(nil), "band.tss.v1beta1.MsgSubmitDKGRound1")
	proto.RegisterType((*MsgSubmitDKGRound1Response)(nil), "band.tss.v1beta1.MsgSubmitDKGRound1Response")
	proto.RegisterType((*MsgSubmitDKGRound2)(nil), "band.tss.v1beta1.MsgSubmitDKGRound2")
	proto.RegisterType((*MsgSubmitDKGRound2Response)(nil), "band.tss.v1beta1.MsgSubmitDKGRound2Response")
	proto.RegisterType((*MsgComplain)(nil), "band.tss.v1beta1.MsgComplain")
	proto.RegisterType((*MsgComplainResponse)(nil), "band.tss.v1beta1.MsgComplainResponse")
	proto.RegisterType((*MsgConfirm)(nil), "band.tss.v1beta1.MsgConfirm")
	proto.RegisterType((*MsgConfirmResponse)(nil), "band.tss.v1beta1.MsgConfirmResponse")
	proto.RegisterType((*MsgSubmitDEs)(nil), "band.tss.v1beta1.MsgSubmitDEs")
	proto.RegisterType((*MsgSubmitDEsResponse)(nil), "band.tss.v1beta1.MsgSubmitDEsResponse")
	proto.RegisterType((*MsgResetDE)(nil), "band.tss.v1beta1.MsgResetDE")
	proto.RegisterType((*MsgResetDEResponse)(nil), "band.tss.v1beta1.MsgResetDEResponse")
	proto.RegisterType((*MsgSubmitSignature)(nil), "band.tss.v1beta1.MsgSubmitSignature")
	proto.RegisterType((*MsgSubmitSignatureResponse)(nil), "band.tss.v1beta1.MsgSubmitSignatureResponse")
	proto.RegisterType((*MsgUpdateParams)(nil), "band.tss.v1beta1.MsgUpdateParams")
	proto.RegisterType((*MsgUpdateParamsResponse)(nil), "band.tss.v1beta1.MsgUpdateParamsResponse")
}

func init() { proto.RegisterFile("band/tss/v1beta1/tx.proto", fileDescriptor_150c9f4f841f0dbb) }

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// MsgClient is the client API for Msg service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MsgClient interface {
	// SubmitDKGRound1 submits dkg for computing round 1.
	SubmitDKGRound1(ctx context.Context, in *MsgSubmitDKGRound1, opts ...grpc.CallOption) (*MsgSubmitDKGRound1Response, error)
	// SubmitDKGRound2 submits dkg for computing round 2.
	SubmitDKGRound2(ctx context.Context, in *MsgSubmitDKGRound2, opts ...grpc.CallOption) (*MsgSubmitDKGRound2Response, error)
	// Complain submits proof for complaining malicious.
	Complain(ctx context.Context, in *MsgComplain, opts ...grpc.CallOption) (*MsgComplainResponse, error)
	// Confirm submits own signature for proof that it can derive the secret.
	Confirm(ctx context.Context, in *MsgConfirm, opts ...grpc.CallOption) (*MsgConfirmResponse, error)
	// SubmitDEs submits list of pre-commits DE for signing process.
	SubmitDEs(ctx context.Context, in *MsgSubmitDEs, opts ...grpc.CallOption) (*MsgSubmitDEsResponse, error)
	// ResetDE resets the submitted DEs that being stored on chain.
	ResetDE(ctx context.Context, in *MsgResetDE, opts ...grpc.CallOption) (*MsgResetDEResponse, error)
	// SubmitSignature submits signature on task participant need to do.
	SubmitSignature(ctx context.Context, in *MsgSubmitSignature, opts ...grpc.CallOption) (*MsgSubmitSignatureResponse, error)
	// UpdateParams defines a governance operation for updating the x/tss module
	// parameters.
	UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

func NewMsgClient(cc grpc1.ClientConn) MsgClient {
	return &msgClient{cc}
}

func (c *msgClient) SubmitDKGRound1(ctx context.Context, in *MsgSubmitDKGRound1, opts ...grpc.CallOption) (*MsgSubmitDKGRound1Response, error) {
	out := new(MsgSubmitDKGRound1Response)
	err := c.cc.Invoke(ctx, "/band.tss.v1beta1.Msg/SubmitDKGRound1", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) SubmitDKGRound2(ctx context.Context, in *MsgSubmitDKGRound2, opts ...grpc.CallOption) (*MsgSubmitDKGRound2Response, error) {
	out := new(MsgSubmitDKGRound2Response)
	err := c.cc.Invoke(ctx, "/band.tss.v1beta1.Msg/SubmitDKGRound2", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) Complain(ctx context.Context, in *MsgComplain, opts ...grpc.CallOption) (*MsgComplainResponse, error) {
	out := new(MsgComplainResponse)
	err := c.cc.Invoke(ctx, "/band.tss.v1beta1.Msg/Complain", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) Confirm(ctx context.Context, in *MsgConfirm, opts ...grpc.CallOption) (*MsgConfirmResponse, error) {
	out := new(MsgConfirmResponse)
	err := c.cc.Invoke(ctx, "/band.tss.v1beta1.Msg/Confirm", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) SubmitDEs(ctx context.Context, in *MsgSubmitDEs, opts ...grpc.CallOption) (*MsgSubmitDEsResponse, error) {
	out := new(MsgSubmitDEsResponse)
	err := c.cc.Invoke(ctx, "/band.tss.v1beta1.Msg/SubmitDEs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) ResetDE(ctx context.Context, in *MsgResetDE, opts ...grpc.CallOption) (*MsgResetDEResponse, error) {
	out := new(MsgResetDEResponse)
	err := c.cc.Invoke(ctx, "/band.tss.v1beta1.Msg/ResetDE", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) SubmitSignature(ctx context.Context, in *MsgSubmitSignature, opts ...grpc.CallOption) (*MsgSubmitSignatureResponse, error) {
	out := new(MsgSubmitSignatureResponse)
	err := c.cc.Invoke(ctx, "/band.tss.v1beta1.Msg/SubmitSignature", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) {
	out := new(MsgUpdateParamsResponse)
	err := c.cc.Invoke(ctx, "/band.tss.v1beta1.Msg/UpdateParams", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	// SubmitDKGRound1 submits dkg for computing round 1.
	SubmitDKGRound1(context.Context, *MsgSubmitDKGRound1) (*MsgSubmitDKGRound1Response, error)
	// SubmitDKGRound2 submits dkg for computing round 2.
	SubmitDKGRound2(context.Context, *MsgSubmitDKGRound2) (*MsgSubmitDKGRound2Response, error)
	// Complain submits proof for complaining malicious.
	Complain(context.Context, *MsgComplain) (*MsgComplainResponse, error)
	// Confirm submits own signature for proof that it can derive the secret.
	Confirm(context.Context, *MsgConfirm) (*MsgConfirmResponse, error)
	// SubmitDEs submits list of pre-commits DE for signing process.
	SubmitDEs(context.Context, *MsgSubmitDEs) (*MsgSubmitDEsResponse, error)
	// ResetDE resets the submitted DEs that being stored on chain.
	ResetDE(context.Context, *MsgResetDE) (*MsgResetDEResponse, error)
	// SubmitSignature submits signature on task participant need to do.
	SubmitSignature(context.Context, *MsgSubmitSignature) (*MsgSubmitSignatureResponse, error)
	// UpdateParams defines a governance operation for updating the x/tss module
	// parameters.
	UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error)
}

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

func (*UnimplementedMsgServer) SubmitDKGRound1(ctx context.Context, req *MsgSubmitDKGRound1) (*MsgSubmitDKGRound1Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SubmitDKGRound1 not implemented")
}
func (*UnimplementedMsgServer) SubmitDKGRound2(ctx context.Context, req *MsgSubmitDKGRound2) (*MsgSubmitDKGRound2Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SubmitDKGRound2 not implemented")
}
func (*UnimplementedMsgServer) Complain(ctx context.Context, req *MsgComplain) (*MsgComplainResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Complain not implemented")
}
func (*UnimplementedMsgServer) Confirm(ctx context.Context, req *MsgConfirm) (*MsgConfirmResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Confirm not implemented")
}
func (*UnimplementedMsgServer) SubmitDEs(ctx context.Context, req *MsgSubmitDEs) (*MsgSubmitDEsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SubmitDEs not implemented")
}
func (*UnimplementedMsgServer) ResetDE(ctx context.Context, req *MsgResetDE) (*MsgResetDEResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ResetDE not implemented")
}
func (*UnimplementedMsgServer) SubmitSignature(ctx context.Context, req *MsgSubmitSignature) (*MsgSubmitSignatureResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SubmitSignature not implemented")
}
func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented")
}

func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
	s.RegisterService(&_Msg_serviceDesc, srv)
}

func _Msg_SubmitDKGRound1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSubmitDKGRound1)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).SubmitDKGRound1(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.tss.v1beta1.Msg/SubmitDKGRound1",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).SubmitDKGRound1(ctx, req.(*MsgSubmitDKGRound1))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_SubmitDKGRound2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSubmitDKGRound2)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).SubmitDKGRound2(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.tss.v1beta1.Msg/SubmitDKGRound2",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).SubmitDKGRound2(ctx, req.(*MsgSubmitDKGRound2))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_Complain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgComplain)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).Complain(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.tss.v1beta1.Msg/Complain",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).Complain(ctx, req.(*MsgComplain))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_Confirm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgConfirm)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).Confirm(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.tss.v1beta1.Msg/Confirm",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).Confirm(ctx, req.(*MsgConfirm))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_SubmitDEs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSubmitDEs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).SubmitDEs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.tss.v1beta1.Msg/SubmitDEs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).SubmitDEs(ctx, req.(*MsgSubmitDEs))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_ResetDE_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgResetDE)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).ResetDE(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.tss.v1beta1.Msg/ResetDE",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).ResetDE(ctx, req.(*MsgResetDE))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_SubmitSignature_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSubmitSignature)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).SubmitSignature(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.tss.v1beta1.Msg/SubmitSignature",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).SubmitSignature(ctx, req.(*MsgSubmitSignature))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUpdateParams)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UpdateParams(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.tss.v1beta1.Msg/UpdateParams",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams))
	}
	return interceptor(ctx, in, info, handler)
}

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "band.tss.v1beta1.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SubmitDKGRound1",
			Handler:    _Msg_SubmitDKGRound1_Handler,
		},
		{
			MethodName: "SubmitDKGRound2",
			Handler:    _Msg_SubmitDKGRound2_Handler,
		},
		{
			MethodName: "Complain",
			Handler:    _Msg_Complain_Handler,
		},
		{
			MethodName: "Confirm",
			Handler:    _Msg_Confirm_Handler,
		},
		{
			MethodName: "SubmitDEs",
			Handler:    _Msg_SubmitDEs_Handler,
		},
		{
			MethodName: "ResetDE",
			Handler:    _Msg_ResetDE_Handler,
		},
		{
			MethodName: "SubmitSignature",
			Handler:    _Msg_SubmitSignature_Handler,
		},
		{
			MethodName: "UpdateParams",
			Handler:    _Msg_UpdateParams_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "band/tss/v1beta1/tx.proto",
}

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

func (m *MsgSubmitDKGRound1) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size, err := m.Round1Info.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.GroupID != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.GroupID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgSubmitDKGRound2) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size, err := m.Round2Info.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.GroupID != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.GroupID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgComplain) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Complaints) > 0 {
		for iNdEx := len(m.Complaints) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Complaints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.GroupID != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.GroupID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgConfirm) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.OwnPubKeySig) > 0 {
		i -= len(m.OwnPubKeySig)
		copy(dAtA[i:], m.OwnPubKeySig)
		i = encodeVarintTx(dAtA, i, uint64(len(m.OwnPubKeySig)))
		i--
		dAtA[i] = 0x1a
	}
	if m.MemberID != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.MemberID))
		i--
		dAtA[i] = 0x10
	}
	if m.GroupID != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.GroupID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

func (m *MsgSubmitSignature) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Signer) > 0 {
		i -= len(m.Signer)
		copy(dAtA[i:], m.Signer)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Signer)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Signature) > 0 {
		i -= len(m.Signature)
		copy(dAtA[i:], m.Signature)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x1a
	}
	if m.MemberID != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.MemberID))
		i--
		dAtA[i] = 0x10
	}
	if m.SigningID != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.SigningID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
	offset -= sovTx(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *MsgSubmitDKGRound1) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GroupID != 0 {
		n += 1 + sovTx(uint64(m.GroupID))
	}
	l = m.Round1Info.Size()
	n += 1 + l + sovTx(uint64(l))
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgSubmitDKGRound2) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GroupID != 0 {
		n += 1 + sovTx(uint64(m.GroupID))
	}
	l = m.Round2Info.Size()
	n += 1 + l + sovTx(uint64(l))
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgComplain) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GroupID != 0 {
		n += 1 + sovTx(uint64(m.GroupID))
	}
	if len(m.Complaints) > 0 {
		for _, e := range m.Complaints {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgConfirm) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GroupID != 0 {
		n += 1 + sovTx(uint64(m.GroupID))
	}
	if m.MemberID != 0 {
		n += 1 + sovTx(uint64(m.MemberID))
	}
	l = len(m.OwnPubKeySig)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

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

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

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

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

func (m *MsgSubmitSignature) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SigningID != 0 {
		n += 1 + sovTx(uint64(m.SigningID))
	}
	if m.MemberID != 0 {
		n += 1 + sovTx(uint64(m.MemberID))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgUpdateParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Params.Size()
	n += 1 + l + sovTx(uint64(l))
	l = len(m.Authority)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func sovTx(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTx(x uint64) (n int) {
	return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MsgSubmitDKGRound1) 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 ErrIntOverflowTx
			}
			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: MsgSubmitDKGRound1: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSubmitDKGRound1: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupID", wireType)
			}
			m.GroupID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupID |= github_com_bandprotocol_chain_v3_pkg_tss.GroupID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Round1Info", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Round1Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgComplain) 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 ErrIntOverflowTx
			}
			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: MsgComplain: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgComplain: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupID", wireType)
			}
			m.GroupID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupID |= github_com_bandprotocol_chain_v3_pkg_tss.GroupID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Complaints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Complaints = append(m.Complaints, Complaint{})
			if err := m.Complaints[len(m.Complaints)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgConfirm) 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 ErrIntOverflowTx
			}
			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: MsgConfirm: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgConfirm: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupID", wireType)
			}
			m.GroupID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupID |= github_com_bandprotocol_chain_v3_pkg_tss.GroupID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MemberID", wireType)
			}
			m.MemberID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MemberID |= github_com_bandprotocol_chain_v3_pkg_tss.MemberID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OwnPubKeySig", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OwnPubKeySig = append(m.OwnPubKeySig[:0], dAtA[iNdEx:postIndex]...)
			if m.OwnPubKeySig == nil {
				m.OwnPubKeySig = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgResetDE) 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 ErrIntOverflowTx
			}
			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: MsgResetDE: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgResetDE: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgSubmitSignature) 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 ErrIntOverflowTx
			}
			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: MsgSubmitSignature: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSubmitSignature: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SigningID", wireType)
			}
			m.SigningID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SigningID |= github_com_bandprotocol_chain_v3_pkg_tss.SigningID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MemberID", wireType)
			}
			m.MemberID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MemberID |= github_com_bandprotocol_chain_v3_pkg_tss.MemberID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

var (
	ErrInvalidLengthTx        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTx          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group")
)
