laconicd/x/registry/tx.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: cerc/registry/v1/tx.proto

package registry

import (
	context "context"
	fmt "fmt"
	_ "github.com/cosmos/cosmos-sdk/types/msgservice"
	_ "github.com/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

// MsgSetRecord
type MsgSetRecord struct {
	BondId  string  `protobuf:"bytes,1,opt,name=bond_id,json=bondId,proto3" json:"bond_id,omitempty" json:"bond_id" yaml:"bond_id"`
	Signer  string  `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty"`
	Payload Payload `protobuf:"bytes,3,opt,name=payload,proto3" json:"payload"`
}

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

var xxx_messageInfo_MsgSetRecord proto.InternalMessageInfo

func (m *MsgSetRecord) GetBondId() string {
	if m != nil {
		return m.BondId
	}
	return ""
}

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

func (m *MsgSetRecord) GetPayload() Payload {
	if m != nil {
		return m.Payload
	}
	return Payload{}
}

// MsgSetRecordResponse
type MsgSetRecordResponse struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}

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

var xxx_messageInfo_MsgSetRecordResponse proto.InternalMessageInfo

func (m *MsgSetRecordResponse) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

// Payload
type Payload struct {
	Record     *Record     `protobuf:"bytes,1,opt,name=record,proto3" json:"record,omitempty"`
	Signatures []Signature `protobuf:"bytes,2,rep,name=signatures,proto3" json:"signatures" json:"signatures" yaml:"signatures"`
}

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

var xxx_messageInfo_Payload proto.InternalMessageInfo

func (m *Payload) GetRecord() *Record {
	if m != nil {
		return m.Record
	}
	return nil
}

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

// MsgSetName
type MsgSetName struct {
	Lrn    string `protobuf:"bytes,1,opt,name=lrn,proto3" json:"lrn,omitempty"`
	Cid    string `protobuf:"bytes,2,opt,name=cid,proto3" json:"cid,omitempty"`
	Signer string `protobuf:"bytes,3,opt,name=signer,proto3" json:"signer,omitempty"`
}

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

var xxx_messageInfo_MsgSetName proto.InternalMessageInfo

func (m *MsgSetName) GetLrn() string {
	if m != nil {
		return m.Lrn
	}
	return ""
}

func (m *MsgSetName) GetCid() string {
	if m != nil {
		return m.Cid
	}
	return ""
}

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

// MsgSetNameResponse
type MsgSetNameResponse struct {
}

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

var xxx_messageInfo_MsgSetNameResponse proto.InternalMessageInfo

// MsgReserveName
type MsgReserveAuthority struct {
	Name   string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Signer string `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty"`
	// if creating a sub-authority.
	Owner string `protobuf:"bytes,3,opt,name=owner,proto3" json:"owner,omitempty"`
}

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

var xxx_messageInfo_MsgReserveAuthority proto.InternalMessageInfo

func (m *MsgReserveAuthority) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

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

func (m *MsgReserveAuthority) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

// MsgReserveNameResponse
type MsgReserveAuthorityResponse struct {
}

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

var xxx_messageInfo_MsgReserveAuthorityResponse proto.InternalMessageInfo

// MsgSetAuthorityBond
type MsgSetAuthorityBond struct {
	Name   string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	BondId string `protobuf:"bytes,2,opt,name=bond_id,json=bondId,proto3" json:"bond_id,omitempty" json:"bond_id" yaml:"bond_id"`
	Signer string `protobuf:"bytes,3,opt,name=signer,proto3" json:"signer,omitempty"`
}

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

var xxx_messageInfo_MsgSetAuthorityBond proto.InternalMessageInfo

func (m *MsgSetAuthorityBond) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *MsgSetAuthorityBond) GetBondId() string {
	if m != nil {
		return m.BondId
	}
	return ""
}

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

// MsgSetAuthorityBondResponse
type MsgSetAuthorityBondResponse struct {
}

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

var xxx_messageInfo_MsgSetAuthorityBondResponse proto.InternalMessageInfo

