verifier.pb.go

// Code generated by protoc-gen-gogo.
// source: verifier.proto
// DO NOT EDIT!

package proto

import proto1 "github.com/maditya/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/maditya/protobuf/gogoproto"

import strings "strings"
import github_com_maditya_protobuf_proto "github.com/maditya/protobuf/proto"
import sort "sort"
import strconv "strconv"
import reflect "reflect"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

import io "io"

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

// UpdateRequest streams a specified number of committed updates or
// ratifications. See replication.GetCommitted and replication.WaitCommitted.
type VerifierStreamRequest struct {
	// Start identifies the first epoch for which verifier steps should be
	// returned.
	Start uint64 `protobuf:"varint,1,opt,name=start,proto3" json:"start,omitempty"`
	// PageSize specifies number of entries to be returned, MaxUint64 for
	// unlimited.
	PageSize uint64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
}

func (m *VerifierStreamRequest) Reset()                    { *m = VerifierStreamRequest{} }
func (*VerifierStreamRequest) ProtoMessage()               {}
func (*VerifierStreamRequest) Descriptor() ([]byte, []int) { return fileDescriptorVerifier, []int{0} }

// VerifierStep denotes the input to a single state transition of the verified
// part of the keyserver state machine.
type VerifierStep struct {
	// Types that are valid to be assigned to Type:
	//	*VerifierStep_Update
	//	*VerifierStep_Epoch
	Type isVerifierStep_Type `protobuf_oneof:"type"`
}

func (m *VerifierStep) Reset()                    { *m = VerifierStep{} }
func (*VerifierStep) ProtoMessage()               {}
func (*VerifierStep) Descriptor() ([]byte, []int) { return fileDescriptorVerifier, []int{1} }

type isVerifierStep_Type interface {
	isVerifierStep_Type()
	Equal(interface{}) bool
	VerboseEqual(interface{}) error
	MarshalTo([]byte) (int, error)
	Size() int
}

type VerifierStep_Update struct {
	Update *SignedEntryUpdate `protobuf:"bytes,1,opt,name=Update,oneof"`
}
type VerifierStep_Epoch struct {
	Epoch *SignedEpochHead `protobuf:"bytes,2,opt,name=Epoch,oneof"`
}

func (*VerifierStep_Update) isVerifierStep_Type() {}
func (*VerifierStep_Epoch) isVerifierStep_Type()  {}

func (m *VerifierStep) GetType() isVerifierStep_Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *VerifierStep) GetUpdate() *SignedEntryUpdate {
	if x, ok := m.GetType().(*VerifierStep_Update); ok {
		return x.Update
	}
	return nil
}

