fairnode_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.2.0
// - protoc             v3.20.1
// source: fairnode/fairnode.proto

package fairnode

import (
	context "context"
	common "github.com/anduschain/go-anduschain/protos/common"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

// FairnodeServiceClient is the client API for FairnodeService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type FairnodeServiceClient interface {
	HeartBeat(ctx context.Context, in *common.HeartBeat, opts ...grpc.CallOption) (*emptypb.Empty, error)
	RequestOtprn(ctx context.Context, in *common.ReqOtprn, opts ...grpc.CallOption) (*common.ResOtprn, error)
	ProcessController(ctx context.Context, in *common.Participate, opts ...grpc.CallOption) (FairnodeService_ProcessControllerClient, error)
	RequestLeague(ctx context.Context, in *common.ReqLeague, opts ...grpc.CallOption) (*common.ResLeague, error)
	Vote(ctx context.Context, in *common.Vote, opts ...grpc.CallOption) (*emptypb.Empty, error)
	RequestVoteResult(ctx context.Context, in *common.ReqVoteResult, opts ...grpc.CallOption) (*common.ResVoteResult, error)
	SealConfirm(ctx context.Context, in *common.ReqConfirmSeal, opts ...grpc.CallOption) (FairnodeService_SealConfirmClient, error)
	SendBlock(ctx context.Context, in *common.ReqBlock, opts ...grpc.CallOption) (*emptypb.Empty, error)
	RequestFairnodeSign(ctx context.Context, in *common.ReqFairnodeSign, opts ...grpc.CallOption) (*common.ResFairnodeSign, error)
}

type fairnodeServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewFairnodeServiceClient(cc grpc.ClientConnInterface) FairnodeServiceClient {
	return &fairnodeServiceClient{cc}
}