// MsgDeleteNameAuthority
type MsgDeleteNameAuthority struct {
	Lrn    string `protobuf:"bytes,1,opt,name=lrn,proto3" json:"lrn,omitempty"`
	Signer string `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty"`
}

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

var xxx_messageInfo_MsgDeleteNameAuthority proto.InternalMessageInfo

func (m *MsgDeleteNameAuthority) GetLrn() string {
	if m != nil {
		return m.Lrn
	}
	return ""
}

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

// MsgDeleteNameAuthorityResponse
type MsgDeleteNameAuthorityResponse struct {
}

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

var xxx_messageInfo_MsgDeleteNameAuthorityResponse proto.InternalMessageInfo

// MsgRenewRecord
type MsgRenewRecord struct {
	RecordId string `protobuf:"bytes,1,opt,name=record_id,json=recordId,proto3" json:"record_id,omitempty" json:"record_id" yaml:"record_id"`
	Signer   string `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty"`
}

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

var xxx_messageInfo_MsgRenewRecord proto.InternalMessageInfo

func (m *MsgRenewRecord) GetRecordId() string {
	if m != nil {
		return m.RecordId
	}
	return ""
}

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

// MsgRenewRecordResponse
type MsgRenewRecordResponse struct {
}

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

var xxx_messageInfo_MsgRenewRecordResponse proto.InternalMessageInfo

// MsgAssociateBond
type MsgAssociateBond struct {
	RecordId string `protobuf:"bytes,1,opt,name=record_id,json=recordId,proto3" json:"record_id,omitempty" json:"record_id" yaml:"record_id"`
	BondId   string `protobuf:"bytes,2,opt,name=bond_id,json=bondId,proto3" json:"bond_id,omitempty" json:"bond_id" yaml:"bond_id"`
	Signer   string `protobuf:"bytes,3,opt,name=signer,proto3" json:"signer,omitempty"`
}

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

var xxx_messageInfo_MsgAssociateBond proto.InternalMessageInfo

func (m *MsgAssociateBond) GetRecordId() string {
	if m != nil {
		return m.RecordId
	}
	return ""
}

func (m *MsgAssociateBond) GetBondId() string {
	if m != nil {
		return m.BondId
	}
	return ""
}

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

// MsgAssociateBondResponse
type MsgAssociateBondResponse struct {
}

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

var xxx_messageInfo_MsgAssociateBondResponse proto.InternalMessageInfo

// MsgDissociateBond
type MsgDissociateBond struct {
	RecordId string `protobuf:"bytes,1,opt,name=record_id,json=recordId,proto3" json:"record_id,omitempty" json:"record_id" yaml:"record_id"`
	Signer   string `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty"`
}

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

var xxx_messageInfo_MsgDissociateBond proto.InternalMessageInfo

func (m *MsgDissociateBond) GetRecordId() string {
	if m != nil {
		return m.RecordId
	}
	return ""
}

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

// MsgDissociateBondResponse
type MsgDissociateBondResponse struct {
}

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

var xxx_messageInfo_MsgDissociateBondResponse proto.InternalMessageInfo

// MsgDissociateRecords
type MsgDissociateRecords struct {
	BondId string `protobuf:"bytes,1,opt,name=bond_id,json=bondId,proto3" json:"bond_id,omitempty" json:"bond_id" yaml:"bond_id"`
	Signer string `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty"`
}

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

var xxx_messageInfo_MsgDissociateRecords proto.InternalMessageInfo

func (m *MsgDissociateRecords) GetBondId() string {
	if m != nil {
		return m.BondId
	}
	return ""
}

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

// MsgDissociateRecordsResponse
type MsgDissociateRecordsResponse struct {
}

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

var xxx_messageInfo_MsgDissociateRecordsResponse proto.InternalMessageInfo

// MsgReassociateRecords
type MsgReassociateRecords struct {
	NewBondId string `protobuf:"bytes,1,opt,name=new_bond_id,json=newBondId,proto3" json:"new_bond_id,omitempty" json:"new_bond_id" yaml:"new_bond_id"`
	OldBondId string `protobuf:"bytes,2,opt,name=old_bond_id,json=oldBondId,proto3" json:"old_bond_id,omitempty" json:"old_bond_id" yaml:"old_bond_id"`
	Signer    string `protobuf:"bytes,3,opt,name=signer,proto3" json:"signer,omitempty"`
}

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

