tx.pb.go

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

package types

import (
	context "context"
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	_ "github.com/gogo/protobuf/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type MsgProposeAddX509RootCert struct {
	Signer string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty" validate:"required"`
	Cert   string `protobuf:"bytes,2,opt,name=cert,proto3" json:"cert,omitempty" validate:"required,max=10485760"`
	Info   string `protobuf:"bytes,3,opt,name=info,proto3" json:"info,omitempty" validate:"max=4096"`
	Time   int64  `protobuf:"varint,4,opt,name=time,proto3" json:"time,omitempty"`
	Vid    int32  `protobuf:"varint,5,opt,name=vid,proto3" json:"vid,omitempty" validate:"gte=1,lte=65535,required"`
}

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

var xxx_messageInfo_MsgProposeAddX509RootCert proto.InternalMessageInfo

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

func (m *MsgProposeAddX509RootCert) GetCert() string {
	if m != nil {
		return m.Cert
	}
	return ""
}

func (m *MsgProposeAddX509RootCert) GetInfo() string {
	if m != nil {
		return m.Info
	}
	return ""
}

func (m *MsgProposeAddX509RootCert) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

func (m *MsgProposeAddX509RootCert) GetVid() int32 {
	if m != nil {
		return m.Vid
	}
	return 0
}

type MsgProposeAddX509RootCertResponse struct {
}

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

var xxx_messageInfo_MsgProposeAddX509RootCertResponse proto.InternalMessageInfo

type MsgApproveAddX509RootCert struct {
	Signer       string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty" validate:"required"`
	Subject      string `protobuf:"bytes,2,opt,name=subject,proto3" json:"subject,omitempty" validate:"required,max=1024"`
	SubjectKeyId string `protobuf:"bytes,3,opt,name=subjectKeyId,proto3" json:"subjectKeyId,omitempty" validate:"required,max=256"`
	Info         string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty" validate:"max=4096"`
	Time         int64  `protobuf:"varint,5,opt,name=time,proto3" json:"time,omitempty"`
}

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

var xxx_messageInfo_MsgApproveAddX509RootCert proto.InternalMessageInfo

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

func (m *MsgApproveAddX509RootCert) GetSubject() string {
	if m != nil {
		return m.Subject
	}
	return ""
}

func (m *MsgApproveAddX509RootCert) GetSubjectKeyId() string {
	if m != nil {
		return m.SubjectKeyId
	}
	return ""
}

func (m *MsgApproveAddX509RootCert) GetInfo() string {
	if m != nil {
		return m.Info
	}
	return ""
}

func (m *MsgApproveAddX509RootCert) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

type MsgApproveAddX509RootCertResponse struct {
}

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

var xxx_messageInfo_MsgApproveAddX509RootCertResponse proto.InternalMessageInfo

type MsgAddX509Cert struct {
	Signer string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty" validate:"required"`
	Cert   string `protobuf:"bytes,2,opt,name=cert,proto3" json:"cert,omitempty" validate:"required,max=10485760"`
	Info   string `protobuf:"bytes,3,opt,name=info,proto3" json:"info,omitempty" validate:"max=4096"`
	Time   int64  `protobuf:"varint,4,opt,name=time,proto3" json:"time,omitempty"`
}

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

var xxx_messageInfo_MsgAddX509Cert proto.InternalMessageInfo

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

func (m *MsgAddX509Cert) GetCert() string {
	if m != nil {
		return m.Cert
	}
	return ""
}

func (m *MsgAddX509Cert) GetInfo() string {
	if m != nil {
		return m.Info
	}
	return ""
}

func (m *MsgAddX509Cert) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

type MsgAddX509CertResponse struct {
}

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

var xxx_messageInfo_MsgAddX509CertResponse proto.InternalMessageInfo

type MsgProposeRevokeX509RootCert struct {
	Signer       string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty" validate:"required"`
	Subject      string `protobuf:"bytes,2,opt,name=subject,proto3" json:"subject,omitempty" validate:"required,max=1024"`
	SubjectKeyId string `protobuf:"bytes,3,opt,name=subjectKeyId,proto3" json:"subjectKeyId,omitempty" validate:"required,max=256"`
	Info         string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty" validate:"max=4096"`
	Time         int64  `protobuf:"varint,5,opt,name=time,proto3" json:"time,omitempty"`
}

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

var xxx_messageInfo_MsgProposeRevokeX509RootCert proto.InternalMessageInfo

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

func (m *MsgProposeRevokeX509RootCert) GetSubject() string {
	if m != nil {
		return m.Subject
	}
	return ""
}

func (m *MsgProposeRevokeX509RootCert) GetSubjectKeyId() string {
	if m != nil {
		return m.SubjectKeyId
	}
	return ""
}

func (m *MsgProposeRevokeX509RootCert) GetInfo() string {
	if m != nil {
		return m.Info
	}
	return ""
}

func (m *MsgProposeRevokeX509RootCert) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

type MsgProposeRevokeX509RootCertResponse struct {
}

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

var xxx_messageInfo_MsgProposeRevokeX509RootCertResponse proto.InternalMessageInfo

type MsgApproveRevokeX509RootCert struct {
	Signer       string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty" validate:"required"`
	Subject      string `protobuf:"bytes,2,opt,name=subject,proto3" json:"subject,omitempty" validate:"required,max=1024"`
	SubjectKeyId string `protobuf:"bytes,3,opt,name=subjectKeyId,proto3" json:"subjectKeyId,omitempty" validate:"required,max=256"`
	Info         string `protobuf:"bytes,5,opt,name=info,proto3" json:"info,omitempty" validate:"max=4096"`
	Time         int64  `protobuf:"varint,6,opt,name=time,proto3" json:"time,omitempty"`
}

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

var xxx_messageInfo_MsgApproveRevokeX509RootCert proto.InternalMessageInfo

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

func (m *MsgApproveRevokeX509RootCert) GetSubject() string {
	if m != nil {
		return m.Subject
	}
	return ""
}

func (m *MsgApproveRevokeX509RootCert) GetSubjectKeyId() string {
	if m != nil {
		return m.SubjectKeyId
	}
	return ""
}

func (m *MsgApproveRevokeX509RootCert) GetInfo() string {
	if m != nil {
		return m.Info
	}
	return ""
}

