# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""
import grpc
import warnings

import grpc_pb2 as grpc__pb2

GRPC_GENERATED_VERSION = '1.66.1'
GRPC_VERSION = grpc.__version__
_version_not_supported = False

try:
    from grpc._utilities import first_version_is_lower
    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
except ImportError:
    _version_not_supported = True

if _version_not_supported:
    raise RuntimeError(
        f'The grpc package installed is at version {GRPC_VERSION},'
        + f' but the generated code in grpc_pb2_grpc.py depends on'
        + f' grpcio>={GRPC_GENERATED_VERSION}.'
        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
    )


class HelpStub(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Help
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.GetMethodHelp = channel.unary_unary(
                '/io.haveno.protobuffer.Help/GetMethodHelp',
                request_serializer=grpc__pb2.GetMethodHelpRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetMethodHelpReply.FromString,
                _registered_method=True)


class HelpServicer(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Help
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def GetMethodHelp(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_HelpServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetMethodHelp': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMethodHelp,
                    request_deserializer=grpc__pb2.GetMethodHelpRequest.FromString,
                    response_serializer=grpc__pb2.GetMethodHelpReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'io.haveno.protobuffer.Help', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('io.haveno.protobuffer.Help', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Help(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Help
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    @staticmethod
    def GetMethodHelp(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Help/GetMethodHelp',
            grpc__pb2.GetMethodHelpRequest.SerializeToString,
            grpc__pb2.GetMethodHelpReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class GetVersionStub(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Version
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.GetVersion = channel.unary_unary(
                '/io.haveno.protobuffer.GetVersion/GetVersion',
                request_serializer=grpc__pb2.GetVersionRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetVersionReply.FromString,
                _registered_method=True)


class GetVersionServicer(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Version
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def GetVersion(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_GetVersionServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetVersion': grpc.unary_unary_rpc_method_handler(
                    servicer.GetVersion,
                    request_deserializer=grpc__pb2.GetVersionRequest.FromString,
                    response_serializer=grpc__pb2.GetVersionReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'io.haveno.protobuffer.GetVersion', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('io.haveno.protobuffer.GetVersion', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class GetVersion(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Version
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    @staticmethod
    def GetVersion(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.GetVersion/GetVersion',
            grpc__pb2.GetVersionRequest.SerializeToString,
            grpc__pb2.GetVersionReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class AccountStub(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Account
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.AccountExists = channel.unary_unary(
                '/io.haveno.protobuffer.Account/AccountExists',
                request_serializer=grpc__pb2.AccountExistsRequest.SerializeToString,
                response_deserializer=grpc__pb2.AccountExistsReply.FromString,
                _registered_method=True)
        self.IsAccountOpen = channel.unary_unary(
                '/io.haveno.protobuffer.Account/IsAccountOpen',
                request_serializer=grpc__pb2.IsAccountOpenRequest.SerializeToString,
                response_deserializer=grpc__pb2.IsAccountOpenReply.FromString,
                _registered_method=True)
        self.CreateAccount = channel.unary_unary(
                '/io.haveno.protobuffer.Account/CreateAccount',
                request_serializer=grpc__pb2.CreateAccountRequest.SerializeToString,
                response_deserializer=grpc__pb2.CreateAccountReply.FromString,
                _registered_method=True)
        self.OpenAccount = channel.unary_unary(
                '/io.haveno.protobuffer.Account/OpenAccount',
                request_serializer=grpc__pb2.OpenAccountRequest.SerializeToString,
                response_deserializer=grpc__pb2.OpenAccountReply.FromString,
                _registered_method=True)
        self.IsAppInitialized = channel.unary_unary(
                '/io.haveno.protobuffer.Account/IsAppInitialized',
                request_serializer=grpc__pb2.IsAppInitializedRequest.SerializeToString,
                response_deserializer=grpc__pb2.IsAppInitializedReply.FromString,
                _registered_method=True)
        self.ChangePassword = channel.unary_unary(
                '/io.haveno.protobuffer.Account/ChangePassword',
                request_serializer=grpc__pb2.ChangePasswordRequest.SerializeToString,
                response_deserializer=grpc__pb2.ChangePasswordReply.FromString,
                _registered_method=True)
        self.CloseAccount = channel.unary_unary(
                '/io.haveno.protobuffer.Account/CloseAccount',
                request_serializer=grpc__pb2.CloseAccountRequest.SerializeToString,
                response_deserializer=grpc__pb2.CloseAccountReply.FromString,
                _registered_method=True)
        self.DeleteAccount = channel.unary_unary(
                '/io.haveno.protobuffer.Account/DeleteAccount',
                request_serializer=grpc__pb2.DeleteAccountRequest.SerializeToString,
                response_deserializer=grpc__pb2.DeleteAccountReply.FromString,
                _registered_method=True)
        self.BackupAccount = channel.unary_stream(
                '/io.haveno.protobuffer.Account/BackupAccount',
                request_serializer=grpc__pb2.BackupAccountRequest.SerializeToString,
                response_deserializer=grpc__pb2.BackupAccountReply.FromString,
                _registered_method=True)
        self.RestoreAccount = channel.unary_unary(
                '/io.haveno.protobuffer.Account/RestoreAccount',
                request_serializer=grpc__pb2.RestoreAccountRequest.SerializeToString,
                response_deserializer=grpc__pb2.RestoreAccountReply.FromString,
                _registered_method=True)


class AccountServicer(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Account
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def AccountExists(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def IsAccountOpen(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateAccount(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OpenAccount(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def IsAppInitialized(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ChangePassword(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CloseAccount(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeleteAccount(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def BackupAccount(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RestoreAccount(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_AccountServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'AccountExists': grpc.unary_unary_rpc_method_handler(
                    servicer.AccountExists,
                    request_deserializer=grpc__pb2.AccountExistsRequest.FromString,
                    response_serializer=grpc__pb2.AccountExistsReply.SerializeToString,
            ),
            'IsAccountOpen': grpc.unary_unary_rpc_method_handler(
                    servicer.IsAccountOpen,
                    request_deserializer=grpc__pb2.IsAccountOpenRequest.FromString,
                    response_serializer=grpc__pb2.IsAccountOpenReply.SerializeToString,
            ),
            'CreateAccount': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateAccount,
                    request_deserializer=grpc__pb2.CreateAccountRequest.FromString,
                    response_serializer=grpc__pb2.CreateAccountReply.SerializeToString,
            ),
            'OpenAccount': grpc.unary_unary_rpc_method_handler(
                    servicer.OpenAccount,
                    request_deserializer=grpc__pb2.OpenAccountRequest.FromString,
                    response_serializer=grpc__pb2.OpenAccountReply.SerializeToString,
            ),
            'IsAppInitialized': grpc.unary_unary_rpc_method_handler(
                    servicer.IsAppInitialized,
                    request_deserializer=grpc__pb2.IsAppInitializedRequest.FromString,
                    response_serializer=grpc__pb2.IsAppInitializedReply.SerializeToString,
            ),
            'ChangePassword': grpc.unary_unary_rpc_method_handler(
                    servicer.ChangePassword,
                    request_deserializer=grpc__pb2.ChangePasswordRequest.FromString,
                    response_serializer=grpc__pb2.ChangePasswordReply.SerializeToString,
            ),
            'CloseAccount': grpc.unary_unary_rpc_method_handler(
                    servicer.CloseAccount,
                    request_deserializer=grpc__pb2.CloseAccountRequest.FromString,
                    response_serializer=grpc__pb2.CloseAccountReply.SerializeToString,
            ),
            'DeleteAccount': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteAccount,
                    request_deserializer=grpc__pb2.DeleteAccountRequest.FromString,
                    response_serializer=grpc__pb2.DeleteAccountReply.SerializeToString,
            ),
            'BackupAccount': grpc.unary_stream_rpc_method_handler(
                    servicer.BackupAccount,
                    request_deserializer=grpc__pb2.BackupAccountRequest.FromString,
                    response_serializer=grpc__pb2.BackupAccountReply.SerializeToString,
            ),
            'RestoreAccount': grpc.unary_unary_rpc_method_handler(
                    servicer.RestoreAccount,
                    request_deserializer=grpc__pb2.RestoreAccountRequest.FromString,
                    response_serializer=grpc__pb2.RestoreAccountReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'io.haveno.protobuffer.Account', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('io.haveno.protobuffer.Account', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Account(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Account
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    @staticmethod
    def AccountExists(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Account/AccountExists',
            grpc__pb2.AccountExistsRequest.SerializeToString,
            grpc__pb2.AccountExistsReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def IsAccountOpen(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Account/IsAccountOpen',
            grpc__pb2.IsAccountOpenRequest.SerializeToString,
            grpc__pb2.IsAccountOpenReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateAccount(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Account/CreateAccount',
            grpc__pb2.CreateAccountRequest.SerializeToString,
            grpc__pb2.CreateAccountReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def OpenAccount(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Account/OpenAccount',
            grpc__pb2.OpenAccountRequest.SerializeToString,
            grpc__pb2.OpenAccountReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def IsAppInitialized(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Account/IsAppInitialized',
            grpc__pb2.IsAppInitializedRequest.SerializeToString,
            grpc__pb2.IsAppInitializedReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ChangePassword(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Account/ChangePassword',
            grpc__pb2.ChangePasswordRequest.SerializeToString,
            grpc__pb2.ChangePasswordReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CloseAccount(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Account/CloseAccount',
            grpc__pb2.CloseAccountRequest.SerializeToString,
            grpc__pb2.CloseAccountReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteAccount(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Account/DeleteAccount',
            grpc__pb2.DeleteAccountRequest.SerializeToString,
            grpc__pb2.DeleteAccountReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def BackupAccount(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/io.haveno.protobuffer.Account/BackupAccount',
            grpc__pb2.BackupAccountRequest.SerializeToString,
            grpc__pb2.BackupAccountReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RestoreAccount(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Account/RestoreAccount',
            grpc__pb2.RestoreAccountRequest.SerializeToString,
            grpc__pb2.RestoreAccountReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class DisputesStub(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Disputes
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.GetDispute = channel.unary_unary(
                '/io.haveno.protobuffer.Disputes/GetDispute',
                request_serializer=grpc__pb2.GetDisputeRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetDisputeReply.FromString,
                _registered_method=True)
        self.GetDisputes = channel.unary_unary(
                '/io.haveno.protobuffer.Disputes/GetDisputes',
                request_serializer=grpc__pb2.GetDisputesRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetDisputesReply.FromString,
                _registered_method=True)
        self.OpenDispute = channel.unary_unary(
                '/io.haveno.protobuffer.Disputes/OpenDispute',
                request_serializer=grpc__pb2.OpenDisputeRequest.SerializeToString,
                response_deserializer=grpc__pb2.OpenDisputeReply.FromString,
                _registered_method=True)
        self.ResolveDispute = channel.unary_unary(
                '/io.haveno.protobuffer.Disputes/ResolveDispute',
                request_serializer=grpc__pb2.ResolveDisputeRequest.SerializeToString,
                response_deserializer=grpc__pb2.ResolveDisputeReply.FromString,
                _registered_method=True)
        self.SendDisputeChatMessage = channel.unary_unary(
                '/io.haveno.protobuffer.Disputes/SendDisputeChatMessage',
                request_serializer=grpc__pb2.SendDisputeChatMessageRequest.SerializeToString,
                response_deserializer=grpc__pb2.SendDisputeChatMessageReply.FromString,
                _registered_method=True)


class DisputesServicer(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Disputes
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def GetDispute(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetDisputes(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OpenDispute(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ResolveDispute(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SendDisputeChatMessage(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_DisputesServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetDispute': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDispute,
                    request_deserializer=grpc__pb2.GetDisputeRequest.FromString,
                    response_serializer=grpc__pb2.GetDisputeReply.SerializeToString,
            ),
            'GetDisputes': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDisputes,
                    request_deserializer=grpc__pb2.GetDisputesRequest.FromString,
                    response_serializer=grpc__pb2.GetDisputesReply.SerializeToString,
            ),
            'OpenDispute': grpc.unary_unary_rpc_method_handler(
                    servicer.OpenDispute,
                    request_deserializer=grpc__pb2.OpenDisputeRequest.FromString,
                    response_serializer=grpc__pb2.OpenDisputeReply.SerializeToString,
            ),
            'ResolveDispute': grpc.unary_unary_rpc_method_handler(
                    servicer.ResolveDispute,
                    request_deserializer=grpc__pb2.ResolveDisputeRequest.FromString,
                    response_serializer=grpc__pb2.ResolveDisputeReply.SerializeToString,
            ),
            'SendDisputeChatMessage': grpc.unary_unary_rpc_method_handler(
                    servicer.SendDisputeChatMessage,
                    request_deserializer=grpc__pb2.SendDisputeChatMessageRequest.FromString,
                    response_serializer=grpc__pb2.SendDisputeChatMessageReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'io.haveno.protobuffer.Disputes', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('io.haveno.protobuffer.Disputes', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Disputes(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Disputes
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    @staticmethod
    def GetDispute(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Disputes/GetDispute',
            grpc__pb2.GetDisputeRequest.SerializeToString,
            grpc__pb2.GetDisputeReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetDisputes(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Disputes/GetDisputes',
            grpc__pb2.GetDisputesRequest.SerializeToString,
            grpc__pb2.GetDisputesReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def OpenDispute(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Disputes/OpenDispute',
            grpc__pb2.OpenDisputeRequest.SerializeToString,
            grpc__pb2.OpenDisputeReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ResolveDispute(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Disputes/ResolveDispute',
            grpc__pb2.ResolveDisputeRequest.SerializeToString,
            grpc__pb2.ResolveDisputeReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SendDisputeChatMessage(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Disputes/SendDisputeChatMessage',
            grpc__pb2.SendDisputeChatMessageRequest.SerializeToString,
            grpc__pb2.SendDisputeChatMessageReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class DisputeAgentsStub(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    DisputeAgents
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.RegisterDisputeAgent = channel.unary_unary(
                '/io.haveno.protobuffer.DisputeAgents/RegisterDisputeAgent',
                request_serializer=grpc__pb2.RegisterDisputeAgentRequest.SerializeToString,
                response_deserializer=grpc__pb2.RegisterDisputeAgentReply.FromString,
                _registered_method=True)
        self.UnregisterDisputeAgent = channel.unary_unary(
                '/io.haveno.protobuffer.DisputeAgents/UnregisterDisputeAgent',
                request_serializer=grpc__pb2.UnregisterDisputeAgentRequest.SerializeToString,
                response_deserializer=grpc__pb2.UnregisterDisputeAgentReply.FromString,
                _registered_method=True)


class DisputeAgentsServicer(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    DisputeAgents
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def RegisterDisputeAgent(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UnregisterDisputeAgent(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_DisputeAgentsServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'RegisterDisputeAgent': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterDisputeAgent,
                    request_deserializer=grpc__pb2.RegisterDisputeAgentRequest.FromString,
                    response_serializer=grpc__pb2.RegisterDisputeAgentReply.SerializeToString,
            ),
            'UnregisterDisputeAgent': grpc.unary_unary_rpc_method_handler(
                    servicer.UnregisterDisputeAgent,
                    request_deserializer=grpc__pb2.UnregisterDisputeAgentRequest.FromString,
                    response_serializer=grpc__pb2.UnregisterDisputeAgentReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'io.haveno.protobuffer.DisputeAgents', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('io.haveno.protobuffer.DisputeAgents', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class DisputeAgents(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    DisputeAgents
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    @staticmethod
    def RegisterDisputeAgent(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.DisputeAgents/RegisterDisputeAgent',
            grpc__pb2.RegisterDisputeAgentRequest.SerializeToString,
            grpc__pb2.RegisterDisputeAgentReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UnregisterDisputeAgent(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.DisputeAgents/UnregisterDisputeAgent',
            grpc__pb2.UnregisterDisputeAgentRequest.SerializeToString,
            grpc__pb2.UnregisterDisputeAgentReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class NotificationsStub(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Notifications
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.RegisterNotificationListener = channel.unary_stream(
                '/io.haveno.protobuffer.Notifications/RegisterNotificationListener',
                request_serializer=grpc__pb2.RegisterNotificationListenerRequest.SerializeToString,
                response_deserializer=grpc__pb2.NotificationMessage.FromString,
                _registered_method=True)
        self.SendNotification = channel.unary_unary(
                '/io.haveno.protobuffer.Notifications/SendNotification',
                request_serializer=grpc__pb2.SendNotificationRequest.SerializeToString,
                response_deserializer=grpc__pb2.SendNotificationReply.FromString,
                _registered_method=True)


class NotificationsServicer(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Notifications
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def RegisterNotificationListener(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SendNotification(self, request, context):
        """only used for testing
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_NotificationsServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'RegisterNotificationListener': grpc.unary_stream_rpc_method_handler(
                    servicer.RegisterNotificationListener,
                    request_deserializer=grpc__pb2.RegisterNotificationListenerRequest.FromString,
                    response_serializer=grpc__pb2.NotificationMessage.SerializeToString,
            ),
            'SendNotification': grpc.unary_unary_rpc_method_handler(
                    servicer.SendNotification,
                    request_deserializer=grpc__pb2.SendNotificationRequest.FromString,
                    response_serializer=grpc__pb2.SendNotificationReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'io.haveno.protobuffer.Notifications', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('io.haveno.protobuffer.Notifications', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Notifications(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Notifications
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    @staticmethod
    def RegisterNotificationListener(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/io.haveno.protobuffer.Notifications/RegisterNotificationListener',
            grpc__pb2.RegisterNotificationListenerRequest.SerializeToString,
            grpc__pb2.NotificationMessage.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SendNotification(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Notifications/SendNotification',
            grpc__pb2.SendNotificationRequest.SerializeToString,
            grpc__pb2.SendNotificationReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class XmrConnectionsStub(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    XmrConnections
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.AddConnection = channel.unary_unary(
                '/io.haveno.protobuffer.XmrConnections/AddConnection',
                request_serializer=grpc__pb2.AddConnectionRequest.SerializeToString,
                response_deserializer=grpc__pb2.AddConnectionReply.FromString,
                _registered_method=True)
        self.RemoveConnection = channel.unary_unary(
                '/io.haveno.protobuffer.XmrConnections/RemoveConnection',
                request_serializer=grpc__pb2.RemoveConnectionRequest.SerializeToString,
                response_deserializer=grpc__pb2.RemoveConnectionReply.FromString,
                _registered_method=True)
        self.GetConnection = channel.unary_unary(
                '/io.haveno.protobuffer.XmrConnections/GetConnection',
                request_serializer=grpc__pb2.GetConnectionRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetConnectionReply.FromString,
                _registered_method=True)
        self.GetConnections = channel.unary_unary(
                '/io.haveno.protobuffer.XmrConnections/GetConnections',
                request_serializer=grpc__pb2.GetConnectionsRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetConnectionsReply.FromString,
                _registered_method=True)
        self.SetConnection = channel.unary_unary(
                '/io.haveno.protobuffer.XmrConnections/SetConnection',
                request_serializer=grpc__pb2.SetConnectionRequest.SerializeToString,
                response_deserializer=grpc__pb2.SetConnectionReply.FromString,
                _registered_method=True)
        self.CheckConnection = channel.unary_unary(
                '/io.haveno.protobuffer.XmrConnections/CheckConnection',
                request_serializer=grpc__pb2.CheckConnectionRequest.SerializeToString,
                response_deserializer=grpc__pb2.CheckConnectionReply.FromString,
                _registered_method=True)
        self.CheckConnections = channel.unary_unary(
                '/io.haveno.protobuffer.XmrConnections/CheckConnections',
                request_serializer=grpc__pb2.CheckConnectionsRequest.SerializeToString,
                response_deserializer=grpc__pb2.CheckConnectionsReply.FromString,
                _registered_method=True)
        self.StartCheckingConnection = channel.unary_unary(
                '/io.haveno.protobuffer.XmrConnections/StartCheckingConnection',
                request_serializer=grpc__pb2.StartCheckingConnectionRequest.SerializeToString,
                response_deserializer=grpc__pb2.StartCheckingConnectionReply.FromString,
                _registered_method=True)
        self.StopCheckingConnection = channel.unary_unary(
                '/io.haveno.protobuffer.XmrConnections/StopCheckingConnection',
                request_serializer=grpc__pb2.StopCheckingConnectionRequest.SerializeToString,
                response_deserializer=grpc__pb2.StopCheckingConnectionReply.FromString,
                _registered_method=True)
        self.GetBestAvailableConnection = channel.unary_unary(
                '/io.haveno.protobuffer.XmrConnections/GetBestAvailableConnection',
                request_serializer=grpc__pb2.GetBestAvailableConnectionRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetBestAvailableConnectionReply.FromString,
                _registered_method=True)
        self.SetAutoSwitch = channel.unary_unary(
                '/io.haveno.protobuffer.XmrConnections/SetAutoSwitch',
                request_serializer=grpc__pb2.SetAutoSwitchRequest.SerializeToString,
                response_deserializer=grpc__pb2.SetAutoSwitchReply.FromString,
                _registered_method=True)


class XmrConnectionsServicer(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    XmrConnections
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def AddConnection(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RemoveConnection(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetConnection(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetConnections(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetConnection(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CheckConnection(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CheckConnections(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StartCheckingConnection(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StopCheckingConnection(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetBestAvailableConnection(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetAutoSwitch(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_XmrConnectionsServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'AddConnection': grpc.unary_unary_rpc_method_handler(
                    servicer.AddConnection,
                    request_deserializer=grpc__pb2.AddConnectionRequest.FromString,
                    response_serializer=grpc__pb2.AddConnectionReply.SerializeToString,
            ),
            'RemoveConnection': grpc.unary_unary_rpc_method_handler(
                    servicer.RemoveConnection,
                    request_deserializer=grpc__pb2.RemoveConnectionRequest.FromString,
                    response_serializer=grpc__pb2.RemoveConnectionReply.SerializeToString,
            ),
            'GetConnection': grpc.unary_unary_rpc_method_handler(
                    servicer.GetConnection,
                    request_deserializer=grpc__pb2.GetConnectionRequest.FromString,
                    response_serializer=grpc__pb2.GetConnectionReply.SerializeToString,
            ),
            'GetConnections': grpc.unary_unary_rpc_method_handler(
                    servicer.GetConnections,
                    request_deserializer=grpc__pb2.GetConnectionsRequest.FromString,
                    response_serializer=grpc__pb2.GetConnectionsReply.SerializeToString,
            ),
            'SetConnection': grpc.unary_unary_rpc_method_handler(
                    servicer.SetConnection,
                    request_deserializer=grpc__pb2.SetConnectionRequest.FromString,
                    response_serializer=grpc__pb2.SetConnectionReply.SerializeToString,
            ),
            'CheckConnection': grpc.unary_unary_rpc_method_handler(
                    servicer.CheckConnection,
                    request_deserializer=grpc__pb2.CheckConnectionRequest.FromString,
                    response_serializer=grpc__pb2.CheckConnectionReply.SerializeToString,
            ),
            'CheckConnections': grpc.unary_unary_rpc_method_handler(
                    servicer.CheckConnections,
                    request_deserializer=grpc__pb2.CheckConnectionsRequest.FromString,
                    response_serializer=grpc__pb2.CheckConnectionsReply.SerializeToString,
            ),
            'StartCheckingConnection': grpc.unary_unary_rpc_method_handler(
                    servicer.StartCheckingConnection,
                    request_deserializer=grpc__pb2.StartCheckingConnectionRequest.FromString,
                    response_serializer=grpc__pb2.StartCheckingConnectionReply.SerializeToString,
            ),
            'StopCheckingConnection': grpc.unary_unary_rpc_method_handler(
                    servicer.StopCheckingConnection,
                    request_deserializer=grpc__pb2.StopCheckingConnectionRequest.FromString,
                    response_serializer=grpc__pb2.StopCheckingConnectionReply.SerializeToString,
            ),
            'GetBestAvailableConnection': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBestAvailableConnection,
                    request_deserializer=grpc__pb2.GetBestAvailableConnectionRequest.FromString,
                    response_serializer=grpc__pb2.GetBestAvailableConnectionReply.SerializeToString,
            ),
            'SetAutoSwitch': grpc.unary_unary_rpc_method_handler(
                    servicer.SetAutoSwitch,
                    request_deserializer=grpc__pb2.SetAutoSwitchRequest.FromString,
                    response_serializer=grpc__pb2.SetAutoSwitchReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'io.haveno.protobuffer.XmrConnections', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('io.haveno.protobuffer.XmrConnections', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class XmrConnections(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    XmrConnections
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    @staticmethod
    def AddConnection(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.XmrConnections/AddConnection',
            grpc__pb2.AddConnectionRequest.SerializeToString,
            grpc__pb2.AddConnectionReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RemoveConnection(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.XmrConnections/RemoveConnection',
            grpc__pb2.RemoveConnectionRequest.SerializeToString,
            grpc__pb2.RemoveConnectionReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetConnection(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.XmrConnections/GetConnection',
            grpc__pb2.GetConnectionRequest.SerializeToString,
            grpc__pb2.GetConnectionReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetConnections(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.XmrConnections/GetConnections',
            grpc__pb2.GetConnectionsRequest.SerializeToString,
            grpc__pb2.GetConnectionsReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetConnection(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.XmrConnections/SetConnection',
            grpc__pb2.SetConnectionRequest.SerializeToString,
            grpc__pb2.SetConnectionReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CheckConnection(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.XmrConnections/CheckConnection',
            grpc__pb2.CheckConnectionRequest.SerializeToString,
            grpc__pb2.CheckConnectionReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CheckConnections(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.XmrConnections/CheckConnections',
            grpc__pb2.CheckConnectionsRequest.SerializeToString,
            grpc__pb2.CheckConnectionsReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StartCheckingConnection(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.XmrConnections/StartCheckingConnection',
            grpc__pb2.StartCheckingConnectionRequest.SerializeToString,
            grpc__pb2.StartCheckingConnectionReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StopCheckingConnection(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.XmrConnections/StopCheckingConnection',
            grpc__pb2.StopCheckingConnectionRequest.SerializeToString,
            grpc__pb2.StopCheckingConnectionReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetBestAvailableConnection(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.XmrConnections/GetBestAvailableConnection',
            grpc__pb2.GetBestAvailableConnectionRequest.SerializeToString,
            grpc__pb2.GetBestAvailableConnectionReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetAutoSwitch(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.XmrConnections/SetAutoSwitch',
            grpc__pb2.SetAutoSwitchRequest.SerializeToString,
            grpc__pb2.SetAutoSwitchReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class XmrNodeStub(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    XmrNode
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.IsXmrNodeOnline = channel.unary_unary(
                '/io.haveno.protobuffer.XmrNode/IsXmrNodeOnline',
                request_serializer=grpc__pb2.IsXmrNodeOnlineRequest.SerializeToString,
                response_deserializer=grpc__pb2.IsXmrNodeOnlineReply.FromString,
                _registered_method=True)
        self.GetXmrNodeSettings = channel.unary_unary(
                '/io.haveno.protobuffer.XmrNode/GetXmrNodeSettings',
                request_serializer=grpc__pb2.GetXmrNodeSettingsRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetXmrNodeSettingsReply.FromString,
                _registered_method=True)
        self.StartXmrNode = channel.unary_unary(
                '/io.haveno.protobuffer.XmrNode/StartXmrNode',
                request_serializer=grpc__pb2.StartXmrNodeRequest.SerializeToString,
                response_deserializer=grpc__pb2.StartXmrNodeReply.FromString,
                _registered_method=True)
        self.StopXmrNode = channel.unary_unary(
                '/io.haveno.protobuffer.XmrNode/StopXmrNode',
                request_serializer=grpc__pb2.StopXmrNodeRequest.SerializeToString,
                response_deserializer=grpc__pb2.StopXmrNodeReply.FromString,
                _registered_method=True)


class XmrNodeServicer(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    XmrNode
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def IsXmrNodeOnline(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetXmrNodeSettings(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StartXmrNode(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StopXmrNode(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_XmrNodeServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'IsXmrNodeOnline': grpc.unary_unary_rpc_method_handler(
                    servicer.IsXmrNodeOnline,
                    request_deserializer=grpc__pb2.IsXmrNodeOnlineRequest.FromString,
                    response_serializer=grpc__pb2.IsXmrNodeOnlineReply.SerializeToString,
            ),
            'GetXmrNodeSettings': grpc.unary_unary_rpc_method_handler(
                    servicer.GetXmrNodeSettings,
                    request_deserializer=grpc__pb2.GetXmrNodeSettingsRequest.FromString,
                    response_serializer=grpc__pb2.GetXmrNodeSettingsReply.SerializeToString,
            ),
            'StartXmrNode': grpc.unary_unary_rpc_method_handler(
                    servicer.StartXmrNode,
                    request_deserializer=grpc__pb2.StartXmrNodeRequest.FromString,
                    response_serializer=grpc__pb2.StartXmrNodeReply.SerializeToString,
            ),
            'StopXmrNode': grpc.unary_unary_rpc_method_handler(
                    servicer.StopXmrNode,
                    request_deserializer=grpc__pb2.StopXmrNodeRequest.FromString,
                    response_serializer=grpc__pb2.StopXmrNodeReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'io.haveno.protobuffer.XmrNode', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('io.haveno.protobuffer.XmrNode', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class XmrNode(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    XmrNode
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    @staticmethod
    def IsXmrNodeOnline(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.XmrNode/IsXmrNodeOnline',
            grpc__pb2.IsXmrNodeOnlineRequest.SerializeToString,
            grpc__pb2.IsXmrNodeOnlineReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetXmrNodeSettings(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.XmrNode/GetXmrNodeSettings',
            grpc__pb2.GetXmrNodeSettingsRequest.SerializeToString,
            grpc__pb2.GetXmrNodeSettingsReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StartXmrNode(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.XmrNode/StartXmrNode',
            grpc__pb2.StartXmrNodeRequest.SerializeToString,
            grpc__pb2.StartXmrNodeReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StopXmrNode(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.XmrNode/StopXmrNode',
            grpc__pb2.StopXmrNodeRequest.SerializeToString,
            grpc__pb2.StopXmrNodeReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class OffersStub(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Offers
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.GetOffer = channel.unary_unary(
                '/io.haveno.protobuffer.Offers/GetOffer',
                request_serializer=grpc__pb2.GetOfferRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetOfferReply.FromString,
                _registered_method=True)
        self.GetMyOffer = channel.unary_unary(
                '/io.haveno.protobuffer.Offers/GetMyOffer',
                request_serializer=grpc__pb2.GetMyOfferRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetMyOfferReply.FromString,
                _registered_method=True)
        self.GetOffers = channel.unary_unary(
                '/io.haveno.protobuffer.Offers/GetOffers',
                request_serializer=grpc__pb2.GetOffersRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetOffersReply.FromString,
                _registered_method=True)
        self.GetMyOffers = channel.unary_unary(
                '/io.haveno.protobuffer.Offers/GetMyOffers',
                request_serializer=grpc__pb2.GetMyOffersRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetMyOffersReply.FromString,
                _registered_method=True)
        self.PostOffer = channel.unary_unary(
                '/io.haveno.protobuffer.Offers/PostOffer',
                request_serializer=grpc__pb2.PostOfferRequest.SerializeToString,
                response_deserializer=grpc__pb2.PostOfferReply.FromString,
                _registered_method=True)
        self.CancelOffer = channel.unary_unary(
                '/io.haveno.protobuffer.Offers/CancelOffer',
                request_serializer=grpc__pb2.CancelOfferRequest.SerializeToString,
                response_deserializer=grpc__pb2.CancelOfferReply.FromString,
                _registered_method=True)


class OffersServicer(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Offers
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def GetOffer(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetMyOffer(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetOffers(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetMyOffers(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PostOffer(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CancelOffer(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_OffersServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetOffer': grpc.unary_unary_rpc_method_handler(
                    servicer.GetOffer,
                    request_deserializer=grpc__pb2.GetOfferRequest.FromString,
                    response_serializer=grpc__pb2.GetOfferReply.SerializeToString,
            ),
            'GetMyOffer': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMyOffer,
                    request_deserializer=grpc__pb2.GetMyOfferRequest.FromString,
                    response_serializer=grpc__pb2.GetMyOfferReply.SerializeToString,
            ),
            'GetOffers': grpc.unary_unary_rpc_method_handler(
                    servicer.GetOffers,
                    request_deserializer=grpc__pb2.GetOffersRequest.FromString,
                    response_serializer=grpc__pb2.GetOffersReply.SerializeToString,
            ),
            'GetMyOffers': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMyOffers,
                    request_deserializer=grpc__pb2.GetMyOffersRequest.FromString,
                    response_serializer=grpc__pb2.GetMyOffersReply.SerializeToString,
            ),
            'PostOffer': grpc.unary_unary_rpc_method_handler(
                    servicer.PostOffer,
                    request_deserializer=grpc__pb2.PostOfferRequest.FromString,
                    response_serializer=grpc__pb2.PostOfferReply.SerializeToString,
            ),
            'CancelOffer': grpc.unary_unary_rpc_method_handler(
                    servicer.CancelOffer,
                    request_deserializer=grpc__pb2.CancelOfferRequest.FromString,
                    response_serializer=grpc__pb2.CancelOfferReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'io.haveno.protobuffer.Offers', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('io.haveno.protobuffer.Offers', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Offers(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Offers
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    @staticmethod
    def GetOffer(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Offers/GetOffer',
            grpc__pb2.GetOfferRequest.SerializeToString,
            grpc__pb2.GetOfferReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMyOffer(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Offers/GetMyOffer',
            grpc__pb2.GetMyOfferRequest.SerializeToString,
            grpc__pb2.GetMyOfferReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetOffers(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Offers/GetOffers',
            grpc__pb2.GetOffersRequest.SerializeToString,
            grpc__pb2.GetOffersReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMyOffers(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Offers/GetMyOffers',
            grpc__pb2.GetMyOffersRequest.SerializeToString,
            grpc__pb2.GetMyOffersReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def PostOffer(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Offers/PostOffer',
            grpc__pb2.PostOfferRequest.SerializeToString,
            grpc__pb2.PostOfferReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CancelOffer(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Offers/CancelOffer',
            grpc__pb2.CancelOfferRequest.SerializeToString,
            grpc__pb2.CancelOfferReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class PaymentAccountsStub(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    PaymentAccounts
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.CreatePaymentAccount = channel.unary_unary(
                '/io.haveno.protobuffer.PaymentAccounts/CreatePaymentAccount',
                request_serializer=grpc__pb2.CreatePaymentAccountRequest.SerializeToString,
                response_deserializer=grpc__pb2.CreatePaymentAccountReply.FromString,
                _registered_method=True)
        self.GetPaymentAccounts = channel.unary_unary(
                '/io.haveno.protobuffer.PaymentAccounts/GetPaymentAccounts',
                request_serializer=grpc__pb2.GetPaymentAccountsRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetPaymentAccountsReply.FromString,
                _registered_method=True)
        self.GetPaymentMethods = channel.unary_unary(
                '/io.haveno.protobuffer.PaymentAccounts/GetPaymentMethods',
                request_serializer=grpc__pb2.GetPaymentMethodsRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetPaymentMethodsReply.FromString,
                _registered_method=True)
        self.GetPaymentAccountForm = channel.unary_unary(
                '/io.haveno.protobuffer.PaymentAccounts/GetPaymentAccountForm',
                request_serializer=grpc__pb2.GetPaymentAccountFormRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetPaymentAccountFormReply.FromString,
                _registered_method=True)
        self.GetPaymentAccountFormAsJson = channel.unary_unary(
                '/io.haveno.protobuffer.PaymentAccounts/GetPaymentAccountFormAsJson',
                request_serializer=grpc__pb2.GetPaymentAccountFormAsJsonRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetPaymentAccountFormAsJsonReply.FromString,
                _registered_method=True)
        self.CreateCryptoCurrencyPaymentAccount = channel.unary_unary(
                '/io.haveno.protobuffer.PaymentAccounts/CreateCryptoCurrencyPaymentAccount',
                request_serializer=grpc__pb2.CreateCryptoCurrencyPaymentAccountRequest.SerializeToString,
                response_deserializer=grpc__pb2.CreateCryptoCurrencyPaymentAccountReply.FromString,
                _registered_method=True)
        self.DeletePaymentAccount = channel.unary_unary(
                '/io.haveno.protobuffer.PaymentAccounts/DeletePaymentAccount',
                request_serializer=grpc__pb2.DeletePaymentAccountRequest.SerializeToString,
                response_deserializer=grpc__pb2.DeletePaymentAccountReply.FromString,
                _registered_method=True)
        self.GetCryptoCurrencyPaymentMethods = channel.unary_unary(
                '/io.haveno.protobuffer.PaymentAccounts/GetCryptoCurrencyPaymentMethods',
                request_serializer=grpc__pb2.GetCryptoCurrencyPaymentMethodsRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetCryptoCurrencyPaymentMethodsReply.FromString,
                _registered_method=True)
        self.ValidateFormField = channel.unary_unary(
                '/io.haveno.protobuffer.PaymentAccounts/ValidateFormField',
                request_serializer=grpc__pb2.ValidateFormFieldRequest.SerializeToString,
                response_deserializer=grpc__pb2.ValidateFormFieldReply.FromString,
                _registered_method=True)


class PaymentAccountsServicer(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    PaymentAccounts
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def CreatePaymentAccount(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetPaymentAccounts(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetPaymentMethods(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetPaymentAccountForm(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetPaymentAccountFormAsJson(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateCryptoCurrencyPaymentAccount(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeletePaymentAccount(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetCryptoCurrencyPaymentMethods(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ValidateFormField(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_PaymentAccountsServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'CreatePaymentAccount': grpc.unary_unary_rpc_method_handler(
                    servicer.CreatePaymentAccount,
                    request_deserializer=grpc__pb2.CreatePaymentAccountRequest.FromString,
                    response_serializer=grpc__pb2.CreatePaymentAccountReply.SerializeToString,
            ),
            'GetPaymentAccounts': grpc.unary_unary_rpc_method_handler(
                    servicer.GetPaymentAccounts,
                    request_deserializer=grpc__pb2.GetPaymentAccountsRequest.FromString,
                    response_serializer=grpc__pb2.GetPaymentAccountsReply.SerializeToString,
            ),
            'GetPaymentMethods': grpc.unary_unary_rpc_method_handler(
                    servicer.GetPaymentMethods,
                    request_deserializer=grpc__pb2.GetPaymentMethodsRequest.FromString,
                    response_serializer=grpc__pb2.GetPaymentMethodsReply.SerializeToString,
            ),
            'GetPaymentAccountForm': grpc.unary_unary_rpc_method_handler(
                    servicer.GetPaymentAccountForm,
                    request_deserializer=grpc__pb2.GetPaymentAccountFormRequest.FromString,
                    response_serializer=grpc__pb2.GetPaymentAccountFormReply.SerializeToString,
            ),
            'GetPaymentAccountFormAsJson': grpc.unary_unary_rpc_method_handler(
                    servicer.GetPaymentAccountFormAsJson,
                    request_deserializer=grpc__pb2.GetPaymentAccountFormAsJsonRequest.FromString,
                    response_serializer=grpc__pb2.GetPaymentAccountFormAsJsonReply.SerializeToString,
            ),
            'CreateCryptoCurrencyPaymentAccount': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateCryptoCurrencyPaymentAccount,
                    request_deserializer=grpc__pb2.CreateCryptoCurrencyPaymentAccountRequest.FromString,
                    response_serializer=grpc__pb2.CreateCryptoCurrencyPaymentAccountReply.SerializeToString,
            ),
            'DeletePaymentAccount': grpc.unary_unary_rpc_method_handler(
                    servicer.DeletePaymentAccount,
                    request_deserializer=grpc__pb2.DeletePaymentAccountRequest.FromString,
                    response_serializer=grpc__pb2.DeletePaymentAccountReply.SerializeToString,
            ),
            'GetCryptoCurrencyPaymentMethods': grpc.unary_unary_rpc_method_handler(
                    servicer.GetCryptoCurrencyPaymentMethods,
                    request_deserializer=grpc__pb2.GetCryptoCurrencyPaymentMethodsRequest.FromString,
                    response_serializer=grpc__pb2.GetCryptoCurrencyPaymentMethodsReply.SerializeToString,
            ),
            'ValidateFormField': grpc.unary_unary_rpc_method_handler(
                    servicer.ValidateFormField,
                    request_deserializer=grpc__pb2.ValidateFormFieldRequest.FromString,
                    response_serializer=grpc__pb2.ValidateFormFieldReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'io.haveno.protobuffer.PaymentAccounts', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('io.haveno.protobuffer.PaymentAccounts', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class PaymentAccounts(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    PaymentAccounts
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    @staticmethod
    def CreatePaymentAccount(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.PaymentAccounts/CreatePaymentAccount',
            grpc__pb2.CreatePaymentAccountRequest.SerializeToString,
            grpc__pb2.CreatePaymentAccountReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetPaymentAccounts(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.PaymentAccounts/GetPaymentAccounts',
            grpc__pb2.GetPaymentAccountsRequest.SerializeToString,
            grpc__pb2.GetPaymentAccountsReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetPaymentMethods(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.PaymentAccounts/GetPaymentMethods',
            grpc__pb2.GetPaymentMethodsRequest.SerializeToString,
            grpc__pb2.GetPaymentMethodsReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetPaymentAccountForm(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.PaymentAccounts/GetPaymentAccountForm',
            grpc__pb2.GetPaymentAccountFormRequest.SerializeToString,
            grpc__pb2.GetPaymentAccountFormReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetPaymentAccountFormAsJson(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.PaymentAccounts/GetPaymentAccountFormAsJson',
            grpc__pb2.GetPaymentAccountFormAsJsonRequest.SerializeToString,
            grpc__pb2.GetPaymentAccountFormAsJsonReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateCryptoCurrencyPaymentAccount(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.PaymentAccounts/CreateCryptoCurrencyPaymentAccount',
            grpc__pb2.CreateCryptoCurrencyPaymentAccountRequest.SerializeToString,
            grpc__pb2.CreateCryptoCurrencyPaymentAccountReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeletePaymentAccount(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.PaymentAccounts/DeletePaymentAccount',
            grpc__pb2.DeletePaymentAccountRequest.SerializeToString,
            grpc__pb2.DeletePaymentAccountReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetCryptoCurrencyPaymentMethods(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.PaymentAccounts/GetCryptoCurrencyPaymentMethods',
            grpc__pb2.GetCryptoCurrencyPaymentMethodsRequest.SerializeToString,
            grpc__pb2.GetCryptoCurrencyPaymentMethodsReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ValidateFormField(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.PaymentAccounts/ValidateFormField',
            grpc__pb2.ValidateFormFieldRequest.SerializeToString,
            grpc__pb2.ValidateFormFieldReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class PriceStub(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Price
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.GetMarketPrice = channel.unary_unary(
                '/io.haveno.protobuffer.Price/GetMarketPrice',
                request_serializer=grpc__pb2.MarketPriceRequest.SerializeToString,
                response_deserializer=grpc__pb2.MarketPriceReply.FromString,
                _registered_method=True)
        self.GetMarketPrices = channel.unary_unary(
                '/io.haveno.protobuffer.Price/GetMarketPrices',
                request_serializer=grpc__pb2.MarketPricesRequest.SerializeToString,
                response_deserializer=grpc__pb2.MarketPricesReply.FromString,
                _registered_method=True)
        self.GetMarketDepth = channel.unary_unary(
                '/io.haveno.protobuffer.Price/GetMarketDepth',
                request_serializer=grpc__pb2.MarketDepthRequest.SerializeToString,
                response_deserializer=grpc__pb2.MarketDepthReply.FromString,
                _registered_method=True)


class PriceServicer(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Price
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def GetMarketPrice(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetMarketPrices(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetMarketDepth(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_PriceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetMarketPrice': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMarketPrice,
                    request_deserializer=grpc__pb2.MarketPriceRequest.FromString,
                    response_serializer=grpc__pb2.MarketPriceReply.SerializeToString,
            ),
            'GetMarketPrices': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMarketPrices,
                    request_deserializer=grpc__pb2.MarketPricesRequest.FromString,
                    response_serializer=grpc__pb2.MarketPricesReply.SerializeToString,
            ),
            'GetMarketDepth': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMarketDepth,
                    request_deserializer=grpc__pb2.MarketDepthRequest.FromString,
                    response_serializer=grpc__pb2.MarketDepthReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'io.haveno.protobuffer.Price', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('io.haveno.protobuffer.Price', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Price(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Price
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    @staticmethod
    def GetMarketPrice(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Price/GetMarketPrice',
            grpc__pb2.MarketPriceRequest.SerializeToString,
            grpc__pb2.MarketPriceReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMarketPrices(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Price/GetMarketPrices',
            grpc__pb2.MarketPricesRequest.SerializeToString,
            grpc__pb2.MarketPricesReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMarketDepth(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Price/GetMarketDepth',
            grpc__pb2.MarketDepthRequest.SerializeToString,
            grpc__pb2.MarketDepthReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class GetTradeStatisticsStub(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    GetTradeStatistics
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.GetTradeStatistics = channel.unary_unary(
                '/io.haveno.protobuffer.GetTradeStatistics/GetTradeStatistics',
                request_serializer=grpc__pb2.GetTradeStatisticsRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetTradeStatisticsReply.FromString,
                _registered_method=True)


class GetTradeStatisticsServicer(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    GetTradeStatistics
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def GetTradeStatistics(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_GetTradeStatisticsServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetTradeStatistics': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTradeStatistics,
                    request_deserializer=grpc__pb2.GetTradeStatisticsRequest.FromString,
                    response_serializer=grpc__pb2.GetTradeStatisticsReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'io.haveno.protobuffer.GetTradeStatistics', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('io.haveno.protobuffer.GetTradeStatistics', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class GetTradeStatistics(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    GetTradeStatistics
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    @staticmethod
    def GetTradeStatistics(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.GetTradeStatistics/GetTradeStatistics',
            grpc__pb2.GetTradeStatisticsRequest.SerializeToString,
            grpc__pb2.GetTradeStatisticsReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class ShutdownServerStub(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Shutdown
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.Stop = channel.unary_unary(
                '/io.haveno.protobuffer.ShutdownServer/Stop',
                request_serializer=grpc__pb2.StopRequest.SerializeToString,
                response_deserializer=grpc__pb2.StopReply.FromString,
                _registered_method=True)


class ShutdownServerServicer(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Shutdown
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def Stop(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_ShutdownServerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Stop': grpc.unary_unary_rpc_method_handler(
                    servicer.Stop,
                    request_deserializer=grpc__pb2.StopRequest.FromString,
                    response_serializer=grpc__pb2.StopReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'io.haveno.protobuffer.ShutdownServer', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('io.haveno.protobuffer.ShutdownServer', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class ShutdownServer(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Shutdown
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    @staticmethod
    def Stop(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.ShutdownServer/Stop',
            grpc__pb2.StopRequest.SerializeToString,
            grpc__pb2.StopReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class TradesStub(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Trades
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.GetTrade = channel.unary_unary(
                '/io.haveno.protobuffer.Trades/GetTrade',
                request_serializer=grpc__pb2.GetTradeRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetTradeReply.FromString,
                _registered_method=True)
        self.GetTrades = channel.unary_unary(
                '/io.haveno.protobuffer.Trades/GetTrades',
                request_serializer=grpc__pb2.GetTradesRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetTradesReply.FromString,
                _registered_method=True)
        self.TakeOffer = channel.unary_unary(
                '/io.haveno.protobuffer.Trades/TakeOffer',
                request_serializer=grpc__pb2.TakeOfferRequest.SerializeToString,
                response_deserializer=grpc__pb2.TakeOfferReply.FromString,
                _registered_method=True)
        self.ConfirmPaymentSent = channel.unary_unary(
                '/io.haveno.protobuffer.Trades/ConfirmPaymentSent',
                request_serializer=grpc__pb2.ConfirmPaymentSentRequest.SerializeToString,
                response_deserializer=grpc__pb2.ConfirmPaymentSentReply.FromString,
                _registered_method=True)
        self.ConfirmPaymentReceived = channel.unary_unary(
                '/io.haveno.protobuffer.Trades/ConfirmPaymentReceived',
                request_serializer=grpc__pb2.ConfirmPaymentReceivedRequest.SerializeToString,
                response_deserializer=grpc__pb2.ConfirmPaymentReceivedReply.FromString,
                _registered_method=True)
        self.CompleteTrade = channel.unary_unary(
                '/io.haveno.protobuffer.Trades/CompleteTrade',
                request_serializer=grpc__pb2.CompleteTradeRequest.SerializeToString,
                response_deserializer=grpc__pb2.CompleteTradeReply.FromString,
                _registered_method=True)
        self.WithdrawFunds = channel.unary_unary(
                '/io.haveno.protobuffer.Trades/WithdrawFunds',
                request_serializer=grpc__pb2.WithdrawFundsRequest.SerializeToString,
                response_deserializer=grpc__pb2.WithdrawFundsReply.FromString,
                _registered_method=True)
        self.GetChatMessages = channel.unary_unary(
                '/io.haveno.protobuffer.Trades/GetChatMessages',
                request_serializer=grpc__pb2.GetChatMessagesRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetChatMessagesReply.FromString,
                _registered_method=True)
        self.SendChatMessage = channel.unary_unary(
                '/io.haveno.protobuffer.Trades/SendChatMessage',
                request_serializer=grpc__pb2.SendChatMessageRequest.SerializeToString,
                response_deserializer=grpc__pb2.SendChatMessageReply.FromString,
                _registered_method=True)


class TradesServicer(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Trades
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def GetTrade(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetTrades(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def TakeOffer(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ConfirmPaymentSent(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ConfirmPaymentReceived(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CompleteTrade(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def WithdrawFunds(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetChatMessages(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SendChatMessage(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_TradesServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetTrade': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTrade,
                    request_deserializer=grpc__pb2.GetTradeRequest.FromString,
                    response_serializer=grpc__pb2.GetTradeReply.SerializeToString,
            ),
            'GetTrades': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTrades,
                    request_deserializer=grpc__pb2.GetTradesRequest.FromString,
                    response_serializer=grpc__pb2.GetTradesReply.SerializeToString,
            ),
            'TakeOffer': grpc.unary_unary_rpc_method_handler(
                    servicer.TakeOffer,
                    request_deserializer=grpc__pb2.TakeOfferRequest.FromString,
                    response_serializer=grpc__pb2.TakeOfferReply.SerializeToString,
            ),
            'ConfirmPaymentSent': grpc.unary_unary_rpc_method_handler(
                    servicer.ConfirmPaymentSent,
                    request_deserializer=grpc__pb2.ConfirmPaymentSentRequest.FromString,
                    response_serializer=grpc__pb2.ConfirmPaymentSentReply.SerializeToString,
            ),
            'ConfirmPaymentReceived': grpc.unary_unary_rpc_method_handler(
                    servicer.ConfirmPaymentReceived,
                    request_deserializer=grpc__pb2.ConfirmPaymentReceivedRequest.FromString,
                    response_serializer=grpc__pb2.ConfirmPaymentReceivedReply.SerializeToString,
            ),
            'CompleteTrade': grpc.unary_unary_rpc_method_handler(
                    servicer.CompleteTrade,
                    request_deserializer=grpc__pb2.CompleteTradeRequest.FromString,
                    response_serializer=grpc__pb2.CompleteTradeReply.SerializeToString,
            ),
            'WithdrawFunds': grpc.unary_unary_rpc_method_handler(
                    servicer.WithdrawFunds,
                    request_deserializer=grpc__pb2.WithdrawFundsRequest.FromString,
                    response_serializer=grpc__pb2.WithdrawFundsReply.SerializeToString,
            ),
            'GetChatMessages': grpc.unary_unary_rpc_method_handler(
                    servicer.GetChatMessages,
                    request_deserializer=grpc__pb2.GetChatMessagesRequest.FromString,
                    response_serializer=grpc__pb2.GetChatMessagesReply.SerializeToString,
            ),
            'SendChatMessage': grpc.unary_unary_rpc_method_handler(
                    servicer.SendChatMessage,
                    request_deserializer=grpc__pb2.SendChatMessageRequest.FromString,
                    response_serializer=grpc__pb2.SendChatMessageReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'io.haveno.protobuffer.Trades', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('io.haveno.protobuffer.Trades', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Trades(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Trades
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    @staticmethod
    def GetTrade(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Trades/GetTrade',
            grpc__pb2.GetTradeRequest.SerializeToString,
            grpc__pb2.GetTradeReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetTrades(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Trades/GetTrades',
            grpc__pb2.GetTradesRequest.SerializeToString,
            grpc__pb2.GetTradesReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TakeOffer(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Trades/TakeOffer',
            grpc__pb2.TakeOfferRequest.SerializeToString,
            grpc__pb2.TakeOfferReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ConfirmPaymentSent(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Trades/ConfirmPaymentSent',
            grpc__pb2.ConfirmPaymentSentRequest.SerializeToString,
            grpc__pb2.ConfirmPaymentSentReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ConfirmPaymentReceived(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Trades/ConfirmPaymentReceived',
            grpc__pb2.ConfirmPaymentReceivedRequest.SerializeToString,
            grpc__pb2.ConfirmPaymentReceivedReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CompleteTrade(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Trades/CompleteTrade',
            grpc__pb2.CompleteTradeRequest.SerializeToString,
            grpc__pb2.CompleteTradeReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def WithdrawFunds(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Trades/WithdrawFunds',
            grpc__pb2.WithdrawFundsRequest.SerializeToString,
            grpc__pb2.WithdrawFundsReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetChatMessages(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Trades/GetChatMessages',
            grpc__pb2.GetChatMessagesRequest.SerializeToString,
            grpc__pb2.GetChatMessagesReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SendChatMessage(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Trades/SendChatMessage',
            grpc__pb2.SendChatMessageRequest.SerializeToString,
            grpc__pb2.SendChatMessageReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class WalletsStub(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Wallets
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.GetBalances = channel.unary_unary(
                '/io.haveno.protobuffer.Wallets/GetBalances',
                request_serializer=grpc__pb2.GetBalancesRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetBalancesReply.FromString,
                _registered_method=True)
        self.GetXmrSeed = channel.unary_unary(
                '/io.haveno.protobuffer.Wallets/GetXmrSeed',
                request_serializer=grpc__pb2.GetXmrSeedRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetXmrSeedReply.FromString,
                _registered_method=True)
        self.GetXmrPrimaryAddress = channel.unary_unary(
                '/io.haveno.protobuffer.Wallets/GetXmrPrimaryAddress',
                request_serializer=grpc__pb2.GetXmrPrimaryAddressRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetXmrPrimaryAddressReply.FromString,
                _registered_method=True)
        self.GetXmrNewSubaddress = channel.unary_unary(
                '/io.haveno.protobuffer.Wallets/GetXmrNewSubaddress',
                request_serializer=grpc__pb2.GetXmrNewSubaddressRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetXmrNewSubaddressReply.FromString,
                _registered_method=True)
        self.GetXmrTxs = channel.unary_unary(
                '/io.haveno.protobuffer.Wallets/GetXmrTxs',
                request_serializer=grpc__pb2.GetXmrTxsRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetXmrTxsReply.FromString,
                _registered_method=True)
        self.CreateXmrTx = channel.unary_unary(
                '/io.haveno.protobuffer.Wallets/CreateXmrTx',
                request_serializer=grpc__pb2.CreateXmrTxRequest.SerializeToString,
                response_deserializer=grpc__pb2.CreateXmrTxReply.FromString,
                _registered_method=True)
        self.relayXmrTx = channel.unary_unary(
                '/io.haveno.protobuffer.Wallets/relayXmrTx',
                request_serializer=grpc__pb2.RelayXmrTxRequest.SerializeToString,
                response_deserializer=grpc__pb2.RelayXmrTxReply.FromString,
                _registered_method=True)
        self.GetAddressBalance = channel.unary_unary(
                '/io.haveno.protobuffer.Wallets/GetAddressBalance',
                request_serializer=grpc__pb2.GetAddressBalanceRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetAddressBalanceReply.FromString,
                _registered_method=True)
        self.GetFundingAddresses = channel.unary_unary(
                '/io.haveno.protobuffer.Wallets/GetFundingAddresses',
                request_serializer=grpc__pb2.GetFundingAddressesRequest.SerializeToString,
                response_deserializer=grpc__pb2.GetFundingAddressesReply.FromString,
                _registered_method=True)
        self.SetWalletPassword = channel.unary_unary(
                '/io.haveno.protobuffer.Wallets/SetWalletPassword',
                request_serializer=grpc__pb2.SetWalletPasswordRequest.SerializeToString,
                response_deserializer=grpc__pb2.SetWalletPasswordReply.FromString,
                _registered_method=True)
        self.RemoveWalletPassword = channel.unary_unary(
                '/io.haveno.protobuffer.Wallets/RemoveWalletPassword',
                request_serializer=grpc__pb2.RemoveWalletPasswordRequest.SerializeToString,
                response_deserializer=grpc__pb2.RemoveWalletPasswordReply.FromString,
                _registered_method=True)
        self.LockWallet = channel.unary_unary(
                '/io.haveno.protobuffer.Wallets/LockWallet',
                request_serializer=grpc__pb2.LockWalletRequest.SerializeToString,
                response_deserializer=grpc__pb2.LockWalletReply.FromString,
                _registered_method=True)
        self.UnlockWallet = channel.unary_unary(
                '/io.haveno.protobuffer.Wallets/UnlockWallet',
                request_serializer=grpc__pb2.UnlockWalletRequest.SerializeToString,
                response_deserializer=grpc__pb2.UnlockWalletReply.FromString,
                _registered_method=True)


class WalletsServicer(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Wallets
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    def GetBalances(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetXmrSeed(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetXmrPrimaryAddress(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetXmrNewSubaddress(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetXmrTxs(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateXmrTx(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def relayXmrTx(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetAddressBalance(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetFundingAddresses(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetWalletPassword(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RemoveWalletPassword(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def LockWallet(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UnlockWallet(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_WalletsServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetBalances': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBalances,
                    request_deserializer=grpc__pb2.GetBalancesRequest.FromString,
                    response_serializer=grpc__pb2.GetBalancesReply.SerializeToString,
            ),
            'GetXmrSeed': grpc.unary_unary_rpc_method_handler(
                    servicer.GetXmrSeed,
                    request_deserializer=grpc__pb2.GetXmrSeedRequest.FromString,
                    response_serializer=grpc__pb2.GetXmrSeedReply.SerializeToString,
            ),
            'GetXmrPrimaryAddress': grpc.unary_unary_rpc_method_handler(
                    servicer.GetXmrPrimaryAddress,
                    request_deserializer=grpc__pb2.GetXmrPrimaryAddressRequest.FromString,
                    response_serializer=grpc__pb2.GetXmrPrimaryAddressReply.SerializeToString,
            ),
            'GetXmrNewSubaddress': grpc.unary_unary_rpc_method_handler(
                    servicer.GetXmrNewSubaddress,
                    request_deserializer=grpc__pb2.GetXmrNewSubaddressRequest.FromString,
                    response_serializer=grpc__pb2.GetXmrNewSubaddressReply.SerializeToString,
            ),
            'GetXmrTxs': grpc.unary_unary_rpc_method_handler(
                    servicer.GetXmrTxs,
                    request_deserializer=grpc__pb2.GetXmrTxsRequest.FromString,
                    response_serializer=grpc__pb2.GetXmrTxsReply.SerializeToString,
            ),
            'CreateXmrTx': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateXmrTx,
                    request_deserializer=grpc__pb2.CreateXmrTxRequest.FromString,
                    response_serializer=grpc__pb2.CreateXmrTxReply.SerializeToString,
            ),
            'relayXmrTx': grpc.unary_unary_rpc_method_handler(
                    servicer.relayXmrTx,
                    request_deserializer=grpc__pb2.RelayXmrTxRequest.FromString,
                    response_serializer=grpc__pb2.RelayXmrTxReply.SerializeToString,
            ),
            'GetAddressBalance': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAddressBalance,
                    request_deserializer=grpc__pb2.GetAddressBalanceRequest.FromString,
                    response_serializer=grpc__pb2.GetAddressBalanceReply.SerializeToString,
            ),
            'GetFundingAddresses': grpc.unary_unary_rpc_method_handler(
                    servicer.GetFundingAddresses,
                    request_deserializer=grpc__pb2.GetFundingAddressesRequest.FromString,
                    response_serializer=grpc__pb2.GetFundingAddressesReply.SerializeToString,
            ),
            'SetWalletPassword': grpc.unary_unary_rpc_method_handler(
                    servicer.SetWalletPassword,
                    request_deserializer=grpc__pb2.SetWalletPasswordRequest.FromString,
                    response_serializer=grpc__pb2.SetWalletPasswordReply.SerializeToString,
            ),
            'RemoveWalletPassword': grpc.unary_unary_rpc_method_handler(
                    servicer.RemoveWalletPassword,
                    request_deserializer=grpc__pb2.RemoveWalletPasswordRequest.FromString,
                    response_serializer=grpc__pb2.RemoveWalletPasswordReply.SerializeToString,
            ),
            'LockWallet': grpc.unary_unary_rpc_method_handler(
                    servicer.LockWallet,
                    request_deserializer=grpc__pb2.LockWalletRequest.FromString,
                    response_serializer=grpc__pb2.LockWalletReply.SerializeToString,
            ),
            'UnlockWallet': grpc.unary_unary_rpc_method_handler(
                    servicer.UnlockWallet,
                    request_deserializer=grpc__pb2.UnlockWalletRequest.FromString,
                    response_serializer=grpc__pb2.UnlockWalletReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'io.haveno.protobuffer.Wallets', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('io.haveno.protobuffer.Wallets', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Wallets(object):
    """/////////////////////////////////////////////////////////////////////////////////////////
    Wallets
    /////////////////////////////////////////////////////////////////////////////////////////

    """

    @staticmethod
    def GetBalances(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Wallets/GetBalances',
            grpc__pb2.GetBalancesRequest.SerializeToString,
            grpc__pb2.GetBalancesReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetXmrSeed(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Wallets/GetXmrSeed',
            grpc__pb2.GetXmrSeedRequest.SerializeToString,
            grpc__pb2.GetXmrSeedReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetXmrPrimaryAddress(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Wallets/GetXmrPrimaryAddress',
            grpc__pb2.GetXmrPrimaryAddressRequest.SerializeToString,
            grpc__pb2.GetXmrPrimaryAddressReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetXmrNewSubaddress(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Wallets/GetXmrNewSubaddress',
            grpc__pb2.GetXmrNewSubaddressRequest.SerializeToString,
            grpc__pb2.GetXmrNewSubaddressReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetXmrTxs(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Wallets/GetXmrTxs',
            grpc__pb2.GetXmrTxsRequest.SerializeToString,
            grpc__pb2.GetXmrTxsReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateXmrTx(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Wallets/CreateXmrTx',
            grpc__pb2.CreateXmrTxRequest.SerializeToString,
            grpc__pb2.CreateXmrTxReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def relayXmrTx(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Wallets/relayXmrTx',
            grpc__pb2.RelayXmrTxRequest.SerializeToString,
            grpc__pb2.RelayXmrTxReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetAddressBalance(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Wallets/GetAddressBalance',
            grpc__pb2.GetAddressBalanceRequest.SerializeToString,
            grpc__pb2.GetAddressBalanceReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetFundingAddresses(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Wallets/GetFundingAddresses',
            grpc__pb2.GetFundingAddressesRequest.SerializeToString,
            grpc__pb2.GetFundingAddressesReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetWalletPassword(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Wallets/SetWalletPassword',
            grpc__pb2.SetWalletPasswordRequest.SerializeToString,
            grpc__pb2.SetWalletPasswordReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RemoveWalletPassword(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Wallets/RemoveWalletPassword',
            grpc__pb2.RemoveWalletPasswordRequest.SerializeToString,
            grpc__pb2.RemoveWalletPasswordReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def LockWallet(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Wallets/LockWallet',
            grpc__pb2.LockWalletRequest.SerializeToString,
            grpc__pb2.LockWalletReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UnlockWallet(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/io.haveno.protobuffer.Wallets/UnlockWallet',
            grpc__pb2.UnlockWalletRequest.SerializeToString,
            grpc__pb2.UnlockWalletReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