var xxx_messageInfo_MsgReassociateRecords proto.InternalMessageInfo

func (m *MsgReassociateRecords) GetNewBondId() string {
	if m != nil {
		return m.NewBondId
	}
	return ""
}

func (m *MsgReassociateRecords) GetOldBondId() string {
	if m != nil {
		return m.OldBondId
	}
	return ""
}

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

// MsgReassociateRecordsResponse
type MsgReassociateRecordsResponse struct {
}

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

var xxx_messageInfo_MsgReassociateRecordsResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*MsgSetRecord)(nil), "cerc.registry.v1.MsgSetRecord")
	proto.RegisterType((*MsgSetRecordResponse)(nil), "cerc.registry.v1.MsgSetRecordResponse")
	proto.RegisterType((*Payload)(nil), "cerc.registry.v1.Payload")
	proto.RegisterType((*MsgSetName)(nil), "cerc.registry.v1.MsgSetName")
	proto.RegisterType((*MsgSetNameResponse)(nil), "cerc.registry.v1.MsgSetNameResponse")
	proto.RegisterType((*MsgReserveAuthority)(nil), "cerc.registry.v1.MsgReserveAuthority")
	proto.RegisterType((*MsgReserveAuthorityResponse)(nil), "cerc.registry.v1.MsgReserveAuthorityResponse")
	proto.RegisterType((*MsgSetAuthorityBond)(nil), "cerc.registry.v1.MsgSetAuthorityBond")
	proto.RegisterType((*MsgSetAuthorityBondResponse)(nil), "cerc.registry.v1.MsgSetAuthorityBondResponse")
	proto.RegisterType((*MsgDeleteNameAuthority)(nil), "cerc.registry.v1.MsgDeleteNameAuthority")
	proto.RegisterType((*MsgDeleteNameAuthorityResponse)(nil), "cerc.registry.v1.MsgDeleteNameAuthorityResponse")
	proto.RegisterType((*MsgRenewRecord)(nil), "cerc.registry.v1.MsgRenewRecord")
	proto.RegisterType((*MsgRenewRecordResponse)(nil), "cerc.registry.v1.MsgRenewRecordResponse")
	proto.RegisterType((*MsgAssociateBond)(nil), "cerc.registry.v1.MsgAssociateBond")
	proto.RegisterType((*MsgAssociateBondResponse)(nil), "cerc.registry.v1.MsgAssociateBondResponse")
	proto.RegisterType((*MsgDissociateBond)(nil), "cerc.registry.v1.MsgDissociateBond")
	proto.RegisterType((*MsgDissociateBondResponse)(nil), "cerc.registry.v1.MsgDissociateBondResponse")
	proto.RegisterType((*MsgDissociateRecords)(nil), "cerc.registry.v1.MsgDissociateRecords")
	proto.RegisterType((*MsgDissociateRecordsResponse)(nil), "cerc.registry.v1.MsgDissociateRecordsResponse")
	proto.RegisterType((*MsgReassociateRecords)(nil), "cerc.registry.v1.MsgReassociateRecords")
	proto.RegisterType((*MsgReassociateRecordsResponse)(nil), "cerc.registry.v1.MsgReassociateRecordsResponse")
}

func init() { proto.RegisterFile("cerc/registry/v1/tx.proto", fileDescriptor_3c6eb2e5a4d8fa03) }

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

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

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