func (m *MsgApproveRevokeX509RootCert) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

type MsgApproveRevokeX509RootCertResponse struct {
}

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

var xxx_messageInfo_MsgApproveRevokeX509RootCertResponse proto.InternalMessageInfo

type MsgRevokeX509Cert struct {
	Signer       string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty" validate:"required"`
	Subject      string `protobuf:"bytes,2,opt,name=subject,proto3" json:"subject,omitempty" validate:"required,max=1024"`
	SubjectKeyId string `protobuf:"bytes,3,opt,name=subjectKeyId,proto3" json:"subjectKeyId,omitempty" validate:"required,max=256"`
	Info         string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty" validate:"max=4096"`
	Time         int64  `protobuf:"varint,5,opt,name=time,proto3" json:"time,omitempty"`
}

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

var xxx_messageInfo_MsgRevokeX509Cert proto.InternalMessageInfo

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

func (m *MsgRevokeX509Cert) GetSubject() string {
	if m != nil {
		return m.Subject
	}
	return ""
}

func (m *MsgRevokeX509Cert) GetSubjectKeyId() string {
	if m != nil {
		return m.SubjectKeyId
	}
	return ""
}

func (m *MsgRevokeX509Cert) GetInfo() string {
	if m != nil {
		return m.Info
	}
	return ""
}

func (m *MsgRevokeX509Cert) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

type MsgRevokeX509CertResponse struct {
}

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

var xxx_messageInfo_MsgRevokeX509CertResponse proto.InternalMessageInfo

type MsgRejectAddX509RootCert struct {
	Signer       string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty" validate:"required"`
	Subject      string `protobuf:"bytes,2,opt,name=subject,proto3" json:"subject,omitempty" validate:"required,max=1024"`
	SubjectKeyId string `protobuf:"bytes,3,opt,name=subjectKeyId,proto3" json:"subjectKeyId,omitempty" validate:"required,max=256"`
	Info         string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty" validate:"max=4096"`
	Time         int64  `protobuf:"varint,5,opt,name=time,proto3" json:"time,omitempty"`
}

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

var xxx_messageInfo_MsgRejectAddX509RootCert proto.InternalMessageInfo

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

func (m *MsgRejectAddX509RootCert) GetSubject() string {
	if m != nil {
		return m.Subject
	}
	return ""
}

func (m *MsgRejectAddX509RootCert) GetSubjectKeyId() string {
	if m != nil {
		return m.SubjectKeyId
	}
	return ""
}

func (m *MsgRejectAddX509RootCert) GetInfo() string {
	if m != nil {
		return m.Info
	}
	return ""
}

func (m *MsgRejectAddX509RootCert) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

type MsgRejectAddX509RootCertResponse struct {
}

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

var xxx_messageInfo_MsgRejectAddX509RootCertResponse proto.InternalMessageInfo

type MsgAddPkiRevocationDistributionPoint struct {
	Signer               string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty" validate:"required"`
	Vid                  int32  `protobuf:"varint,2,opt,name=vid,proto3" json:"vid,omitempty" validate:"gte=1,lte=65535,required"`
	Pid                  int32  `protobuf:"varint,3,opt,name=pid,proto3" json:"pid,omitempty" validate:"gte=0,lte=65535"`
	IsPAA                bool   `protobuf:"varint,4,opt,name=isPAA,proto3" json:"isPAA,omitempty"`
	Label                string `protobuf:"bytes,5,opt,name=label,proto3" json:"label,omitempty" validate:"required"`
	CrlSignerCertificate string `protobuf:"bytes,6,opt,name=crlSignerCertificate,proto3" json:"crlSignerCertificate,omitempty" validate:"required"`
	IssuerSubjectKeyID   string `protobuf:"bytes,7,opt,name=issuerSubjectKeyID,proto3" json:"issuerSubjectKeyID,omitempty" validate:"required"`
	DataURL              string `protobuf:"bytes,8,opt,name=dataURL,proto3" json:"dataURL,omitempty" validate:"required,url"`
	DataFileSize         uint64 `protobuf:"varint,9,opt,name=dataFileSize,proto3" json:"dataFileSize,omitempty"`
	DataDigest           string `protobuf:"bytes,10,opt,name=dataDigest,proto3" json:"dataDigest,omitempty"`
	DataDigestType       uint32 `protobuf:"varint,11,opt,name=dataDigestType,proto3" json:"dataDigestType,omitempty"`
	RevocationType       uint32 `protobuf:"varint,12,opt,name=revocationType,proto3" json:"revocationType,omitempty" validate:"required"`
}

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

var xxx_messageInfo_MsgAddPkiRevocationDistributionPoint proto.InternalMessageInfo

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

func (m *MsgAddPkiRevocationDistributionPoint) GetVid() int32 {
	if m != nil {
		return m.Vid
	}
	return 0
}

func (m *MsgAddPkiRevocationDistributionPoint) GetPid() int32 {
	if m != nil {
		return m.Pid
	}
	return 0
}

func (m *MsgAddPkiRevocationDistributionPoint) GetIsPAA() bool {
	if m != nil {
		return m.IsPAA
	}
	return false
}

func (m *MsgAddPkiRevocationDistributionPoint) GetLabel() string {
	if m != nil {
		return m.Label
	}
	return ""
}

func (m *MsgAddPkiRevocationDistributionPoint) GetCrlSignerCertificate() string {
	if m != nil {
		return m.CrlSignerCertificate
	}
	return ""
}

func (m *MsgAddPkiRevocationDistributionPoint) GetIssuerSubjectKeyID() string {
	if m != nil {
		return m.IssuerSubjectKeyID
	}
	return ""
}

func (m *MsgAddPkiRevocationDistributionPoint) GetDataURL() string {
	if m != nil {
		return m.DataURL
	}
	return ""
}

func (m *MsgAddPkiRevocationDistributionPoint) GetDataFileSize() uint64 {
	if m != nil {
		return m.DataFileSize
	}
	return 0
}

func (m *MsgAddPkiRevocationDistributionPoint) GetDataDigest() string {
	if m != nil {
		return m.DataDigest
	}
	return ""
}

func (m *MsgAddPkiRevocationDistributionPoint) GetDataDigestType() uint32 {
	if m != nil {
		return m.DataDigestType
	}
	return 0
}