func (m *VerifierStep) GetEpoch() *SignedEpochHead {
	if x, ok := m.GetType().(*VerifierStep_Epoch); ok {
		return x.Epoch
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*VerifierStep) XXX_OneofFuncs() (func(msg proto1.Message, b *proto1.Buffer) error, func(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error), func(msg proto1.Message) (n int), []interface{}) {
	return _VerifierStep_OneofMarshaler, _VerifierStep_OneofUnmarshaler, _VerifierStep_OneofSizer, []interface{}{
		(*VerifierStep_Update)(nil),
		(*VerifierStep_Epoch)(nil),
	}
}

func _VerifierStep_OneofMarshaler(msg proto1.Message, b *proto1.Buffer) error {
	m := msg.(*VerifierStep)
	// type
	switch x := m.Type.(type) {
	case *VerifierStep_Update:
		_ = b.EncodeVarint(1<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.Update); err != nil {
			return err
		}
	case *VerifierStep_Epoch:
		_ = b.EncodeVarint(2<<3 | proto1.WireBytes)
		if err := b.EncodeMessage(x.Epoch); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("VerifierStep.Type has unexpected type %T", x)
	}
	return nil
}

func _VerifierStep_OneofUnmarshaler(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error) {
	m := msg.(*VerifierStep)
	switch tag {
	case 1: // type.Update
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(SignedEntryUpdate)
		err := b.DecodeMessage(msg)
		m.Type = &VerifierStep_Update{msg}
		return true, err
	case 2: // type.Epoch
		if wire != proto1.WireBytes {
			return true, proto1.ErrInternalBadWireType
		}
		msg := new(SignedEpochHead)
		err := b.DecodeMessage(msg)
		m.Type = &VerifierStep_Epoch{msg}
		return true, err
	default:
		return false, nil
	}
}

func _VerifierStep_OneofSizer(msg proto1.Message) (n int) {
	m := msg.(*VerifierStep)
	// type
	switch x := m.Type.(type) {
	case *VerifierStep_Update:
		s := proto1.Size(x.Update)
		n += proto1.SizeVarint(1<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case *VerifierStep_Epoch:
		s := proto1.Size(x.Epoch)
		n += proto1.SizeVarint(2<<3 | proto1.WireBytes)
		n += proto1.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type Nothing struct {
}

func (m *Nothing) Reset()                    { *m = Nothing{} }
func (*Nothing) ProtoMessage()               {}
func (*Nothing) Descriptor() ([]byte, []int) { return fileDescriptorVerifier, []int{2} }

func init() {
	proto1.RegisterType((*VerifierStreamRequest)(nil), "proto.VerifierStreamRequest")
	proto1.RegisterType((*VerifierStep)(nil), "proto.VerifierStep")
	proto1.RegisterType((*Nothing)(nil), "proto.Nothing")
}
func (this *VerifierStreamRequest) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*VerifierStreamRequest)
	if !ok {
		that2, ok := that.(VerifierStreamRequest)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *VerifierStreamRequest")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *VerifierStreamRequest but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *VerifierStreamRequest but is not nil && this == nil")
	}
	if this.Start != that1.Start {
		return fmt.Errorf("Start this(%v) Not Equal that(%v)", this.Start, that1.Start)
	}
	if this.PageSize != that1.PageSize {
		return fmt.Errorf("PageSize this(%v) Not Equal that(%v)", this.PageSize, that1.PageSize)
	}
	return nil
}
func (this *VerifierStreamRequest) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*VerifierStreamRequest)
	if !ok {
		that2, ok := that.(VerifierStreamRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Start != that1.Start {
		return false
	}
	if this.PageSize != that1.PageSize {
		return false
	}
	return true
}
func (this *VerifierStep) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*VerifierStep)
	if !ok {
		that2, ok := that.(VerifierStep)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *VerifierStep")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *VerifierStep but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *VerifierStep but is not nil && this == nil")
	}
	if that1.Type == nil {
		if this.Type != nil {
			return fmt.Errorf("this.Type != nil && that1.Type == nil")
		}
	} else if this.Type == nil {
		return fmt.Errorf("this.Type == nil && that1.Type != nil")
	} else if err := this.Type.VerboseEqual(that1.Type); err != nil {
		return err
	}
	return nil
}
func (this *VerifierStep_Update) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*VerifierStep_Update)
	if !ok {
		that2, ok := that.(VerifierStep_Update)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *VerifierStep_Update")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *VerifierStep_Update but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *VerifierStep_Update but is not nil && this == nil")
	}
	if !this.Update.Equal(that1.Update) {
		return fmt.Errorf("Update this(%v) Not Equal that(%v)", this.Update, that1.Update)
	}
	return nil
}
func (this *VerifierStep_Epoch) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*VerifierStep_Epoch)
	if !ok {
		that2, ok := that.(VerifierStep_Epoch)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *VerifierStep_Epoch")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *VerifierStep_Epoch but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *VerifierStep_Epoch but is not nil && this == nil")
	}
	if !this.Epoch.Equal(that1.Epoch) {
		return fmt.Errorf("Epoch this(%v) Not Equal that(%v)", this.Epoch, that1.Epoch)
	}
	return nil
}
func (this *VerifierStep) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*VerifierStep)
	if !ok {
		that2, ok := that.(VerifierStep)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if that1.Type == nil {
		if this.Type != nil {
			return false
		}
	} else if this.Type == nil {
		return false
	} else if !this.Type.Equal(that1.Type) {
		return false
	}
	return true
}
func (this *VerifierStep_Update) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*VerifierStep_Update)
	if !ok {
		that2, ok := that.(VerifierStep_Update)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.Update.Equal(that1.Update) {
		return false
	}
	return true
}
func (this *VerifierStep_Epoch) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*VerifierStep_Epoch)
	if !ok {
		that2, ok := that.(VerifierStep_Epoch)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.Epoch.Equal(that1.Epoch) {
		return false
	}
	return true
}
func (this *Nothing) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Nothing)
	if !ok {
		that2, ok := that.(Nothing)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Nothing")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Nothing but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Nothing but is not nil && this == nil")
	}
	return nil
}
func (this *Nothing) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Nothing)
	if !ok {
		that2, ok := that.(Nothing)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	return true
}
func (this *VerifierStreamRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&proto.VerifierStreamRequest{")
	s = append(s, "Start: "+fmt.Sprintf("%#v", this.Start)+",\n")
	s = append(s, "PageSize: "+fmt.Sprintf("%#v", this.PageSize)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *VerifierStep) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&proto.VerifierStep{")
	if this.Type != nil {
		s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *VerifierStep_Update) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&proto.VerifierStep_Update{` +
		`Update:` + fmt.Sprintf("%#v", this.Update) + `}`}, ", ")
	return s
}
func (this *VerifierStep_Epoch) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&proto.VerifierStep_Epoch{` +
		`Epoch:` + fmt.Sprintf("%#v", this.Epoch) + `}`}, ", ")
	return s
}
func valueToGoStringVerifier(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func extensionToGoStringVerifier(m github_com_maditya_protobuf_proto.Message) string {
	e := github_com_maditya_protobuf_proto.GetUnsafeExtensionsMap(m)
	if e == nil {
		return "nil"
	}
	s := "proto.NewUnsafeXXX_InternalExtensions(map[int32]proto.Extension{"
	keys := make([]int, 0, len(e))
	for k := range e {
		keys = append(keys, int(k))
	}
	sort.Ints(keys)
	ss := []string{}
	for _, k := range keys {
		ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString())
	}
	s += strings.Join(ss, ",") + "})"
	return s
}

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