// 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 {
	// SetRecord records a new record with given payload and bond id
	SetRecord(ctx context.Context, in *MsgSetRecord, opts ...grpc.CallOption) (*MsgSetRecordResponse, error)
	// Renew Record renews an expired record
	RenewRecord(ctx context.Context, in *MsgRenewRecord, opts ...grpc.CallOption) (*MsgRenewRecordResponse, error)
	// AssociateBond
	AssociateBond(ctx context.Context, in *MsgAssociateBond, opts ...grpc.CallOption) (*MsgAssociateBondResponse, error)
	// DissociateBond
	DissociateBond(ctx context.Context, in *MsgDissociateBond, opts ...grpc.CallOption) (*MsgDissociateBondResponse, error)
	// DissociateRecords
	DissociateRecords(ctx context.Context, in *MsgDissociateRecords, opts ...grpc.CallOption) (*MsgDissociateRecordsResponse, error)
	// ReassociateRecords
	ReassociateRecords(ctx context.Context, in *MsgReassociateRecords, opts ...grpc.CallOption) (*MsgReassociateRecordsResponse, error)
	// SetName will store the name with given lrn and name
	SetName(ctx context.Context, in *MsgSetName, opts ...grpc.CallOption) (*MsgSetNameResponse, error)
	// Reserve name
	ReserveName(ctx context.Context, in *MsgReserveAuthority, opts ...grpc.CallOption) (*MsgReserveAuthorityResponse, error)
	// Delete Name method will remove authority name
	DeleteName(ctx context.Context, in *MsgDeleteNameAuthority, opts ...grpc.CallOption) (*MsgDeleteNameAuthorityResponse, error)
	// SetAuthorityBond
	SetAuthorityBond(ctx context.Context, in *MsgSetAuthorityBond, opts ...grpc.CallOption) (*MsgSetAuthorityBondResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

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

func (c *msgClient) SetRecord(ctx context.Context, in *MsgSetRecord, opts ...grpc.CallOption) (*MsgSetRecordResponse, error) {
	out := new(MsgSetRecordResponse)
	err := c.cc.Invoke(ctx, "/cerc.registry.v1.Msg/SetRecord", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) RenewRecord(ctx context.Context, in *MsgRenewRecord, opts ...grpc.CallOption) (*MsgRenewRecordResponse, error) {
	out := new(MsgRenewRecordResponse)
	err := c.cc.Invoke(ctx, "/cerc.registry.v1.Msg/RenewRecord", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) AssociateBond(ctx context.Context, in *MsgAssociateBond, opts ...grpc.CallOption) (*MsgAssociateBondResponse, error) {
	out := new(MsgAssociateBondResponse)
	err := c.cc.Invoke(ctx, "/cerc.registry.v1.Msg/AssociateBond", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) DissociateBond(ctx context.Context, in *MsgDissociateBond, opts ...grpc.CallOption) (*MsgDissociateBondResponse, error) {
	out := new(MsgDissociateBondResponse)
	err := c.cc.Invoke(ctx, "/cerc.registry.v1.Msg/DissociateBond", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) DissociateRecords(ctx context.Context, in *MsgDissociateRecords, opts ...grpc.CallOption) (*MsgDissociateRecordsResponse, error) {
	out := new(MsgDissociateRecordsResponse)
	err := c.cc.Invoke(ctx, "/cerc.registry.v1.Msg/DissociateRecords", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) ReassociateRecords(ctx context.Context, in *MsgReassociateRecords, opts ...grpc.CallOption) (*MsgReassociateRecordsResponse, error) {
	out := new(MsgReassociateRecordsResponse)
	err := c.cc.Invoke(ctx, "/cerc.registry.v1.Msg/ReassociateRecords", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) SetName(ctx context.Context, in *MsgSetName, opts ...grpc.CallOption) (*MsgSetNameResponse, error) {
	out := new(MsgSetNameResponse)
	err := c.cc.Invoke(ctx, "/cerc.registry.v1.Msg/SetName", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) ReserveName(ctx context.Context, in *MsgReserveAuthority, opts ...grpc.CallOption) (*MsgReserveAuthorityResponse, error) {
	out := new(MsgReserveAuthorityResponse)
	err := c.cc.Invoke(ctx, "/cerc.registry.v1.Msg/ReserveName", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) DeleteName(ctx context.Context, in *MsgDeleteNameAuthority, opts ...grpc.CallOption) (*MsgDeleteNameAuthorityResponse, error) {
	out := new(MsgDeleteNameAuthorityResponse)
	err := c.cc.Invoke(ctx, "/cerc.registry.v1.Msg/DeleteName", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) SetAuthorityBond(ctx context.Context, in *MsgSetAuthorityBond, opts ...grpc.CallOption) (*MsgSetAuthorityBondResponse, error) {
	out := new(MsgSetAuthorityBondResponse)
	err := c.cc.Invoke(ctx, "/cerc.registry.v1.Msg/SetAuthorityBond", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	// SetRecord records a new record with given payload and bond id
	SetRecord(context.Context, *MsgSetRecord) (*MsgSetRecordResponse, error)
	// Renew Record renews an expired record
	RenewRecord(context.Context, *MsgRenewRecord) (*MsgRenewRecordResponse, error)
	// AssociateBond
	AssociateBond(context.Context, *MsgAssociateBond) (*MsgAssociateBondResponse, error)
	// DissociateBond
	DissociateBond(context.Context, *MsgDissociateBond) (*MsgDissociateBondResponse, error)
	// DissociateRecords
	DissociateRecords(context.Context, *MsgDissociateRecords) (*MsgDissociateRecordsResponse, error)
	// ReassociateRecords
	ReassociateRecords(context.Context, *MsgReassociateRecords) (*MsgReassociateRecordsResponse, error)
	// SetName will store the name with given lrn and name
	SetName(context.Context, *MsgSetName) (*MsgSetNameResponse, error)
	// Reserve name
	ReserveName(context.Context, *MsgReserveAuthority) (*MsgReserveAuthorityResponse, error)
	// Delete Name method will remove authority name
	DeleteName(context.Context, *MsgDeleteNameAuthority) (*MsgDeleteNameAuthorityResponse, error)
	// SetAuthorityBond
	SetAuthorityBond(context.Context, *MsgSetAuthorityBond) (*MsgSetAuthorityBondResponse, error)
}

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

func (*UnimplementedMsgServer) SetRecord(ctx context.Context, req *MsgSetRecord) (*MsgSetRecordResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetRecord not implemented")
}
func (*UnimplementedMsgServer) RenewRecord(ctx context.Context, req *MsgRenewRecord) (*MsgRenewRecordResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RenewRecord not implemented")
}
func (*UnimplementedMsgServer) AssociateBond(ctx context.Context, req *MsgAssociateBond) (*MsgAssociateBondResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AssociateBond not implemented")
}
func (*UnimplementedMsgServer) DissociateBond(ctx context.Context, req *MsgDissociateBond) (*MsgDissociateBondResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DissociateBond not implemented")
}
func (*UnimplementedMsgServer) DissociateRecords(ctx context.Context, req *MsgDissociateRecords) (*MsgDissociateRecordsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DissociateRecords not implemented")
}
func (*UnimplementedMsgServer) ReassociateRecords(ctx context.Context, req *MsgReassociateRecords) (*MsgReassociateRecordsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReassociateRecords not implemented")
}
func (*UnimplementedMsgServer) SetName(ctx context.Context, req *MsgSetName) (*MsgSetNameResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetName not implemented")
}
func (*UnimplementedMsgServer) ReserveName(ctx context.Context, req *MsgReserveAuthority) (*MsgReserveAuthorityResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReserveName not implemented")
}
func (*UnimplementedMsgServer) DeleteName(ctx context.Context, req *MsgDeleteNameAuthority) (*MsgDeleteNameAuthorityResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteName not implemented")
}
func (*UnimplementedMsgServer) SetAuthorityBond(ctx context.Context, req *MsgSetAuthorityBond) (*MsgSetAuthorityBondResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetAuthorityBond not implemented")
}

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

func _Msg_SetRecord_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSetRecord)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).SetRecord(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cerc.registry.v1.Msg/SetRecord",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).SetRecord(ctx, req.(*MsgSetRecord))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_RenewRecord_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgRenewRecord)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).RenewRecord(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cerc.registry.v1.Msg/RenewRecord",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).RenewRecord(ctx, req.(*MsgRenewRecord))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_AssociateBond_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgAssociateBond)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).AssociateBond(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cerc.registry.v1.Msg/AssociateBond",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).AssociateBond(ctx, req.(*MsgAssociateBond))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_DissociateBond_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgDissociateBond)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).DissociateBond(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cerc.registry.v1.Msg/DissociateBond",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).DissociateBond(ctx, req.(*MsgDissociateBond))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_DissociateRecords_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgDissociateRecords)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).DissociateRecords(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cerc.registry.v1.Msg/DissociateRecords",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).DissociateRecords(ctx, req.(*MsgDissociateRecords))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_ReassociateRecords_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgReassociateRecords)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).ReassociateRecords(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cerc.registry.v1.Msg/ReassociateRecords",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).ReassociateRecords(ctx, req.(*MsgReassociateRecords))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_SetName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSetName)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).SetName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cerc.registry.v1.Msg/SetName",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).SetName(ctx, req.(*MsgSetName))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_ReserveName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgReserveAuthority)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).ReserveName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cerc.registry.v1.Msg/ReserveName",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).ReserveName(ctx, req.(*MsgReserveAuthority))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_DeleteName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgDeleteNameAuthority)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).DeleteName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cerc.registry.v1.Msg/DeleteName",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).DeleteName(ctx, req.(*MsgDeleteNameAuthority))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_SetAuthorityBond_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSetAuthorityBond)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).SetAuthorityBond(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cerc.registry.v1.Msg/SetAuthorityBond",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).SetAuthorityBond(ctx, req.(*MsgSetAuthorityBond))
	}
	return interceptor(ctx, in, info, handler)
}

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "cerc.registry.v1.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SetRecord",
			Handler:    _Msg_SetRecord_Handler,
		},
		{
			MethodName: "RenewRecord",
			Handler:    _Msg_RenewRecord_Handler,
		},
		{
			MethodName: "AssociateBond",
			Handler:    _Msg_AssociateBond_Handler,
		},
		{
			MethodName: "DissociateBond",
			Handler:    _Msg_DissociateBond_Handler,
		},
		{
			MethodName: "DissociateRecords",
			Handler:    _Msg_DissociateRecords_Handler,
		},
		{
			MethodName: "ReassociateRecords",
			Handler:    _Msg_ReassociateRecords_Handler,
		},
		{
			MethodName: "SetName",
			Handler:    _Msg_SetName_Handler,
		},
		{
			MethodName: "ReserveName",
			Handler:    _Msg_ReserveName_Handler,
		},
		{
			MethodName: "DeleteName",
			Handler:    _Msg_DeleteName_Handler,
		},
		{
			MethodName: "SetAuthorityBond",
			Handler:    _Msg_SetAuthorityBond_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "cerc/registry/v1/tx.proto",
}

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