func (m *MsgAddPkiRevocationDistributionPoint) GetRevocationType() uint32 {
	if m != nil {
		return m.RevocationType
	}
	return 0
}

type MsgAddPkiRevocationDistributionPointResponse struct {
}

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

var xxx_messageInfo_MsgAddPkiRevocationDistributionPointResponse proto.InternalMessageInfo

type MsgUpdatePkiRevocationDistributionPoint struct {
	Signer               string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty" validate:"required"`
	Vid                  int32  `protobuf:"varint,2,opt,name=vid,proto3" json:"vid,omitempty" validate:"gte=1,lte=65535,required"`
	Label                string `protobuf:"bytes,3,opt,name=label,proto3" json:"label,omitempty" validate:"required"`
	CrlSignerCertificate string `protobuf:"bytes,4,opt,name=crlSignerCertificate,proto3" json:"crlSignerCertificate,omitempty"`
	IssuerSubjectKeyID   string `protobuf:"bytes,5,opt,name=issuerSubjectKeyID,proto3" json:"issuerSubjectKeyID,omitempty" validate:"required"`
	DataURL              string `protobuf:"bytes,6,opt,name=dataURL,proto3" json:"dataURL,omitempty" validate:"omitempty,url"`
	DataFileSize         uint64 `protobuf:"varint,7,opt,name=dataFileSize,proto3" json:"dataFileSize,omitempty"`
	DataDigest           string `protobuf:"bytes,8,opt,name=dataDigest,proto3" json:"dataDigest,omitempty"`
	DataDigestType       uint32 `protobuf:"varint,9,opt,name=dataDigestType,proto3" json:"dataDigestType,omitempty"`
}

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

var xxx_messageInfo_MsgUpdatePkiRevocationDistributionPoint proto.InternalMessageInfo

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

func (m *MsgUpdatePkiRevocationDistributionPoint) GetVid() int32 {
	if m != nil {
		return m.Vid
	}
	return 0
}

func (m *MsgUpdatePkiRevocationDistributionPoint) GetLabel() string {
	if m != nil {
		return m.Label
	}
	return ""
}

func (m *MsgUpdatePkiRevocationDistributionPoint) GetCrlSignerCertificate() string {
	if m != nil {
		return m.CrlSignerCertificate
	}
	return ""
}

func (m *MsgUpdatePkiRevocationDistributionPoint) GetIssuerSubjectKeyID() string {
	if m != nil {
		return m.IssuerSubjectKeyID
	}
	return ""
}

func (m *MsgUpdatePkiRevocationDistributionPoint) GetDataURL() string {
	if m != nil {
		return m.DataURL
	}
	return ""
}

func (m *MsgUpdatePkiRevocationDistributionPoint) GetDataFileSize() uint64 {
	if m != nil {
		return m.DataFileSize
	}
	return 0
}

func (m *MsgUpdatePkiRevocationDistributionPoint) GetDataDigest() string {
	if m != nil {
		return m.DataDigest
	}
	return ""
}

func (m *MsgUpdatePkiRevocationDistributionPoint) GetDataDigestType() uint32 {
	if m != nil {
		return m.DataDigestType
	}
	return 0
}

type MsgUpdatePkiRevocationDistributionPointResponse struct {
}

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

var xxx_messageInfo_MsgUpdatePkiRevocationDistributionPointResponse proto.InternalMessageInfo

type MsgDeletePkiRevocationDistributionPoint struct {
	Signer             string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty" validate:"required"`
	Vid                int32  `protobuf:"varint,2,opt,name=vid,proto3" json:"vid,omitempty" validate:"gte=1,lte=65535,required"`
	Label              string `protobuf:"bytes,3,opt,name=label,proto3" json:"label,omitempty" validate:"required"`
	IssuerSubjectKeyID string `protobuf:"bytes,4,opt,name=issuerSubjectKeyID,proto3" json:"issuerSubjectKeyID,omitempty" validate:"required"`
}

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

var xxx_messageInfo_MsgDeletePkiRevocationDistributionPoint proto.InternalMessageInfo

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

func (m *MsgDeletePkiRevocationDistributionPoint) GetVid() int32 {
	if m != nil {
		return m.Vid
	}
	return 0
}

func (m *MsgDeletePkiRevocationDistributionPoint) GetLabel() string {
	if m != nil {
		return m.Label
	}
	return ""
}

func (m *MsgDeletePkiRevocationDistributionPoint) GetIssuerSubjectKeyID() string {
	if m != nil {
		return m.IssuerSubjectKeyID
	}
	return ""
}

type MsgDeletePkiRevocationDistributionPointResponse struct {
}

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

var xxx_messageInfo_MsgDeletePkiRevocationDistributionPointResponse proto.InternalMessageInfo

type MsgAssignVid struct {
	Signer       string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty" validate:"required"`
	Subject      string `protobuf:"bytes,2,opt,name=subject,proto3" json:"subject,omitempty" validate:"required,max=1024"`
	SubjectKeyId string `protobuf:"bytes,3,opt,name=subjectKeyId,proto3" json:"subjectKeyId,omitempty" validate:"required,max=256"`
	Vid          int32  `protobuf:"varint,4,opt,name=vid,proto3" json:"vid,omitempty" validate:"gte=1,lte=65535,required"`
}

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

var xxx_messageInfo_MsgAssignVid proto.InternalMessageInfo

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

func (m *MsgAssignVid) GetSubject() string {
	if m != nil {
		return m.Subject
	}
	return ""
}

func (m *MsgAssignVid) GetSubjectKeyId() string {
	if m != nil {
		return m.SubjectKeyId
	}
	return ""
}

func (m *MsgAssignVid) GetVid() int32 {
	if m != nil {
		return m.Vid
	}
	return 0
}

type MsgAssignVidResponse struct {
}

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