// Client API for E2EKSVerification service

type E2EKSVerificationClient interface {
	// VerifierStream accesses the public inputs to a keyserver state machine.
	// The returned stream is given a limited view of the log which the keyserver
	// being verified uses to replicate its state internally.  However, private
	// user data, such as usernames and profile details, is not included (the
	// relevant fields are set to nil).  note: the keyserver implementation also
	// uses the same log to persist verifier ratifications, but as they do not
	// affect any username:profile mappings, they are excluded as well.
	VerifierStream(ctx context.Context, in *VerifierStreamRequest, opts ...grpc.CallOption) (E2EKSVerification_VerifierStreamClient, error)
	// PushRatification is called each time a verifier who has been
	// successfully replaying the log returned by VerifierStream interprets a
	// keyserver_ratified step and agrees that the keyserver state summarized
	// by it is the unique result of applying all the previous update steps.
	// The SignedRatification will be stored by the server and used to
	// argue the correctness of future lookups in front of clients.
	PushRatification(ctx context.Context, in *SignedEpochHead, opts ...grpc.CallOption) (*Nothing, error)
}

type e2EKSVerificationClient struct {
	cc *grpc.ClientConn
}

func NewE2EKSVerificationClient(cc *grpc.ClientConn) E2EKSVerificationClient {
	return &e2EKSVerificationClient{cc}
}

func (c *e2EKSVerificationClient) VerifierStream(ctx context.Context, in *VerifierStreamRequest, opts ...grpc.CallOption) (E2EKSVerification_VerifierStreamClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_E2EKSVerification_serviceDesc.Streams[0], c.cc, "/proto.E2EKSVerification/VerifierStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &e2EKSVerificationVerifierStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type E2EKSVerification_VerifierStreamClient interface {
	Recv() (*VerifierStep, error)
	grpc.ClientStream
}

