# 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 qbitcoin.generated.qbit_pb2 as qbit__pb2

GRPC_GENERATED_VERSION = '1.72.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 qbit_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 PublicAPIStub(object):
    """//////////////////////////
    //////////////////////////
    //////////////////////////
    ////     API       ///////
    //////////////////////////
    //////////////////////////
    //////////////////////////

    This service describes the Public API used by clients (wallet/cli/etc)
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetNodeState = channel.unary_unary(
                '/qrl.PublicAPI/GetNodeState',
                request_serializer=qbit__pb2.GetNodeStateReq.SerializeToString,
                response_deserializer=qbit__pb2.GetNodeStateResp.FromString,
                _registered_method=True)
        self.GetKnownPeers = channel.unary_unary(
                '/qrl.PublicAPI/GetKnownPeers',
                request_serializer=qbit__pb2.GetKnownPeersReq.SerializeToString,
                response_deserializer=qbit__pb2.GetKnownPeersResp.FromString,
                _registered_method=True)
        self.GetPeersStat = channel.unary_unary(
                '/qrl.PublicAPI/GetPeersStat',
                request_serializer=qbit__pb2.GetPeersStatReq.SerializeToString,
                response_deserializer=qbit__pb2.GetPeersStatResp.FromString,
                _registered_method=True)
        self.GetStats = channel.unary_unary(
                '/qrl.PublicAPI/GetStats',
                request_serializer=qbit__pb2.GetStatsReq.SerializeToString,
                response_deserializer=qbit__pb2.GetStatsResp.FromString,
                _registered_method=True)
        self.GetAddressState = channel.unary_unary(
                '/qrl.PublicAPI/GetAddressState',
                request_serializer=qbit__pb2.GetAddressStateReq.SerializeToString,
                response_deserializer=qbit__pb2.GetAddressStateResp.FromString,
                _registered_method=True)
        self.GetOptimizedAddressState = channel.unary_unary(
                '/qrl.PublicAPI/GetOptimizedAddressState',
                request_serializer=qbit__pb2.GetAddressStateReq.SerializeToString,
                response_deserializer=qbit__pb2.GetOptimizedAddressStateResp.FromString,
                _registered_method=True)
        self.GetMultiSigAddressState = channel.unary_unary(
                '/qrl.PublicAPI/GetMultiSigAddressState',
                request_serializer=qbit__pb2.GetMultiSigAddressStateReq.SerializeToString,
                response_deserializer=qbit__pb2.GetMultiSigAddressStateResp.FromString,
                _registered_method=True)
        self.IsSlave = channel.unary_unary(
                '/qrl.PublicAPI/IsSlave',
                request_serializer=qbit__pb2.IsSlaveReq.SerializeToString,
                response_deserializer=qbit__pb2.IsSlaveResp.FromString,
                _registered_method=True)
        self.GetObject = channel.unary_unary(
                '/qrl.PublicAPI/GetObject',
                request_serializer=qbit__pb2.GetObjectReq.SerializeToString,
                response_deserializer=qbit__pb2.GetObjectResp.FromString,
                _registered_method=True)
        self.GetLatestData = channel.unary_unary(
                '/qrl.PublicAPI/GetLatestData',
                request_serializer=qbit__pb2.GetLatestDataReq.SerializeToString,
                response_deserializer=qbit__pb2.GetLatestDataResp.FromString,
                _registered_method=True)
        self.PushTransaction = channel.unary_unary(
                '/qrl.PublicAPI/PushTransaction',
                request_serializer=qbit__pb2.PushTransactionReq.SerializeToString,
                response_deserializer=qbit__pb2.PushTransactionResp.FromString,
                _registered_method=True)
        self.TransferCoins = channel.unary_unary(
                '/qrl.PublicAPI/TransferCoins',
                request_serializer=qbit__pb2.TransferCoinsReq.SerializeToString,
                response_deserializer=qbit__pb2.TransferCoinsResp.FromString,
                _registered_method=True)
        self.ParseAddress = channel.unary_unary(
                '/qrl.PublicAPI/ParseAddress',
                request_serializer=qbit__pb2.ParseAddressReq.SerializeToString,
                response_deserializer=qbit__pb2.ParseAddressResp.FromString,
                _registered_method=True)
        self.GetChainStats = channel.unary_unary(
                '/qrl.PublicAPI/GetChainStats',
                request_serializer=qbit__pb2.GetChainStatsReq.SerializeToString,
                response_deserializer=qbit__pb2.GetChainStatsResp.FromString,
                _registered_method=True)
        self.GetStakingStats = channel.unary_unary(
                '/qrl.PublicAPI/GetStakingStats',
                request_serializer=qbit__pb2.GetStakingStatsReq.SerializeToString,
                response_deserializer=qbit__pb2.GetStakingStatsResp.FromString,
                _registered_method=True)
        self.GetStakerList = channel.unary_unary(
                '/qrl.PublicAPI/GetStakerList',
                request_serializer=qbit__pb2.GetStakerListReq.SerializeToString,
                response_deserializer=qbit__pb2.GetStakerListResp.FromString,
                _registered_method=True)
        self.GetAddressFromPK = channel.unary_unary(
                '/qrl.PublicAPI/GetAddressFromPK',
                request_serializer=qbit__pb2.GetAddressFromPKReq.SerializeToString,
                response_deserializer=qbit__pb2.GetAddressFromPKResp.FromString,
                _registered_method=True)
        self.GetMultiSigCreateTxn = channel.unary_unary(
                '/qrl.PublicAPI/GetMultiSigCreateTxn',
                request_serializer=qbit__pb2.MultiSigCreateTxnReq.SerializeToString,
                response_deserializer=qbit__pb2.TransferCoinsResp.FromString,
                _registered_method=True)
        self.GetMultiSigSpendTxn = channel.unary_unary(
                '/qrl.PublicAPI/GetMultiSigSpendTxn',
                request_serializer=qbit__pb2.MultiSigSpendTxnReq.SerializeToString,
                response_deserializer=qbit__pb2.TransferCoinsResp.FromString,
                _registered_method=True)
        self.GetMultiSigVoteTxn = channel.unary_unary(
                '/qrl.PublicAPI/GetMultiSigVoteTxn',
                request_serializer=qbit__pb2.MultiSigVoteTxnReq.SerializeToString,
                response_deserializer=qbit__pb2.TransferCoinsResp.FromString,
                _registered_method=True)
        self.GetMessageTxn = channel.unary_unary(
                '/qrl.PublicAPI/GetMessageTxn',
                request_serializer=qbit__pb2.MessageTxnReq.SerializeToString,
                response_deserializer=qbit__pb2.TransferCoinsResp.FromString,
                _registered_method=True)
        self.GetTokenTxn = channel.unary_unary(
                '/qrl.PublicAPI/GetTokenTxn',
                request_serializer=qbit__pb2.TokenTxnReq.SerializeToString,
                response_deserializer=qbit__pb2.TransferCoinsResp.FromString,
                _registered_method=True)
        self.GetTransferTokenTxn = channel.unary_unary(
                '/qrl.PublicAPI/GetTransferTokenTxn',
                request_serializer=qbit__pb2.TransferTokenTxnReq.SerializeToString,
                response_deserializer=qbit__pb2.TransferCoinsResp.FromString,
                _registered_method=True)
        self.GetSlaveTxn = channel.unary_unary(
                '/qrl.PublicAPI/GetSlaveTxn',
                request_serializer=qbit__pb2.SlaveTxnReq.SerializeToString,
                response_deserializer=qbit__pb2.TransferCoinsResp.FromString,
                _registered_method=True)
        self.GetLatticeTxn = channel.unary_unary(
                '/qrl.PublicAPI/GetLatticeTxn',
                request_serializer=qbit__pb2.LatticeTxnReq.SerializeToString,
                response_deserializer=qbit__pb2.TransferCoinsResp.FromString,
                _registered_method=True)
        self.GetTransaction = channel.unary_unary(
                '/qrl.PublicAPI/GetTransaction',
                request_serializer=qbit__pb2.GetTransactionReq.SerializeToString,
                response_deserializer=qbit__pb2.GetTransactionResp.FromString,
                _registered_method=True)
        self.GetMiniTransactionsByAddress = channel.unary_unary(
                '/qrl.PublicAPI/GetMiniTransactionsByAddress',
                request_serializer=qbit__pb2.GetMiniTransactionsByAddressReq.SerializeToString,
                response_deserializer=qbit__pb2.GetMiniTransactionsByAddressResp.FromString,
                _registered_method=True)
        self.GetTransactionsByAddress = channel.unary_unary(
                '/qrl.PublicAPI/GetTransactionsByAddress',
                request_serializer=qbit__pb2.GetTransactionsByAddressReq.SerializeToString,
                response_deserializer=qbit__pb2.GetTransactionsByAddressResp.FromString,
                _registered_method=True)
        self.GetTokensByAddress = channel.unary_unary(
                '/qrl.PublicAPI/GetTokensByAddress',
                request_serializer=qbit__pb2.GetTransactionsByAddressReq.SerializeToString,
                response_deserializer=qbit__pb2.GetTokensByAddressResp.FromString,
                _registered_method=True)
        self.GetSlavesByAddress = channel.unary_unary(
                '/qrl.PublicAPI/GetSlavesByAddress',
                request_serializer=qbit__pb2.GetTransactionsByAddressReq.SerializeToString,
                response_deserializer=qbit__pb2.GetSlavesByAddressResp.FromString,
                _registered_method=True)
        self.GetLatticePKsByAddress = channel.unary_unary(
                '/qrl.PublicAPI/GetLatticePKsByAddress',
                request_serializer=qbit__pb2.GetTransactionsByAddressReq.SerializeToString,
                response_deserializer=qbit__pb2.GetLatticePKsByAddressResp.FromString,
                _registered_method=True)
        self.GetMultiSigAddressesByAddress = channel.unary_unary(
                '/qrl.PublicAPI/GetMultiSigAddressesByAddress',
                request_serializer=qbit__pb2.GetTransactionsByAddressReq.SerializeToString,
                response_deserializer=qbit__pb2.GetMultiSigAddressesByAddressResp.FromString,
                _registered_method=True)
        self.GetMultiSigSpendTxsByAddress = channel.unary_unary(
                '/qrl.PublicAPI/GetMultiSigSpendTxsByAddress',
                request_serializer=qbit__pb2.GetMultiSigSpendTxsByAddressReq.SerializeToString,
                response_deserializer=qbit__pb2.GetMultiSigSpendTxsByAddressResp.FromString,
                _registered_method=True)
        self.GetVoteStats = channel.unary_unary(
                '/qrl.PublicAPI/GetVoteStats',
                request_serializer=qbit__pb2.GetVoteStatsReq.SerializeToString,
                response_deserializer=qbit__pb2.GetVoteStatsResp.FromString,
                _registered_method=True)
        self.GetInboxMessagesByAddress = channel.unary_unary(
                '/qrl.PublicAPI/GetInboxMessagesByAddress',
                request_serializer=qbit__pb2.GetTransactionsByAddressReq.SerializeToString,
                response_deserializer=qbit__pb2.GetInboxMessagesByAddressResp.FromString,
                _registered_method=True)
        self.GetBalance = channel.unary_unary(
                '/qrl.PublicAPI/GetBalance',
                request_serializer=qbit__pb2.GetBalanceReq.SerializeToString,
                response_deserializer=qbit__pb2.GetBalanceResp.FromString,
                _registered_method=True)
        self.GetTotalBalance = channel.unary_unary(
                '/qrl.PublicAPI/GetTotalBalance',
                request_serializer=qbit__pb2.GetTotalBalanceReq.SerializeToString,
                response_deserializer=qbit__pb2.GetTotalBalanceResp.FromString,
                _registered_method=True)
        self.GetOTS = channel.unary_unary(
                '/qrl.PublicAPI/GetOTS',
                request_serializer=qbit__pb2.GetOTSReq.SerializeToString,
                response_deserializer=qbit__pb2.GetOTSResp.FromString,
                _registered_method=True)
        self.GetHeight = channel.unary_unary(
                '/qrl.PublicAPI/GetHeight',
                request_serializer=qbit__pb2.GetHeightReq.SerializeToString,
                response_deserializer=qbit__pb2.GetHeightResp.FromString,
                _registered_method=True)
        self.GetBlock = channel.unary_unary(
                '/qrl.PublicAPI/GetBlock',
                request_serializer=qbit__pb2.GetBlockReq.SerializeToString,
                response_deserializer=qbit__pb2.GetBlockResp.FromString,
                _registered_method=True)
        self.GetBlockByNumber = channel.unary_unary(
                '/qrl.PublicAPI/GetBlockByNumber',
                request_serializer=qbit__pb2.GetBlockByNumberReq.SerializeToString,
                response_deserializer=qbit__pb2.GetBlockByNumberResp.FromString,
                _registered_method=True)


class PublicAPIServicer(object):
    """//////////////////////////
    //////////////////////////
    //////////////////////////
    ////     API       ///////
    //////////////////////////
    //////////////////////////
    //////////////////////////

    This service describes the Public API used by clients (wallet/cli/etc)
    """

    def GetNodeState(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 GetKnownPeers(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 GetPeersStat(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 GetStats(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 GetAddressState(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 GetOptimizedAddressState(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 GetMultiSigAddressState(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 IsSlave(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 GetObject(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 GetLatestData(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 PushTransaction(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 TransferCoins(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 ParseAddress(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 GetChainStats(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 GetStakingStats(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 GetStakerList(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 GetAddressFromPK(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 GetMultiSigCreateTxn(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 GetMultiSigSpendTxn(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 GetMultiSigVoteTxn(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 GetMessageTxn(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 GetTokenTxn(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 GetTransferTokenTxn(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 GetSlaveTxn(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 GetLatticeTxn(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 GetTransaction(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 GetMiniTransactionsByAddress(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 GetTransactionsByAddress(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 GetTokensByAddress(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 GetSlavesByAddress(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 GetLatticePKsByAddress(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 GetMultiSigAddressesByAddress(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 GetMultiSigSpendTxsByAddress(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 GetVoteStats(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 GetInboxMessagesByAddress(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 GetBalance(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 GetTotalBalance(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 GetOTS(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 GetHeight(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 GetBlock(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 GetBlockByNumber(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_PublicAPIServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetNodeState': grpc.unary_unary_rpc_method_handler(
                    servicer.GetNodeState,
                    request_deserializer=qbit__pb2.GetNodeStateReq.FromString,
                    response_serializer=qbit__pb2.GetNodeStateResp.SerializeToString,
            ),
            'GetKnownPeers': grpc.unary_unary_rpc_method_handler(
                    servicer.GetKnownPeers,
                    request_deserializer=qbit__pb2.GetKnownPeersReq.FromString,
                    response_serializer=qbit__pb2.GetKnownPeersResp.SerializeToString,
            ),
            'GetPeersStat': grpc.unary_unary_rpc_method_handler(
                    servicer.GetPeersStat,
                    request_deserializer=qbit__pb2.GetPeersStatReq.FromString,
                    response_serializer=qbit__pb2.GetPeersStatResp.SerializeToString,
            ),
            'GetStats': grpc.unary_unary_rpc_method_handler(
                    servicer.GetStats,
                    request_deserializer=qbit__pb2.GetStatsReq.FromString,
                    response_serializer=qbit__pb2.GetStatsResp.SerializeToString,
            ),
            'GetAddressState': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAddressState,
                    request_deserializer=qbit__pb2.GetAddressStateReq.FromString,
                    response_serializer=qbit__pb2.GetAddressStateResp.SerializeToString,
            ),
            'GetOptimizedAddressState': grpc.unary_unary_rpc_method_handler(
                    servicer.GetOptimizedAddressState,
                    request_deserializer=qbit__pb2.GetAddressStateReq.FromString,
                    response_serializer=qbit__pb2.GetOptimizedAddressStateResp.SerializeToString,
            ),
            'GetMultiSigAddressState': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMultiSigAddressState,
                    request_deserializer=qbit__pb2.GetMultiSigAddressStateReq.FromString,
                    response_serializer=qbit__pb2.GetMultiSigAddressStateResp.SerializeToString,
            ),
            'IsSlave': grpc.unary_unary_rpc_method_handler(
                    servicer.IsSlave,
                    request_deserializer=qbit__pb2.IsSlaveReq.FromString,
                    response_serializer=qbit__pb2.IsSlaveResp.SerializeToString,
            ),
            'GetObject': grpc.unary_unary_rpc_method_handler(
                    servicer.GetObject,
                    request_deserializer=qbit__pb2.GetObjectReq.FromString,
                    response_serializer=qbit__pb2.GetObjectResp.SerializeToString,
            ),
            'GetLatestData': grpc.unary_unary_rpc_method_handler(
                    servicer.GetLatestData,
                    request_deserializer=qbit__pb2.GetLatestDataReq.FromString,
                    response_serializer=qbit__pb2.GetLatestDataResp.SerializeToString,
            ),
            'PushTransaction': grpc.unary_unary_rpc_method_handler(
                    servicer.PushTransaction,
                    request_deserializer=qbit__pb2.PushTransactionReq.FromString,
                    response_serializer=qbit__pb2.PushTransactionResp.SerializeToString,
            ),
            'TransferCoins': grpc.unary_unary_rpc_method_handler(
                    servicer.TransferCoins,
                    request_deserializer=qbit__pb2.TransferCoinsReq.FromString,
                    response_serializer=qbit__pb2.TransferCoinsResp.SerializeToString,
            ),
            'ParseAddress': grpc.unary_unary_rpc_method_handler(
                    servicer.ParseAddress,
                    request_deserializer=qbit__pb2.ParseAddressReq.FromString,
                    response_serializer=qbit__pb2.ParseAddressResp.SerializeToString,
            ),
            'GetChainStats': grpc.unary_unary_rpc_method_handler(
                    servicer.GetChainStats,
                    request_deserializer=qbit__pb2.GetChainStatsReq.FromString,
                    response_serializer=qbit__pb2.GetChainStatsResp.SerializeToString,
            ),
            'GetStakingStats': grpc.unary_unary_rpc_method_handler(
                    servicer.GetStakingStats,
                    request_deserializer=qbit__pb2.GetStakingStatsReq.FromString,
                    response_serializer=qbit__pb2.GetStakingStatsResp.SerializeToString,
            ),
            'GetStakerList': grpc.unary_unary_rpc_method_handler(
                    servicer.GetStakerList,
                    request_deserializer=qbit__pb2.GetStakerListReq.FromString,
                    response_serializer=qbit__pb2.GetStakerListResp.SerializeToString,
            ),
            'GetAddressFromPK': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAddressFromPK,
                    request_deserializer=qbit__pb2.GetAddressFromPKReq.FromString,
                    response_serializer=qbit__pb2.GetAddressFromPKResp.SerializeToString,
            ),
            'GetMultiSigCreateTxn': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMultiSigCreateTxn,
                    request_deserializer=qbit__pb2.MultiSigCreateTxnReq.FromString,
                    response_serializer=qbit__pb2.TransferCoinsResp.SerializeToString,
            ),
            'GetMultiSigSpendTxn': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMultiSigSpendTxn,
                    request_deserializer=qbit__pb2.MultiSigSpendTxnReq.FromString,
                    response_serializer=qbit__pb2.TransferCoinsResp.SerializeToString,
            ),
            'GetMultiSigVoteTxn': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMultiSigVoteTxn,
                    request_deserializer=qbit__pb2.MultiSigVoteTxnReq.FromString,
                    response_serializer=qbit__pb2.TransferCoinsResp.SerializeToString,
            ),
            'GetMessageTxn': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMessageTxn,
                    request_deserializer=qbit__pb2.MessageTxnReq.FromString,
                    response_serializer=qbit__pb2.TransferCoinsResp.SerializeToString,
            ),
            'GetTokenTxn': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTokenTxn,
                    request_deserializer=qbit__pb2.TokenTxnReq.FromString,
                    response_serializer=qbit__pb2.TransferCoinsResp.SerializeToString,
            ),
            'GetTransferTokenTxn': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTransferTokenTxn,
                    request_deserializer=qbit__pb2.TransferTokenTxnReq.FromString,
                    response_serializer=qbit__pb2.TransferCoinsResp.SerializeToString,
            ),
            'GetSlaveTxn': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSlaveTxn,
                    request_deserializer=qbit__pb2.SlaveTxnReq.FromString,
                    response_serializer=qbit__pb2.TransferCoinsResp.SerializeToString,
            ),
            'GetLatticeTxn': grpc.unary_unary_rpc_method_handler(
                    servicer.GetLatticeTxn,
                    request_deserializer=qbit__pb2.LatticeTxnReq.FromString,
                    response_serializer=qbit__pb2.TransferCoinsResp.SerializeToString,
            ),
            'GetTransaction': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTransaction,
                    request_deserializer=qbit__pb2.GetTransactionReq.FromString,
                    response_serializer=qbit__pb2.GetTransactionResp.SerializeToString,
            ),
            'GetMiniTransactionsByAddress': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMiniTransactionsByAddress,
                    request_deserializer=qbit__pb2.GetMiniTransactionsByAddressReq.FromString,
                    response_serializer=qbit__pb2.GetMiniTransactionsByAddressResp.SerializeToString,
            ),
            'GetTransactionsByAddress': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTransactionsByAddress,
                    request_deserializer=qbit__pb2.GetTransactionsByAddressReq.FromString,
                    response_serializer=qbit__pb2.GetTransactionsByAddressResp.SerializeToString,
            ),
            'GetTokensByAddress': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTokensByAddress,
                    request_deserializer=qbit__pb2.GetTransactionsByAddressReq.FromString,
                    response_serializer=qbit__pb2.GetTokensByAddressResp.SerializeToString,
            ),
            'GetSlavesByAddress': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSlavesByAddress,
                    request_deserializer=qbit__pb2.GetTransactionsByAddressReq.FromString,
                    response_serializer=qbit__pb2.GetSlavesByAddressResp.SerializeToString,
            ),
            'GetLatticePKsByAddress': grpc.unary_unary_rpc_method_handler(
                    servicer.GetLatticePKsByAddress,
                    request_deserializer=qbit__pb2.GetTransactionsByAddressReq.FromString,
                    response_serializer=qbit__pb2.GetLatticePKsByAddressResp.SerializeToString,
            ),
            'GetMultiSigAddressesByAddress': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMultiSigAddressesByAddress,
                    request_deserializer=qbit__pb2.GetTransactionsByAddressReq.FromString,
                    response_serializer=qbit__pb2.GetMultiSigAddressesByAddressResp.SerializeToString,
            ),
            'GetMultiSigSpendTxsByAddress': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMultiSigSpendTxsByAddress,
                    request_deserializer=qbit__pb2.GetMultiSigSpendTxsByAddressReq.FromString,
                    response_serializer=qbit__pb2.GetMultiSigSpendTxsByAddressResp.SerializeToString,
            ),
            'GetVoteStats': grpc.unary_unary_rpc_method_handler(
                    servicer.GetVoteStats,
                    request_deserializer=qbit__pb2.GetVoteStatsReq.FromString,
                    response_serializer=qbit__pb2.GetVoteStatsResp.SerializeToString,
            ),
            'GetInboxMessagesByAddress': grpc.unary_unary_rpc_method_handler(
                    servicer.GetInboxMessagesByAddress,
                    request_deserializer=qbit__pb2.GetTransactionsByAddressReq.FromString,
                    response_serializer=qbit__pb2.GetInboxMessagesByAddressResp.SerializeToString,
            ),
            'GetBalance': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBalance,
                    request_deserializer=qbit__pb2.GetBalanceReq.FromString,
                    response_serializer=qbit__pb2.GetBalanceResp.SerializeToString,
            ),
            'GetTotalBalance': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTotalBalance,
                    request_deserializer=qbit__pb2.GetTotalBalanceReq.FromString,
                    response_serializer=qbit__pb2.GetTotalBalanceResp.SerializeToString,
            ),
            'GetOTS': grpc.unary_unary_rpc_method_handler(
                    servicer.GetOTS,
                    request_deserializer=qbit__pb2.GetOTSReq.FromString,
                    response_serializer=qbit__pb2.GetOTSResp.SerializeToString,
            ),
            'GetHeight': grpc.unary_unary_rpc_method_handler(
                    servicer.GetHeight,
                    request_deserializer=qbit__pb2.GetHeightReq.FromString,
                    response_serializer=qbit__pb2.GetHeightResp.SerializeToString,
            ),
            'GetBlock': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBlock,
                    request_deserializer=qbit__pb2.GetBlockReq.FromString,
                    response_serializer=qbit__pb2.GetBlockResp.SerializeToString,
            ),
            'GetBlockByNumber': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBlockByNumber,
                    request_deserializer=qbit__pb2.GetBlockByNumberReq.FromString,
                    response_serializer=qbit__pb2.GetBlockByNumberResp.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'qrl.PublicAPI', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('qrl.PublicAPI', rpc_method_handlers)


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

    This service describes the Public API used by clients (wallet/cli/etc)
    """

    @staticmethod
    def GetNodeState(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,
            '/qrl.PublicAPI/GetNodeState',
            qbit__pb2.GetNodeStateReq.SerializeToString,
            qbit__pb2.GetNodeStateResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetKnownPeers(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,
            '/qrl.PublicAPI/GetKnownPeers',
            qbit__pb2.GetKnownPeersReq.SerializeToString,
            qbit__pb2.GetKnownPeersResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetPeersStat(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,
            '/qrl.PublicAPI/GetPeersStat',
            qbit__pb2.GetPeersStatReq.SerializeToString,
            qbit__pb2.GetPeersStatResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetStats(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,
            '/qrl.PublicAPI/GetStats',
            qbit__pb2.GetStatsReq.SerializeToString,
            qbit__pb2.GetStatsResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetAddressState(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,
            '/qrl.PublicAPI/GetAddressState',
            qbit__pb2.GetAddressStateReq.SerializeToString,
            qbit__pb2.GetAddressStateResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetOptimizedAddressState(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,
            '/qrl.PublicAPI/GetOptimizedAddressState',
            qbit__pb2.GetAddressStateReq.SerializeToString,
            qbit__pb2.GetOptimizedAddressStateResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMultiSigAddressState(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,
            '/qrl.PublicAPI/GetMultiSigAddressState',
            qbit__pb2.GetMultiSigAddressStateReq.SerializeToString,
            qbit__pb2.GetMultiSigAddressStateResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def IsSlave(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,
            '/qrl.PublicAPI/IsSlave',
            qbit__pb2.IsSlaveReq.SerializeToString,
            qbit__pb2.IsSlaveResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetObject(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,
            '/qrl.PublicAPI/GetObject',
            qbit__pb2.GetObjectReq.SerializeToString,
            qbit__pb2.GetObjectResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetLatestData(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,
            '/qrl.PublicAPI/GetLatestData',
            qbit__pb2.GetLatestDataReq.SerializeToString,
            qbit__pb2.GetLatestDataResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def PushTransaction(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,
            '/qrl.PublicAPI/PushTransaction',
            qbit__pb2.PushTransactionReq.SerializeToString,
            qbit__pb2.PushTransactionResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TransferCoins(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,
            '/qrl.PublicAPI/TransferCoins',
            qbit__pb2.TransferCoinsReq.SerializeToString,
            qbit__pb2.TransferCoinsResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ParseAddress(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,
            '/qrl.PublicAPI/ParseAddress',
            qbit__pb2.ParseAddressReq.SerializeToString,
            qbit__pb2.ParseAddressResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetChainStats(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,
            '/qrl.PublicAPI/GetChainStats',
            qbit__pb2.GetChainStatsReq.SerializeToString,
            qbit__pb2.GetChainStatsResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetStakingStats(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,
            '/qrl.PublicAPI/GetStakingStats',
            qbit__pb2.GetStakingStatsReq.SerializeToString,
            qbit__pb2.GetStakingStatsResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetStakerList(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,
            '/qrl.PublicAPI/GetStakerList',
            qbit__pb2.GetStakerListReq.SerializeToString,
            qbit__pb2.GetStakerListResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetAddressFromPK(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,
            '/qrl.PublicAPI/GetAddressFromPK',
            qbit__pb2.GetAddressFromPKReq.SerializeToString,
            qbit__pb2.GetAddressFromPKResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMultiSigCreateTxn(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,
            '/qrl.PublicAPI/GetMultiSigCreateTxn',
            qbit__pb2.MultiSigCreateTxnReq.SerializeToString,
            qbit__pb2.TransferCoinsResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMultiSigSpendTxn(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,
            '/qrl.PublicAPI/GetMultiSigSpendTxn',
            qbit__pb2.MultiSigSpendTxnReq.SerializeToString,
            qbit__pb2.TransferCoinsResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMultiSigVoteTxn(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,
            '/qrl.PublicAPI/GetMultiSigVoteTxn',
            qbit__pb2.MultiSigVoteTxnReq.SerializeToString,
            qbit__pb2.TransferCoinsResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMessageTxn(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,
            '/qrl.PublicAPI/GetMessageTxn',
            qbit__pb2.MessageTxnReq.SerializeToString,
            qbit__pb2.TransferCoinsResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetTokenTxn(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,
            '/qrl.PublicAPI/GetTokenTxn',
            qbit__pb2.TokenTxnReq.SerializeToString,
            qbit__pb2.TransferCoinsResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetTransferTokenTxn(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,
            '/qrl.PublicAPI/GetTransferTokenTxn',
            qbit__pb2.TransferTokenTxnReq.SerializeToString,
            qbit__pb2.TransferCoinsResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetSlaveTxn(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,
            '/qrl.PublicAPI/GetSlaveTxn',
            qbit__pb2.SlaveTxnReq.SerializeToString,
            qbit__pb2.TransferCoinsResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetLatticeTxn(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,
            '/qrl.PublicAPI/GetLatticeTxn',
            qbit__pb2.LatticeTxnReq.SerializeToString,
            qbit__pb2.TransferCoinsResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetTransaction(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,
            '/qrl.PublicAPI/GetTransaction',
            qbit__pb2.GetTransactionReq.SerializeToString,
            qbit__pb2.GetTransactionResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMiniTransactionsByAddress(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,
            '/qrl.PublicAPI/GetMiniTransactionsByAddress',
            qbit__pb2.GetMiniTransactionsByAddressReq.SerializeToString,
            qbit__pb2.GetMiniTransactionsByAddressResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetTransactionsByAddress(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,
            '/qrl.PublicAPI/GetTransactionsByAddress',
            qbit__pb2.GetTransactionsByAddressReq.SerializeToString,
            qbit__pb2.GetTransactionsByAddressResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetTokensByAddress(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,
            '/qrl.PublicAPI/GetTokensByAddress',
            qbit__pb2.GetTransactionsByAddressReq.SerializeToString,
            qbit__pb2.GetTokensByAddressResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetSlavesByAddress(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,
            '/qrl.PublicAPI/GetSlavesByAddress',
            qbit__pb2.GetTransactionsByAddressReq.SerializeToString,
            qbit__pb2.GetSlavesByAddressResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetLatticePKsByAddress(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,
            '/qrl.PublicAPI/GetLatticePKsByAddress',
            qbit__pb2.GetTransactionsByAddressReq.SerializeToString,
            qbit__pb2.GetLatticePKsByAddressResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMultiSigAddressesByAddress(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,
            '/qrl.PublicAPI/GetMultiSigAddressesByAddress',
            qbit__pb2.GetTransactionsByAddressReq.SerializeToString,
            qbit__pb2.GetMultiSigAddressesByAddressResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMultiSigSpendTxsByAddress(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,
            '/qrl.PublicAPI/GetMultiSigSpendTxsByAddress',
            qbit__pb2.GetMultiSigSpendTxsByAddressReq.SerializeToString,
            qbit__pb2.GetMultiSigSpendTxsByAddressResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetVoteStats(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,
            '/qrl.PublicAPI/GetVoteStats',
            qbit__pb2.GetVoteStatsReq.SerializeToString,
            qbit__pb2.GetVoteStatsResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetInboxMessagesByAddress(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,
            '/qrl.PublicAPI/GetInboxMessagesByAddress',
            qbit__pb2.GetTransactionsByAddressReq.SerializeToString,
            qbit__pb2.GetInboxMessagesByAddressResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetBalance(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,
            '/qrl.PublicAPI/GetBalance',
            qbit__pb2.GetBalanceReq.SerializeToString,
            qbit__pb2.GetBalanceResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetTotalBalance(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,
            '/qrl.PublicAPI/GetTotalBalance',
            qbit__pb2.GetTotalBalanceReq.SerializeToString,
            qbit__pb2.GetTotalBalanceResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetOTS(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,
            '/qrl.PublicAPI/GetOTS',
            qbit__pb2.GetOTSReq.SerializeToString,
            qbit__pb2.GetOTSResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetHeight(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,
            '/qrl.PublicAPI/GetHeight',
            qbit__pb2.GetHeightReq.SerializeToString,
            qbit__pb2.GetHeightResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetBlock(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,
            '/qrl.PublicAPI/GetBlock',
            qbit__pb2.GetBlockReq.SerializeToString,
            qbit__pb2.GetBlockResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetBlockByNumber(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,
            '/qrl.PublicAPI/GetBlockByNumber',
            qbit__pb2.GetBlockByNumberReq.SerializeToString,
            qbit__pb2.GetBlockByNumberResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class AdminAPIStub(object):
    """This is a place holder for testing/instrumentation APIs
    """

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

        Args:
            channel: A grpc.Channel.
        """


class AdminAPIServicer(object):
    """This is a place holder for testing/instrumentation APIs
    """


def add_AdminAPIServicer_to_server(servicer, server):
    rpc_method_handlers = {
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'qrl.AdminAPI', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('qrl.AdminAPI', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class AdminAPI(object):
    """This is a place holder for testing/instrumentation APIs
    """