var xxx_messageInfo_MsgAssignVidResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*MsgProposeAddX509RootCert)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgProposeAddX509RootCert")
	proto.RegisterType((*MsgProposeAddX509RootCertResponse)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgProposeAddX509RootCertResponse")
	proto.RegisterType((*MsgApproveAddX509RootCert)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgApproveAddX509RootCert")
	proto.RegisterType((*MsgApproveAddX509RootCertResponse)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgApproveAddX509RootCertResponse")
	proto.RegisterType((*MsgAddX509Cert)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgAddX509Cert")
	proto.RegisterType((*MsgAddX509CertResponse)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgAddX509CertResponse")
	proto.RegisterType((*MsgProposeRevokeX509RootCert)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgProposeRevokeX509RootCert")
	proto.RegisterType((*MsgProposeRevokeX509RootCertResponse)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgProposeRevokeX509RootCertResponse")
	proto.RegisterType((*MsgApproveRevokeX509RootCert)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgApproveRevokeX509RootCert")
	proto.RegisterType((*MsgApproveRevokeX509RootCertResponse)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgApproveRevokeX509RootCertResponse")
	proto.RegisterType((*MsgRevokeX509Cert)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgRevokeX509Cert")
	proto.RegisterType((*MsgRevokeX509CertResponse)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgRevokeX509CertResponse")
	proto.RegisterType((*MsgRejectAddX509RootCert)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgRejectAddX509RootCert")
	proto.RegisterType((*MsgRejectAddX509RootCertResponse)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgRejectAddX509RootCertResponse")
	proto.RegisterType((*MsgAddPkiRevocationDistributionPoint)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgAddPkiRevocationDistributionPoint")
	proto.RegisterType((*MsgAddPkiRevocationDistributionPointResponse)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgAddPkiRevocationDistributionPointResponse")
	proto.RegisterType((*MsgUpdatePkiRevocationDistributionPoint)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgUpdatePkiRevocationDistributionPoint")
	proto.RegisterType((*MsgUpdatePkiRevocationDistributionPointResponse)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgUpdatePkiRevocationDistributionPointResponse")
	proto.RegisterType((*MsgDeletePkiRevocationDistributionPoint)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgDeletePkiRevocationDistributionPoint")
	proto.RegisterType((*MsgDeletePkiRevocationDistributionPointResponse)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgDeletePkiRevocationDistributionPointResponse")
	proto.RegisterType((*MsgAssignVid)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgAssignVid")
	proto.RegisterType((*MsgAssignVidResponse)(nil), "zigbeealliance.distributedcomplianceledger.pki.MsgAssignVidResponse")
}

func init() { proto.RegisterFile("pki/tx.proto", fileDescriptor_badfdb2b39855d16) }

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

type msgClient struct {
	cc grpc1.ClientConn
}

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

func (c *msgClient) ProposeAddX509RootCert(ctx context.Context, in *MsgProposeAddX509RootCert, opts ...grpc.CallOption) (*MsgProposeAddX509RootCertResponse, error) {
	out := new(MsgProposeAddX509RootCertResponse)
	err := c.cc.Invoke(ctx, "/zigbeealliance.distributedcomplianceledger.pki.Msg/ProposeAddX509RootCert", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) ApproveAddX509RootCert(ctx context.Context, in *MsgApproveAddX509RootCert, opts ...grpc.CallOption) (*MsgApproveAddX509RootCertResponse, error) {
	out := new(MsgApproveAddX509RootCertResponse)
	err := c.cc.Invoke(ctx, "/zigbeealliance.distributedcomplianceledger.pki.Msg/ApproveAddX509RootCert", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) AddX509Cert(ctx context.Context, in *MsgAddX509Cert, opts ...grpc.CallOption) (*MsgAddX509CertResponse, error) {
	out := new(MsgAddX509CertResponse)
	err := c.cc.Invoke(ctx, "/zigbeealliance.distributedcomplianceledger.pki.Msg/AddX509Cert", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) ProposeRevokeX509RootCert(ctx context.Context, in *MsgProposeRevokeX509RootCert, opts ...grpc.CallOption) (*MsgProposeRevokeX509RootCertResponse, error) {
	out := new(MsgProposeRevokeX509RootCertResponse)
	err := c.cc.Invoke(ctx, "/zigbeealliance.distributedcomplianceledger.pki.Msg/ProposeRevokeX509RootCert", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) ApproveRevokeX509RootCert(ctx context.Context, in *MsgApproveRevokeX509RootCert, opts ...grpc.CallOption) (*MsgApproveRevokeX509RootCertResponse, error) {
	out := new(MsgApproveRevokeX509RootCertResponse)
	err := c.cc.Invoke(ctx, "/zigbeealliance.distributedcomplianceledger.pki.Msg/ApproveRevokeX509RootCert", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) RevokeX509Cert(ctx context.Context, in *MsgRevokeX509Cert, opts ...grpc.CallOption) (*MsgRevokeX509CertResponse, error) {
	out := new(MsgRevokeX509CertResponse)
	err := c.cc.Invoke(ctx, "/zigbeealliance.distributedcomplianceledger.pki.Msg/RevokeX509Cert", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) RejectAddX509RootCert(ctx context.Context, in *MsgRejectAddX509RootCert, opts ...grpc.CallOption) (*MsgRejectAddX509RootCertResponse, error) {
	out := new(MsgRejectAddX509RootCertResponse)
	err := c.cc.Invoke(ctx, "/zigbeealliance.distributedcomplianceledger.pki.Msg/RejectAddX509RootCert", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) AddPkiRevocationDistributionPoint(ctx context.Context, in *MsgAddPkiRevocationDistributionPoint, opts ...grpc.CallOption) (*MsgAddPkiRevocationDistributionPointResponse, error) {
	out := new(MsgAddPkiRevocationDistributionPointResponse)
	err := c.cc.Invoke(ctx, "/zigbeealliance.distributedcomplianceledger.pki.Msg/AddPkiRevocationDistributionPoint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UpdatePkiRevocationDistributionPoint(ctx context.Context, in *MsgUpdatePkiRevocationDistributionPoint, opts ...grpc.CallOption) (*MsgUpdatePkiRevocationDistributionPointResponse, error) {
	out := new(MsgUpdatePkiRevocationDistributionPointResponse)
	err := c.cc.Invoke(ctx, "/zigbeealliance.distributedcomplianceledger.pki.Msg/UpdatePkiRevocationDistributionPoint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) DeletePkiRevocationDistributionPoint(ctx context.Context, in *MsgDeletePkiRevocationDistributionPoint, opts ...grpc.CallOption) (*MsgDeletePkiRevocationDistributionPointResponse, error) {
	out := new(MsgDeletePkiRevocationDistributionPointResponse)
	err := c.cc.Invoke(ctx, "/zigbeealliance.distributedcomplianceledger.pki.Msg/DeletePkiRevocationDistributionPoint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) AssignVid(ctx context.Context, in *MsgAssignVid, opts ...grpc.CallOption) (*MsgAssignVidResponse, error) {
	out := new(MsgAssignVidResponse)
	err := c.cc.Invoke(ctx, "/zigbeealliance.distributedcomplianceledger.pki.Msg/AssignVid", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	ProposeAddX509RootCert(context.Context, *MsgProposeAddX509RootCert) (*MsgProposeAddX509RootCertResponse, error)
	ApproveAddX509RootCert(context.Context, *MsgApproveAddX509RootCert) (*MsgApproveAddX509RootCertResponse, error)
	AddX509Cert(context.Context, *MsgAddX509Cert) (*MsgAddX509CertResponse, error)
	ProposeRevokeX509RootCert(context.Context, *MsgProposeRevokeX509RootCert) (*MsgProposeRevokeX509RootCertResponse, error)
	ApproveRevokeX509RootCert(context.Context, *MsgApproveRevokeX509RootCert) (*MsgApproveRevokeX509RootCertResponse, error)
	RevokeX509Cert(context.Context, *MsgRevokeX509Cert) (*MsgRevokeX509CertResponse, error)
	RejectAddX509RootCert(context.Context, *MsgRejectAddX509RootCert) (*MsgRejectAddX509RootCertResponse, error)
	AddPkiRevocationDistributionPoint(context.Context, *MsgAddPkiRevocationDistributionPoint) (*MsgAddPkiRevocationDistributionPointResponse, error)
	UpdatePkiRevocationDistributionPoint(context.Context, *MsgUpdatePkiRevocationDistributionPoint) (*MsgUpdatePkiRevocationDistributionPointResponse, error)
	DeletePkiRevocationDistributionPoint(context.Context, *MsgDeletePkiRevocationDistributionPoint) (*MsgDeletePkiRevocationDistributionPointResponse, error)
	AssignVid(context.Context, *MsgAssignVid) (*MsgAssignVidResponse, error)
}

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

func (*UnimplementedMsgServer) ProposeAddX509RootCert(ctx context.Context, req *MsgProposeAddX509RootCert) (*MsgProposeAddX509RootCertResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProposeAddX509RootCert not implemented")
}
func (*UnimplementedMsgServer) ApproveAddX509RootCert(ctx context.Context, req *MsgApproveAddX509RootCert) (*MsgApproveAddX509RootCertResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ApproveAddX509RootCert not implemented")
}
func (*UnimplementedMsgServer) AddX509Cert(ctx context.Context, req *MsgAddX509Cert) (*MsgAddX509CertResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddX509Cert not implemented")
}
func (*UnimplementedMsgServer) ProposeRevokeX509RootCert(ctx context.Context, req *MsgProposeRevokeX509RootCert) (*MsgProposeRevokeX509RootCertResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProposeRevokeX509RootCert not implemented")
}
func (*UnimplementedMsgServer) ApproveRevokeX509RootCert(ctx context.Context, req *MsgApproveRevokeX509RootCert) (*MsgApproveRevokeX509RootCertResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ApproveRevokeX509RootCert not implemented")
}
func (*UnimplementedMsgServer) RevokeX509Cert(ctx context.Context, req *MsgRevokeX509Cert) (*MsgRevokeX509CertResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RevokeX509Cert not implemented")
}
func (*UnimplementedMsgServer) RejectAddX509RootCert(ctx context.Context, req *MsgRejectAddX509RootCert) (*MsgRejectAddX509RootCertResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RejectAddX509RootCert not implemented")
}
func (*UnimplementedMsgServer) AddPkiRevocationDistributionPoint(ctx context.Context, req *MsgAddPkiRevocationDistributionPoint) (*MsgAddPkiRevocationDistributionPointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddPkiRevocationDistributionPoint not implemented")
}
func (*UnimplementedMsgServer) UpdatePkiRevocationDistributionPoint(ctx context.Context, req *MsgUpdatePkiRevocationDistributionPoint) (*MsgUpdatePkiRevocationDistributionPointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdatePkiRevocationDistributionPoint not implemented")
}
func (*UnimplementedMsgServer) DeletePkiRevocationDistributionPoint(ctx context.Context, req *MsgDeletePkiRevocationDistributionPoint) (*MsgDeletePkiRevocationDistributionPointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeletePkiRevocationDistributionPoint not implemented")
}
func (*UnimplementedMsgServer) AssignVid(ctx context.Context, req *MsgAssignVid) (*MsgAssignVidResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AssignVid not implemented")
}

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

func _Msg_ProposeAddX509RootCert_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgProposeAddX509RootCert)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).ProposeAddX509RootCert(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/zigbeealliance.distributedcomplianceledger.pki.Msg/ProposeAddX509RootCert",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).ProposeAddX509RootCert(ctx, req.(*MsgProposeAddX509RootCert))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_ApproveAddX509RootCert_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgApproveAddX509RootCert)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).ApproveAddX509RootCert(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/zigbeealliance.distributedcomplianceledger.pki.Msg/ApproveAddX509RootCert",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).ApproveAddX509RootCert(ctx, req.(*MsgApproveAddX509RootCert))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_AddX509Cert_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgAddX509Cert)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).AddX509Cert(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/zigbeealliance.distributedcomplianceledger.pki.Msg/AddX509Cert",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).AddX509Cert(ctx, req.(*MsgAddX509Cert))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_ProposeRevokeX509RootCert_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgProposeRevokeX509RootCert)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).ProposeRevokeX509RootCert(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/zigbeealliance.distributedcomplianceledger.pki.Msg/ProposeRevokeX509RootCert",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).ProposeRevokeX509RootCert(ctx, req.(*MsgProposeRevokeX509RootCert))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_ApproveRevokeX509RootCert_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgApproveRevokeX509RootCert)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).ApproveRevokeX509RootCert(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/zigbeealliance.distributedcomplianceledger.pki.Msg/ApproveRevokeX509RootCert",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).ApproveRevokeX509RootCert(ctx, req.(*MsgApproveRevokeX509RootCert))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_RevokeX509Cert_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgRevokeX509Cert)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).RevokeX509Cert(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/zigbeealliance.distributedcomplianceledger.pki.Msg/RevokeX509Cert",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).RevokeX509Cert(ctx, req.(*MsgRevokeX509Cert))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_RejectAddX509RootCert_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgRejectAddX509RootCert)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).RejectAddX509RootCert(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/zigbeealliance.distributedcomplianceledger.pki.Msg/RejectAddX509RootCert",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).RejectAddX509RootCert(ctx, req.(*MsgRejectAddX509RootCert))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_AddPkiRevocationDistributionPoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgAddPkiRevocationDistributionPoint)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).AddPkiRevocationDistributionPoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/zigbeealliance.distributedcomplianceledger.pki.Msg/AddPkiRevocationDistributionPoint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).AddPkiRevocationDistributionPoint(ctx, req.(*MsgAddPkiRevocationDistributionPoint))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_UpdatePkiRevocationDistributionPoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUpdatePkiRevocationDistributionPoint)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UpdatePkiRevocationDistributionPoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/zigbeealliance.distributedcomplianceledger.pki.Msg/UpdatePkiRevocationDistributionPoint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UpdatePkiRevocationDistributionPoint(ctx, req.(*MsgUpdatePkiRevocationDistributionPoint))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_DeletePkiRevocationDistributionPoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgDeletePkiRevocationDistributionPoint)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).DeletePkiRevocationDistributionPoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/zigbeealliance.distributedcomplianceledger.pki.Msg/DeletePkiRevocationDistributionPoint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).DeletePkiRevocationDistributionPoint(ctx, req.(*MsgDeletePkiRevocationDistributionPoint))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_AssignVid_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgAssignVid)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).AssignVid(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/zigbeealliance.distributedcomplianceledger.pki.Msg/AssignVid",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).AssignVid(ctx, req.(*MsgAssignVid))
	}
	return interceptor(ctx, in, info, handler)
}

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "zigbeealliance.distributedcomplianceledger.pki.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ProposeAddX509RootCert",
			Handler:    _Msg_ProposeAddX509RootCert_Handler,
		},
		{
			MethodName: "ApproveAddX509RootCert",
			Handler:    _Msg_ApproveAddX509RootCert_Handler,
		},
		{
			MethodName: "AddX509Cert",
			Handler:    _Msg_AddX509Cert_Handler,
		},
		{
			MethodName: "ProposeRevokeX509RootCert",
			Handler:    _Msg_ProposeRevokeX509RootCert_Handler,
		},
		{
			MethodName: "ApproveRevokeX509RootCert",
			Handler:    _Msg_ApproveRevokeX509RootCert_Handler,
		},
		{
			MethodName: "RevokeX509Cert",
			Handler:    _Msg_RevokeX509Cert_Handler,
		},
		{
			MethodName: "RejectAddX509RootCert",
			Handler:    _Msg_RejectAddX509RootCert_Handler,
		},
		{
			MethodName: "AddPkiRevocationDistributionPoint",
			Handler:    _Msg_AddPkiRevocationDistributionPoint_Handler,
		},
		{
			MethodName: "UpdatePkiRevocationDistributionPoint",
			Handler:    _Msg_UpdatePkiRevocationDistributionPoint_Handler,
		},
		{
			MethodName: "DeletePkiRevocationDistributionPoint",
			Handler:    _Msg_DeletePkiRevocationDistributionPoint_Handler,
		},
		{
			MethodName: "AssignVid",
			Handler:    _Msg_AssignVid_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pki/tx.proto",
}

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

func (m *MsgProposeAddX509RootCert) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Vid != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.Vid))
		i--
		dAtA[i] = 0x28
	}
	if m.Time != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.Time))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Info) > 0 {
		i -= len(m.Info)
		copy(dAtA[i:], m.Info)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Info)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Cert) > 0 {
		i -= len(m.Cert)
		copy(dAtA[i:], m.Cert)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Cert)))
		i--
		dAtA[i] = 0x12
	}
	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] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgApproveAddX509RootCert) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Time != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.Time))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Info) > 0 {
		i -= len(m.Info)
		copy(dAtA[i:], m.Info)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Info)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.SubjectKeyId) > 0 {
		i -= len(m.SubjectKeyId)
		copy(dAtA[i:], m.SubjectKeyId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.SubjectKeyId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Subject) > 0 {
		i -= len(m.Subject)
		copy(dAtA[i:], m.Subject)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Subject)))
		i--
		dAtA[i] = 0x12
	}
	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] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *MsgProposeRevokeX509RootCert) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Time != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.Time))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Info) > 0 {
		i -= len(m.Info)
		copy(dAtA[i:], m.Info)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Info)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.SubjectKeyId) > 0 {
		i -= len(m.SubjectKeyId)
		copy(dAtA[i:], m.SubjectKeyId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.SubjectKeyId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Subject) > 0 {
		i -= len(m.Subject)
		copy(dAtA[i:], m.Subject)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Subject)))
		i--
		dAtA[i] = 0x12
	}
	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] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgApproveRevokeX509RootCert) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Time != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.Time))
		i--
		dAtA[i] = 0x30
	}
	if len(m.Info) > 0 {
		i -= len(m.Info)
		copy(dAtA[i:], m.Info)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Info)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.SubjectKeyId) > 0 {
		i -= len(m.SubjectKeyId)
		copy(dAtA[i:], m.SubjectKeyId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.SubjectKeyId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Subject) > 0 {
		i -= len(m.Subject)
		copy(dAtA[i:], m.Subject)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Subject)))
		i--
		dAtA[i] = 0x12
	}
	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] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgRevokeX509Cert) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Time != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.Time))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Info) > 0 {
		i -= len(m.Info)
		copy(dAtA[i:], m.Info)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Info)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.SubjectKeyId) > 0 {
		i -= len(m.SubjectKeyId)
		copy(dAtA[i:], m.SubjectKeyId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.SubjectKeyId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Subject) > 0 {
		i -= len(m.Subject)
		copy(dAtA[i:], m.Subject)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Subject)))
		i--
		dAtA[i] = 0x12
	}
	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] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgRejectAddX509RootCert) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Time != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.Time))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Info) > 0 {
		i -= len(m.Info)
		copy(dAtA[i:], m.Info)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Info)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.SubjectKeyId) > 0 {
		i -= len(m.SubjectKeyId)
		copy(dAtA[i:], m.SubjectKeyId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.SubjectKeyId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Subject) > 0 {
		i -= len(m.Subject)
		copy(dAtA[i:], m.Subject)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Subject)))
		i--
		dAtA[i] = 0x12
	}
	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] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgAddPkiRevocationDistributionPoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RevocationType != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.RevocationType))
		i--
		dAtA[i] = 0x60
	}
	if m.DataDigestType != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.DataDigestType))
		i--
		dAtA[i] = 0x58
	}
	if len(m.DataDigest) > 0 {
		i -= len(m.DataDigest)
		copy(dAtA[i:], m.DataDigest)
		i = encodeVarintTx(dAtA, i, uint64(len(m.DataDigest)))
		i--
		dAtA[i] = 0x52
	}
	if m.DataFileSize != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.DataFileSize))
		i--
		dAtA[i] = 0x48
	}
	if len(m.DataURL) > 0 {
		i -= len(m.DataURL)
		copy(dAtA[i:], m.DataURL)
		i = encodeVarintTx(dAtA, i, uint64(len(m.DataURL)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.IssuerSubjectKeyID) > 0 {
		i -= len(m.IssuerSubjectKeyID)
		copy(dAtA[i:], m.IssuerSubjectKeyID)
		i = encodeVarintTx(dAtA, i, uint64(len(m.IssuerSubjectKeyID)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.CrlSignerCertificate) > 0 {
		i -= len(m.CrlSignerCertificate)
		copy(dAtA[i:], m.CrlSignerCertificate)
		i = encodeVarintTx(dAtA, i, uint64(len(m.CrlSignerCertificate)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Label) > 0 {
		i -= len(m.Label)
		copy(dAtA[i:], m.Label)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Label)))
		i--
		dAtA[i] = 0x2a
	}
	if m.IsPAA {
		i--
		if m.IsPAA {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Pid != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.Pid))
		i--
		dAtA[i] = 0x18
	}
	if m.Vid != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.Vid))
		i--
		dAtA[i] = 0x10
	}
	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] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgUpdatePkiRevocationDistributionPoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DataDigestType != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.DataDigestType))
		i--
		dAtA[i] = 0x48
	}
	if len(m.DataDigest) > 0 {
		i -= len(m.DataDigest)
		copy(dAtA[i:], m.DataDigest)
		i = encodeVarintTx(dAtA, i, uint64(len(m.DataDigest)))
		i--
		dAtA[i] = 0x42
	}
	if m.DataFileSize != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.DataFileSize))
		i--
		dAtA[i] = 0x38
	}
	if len(m.DataURL) > 0 {
		i -= len(m.DataURL)
		copy(dAtA[i:], m.DataURL)
		i = encodeVarintTx(dAtA, i, uint64(len(m.DataURL)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.IssuerSubjectKeyID) > 0 {
		i -= len(m.IssuerSubjectKeyID)
		copy(dAtA[i:], m.IssuerSubjectKeyID)
		i = encodeVarintTx(dAtA, i, uint64(len(m.IssuerSubjectKeyID)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.CrlSignerCertificate) > 0 {
		i -= len(m.CrlSignerCertificate)
		copy(dAtA[i:], m.CrlSignerCertificate)
		i = encodeVarintTx(dAtA, i, uint64(len(m.CrlSignerCertificate)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Label) > 0 {
		i -= len(m.Label)
		copy(dAtA[i:], m.Label)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Label)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Vid != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.Vid))
		i--
		dAtA[i] = 0x10
	}
	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] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgDeletePkiRevocationDistributionPoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.IssuerSubjectKeyID) > 0 {
		i -= len(m.IssuerSubjectKeyID)
		copy(dAtA[i:], m.IssuerSubjectKeyID)
		i = encodeVarintTx(dAtA, i, uint64(len(m.IssuerSubjectKeyID)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Label) > 0 {
		i -= len(m.Label)
		copy(dAtA[i:], m.Label)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Label)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Vid != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.Vid))
		i--
		dAtA[i] = 0x10
	}
	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] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *MsgAssignVidResponse) 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 *MsgProposeAddX509RootCert) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Cert)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Info)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.Time != 0 {
		n += 1 + sovTx(uint64(m.Time))
	}
	if m.Vid != 0 {
		n += 1 + sovTx(uint64(m.Vid))
	}
	return n
}

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