type e2EKSVerificationVerifierStreamClient struct {
	grpc.ClientStream
}

func (x *e2EKSVerificationVerifierStreamClient) Recv() (*VerifierStep, error) {
	m := new(VerifierStep)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *e2EKSVerificationClient) PushRatification(ctx context.Context, in *SignedEpochHead, opts ...grpc.CallOption) (*Nothing, error) {
	out := new(Nothing)
	err := grpc.Invoke(ctx, "/proto.E2EKSVerification/PushRatification", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for E2EKSVerification service

type E2EKSVerificationServer interface {
	// VerifierStream accesses the public inputs to a keyserver state machine.
	// The returned stream is given a limited view of the log which the keyserver
	// being verified uses to replicate its state internally.  However, private
	// user data, such as usernames and profile details, is not included (the
	// relevant fields are set to nil).  note: the keyserver implementation also
	// uses the same log to persist verifier ratifications, but as they do not
	// affect any username:profile mappings, they are excluded as well.
	VerifierStream(*VerifierStreamRequest, E2EKSVerification_VerifierStreamServer) error
	// PushRatification is called each time a verifier who has been
	// successfully replaying the log returned by VerifierStream interprets a
	// keyserver_ratified step and agrees that the keyserver state summarized
	// by it is the unique result of applying all the previous update steps.
	// The SignedRatification will be stored by the server and used to
	// argue the correctness of future lookups in front of clients.
	PushRatification(context.Context, *SignedEpochHead) (*Nothing, error)
}

func RegisterE2EKSVerificationServer(s *grpc.Server, srv E2EKSVerificationServer) {
	s.RegisterService(&_E2EKSVerification_serviceDesc, srv)
}

func _E2EKSVerification_VerifierStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(VerifierStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(E2EKSVerificationServer).VerifierStream(m, &e2EKSVerificationVerifierStreamServer{stream})
}

type E2EKSVerification_VerifierStreamServer interface {
	Send(*VerifierStep) error
	grpc.ServerStream
}

type e2EKSVerificationVerifierStreamServer struct {
	grpc.ServerStream
}

func (x *e2EKSVerificationVerifierStreamServer) Send(m *VerifierStep) error {
	return x.ServerStream.SendMsg(m)
}

func _E2EKSVerification_PushRatification_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedEpochHead)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(E2EKSVerificationServer).PushRatification(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.E2EKSVerification/PushRatification",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(E2EKSVerificationServer).PushRatification(ctx, req.(*SignedEpochHead))
	}
	return interceptor(ctx, in, info, handler)
}

var _E2EKSVerification_serviceDesc = grpc.ServiceDesc{
	ServiceName: "proto.E2EKSVerification",
	HandlerType: (*E2EKSVerificationServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "PushRatification",
			Handler:    _E2EKSVerification_PushRatification_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "VerifierStream",
			Handler:       _E2EKSVerification_VerifierStream_Handler,
			ServerStreams: true,
		},
	},
	Metadata: fileDescriptorVerifier,
}

func (m *VerifierStreamRequest) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *VerifierStreamRequest) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Start != 0 {
		data[i] = 0x8
		i++
		i = encodeVarintVerifier(data, i, uint64(m.Start))
	}
	if m.PageSize != 0 {
		data[i] = 0x10
		i++
		i = encodeVarintVerifier(data, i, uint64(m.PageSize))
	}
	return i, nil
}

func (m *VerifierStep) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *VerifierStep) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != nil {
		nn1, err := m.Type.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += nn1
	}
	return i, nil
}