func (m *MsgSetRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Payload.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	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] = 0x12
	}
	if len(m.BondId) > 0 {
		i -= len(m.BondId)
		copy(dAtA[i:], m.BondId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.BondId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

func (m *MsgSetName) 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] = 0x1a
	}
	if len(m.Cid) > 0 {
		i -= len(m.Cid)
		copy(dAtA[i:], m.Cid)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Cid)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Lrn) > 0 {
		i -= len(m.Lrn)
		copy(dAtA[i:], m.Lrn)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Lrn)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgReserveAuthority) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0x1a
	}
	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] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgSetAuthorityBond) 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] = 0x1a
	}
	if len(m.BondId) > 0 {
		i -= len(m.BondId)
		copy(dAtA[i:], m.BondId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.BondId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgDeleteNameAuthority) 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] = 0x12
	}
	if len(m.Lrn) > 0 {
		i -= len(m.Lrn)
		copy(dAtA[i:], m.Lrn)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Lrn)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgRenewRecord) 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] = 0x12
	}
	if len(m.RecordId) > 0 {
		i -= len(m.RecordId)
		copy(dAtA[i:], m.RecordId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.RecordId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgAssociateBond) 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] = 0x1a
	}
	if len(m.BondId) > 0 {
		i -= len(m.BondId)
		copy(dAtA[i:], m.BondId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.BondId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.RecordId) > 0 {
		i -= len(m.RecordId)
		copy(dAtA[i:], m.RecordId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.RecordId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgDissociateBond) 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] = 0x12
	}
	if len(m.RecordId) > 0 {
		i -= len(m.RecordId)
		copy(dAtA[i:], m.RecordId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.RecordId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgDissociateRecords) 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] = 0x12
	}
	if len(m.BondId) > 0 {
		i -= len(m.BondId)
		copy(dAtA[i:], m.BondId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.BondId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgReassociateRecords) 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] = 0x1a
	}
	if len(m.OldBondId) > 0 {
		i -= len(m.OldBondId)
		copy(dAtA[i:], m.OldBondId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.OldBondId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.NewBondId) > 0 {
		i -= len(m.NewBondId)
		copy(dAtA[i:], m.NewBondId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.NewBondId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgReassociateRecordsResponse) 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 *MsgSetRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BondId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.Payload.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

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

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

func (m *MsgSetName) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Lrn)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Cid)
	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 *MsgSetNameResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

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