func (m *MsgApproveAddX509RootCert) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Subject)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.SubjectKeyId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Info)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.Time != 0 {
		n += 1 + sovTx(uint64(m.Time))
	}
	return n
}

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

func (m *MsgAddX509Cert) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Cert)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Info)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.Time != 0 {
		n += 1 + sovTx(uint64(m.Time))
	}
	return n
}

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

func (m *MsgProposeRevokeX509RootCert) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Subject)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.SubjectKeyId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Info)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.Time != 0 {
		n += 1 + sovTx(uint64(m.Time))
	}
	return n
}

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

func (m *MsgApproveRevokeX509RootCert) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Subject)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.SubjectKeyId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Info)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.Time != 0 {
		n += 1 + sovTx(uint64(m.Time))
	}
	return n
}

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

func (m *MsgRevokeX509Cert) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Subject)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.SubjectKeyId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Info)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.Time != 0 {
		n += 1 + sovTx(uint64(m.Time))
	}
	return n
}

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

func (m *MsgRejectAddX509RootCert) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Subject)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.SubjectKeyId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Info)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.Time != 0 {
		n += 1 + sovTx(uint64(m.Time))
	}
	return n
}

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

func (m *MsgAddPkiRevocationDistributionPoint) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.Vid != 0 {
		n += 1 + sovTx(uint64(m.Vid))
	}
	if m.Pid != 0 {
		n += 1 + sovTx(uint64(m.Pid))
	}
	if m.IsPAA {
		n += 2
	}
	l = len(m.Label)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.CrlSignerCertificate)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.IssuerSubjectKeyID)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.DataURL)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.DataFileSize != 0 {
		n += 1 + sovTx(uint64(m.DataFileSize))
	}
	l = len(m.DataDigest)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.DataDigestType != 0 {
		n += 1 + sovTx(uint64(m.DataDigestType))
	}
	if m.RevocationType != 0 {
		n += 1 + sovTx(uint64(m.RevocationType))
	}
	return n
}

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