func (m *VerifierStep_Update) MarshalTo(data []byte) (int, error) {
	i := 0
	if m.Update != nil {
		data[i] = 0xa
		i++
		i = encodeVarintVerifier(data, i, uint64(m.Update.Size()))
		n2, err := m.Update.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	return i, nil
}
func (m *VerifierStep_Epoch) MarshalTo(data []byte) (int, error) {
	i := 0
	if m.Epoch != nil {
		data[i] = 0x12
		i++
		i = encodeVarintVerifier(data, i, uint64(m.Epoch.Size()))
		n3, err := m.Epoch.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	return i, nil
}
func (m *Nothing) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Nothing) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func encodeFixed64Verifier(data []byte, offset int, v uint64) int {
	data[offset] = uint8(v)
	data[offset+1] = uint8(v >> 8)
	data[offset+2] = uint8(v >> 16)
	data[offset+3] = uint8(v >> 24)
	data[offset+4] = uint8(v >> 32)
	data[offset+5] = uint8(v >> 40)
	data[offset+6] = uint8(v >> 48)
	data[offset+7] = uint8(v >> 56)
	return offset + 8
}
func encodeFixed32Verifier(data []byte, offset int, v uint32) int {
	data[offset] = uint8(v)
	data[offset+1] = uint8(v >> 8)
	data[offset+2] = uint8(v >> 16)
	data[offset+3] = uint8(v >> 24)
	return offset + 4
}
func encodeVarintVerifier(data []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		data[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	data[offset] = uint8(v)
	return offset + 1
}
func NewPopulatedVerifierStreamRequest(r randyVerifier, easy bool) *VerifierStreamRequest {
	this := &VerifierStreamRequest{}
	this.Start = uint64(uint64(r.Uint32()))
	this.PageSize = uint64(uint64(r.Uint32()))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedVerifierStep(r randyVerifier, easy bool) *VerifierStep {
	this := &VerifierStep{}
	oneofNumber_Type := []int32{1, 2}[r.Intn(2)]
	switch oneofNumber_Type {
	case 1:
		this.Type = NewPopulatedVerifierStep_Update(r, easy)
	case 2:
		this.Type = NewPopulatedVerifierStep_Epoch(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedVerifierStep_Update(r randyVerifier, easy bool) *VerifierStep_Update {
	this := &VerifierStep_Update{}
	this.Update = NewPopulatedSignedEntryUpdate(r, easy)
	return this
}
func NewPopulatedVerifierStep_Epoch(r randyVerifier, easy bool) *VerifierStep_Epoch {
	this := &VerifierStep_Epoch{}
	this.Epoch = NewPopulatedSignedEpochHead(r, easy)
	return this
}
func NewPopulatedNothing(r randyVerifier, easy bool) *Nothing {
	this := &Nothing{}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

type randyVerifier interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneVerifier(r randyVerifier) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringVerifier(r randyVerifier) string {
	v1 := r.Intn(100)
	tmps := make([]rune, v1)
	for i := 0; i < v1; i++ {
		tmps[i] = randUTF8RuneVerifier(r)
	}
	return string(tmps)
}
func randUnrecognizedVerifier(r randyVerifier, maxFieldNumber int) (data []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		data = randFieldVerifier(data, r, fieldNumber, wire)
	}
	return data
}
func randFieldVerifier(data []byte, r randyVerifier, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		data = encodeVarintPopulateVerifier(data, uint64(key))
		v2 := r.Int63()
		if r.Intn(2) == 0 {
			v2 *= -1
		}
		data = encodeVarintPopulateVerifier(data, uint64(v2))
	case 1:
		data = encodeVarintPopulateVerifier(data, uint64(key))
		data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		data = encodeVarintPopulateVerifier(data, uint64(key))
		ll := r.Intn(100)
		data = encodeVarintPopulateVerifier(data, uint64(ll))
		for j := 0; j < ll; j++ {
			data = append(data, byte(r.Intn(256)))
		}
	default:
		data = encodeVarintPopulateVerifier(data, uint64(key))
		data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return data
}
func encodeVarintPopulateVerifier(data []byte, v uint64) []byte {
	for v >= 1<<7 {
		data = append(data, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	data = append(data, uint8(v))
	return data
}
func (m *VerifierStreamRequest) Size() (n int) {
	var l int
	_ = l
	if m.Start != 0 {
		n += 1 + sovVerifier(uint64(m.Start))
	}
	if m.PageSize != 0 {
		n += 1 + sovVerifier(uint64(m.PageSize))
	}
	return n
}

func (m *VerifierStep) Size() (n int) {
	var l int
	_ = l
	if m.Type != nil {
		n += m.Type.Size()
	}
	return n
}

func (m *VerifierStep_Update) Size() (n int) {
	var l int
	_ = l
	if m.Update != nil {
		l = m.Update.Size()
		n += 1 + l + sovVerifier(uint64(l))
	}
	return n
}
func (m *VerifierStep_Epoch) Size() (n int) {
	var l int
	_ = l
	if m.Epoch != nil {
		l = m.Epoch.Size()
		n += 1 + l + sovVerifier(uint64(l))
	}
	return n
}
func (m *Nothing) Size() (n int) {
	var l int
	_ = l
	return n
}

func sovVerifier(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozVerifier(x uint64) (n int) {
	return sovVerifier(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *VerifierStreamRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VerifierStreamRequest{`,
		`Start:` + fmt.Sprintf("%v", this.Start) + `,`,
		`PageSize:` + fmt.Sprintf("%v", this.PageSize) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VerifierStep) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VerifierStep{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VerifierStep_Update) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VerifierStep_Update{`,
		`Update:` + strings.Replace(fmt.Sprintf("%v", this.Update), "SignedEntryUpdate", "SignedEntryUpdate", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VerifierStep_Epoch) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VerifierStep_Epoch{`,
		`Epoch:` + strings.Replace(fmt.Sprintf("%v", this.Epoch), "SignedEpochHead", "SignedEpochHead", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Nothing) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Nothing{`,
		`}`,
	}, "")
	return s
}
func valueToStringVerifier(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *VerifierStreamRequest) 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 ErrIntOverflowVerifier
			}
			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: VerifierStreamRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VerifierStreamRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
			}
			m.Start = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVerifier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				m.Start |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PageSize", wireType)
			}
			m.PageSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVerifier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				m.PageSize |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVerifier(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthVerifier
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VerifierStep) 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 ErrIntOverflowVerifier
			}
			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: VerifierStep: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VerifierStep: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Update", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVerifier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVerifier
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &SignedEntryUpdate{}
			if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Type = &VerifierStep_Update{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVerifier
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVerifier
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &SignedEpochHead{}
			if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Type = &VerifierStep_Epoch{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVerifier(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthVerifier
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipVerifier(data []byte) (n int, err error) {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowVerifier
			}
			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, ErrIntOverflowVerifier
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if data[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowVerifier
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthVerifier
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowVerifier
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := data[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipVerifier(data[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthVerifier = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowVerifier   = fmt.Errorf("proto: integer overflow")
)

func init() { proto1.RegisterFile("verifier.proto", fileDescriptorVerifier) }

var fileDescriptorVerifier = []byte{
	// 370 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x90, 0xbf, 0x4f, 0xe3, 0x30,
	0x14, 0xc7, 0xe3, 0x53, 0xdb, 0xbb, 0x73, 0xab, 0xde, 0x9d, 0xef, 0x87, 0xaa, 0xdc, 0xc9, 0x87,
	0x3a, 0x31, 0xa5, 0x55, 0x58, 0x50, 0xc7, 0x4a, 0x91, 0x2a, 0x90, 0x10, 0x4a, 0x04, 0x2b, 0x72,
	0x93, 0xd7, 0xc4, 0x12, 0x8d, 0x43, 0xe2, 0x20, 0xb5, 0x13, 0x7f, 0x05, 0x33, 0x23, 0x23, 0x23,
	0x23, 0x23, 0x63, 0x47, 0xc6, 0xc6, 0x13, 0x63, 0x47, 0x46, 0x54, 0x27, 0x52, 0x55, 0x01, 0x93,
	0xfd, 0x7d, 0xdf, 0xf7, 0x3e, 0xef, 0x6b, 0xe3, 0xf6, 0x25, 0xa4, 0x7c, 0xc2, 0x21, 0xb5, 0x92,
	0x54, 0x48, 0x41, 0xea, 0xfa, 0x30, 0xfb, 0x21, 0x97, 0x51, 0x3e, 0xb6, 0x7c, 0x31, 0xed, 0x4d,
	0x59, 0xc0, 0xe5, 0x8c, 0xf5, 0xb4, 0x33, 0xce, 0x27, 0xbd, 0x50, 0x84, 0x42, 0x0b, 0x7d, 0x2b,
	0x07, 0xcd, 0x96, 0x7f, 0xce, 0x21, 0x96, 0xa5, 0xea, 0x1e, 0xe0, 0xdf, 0xa7, 0x15, 0xd8, 0x93,
	0x29, 0xb0, 0xa9, 0x0b, 0x17, 0x39, 0x64, 0x92, 0xfc, 0xc2, 0xf5, 0x4c, 0xb2, 0x54, 0x76, 0xd0,
	0x0e, 0xda, 0xad, 0xb9, 0xa5, 0x20, 0x7f, 0xf1, 0xd7, 0x84, 0x85, 0x70, 0x96, 0xf1, 0x39, 0x74,
	0x3e, 0x69, 0xe7, 0xcb, 0xba, 0xe0, 0xf1, 0x39, 0x74, 0xe7, 0xb8, 0xb5, 0x61, 0x41, 0x42, 0x6c,
	0xdc, 0x38, 0x49, 0x02, 0x26, 0x41, 0x33, 0x9a, 0x76, 0xa7, 0xdc, 0x69, 0x79, 0x3c, 0x8c, 0x21,
	0x70, 0x62, 0x99, 0xce, 0x4a, 0x7f, 0x64, 0xb8, 0x55, 0x27, 0xb1, 0x70, 0xdd, 0x49, 0x84, 0x1f,
	0x69, 0x78, 0xd3, 0xfe, 0xb3, 0x3d, 0xb2, 0x76, 0x46, 0xc0, 0x82, 0x91, 0xe1, 0x96, 0x6d, 0xc3,
	0x06, 0xae, 0xc9, 0x59, 0x02, 0xdd, 0x6f, 0xf8, 0xf3, 0x91, 0x90, 0x11, 0x8f, 0xc3, 0x41, 0xed,
	0xee, 0xe6, 0xbf, 0x61, 0x5f, 0x23, 0xfc, 0xc3, 0xb1, 0x9d, 0x43, 0xaf, 0x8c, 0xe4, 0x33, 0xc9,
	0x45, 0x4c, 0x1c, 0xdc, 0xde, 0x7e, 0x2e, 0xf9, 0x57, 0x6d, 0x78, 0xf7, 0x17, 0xcc, 0x9f, 0x6f,
	0x5c, 0x48, 0xfa, 0x88, 0x0c, 0xf0, 0xf7, 0xe3, 0x3c, 0x8b, 0x5c, 0x26, 0x37, 0xe8, 0x0f, 0xa2,
	0x9a, 0xed, 0xaa, 0x5e, 0xc5, 0x1b, 0xee, 0x2f, 0x0a, 0x6a, 0x3c, 0x15, 0xd4, 0x58, 0x16, 0x14,
	0xad, 0x0a, 0x8a, 0x5e, 0x0a, 0x8a, 0xae, 0x14, 0x45, 0xb7, 0x8a, 0xa2, 0x7b, 0x45, 0xd1, 0x83,
	0xa2, 0xe8, 0x51, 0x51, 0xb4, 0x50, 0x14, 0x2d, 0x15, 0x45, 0xcf, 0x8a, 0x1a, 0x2b, 0x45, 0xd1,
	0xb8, 0xa1, 0x41, 0x7b, 0xaf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x57, 0x82, 0xf9, 0xed, 0x0b, 0x02,
	0x00, 0x00,
}