func (m *MsgSetAuthorityBond) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.BondId)
	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 *MsgSetAuthorityBondResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgDeleteNameAuthority) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Lrn)
	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 *MsgDeleteNameAuthorityResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgRenewRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RecordId)
	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 *MsgRenewRecordResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgAssociateBond) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RecordId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.BondId)
	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 *MsgAssociateBondResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgDissociateBond) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RecordId)
	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 *MsgDissociateBondResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgDissociateRecords) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BondId)
	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 *MsgDissociateRecordsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgReassociateRecords) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.NewBondId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.OldBondId)
	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 *MsgReassociateRecordsResponse) 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 *MsgSetRecord) 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: MsgSetRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSetRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BondId", 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.BondId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", 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.Payload.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *MsgSetRecordResponse) 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: MsgSetRecordResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSetRecordResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Id = 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 *Payload) 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: Payload: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Payload: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Record", 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 m.Record == nil {
				m.Record = &Record{}
			}
			if err := m.Record.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Signatures = append(m.Signatures, Signature{})
			if err := m.Signatures[len(m.Signatures)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 *MsgSetName) 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: MsgSetName: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSetName: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Lrn", 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.Lrn = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cid", 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.Cid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 *MsgSetNameResponse) 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: MsgSetNameResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSetNameResponse: 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 *MsgReserveAuthority) 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: MsgReserveAuthority: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgReserveAuthority: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", 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.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", 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.Owner = 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 *MsgReserveAuthorityResponse) 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: MsgReserveAuthorityResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgReserveAuthorityResponse: 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 *MsgSetAuthorityBond) 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: MsgSetAuthorityBond: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSetAuthorityBond: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", 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.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BondId", 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.BondId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 *MsgSetAuthorityBondResponse) 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: MsgSetAuthorityBondResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSetAuthorityBondResponse: 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 *MsgDeleteNameAuthority) 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: MsgDeleteNameAuthority: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeleteNameAuthority: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Lrn", 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.Lrn = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 *MsgDeleteNameAuthorityResponse) 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: MsgDeleteNameAuthorityResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeleteNameAuthorityResponse: 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 *MsgRenewRecord) 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: MsgRenewRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRenewRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordId", 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.RecordId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 *MsgRenewRecordResponse) 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: MsgRenewRecordResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRenewRecordResponse: 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 *MsgAssociateBond) 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: MsgAssociateBond: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAssociateBond: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordId", 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.RecordId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BondId", 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.BondId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 *MsgAssociateBondResponse) 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: MsgAssociateBondResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAssociateBondResponse: 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 *MsgDissociateBond) 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: MsgDissociateBond: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDissociateBond: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordId", 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.RecordId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 *MsgDissociateBondResponse) 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: MsgDissociateBondResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDissociateBondResponse: 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 *MsgDissociateRecords) 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: MsgDissociateRecords: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDissociateRecords: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BondId", 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.BondId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 *MsgDissociateRecordsResponse) 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: MsgDissociateRecordsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDissociateRecordsResponse: 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 *MsgReassociateRecords) 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: MsgReassociateRecords: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgReassociateRecords: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewBondId", 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.NewBondId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OldBondId", 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.OldBondId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 *MsgReassociateRecordsResponse) 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: MsgReassociateRecordsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgReassociateRecordsResponse: 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")
)