func (c *fairnodeServiceClient) HeartBeat(ctx context.Context, in *common.HeartBeat, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/fairnode.FairnodeService/HeartBeat", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fairnodeServiceClient) RequestOtprn(ctx context.Context, in *common.ReqOtprn, opts ...grpc.CallOption) (*common.ResOtprn, error) {
	out := new(common.ResOtprn)
	err := c.cc.Invoke(ctx, "/fairnode.FairnodeService/RequestOtprn", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fairnodeServiceClient) ProcessController(ctx context.Context, in *common.Participate, opts ...grpc.CallOption) (FairnodeService_ProcessControllerClient, error) {
	stream, err := c.cc.NewStream(ctx, &FairnodeService_ServiceDesc.Streams[0], "/fairnode.FairnodeService/ProcessController", opts...)
	if err != nil {
		return nil, err
	}
	x := &fairnodeServiceProcessControllerClient{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 FairnodeService_ProcessControllerClient interface {
	Recv() (*common.ProcessMessage, error)
	grpc.ClientStream
}

type fairnodeServiceProcessControllerClient struct {
	grpc.ClientStream
}

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

func (c *fairnodeServiceClient) RequestLeague(ctx context.Context, in *common.ReqLeague, opts ...grpc.CallOption) (*common.ResLeague, error) {
	out := new(common.ResLeague)
	err := c.cc.Invoke(ctx, "/fairnode.FairnodeService/RequestLeague", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fairnodeServiceClient) Vote(ctx context.Context, in *common.Vote, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/fairnode.FairnodeService/Vote", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fairnodeServiceClient) RequestVoteResult(ctx context.Context, in *common.ReqVoteResult, opts ...grpc.CallOption) (*common.ResVoteResult, error) {
	out := new(common.ResVoteResult)
	err := c.cc.Invoke(ctx, "/fairnode.FairnodeService/RequestVoteResult", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fairnodeServiceClient) SealConfirm(ctx context.Context, in *common.ReqConfirmSeal, opts ...grpc.CallOption) (FairnodeService_SealConfirmClient, error) {
	stream, err := c.cc.NewStream(ctx, &FairnodeService_ServiceDesc.Streams[1], "/fairnode.FairnodeService/SealConfirm", opts...)
	if err != nil {
		return nil, err
	}
	x := &fairnodeServiceSealConfirmClient{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 FairnodeService_SealConfirmClient interface {
	Recv() (*common.ResConfirmSeal, error)
	grpc.ClientStream
}

type fairnodeServiceSealConfirmClient struct {
	grpc.ClientStream
}

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

func (c *fairnodeServiceClient) SendBlock(ctx context.Context, in *common.ReqBlock, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/fairnode.FairnodeService/SendBlock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fairnodeServiceClient) RequestFairnodeSign(ctx context.Context, in *common.ReqFairnodeSign, opts ...grpc.CallOption) (*common.ResFairnodeSign, error) {
	out := new(common.ResFairnodeSign)
	err := c.cc.Invoke(ctx, "/fairnode.FairnodeService/RequestFairnodeSign", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// FairnodeServiceServer is the server API for FairnodeService service.
// All implementations should embed UnimplementedFairnodeServiceServer
// for forward compatibility
type FairnodeServiceServer interface {
	HeartBeat(context.Context, *common.HeartBeat) (*emptypb.Empty, error)
	RequestOtprn(context.Context, *common.ReqOtprn) (*common.ResOtprn, error)
	ProcessController(*common.Participate, FairnodeService_ProcessControllerServer) error
	RequestLeague(context.Context, *common.ReqLeague) (*common.ResLeague, error)
	Vote(context.Context, *common.Vote) (*emptypb.Empty, error)
	RequestVoteResult(context.Context, *common.ReqVoteResult) (*common.ResVoteResult, error)
	SealConfirm(*common.ReqConfirmSeal, FairnodeService_SealConfirmServer) error
	SendBlock(context.Context, *common.ReqBlock) (*emptypb.Empty, error)
	RequestFairnodeSign(context.Context, *common.ReqFairnodeSign) (*common.ResFairnodeSign, error)
}

// UnimplementedFairnodeServiceServer should be embedded to have forward compatible implementations.
type UnimplementedFairnodeServiceServer struct {
}

func (UnimplementedFairnodeServiceServer) HeartBeat(context.Context, *common.HeartBeat) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method HeartBeat not implemented")
}
func (UnimplementedFairnodeServiceServer) RequestOtprn(context.Context, *common.ReqOtprn) (*common.ResOtprn, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RequestOtprn not implemented")
}
func (UnimplementedFairnodeServiceServer) ProcessController(*common.Participate, FairnodeService_ProcessControllerServer) error {
	return status.Errorf(codes.Unimplemented, "method ProcessController not implemented")
}
func (UnimplementedFairnodeServiceServer) RequestLeague(context.Context, *common.ReqLeague) (*common.ResLeague, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RequestLeague not implemented")
}
func (UnimplementedFairnodeServiceServer) Vote(context.Context, *common.Vote) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Vote not implemented")
}
func (UnimplementedFairnodeServiceServer) RequestVoteResult(context.Context, *common.ReqVoteResult) (*common.ResVoteResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RequestVoteResult not implemented")
}
func (UnimplementedFairnodeServiceServer) SealConfirm(*common.ReqConfirmSeal, FairnodeService_SealConfirmServer) error {
	return status.Errorf(codes.Unimplemented, "method SealConfirm not implemented")
}
func (UnimplementedFairnodeServiceServer) SendBlock(context.Context, *common.ReqBlock) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendBlock not implemented")
}
func (UnimplementedFairnodeServiceServer) RequestFairnodeSign(context.Context, *common.ReqFairnodeSign) (*common.ResFairnodeSign, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RequestFairnodeSign not implemented")
}

// UnsafeFairnodeServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to FairnodeServiceServer will
// result in compilation errors.
type UnsafeFairnodeServiceServer interface {
	mustEmbedUnimplementedFairnodeServiceServer()
}

func RegisterFairnodeServiceServer(s grpc.ServiceRegistrar, srv FairnodeServiceServer) {
	s.RegisterService(&FairnodeService_ServiceDesc, srv)
}

func _FairnodeService_HeartBeat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(common.HeartBeat)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FairnodeServiceServer).HeartBeat(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/fairnode.FairnodeService/HeartBeat",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FairnodeServiceServer).HeartBeat(ctx, req.(*common.HeartBeat))
	}
	return interceptor(ctx, in, info, handler)
}

func _FairnodeService_RequestOtprn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(common.ReqOtprn)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FairnodeServiceServer).RequestOtprn(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/fairnode.FairnodeService/RequestOtprn",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FairnodeServiceServer).RequestOtprn(ctx, req.(*common.ReqOtprn))
	}
	return interceptor(ctx, in, info, handler)
}

func _FairnodeService_ProcessController_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(common.Participate)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(FairnodeServiceServer).ProcessController(m, &fairnodeServiceProcessControllerServer{stream})
}

type FairnodeService_ProcessControllerServer interface {
	Send(*common.ProcessMessage) error
	grpc.ServerStream
}

type fairnodeServiceProcessControllerServer struct {
	grpc.ServerStream
}

func (x *fairnodeServiceProcessControllerServer) Send(m *common.ProcessMessage) error {
	return x.ServerStream.SendMsg(m)
}

func _FairnodeService_RequestLeague_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(common.ReqLeague)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FairnodeServiceServer).RequestLeague(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/fairnode.FairnodeService/RequestLeague",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FairnodeServiceServer).RequestLeague(ctx, req.(*common.ReqLeague))
	}
	return interceptor(ctx, in, info, handler)
}