func (m *MsgUpdatePkiRevocationDistributionPoint) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.Vid != 0 {
		n += 1 + sovTx(uint64(m.Vid))
	}
	l = len(m.Label)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.CrlSignerCertificate)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.IssuerSubjectKeyID)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.DataURL)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.DataFileSize != 0 {
		n += 1 + sovTx(uint64(m.DataFileSize))
	}
	l = len(m.DataDigest)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.DataDigestType != 0 {
		n += 1 + sovTx(uint64(m.DataDigestType))
	}
	return n
}

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

func (m *MsgDeletePkiRevocationDistributionPoint) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.Vid != 0 {
		n += 1 + sovTx(uint64(m.Vid))
	}
	l = len(m.Label)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.IssuerSubjectKeyID)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgAssignVid) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Subject)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.SubjectKeyId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.Vid != 0 {
		n += 1 + sovTx(uint64(m.Vid))
	}
	return n
}

func (m *MsgAssignVidResponse) 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 *MsgProposeAddX509RootCert) 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: MsgProposeAddX509RootCert: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgProposeAddX509RootCert: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cert", 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.Cert = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", 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.Info = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			m.Time = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Time |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Vid", wireType)
			}
			m.Vid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Vid |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *MsgProposeAddX509RootCertResponse) 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: MsgProposeAddX509RootCertResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgProposeAddX509RootCertResponse: 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 *MsgApproveAddX509RootCert) 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: MsgApproveAddX509RootCert: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgApproveAddX509RootCert: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subject", 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.Subject = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubjectKeyId", 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.SubjectKeyId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", 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.Info = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			m.Time = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Time |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *MsgApproveAddX509RootCertResponse) 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: MsgApproveAddX509RootCertResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgApproveAddX509RootCertResponse: 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 *MsgAddX509Cert) 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: MsgAddX509Cert: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddX509Cert: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cert", 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.Cert = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", 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.Info = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			m.Time = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Time |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *MsgAddX509CertResponse) 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: MsgAddX509CertResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddX509CertResponse: 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 *MsgProposeRevokeX509RootCert) 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: MsgProposeRevokeX509RootCert: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgProposeRevokeX509RootCert: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subject", 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.Subject = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubjectKeyId", 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.SubjectKeyId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", 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.Info = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			m.Time = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Time |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *MsgProposeRevokeX509RootCertResponse) 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: MsgProposeRevokeX509RootCertResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgProposeRevokeX509RootCertResponse: 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 *MsgApproveRevokeX509RootCert) 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: MsgApproveRevokeX509RootCert: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgApproveRevokeX509RootCert: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subject", 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.Subject = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubjectKeyId", 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.SubjectKeyId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", 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.Info = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			m.Time = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Time |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *MsgApproveRevokeX509RootCertResponse) 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: MsgApproveRevokeX509RootCertResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgApproveRevokeX509RootCertResponse: 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 *MsgRevokeX509Cert) 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: MsgRevokeX509Cert: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRevokeX509Cert: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subject", 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.Subject = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubjectKeyId", 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.SubjectKeyId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", 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.Info = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			m.Time = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Time |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *MsgRevokeX509CertResponse) 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: MsgRevokeX509CertResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRevokeX509CertResponse: 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 *MsgRejectAddX509RootCert) 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: MsgRejectAddX509RootCert: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRejectAddX509RootCert: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subject", 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.Subject = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubjectKeyId", 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.SubjectKeyId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", 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.Info = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			m.Time = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Time |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *MsgRejectAddX509RootCertResponse) 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: MsgRejectAddX509RootCertResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRejectAddX509RootCertResponse: 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 *MsgAddPkiRevocationDistributionPoint) 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: MsgAddPkiRevocationDistributionPoint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddPkiRevocationDistributionPoint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Vid", wireType)
			}
			m.Vid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Vid |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
			}
			m.Pid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Pid |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsPAA", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsPAA = bool(v != 0)
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Label", 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.Label = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CrlSignerCertificate", 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.CrlSignerCertificate = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IssuerSubjectKeyID", 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.IssuerSubjectKeyID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataURL", 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.DataURL = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataFileSize", wireType)
			}
			m.DataFileSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DataFileSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataDigest", 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.DataDigest = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataDigestType", wireType)
			}
			m.DataDigestType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DataDigestType |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RevocationType", wireType)
			}
			m.RevocationType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RevocationType |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *MsgAddPkiRevocationDistributionPointResponse) 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: MsgAddPkiRevocationDistributionPointResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddPkiRevocationDistributionPointResponse: 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 *MsgUpdatePkiRevocationDistributionPoint) 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: MsgUpdatePkiRevocationDistributionPoint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdatePkiRevocationDistributionPoint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Vid", wireType)
			}
			m.Vid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Vid |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Label", 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.Label = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CrlSignerCertificate", 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.CrlSignerCertificate = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IssuerSubjectKeyID", 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.IssuerSubjectKeyID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataURL", 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.DataURL = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataFileSize", wireType)
			}
			m.DataFileSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DataFileSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataDigest", 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.DataDigest = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataDigestType", wireType)
			}
			m.DataDigestType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DataDigestType |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *MsgUpdatePkiRevocationDistributionPointResponse) 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: MsgUpdatePkiRevocationDistributionPointResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdatePkiRevocationDistributionPointResponse: 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 *MsgDeletePkiRevocationDistributionPoint) 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: MsgDeletePkiRevocationDistributionPoint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeletePkiRevocationDistributionPoint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Vid", wireType)
			}
			m.Vid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Vid |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Label", 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.Label = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IssuerSubjectKeyID", 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.IssuerSubjectKeyID = 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 *MsgDeletePkiRevocationDistributionPointResponse) 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: MsgDeletePkiRevocationDistributionPointResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeletePkiRevocationDistributionPointResponse: 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 *MsgAssignVid) 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: MsgAssignVid: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAssignVid: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subject", 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.Subject = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubjectKeyId", 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.SubjectKeyId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Vid", wireType)
			}
			m.Vid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Vid |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 *MsgAssignVidResponse) 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: MsgAssignVidResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAssignVidResponse: 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")
)