func _FairnodeService_Vote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(common.Vote)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FairnodeServiceServer).Vote(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/fairnode.FairnodeService/Vote",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FairnodeServiceServer).Vote(ctx, req.(*common.Vote))
	}
	return interceptor(ctx, in, info, handler)
}

func _FairnodeService_RequestVoteResult_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(common.ReqVoteResult)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FairnodeServiceServer).RequestVoteResult(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/fairnode.FairnodeService/RequestVoteResult",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FairnodeServiceServer).RequestVoteResult(ctx, req.(*common.ReqVoteResult))
	}
	return interceptor(ctx, in, info, handler)
}

func _FairnodeService_SealConfirm_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(common.ReqConfirmSeal)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(FairnodeServiceServer).SealConfirm(m, &fairnodeServiceSealConfirmServer{stream})
}

type FairnodeService_SealConfirmServer interface {
	Send(*common.ResConfirmSeal) error
	grpc.ServerStream
}

type fairnodeServiceSealConfirmServer struct {
	grpc.ServerStream
}

func (x *fairnodeServiceSealConfirmServer) Send(m *common.ResConfirmSeal) error {
	return x.ServerStream.SendMsg(m)
}

func _FairnodeService_SendBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(common.ReqBlock)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FairnodeServiceServer).SendBlock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/fairnode.FairnodeService/SendBlock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FairnodeServiceServer).SendBlock(ctx, req.(*common.ReqBlock))
	}
	return interceptor(ctx, in, info, handler)
}

func _FairnodeService_RequestFairnodeSign_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(common.ReqFairnodeSign)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FairnodeServiceServer).RequestFairnodeSign(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/fairnode.FairnodeService/RequestFairnodeSign",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FairnodeServiceServer).RequestFairnodeSign(ctx, req.(*common.ReqFairnodeSign))
	}
	return interceptor(ctx, in, info, handler)
}

// FairnodeService_ServiceDesc is the grpc.ServiceDesc for FairnodeService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var FairnodeService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "fairnode.FairnodeService",
	HandlerType: (*FairnodeServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "HeartBeat",
			Handler:    _FairnodeService_HeartBeat_Handler,
		},
		{
			MethodName: "RequestOtprn",
			Handler:    _FairnodeService_RequestOtprn_Handler,
		},
		{
			MethodName: "RequestLeague",
			Handler:    _FairnodeService_RequestLeague_Handler,
		},
		{
			MethodName: "Vote",
			Handler:    _FairnodeService_Vote_Handler,
		},
		{
			MethodName: "RequestVoteResult",
			Handler:    _FairnodeService_RequestVoteResult_Handler,
		},
		{
			MethodName: "SendBlock",
			Handler:    _FairnodeService_SendBlock_Handler,
		},
		{
			MethodName: "RequestFairnodeSign",
			Handler:    _FairnodeService_RequestFairnodeSign_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ProcessController",
			Handler:       _FairnodeService_ProcessController_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SealConfirm",
			Handler:       _FairnodeService_SealConfirm_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "fairnode/fairnode.proto",
}

// FairnodeSyncServiceClient is the client API for FairnodeSyncService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type FairnodeSyncServiceClient interface {
	SyncController(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (FairnodeSyncService_SyncControllerClient, error)
}

type fairnodeSyncServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewFairnodeSyncServiceClient(cc grpc.ClientConnInterface) FairnodeSyncServiceClient {
	return &fairnodeSyncServiceClient{cc}
}

func (c *fairnodeSyncServiceClient) SyncController(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (FairnodeSyncService_SyncControllerClient, error) {
	stream, err := c.cc.NewStream(ctx, &FairnodeSyncService_ServiceDesc.Streams[0], "/fairnode.FairnodeSyncService/SyncController", opts...)
	if err != nil {
		return nil, err
	}
	x := &fairnodeSyncServiceSyncControllerClient{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 FairnodeSyncService_SyncControllerClient interface {
	Recv() (*common.FairnodeMessage, error)
	grpc.ClientStream
}

type fairnodeSyncServiceSyncControllerClient struct {
	grpc.ClientStream
}

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

// FairnodeSyncServiceServer is the server API for FairnodeSyncService service.
// All implementations should embed UnimplementedFairnodeSyncServiceServer
// for forward compatibility
type FairnodeSyncServiceServer interface {
	SyncController(*emptypb.Empty, FairnodeSyncService_SyncControllerServer) error
}

// UnimplementedFairnodeSyncServiceServer should be embedded to have forward compatible implementations.
type UnimplementedFairnodeSyncServiceServer struct {
}

func (UnimplementedFairnodeSyncServiceServer) SyncController(*emptypb.Empty, FairnodeSyncService_SyncControllerServer) error {
	return status.Errorf(codes.Unimplemented, "method SyncController not implemented")
}

// UnsafeFairnodeSyncServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to FairnodeSyncServiceServer will
// result in compilation errors.
type UnsafeFairnodeSyncServiceServer interface {
	mustEmbedUnimplementedFairnodeSyncServiceServer()
}

func RegisterFairnodeSyncServiceServer(s grpc.ServiceRegistrar, srv FairnodeSyncServiceServer) {
	s.RegisterService(&FairnodeSyncService_ServiceDesc, srv)
}

func _FairnodeSyncService_SyncController_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(emptypb.Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(FairnodeSyncServiceServer).SyncController(m, &fairnodeSyncServiceSyncControllerServer{stream})
}

type FairnodeSyncService_SyncControllerServer interface {
	Send(*common.FairnodeMessage) error
	grpc.ServerStream
}

type fairnodeSyncServiceSyncControllerServer struct {
	grpc.ServerStream
}

func (x *fairnodeSyncServiceSyncControllerServer) Send(m *common.FairnodeMessage) error {
	return x.ServerStream.SendMsg(m)
}

// FairnodeSyncService_ServiceDesc is the grpc.ServiceDesc for FairnodeSyncService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var FairnodeSyncService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "fairnode.FairnodeSyncService",
	HandlerType: (*FairnodeSyncServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "SyncController",
			Handler:       _FairnodeSyncService_SyncController_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "fairnode/fairnode.proto",
}