# 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.qbitwallet_pb2 as qbitwallet__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 qbitwallet_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 WalletAPIStub(object):
    """//////////////////////////
    //////////////////////////
    //////////////////////////
    ////     API       ///////
    //////////////////////////
    //////////////////////////
    //////////////////////////

    This service describes the Wallet API
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.AddNewAddress = channel.unary_unary(
                '/qrl.WalletAPI/AddNewAddress',
                request_serializer=qbitwallet__pb2.AddNewAddressReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.AddNewAddressResp.FromString,
                _registered_method=True)
        self.AddNewAddressWithSlaves = channel.unary_unary(
                '/qrl.WalletAPI/AddNewAddressWithSlaves',
                request_serializer=qbitwallet__pb2.AddNewAddressWithSlavesReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.AddNewAddressResp.FromString,
                _registered_method=True)
        self.ListAddresses = channel.unary_unary(
                '/qrl.WalletAPI/ListAddresses',
                request_serializer=qbitwallet__pb2.ListAddressesReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.ListAddressesResp.FromString,
                _registered_method=True)
        self.RemoveAddress = channel.unary_unary(
                '/qrl.WalletAPI/RemoveAddress',
                request_serializer=qbitwallet__pb2.RemoveAddressReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.RemoveAddressResp.FromString,
                _registered_method=True)
        self.IsValidAddress = channel.unary_unary(
                '/qrl.WalletAPI/IsValidAddress',
                request_serializer=qbitwallet__pb2.ValidAddressReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.ValidAddressResp.FromString,
                _registered_method=True)
        self.EncryptWallet = channel.unary_unary(
                '/qrl.WalletAPI/EncryptWallet',
                request_serializer=qbitwallet__pb2.EncryptWalletReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.EncryptWalletResp.FromString,
                _registered_method=True)
        self.LockWallet = channel.unary_unary(
                '/qrl.WalletAPI/LockWallet',
                request_serializer=qbitwallet__pb2.LockWalletReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.LockWalletResp.FromString,
                _registered_method=True)
        self.UnlockWallet = channel.unary_unary(
                '/qrl.WalletAPI/UnlockWallet',
                request_serializer=qbitwallet__pb2.UnlockWalletReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.UnlockWalletResp.FromString,
                _registered_method=True)
        self.GetRecoverySeeds = channel.unary_unary(
                '/qrl.WalletAPI/GetRecoverySeeds',
                request_serializer=qbitwallet__pb2.GetRecoverySeedsReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.GetRecoverySeedsResp.FromString,
                _registered_method=True)
        self.GetWalletInfo = channel.unary_unary(
                '/qrl.WalletAPI/GetWalletInfo',
                request_serializer=qbitwallet__pb2.GetWalletInfoReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.GetWalletInfoResp.FromString,
                _registered_method=True)
        self.RelayTransferTxn = channel.unary_unary(
                '/qrl.WalletAPI/RelayTransferTxn',
                request_serializer=qbitwallet__pb2.RelayTransferTxnReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.RelayTxnResp.FromString,
                _registered_method=True)
        self.RelayTransferTxnBySlave = channel.unary_unary(
                '/qrl.WalletAPI/RelayTransferTxnBySlave',
                request_serializer=qbitwallet__pb2.RelayTransferTxnBySlaveReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.RelayTxnResp.FromString,
                _registered_method=True)
        self.RelayMessageTxn = channel.unary_unary(
                '/qrl.WalletAPI/RelayMessageTxn',
                request_serializer=qbitwallet__pb2.RelayMessageTxnReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.RelayTxnResp.FromString,
                _registered_method=True)
        self.RelayMessageTxnBySlave = channel.unary_unary(
                '/qrl.WalletAPI/RelayMessageTxnBySlave',
                request_serializer=qbitwallet__pb2.RelayMessageTxnBySlaveReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.RelayTxnResp.FromString,
                _registered_method=True)
        self.RelayTokenTxn = channel.unary_unary(
                '/qrl.WalletAPI/RelayTokenTxn',
                request_serializer=qbitwallet__pb2.RelayTokenTxnReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.RelayTxnResp.FromString,
                _registered_method=True)
        self.RelayTokenTxnBySlave = channel.unary_unary(
                '/qrl.WalletAPI/RelayTokenTxnBySlave',
                request_serializer=qbitwallet__pb2.RelayTokenTxnBySlaveReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.RelayTxnResp.FromString,
                _registered_method=True)
        self.RelayTransferTokenTxn = channel.unary_unary(
                '/qrl.WalletAPI/RelayTransferTokenTxn',
                request_serializer=qbitwallet__pb2.RelayTransferTokenTxnReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.RelayTxnResp.FromString,
                _registered_method=True)
        self.RelayTransferTokenTxnBySlave = channel.unary_unary(
                '/qrl.WalletAPI/RelayTransferTokenTxnBySlave',
                request_serializer=qbitwallet__pb2.RelayTransferTokenTxnBySlaveReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.RelayTxnResp.FromString,
                _registered_method=True)
        self.RelaySlaveTxn = channel.unary_unary(
                '/qrl.WalletAPI/RelaySlaveTxn',
                request_serializer=qbitwallet__pb2.RelaySlaveTxnReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.RelayTxnResp.FromString,
                _registered_method=True)
        self.RelaySlaveTxnBySlave = channel.unary_unary(
                '/qrl.WalletAPI/RelaySlaveTxnBySlave',
                request_serializer=qbitwallet__pb2.RelaySlaveTxnBySlaveReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.RelayTxnResp.FromString,
                _registered_method=True)
        self.ChangePassphrase = channel.unary_unary(
                '/qrl.WalletAPI/ChangePassphrase',
                request_serializer=qbitwallet__pb2.ChangePassphraseReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.ChangePassphraseResp.FromString,
                _registered_method=True)
        self.GetTransactionsByAddress = channel.unary_unary(
                '/qrl.WalletAPI/GetTransactionsByAddress',
                request_serializer=qbitwallet__pb2.TransactionsByAddressReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.TransactionsByAddressResp.FromString,
                _registered_method=True)
        self.GetPaginatedTransactionsByAddress = channel.unary_unary(
                '/qrl.WalletAPI/GetPaginatedTransactionsByAddress',
                request_serializer=qbitwallet__pb2.PaginatedTransactionsByAddressReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.PaginatedTransactionsByAddressResp.FromString,
                _registered_method=True)
        self.GetTransaction = channel.unary_unary(
                '/qrl.WalletAPI/GetTransaction',
                request_serializer=qbitwallet__pb2.TransactionReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.TransactionResp.FromString,
                _registered_method=True)
        self.GetBalance = channel.unary_unary(
                '/qrl.WalletAPI/GetBalance',
                request_serializer=qbitwallet__pb2.BalanceReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.BalanceResp.FromString,
                _registered_method=True)
        self.GetTotalBalance = channel.unary_unary(
                '/qrl.WalletAPI/GetTotalBalance',
                request_serializer=qbitwallet__pb2.TotalBalanceReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.TotalBalanceResp.FromString,
                _registered_method=True)
        self.GetOTS = channel.unary_unary(
                '/qrl.WalletAPI/GetOTS',
                request_serializer=qbitwallet__pb2.OTSReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.OTSResp.FromString,
                _registered_method=True)
        self.GetHeight = channel.unary_unary(
                '/qrl.WalletAPI/GetHeight',
                request_serializer=qbitwallet__pb2.HeightReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.HeightResp.FromString,
                _registered_method=True)
        self.GetBlock = channel.unary_unary(
                '/qrl.WalletAPI/GetBlock',
                request_serializer=qbitwallet__pb2.BlockReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.BlockResp.FromString,
                _registered_method=True)
        self.GetBlockByNumber = channel.unary_unary(
                '/qrl.WalletAPI/GetBlockByNumber',
                request_serializer=qbitwallet__pb2.BlockByNumberReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.BlockResp.FromString,
                _registered_method=True)
        self.GetAddressFromPK = channel.unary_unary(
                '/qrl.WalletAPI/GetAddressFromPK',
                request_serializer=qbitwallet__pb2.AddressFromPKReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.AddressFromPKResp.FromString,
                _registered_method=True)
        self.GetNodeInfo = channel.unary_unary(
                '/qrl.WalletAPI/GetNodeInfo',
                request_serializer=qbitwallet__pb2.NodeInfoReq.SerializeToString,
                response_deserializer=qbitwallet__pb2.NodeInfoResp.FromString,
                _registered_method=True)


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

    This service describes the Wallet API
    """

    def AddNewAddress(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 AddNewAddressWithSlaves(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 ListAddresses(self, request, context):
        """rpc AddAddressFromSeed(AddAddressFromSeedReq) returns (AddAddressFromSeedResp);

        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RemoveAddress(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 IsValidAddress(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 EncryptWallet(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 GetRecoverySeeds(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 GetWalletInfo(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 RelayTransferTxn(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 RelayTransferTxnBySlave(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 RelayMessageTxn(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 RelayMessageTxnBySlave(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 RelayTokenTxn(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 RelayTokenTxnBySlave(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 RelayTransferTokenTxn(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 RelayTransferTokenTxnBySlave(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 RelaySlaveTxn(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 RelaySlaveTxnBySlave(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 ChangePassphrase(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 GetPaginatedTransactionsByAddress(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 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 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 GetNodeInfo(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_WalletAPIServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'AddNewAddress': grpc.unary_unary_rpc_method_handler(
                    servicer.AddNewAddress,
                    request_deserializer=qbitwallet__pb2.AddNewAddressReq.FromString,
                    response_serializer=qbitwallet__pb2.AddNewAddressResp.SerializeToString,
            ),
            'AddNewAddressWithSlaves': grpc.unary_unary_rpc_method_handler(
                    servicer.AddNewAddressWithSlaves,
                    request_deserializer=qbitwallet__pb2.AddNewAddressWithSlavesReq.FromString,
                    response_serializer=qbitwallet__pb2.AddNewAddressResp.SerializeToString,
            ),
            'ListAddresses': grpc.unary_unary_rpc_method_handler(
                    servicer.ListAddresses,
                    request_deserializer=qbitwallet__pb2.ListAddressesReq.FromString,
                    response_serializer=qbitwallet__pb2.ListAddressesResp.SerializeToString,
            ),
            'RemoveAddress': grpc.unary_unary_rpc_method_handler(
                    servicer.RemoveAddress,
                    request_deserializer=qbitwallet__pb2.RemoveAddressReq.FromString,
                    response_serializer=qbitwallet__pb2.RemoveAddressResp.SerializeToString,
            ),
            'IsValidAddress': grpc.unary_unary_rpc_method_handler(
                    servicer.IsValidAddress,
                    request_deserializer=qbitwallet__pb2.ValidAddressReq.FromString,
                    response_serializer=qbitwallet__pb2.ValidAddressResp.SerializeToString,
            ),
            'EncryptWallet': grpc.unary_unary_rpc_method_handler(
                    servicer.EncryptWallet,
                    request_deserializer=qbitwallet__pb2.EncryptWalletReq.FromString,
                    response_serializer=qbitwallet__pb2.EncryptWalletResp.SerializeToString,
            ),
            'LockWallet': grpc.unary_unary_rpc_method_handler(
                    servicer.LockWallet,
                    request_deserializer=qbitwallet__pb2.LockWalletReq.FromString,
                    response_serializer=qbitwallet__pb2.LockWalletResp.SerializeToString,
            ),
            'UnlockWallet': grpc.unary_unary_rpc_method_handler(
                    servicer.UnlockWallet,
                    request_deserializer=qbitwallet__pb2.UnlockWalletReq.FromString,
                    response_serializer=qbitwallet__pb2.UnlockWalletResp.SerializeToString,
            ),
            'GetRecoverySeeds': grpc.unary_unary_rpc_method_handler(
                    servicer.GetRecoverySeeds,
                    request_deserializer=qbitwallet__pb2.GetRecoverySeedsReq.FromString,
                    response_serializer=qbitwallet__pb2.GetRecoverySeedsResp.SerializeToString,
            ),
            'GetWalletInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.GetWalletInfo,
                    request_deserializer=qbitwallet__pb2.GetWalletInfoReq.FromString,
                    response_serializer=qbitwallet__pb2.GetWalletInfoResp.SerializeToString,
            ),
            'RelayTransferTxn': grpc.unary_unary_rpc_method_handler(
                    servicer.RelayTransferTxn,
                    request_deserializer=qbitwallet__pb2.RelayTransferTxnReq.FromString,
                    response_serializer=qbitwallet__pb2.RelayTxnResp.SerializeToString,
            ),
            'RelayTransferTxnBySlave': grpc.unary_unary_rpc_method_handler(
                    servicer.RelayTransferTxnBySlave,
                    request_deserializer=qbitwallet__pb2.RelayTransferTxnBySlaveReq.FromString,
                    response_serializer=qbitwallet__pb2.RelayTxnResp.SerializeToString,
            ),
            'RelayMessageTxn': grpc.unary_unary_rpc_method_handler(
                    servicer.RelayMessageTxn,
                    request_deserializer=qbitwallet__pb2.RelayMessageTxnReq.FromString,
                    response_serializer=qbitwallet__pb2.RelayTxnResp.SerializeToString,
            ),
            'RelayMessageTxnBySlave': grpc.unary_unary_rpc_method_handler(
                    servicer.RelayMessageTxnBySlave,
                    request_deserializer=qbitwallet__pb2.RelayMessageTxnBySlaveReq.FromString,
                    response_serializer=qbitwallet__pb2.RelayTxnResp.SerializeToString,
            ),
            'RelayTokenTxn': grpc.unary_unary_rpc_method_handler(
                    servicer.RelayTokenTxn,
                    request_deserializer=qbitwallet__pb2.RelayTokenTxnReq.FromString,
                    response_serializer=qbitwallet__pb2.RelayTxnResp.SerializeToString,
            ),
            'RelayTokenTxnBySlave': grpc.unary_unary_rpc_method_handler(
                    servicer.RelayTokenTxnBySlave,
                    request_deserializer=qbitwallet__pb2.RelayTokenTxnBySlaveReq.FromString,
                    response_serializer=qbitwallet__pb2.RelayTxnResp.SerializeToString,
            ),
            'RelayTransferTokenTxn': grpc.unary_unary_rpc_method_handler(
                    servicer.RelayTransferTokenTxn,
                    request_deserializer=qbitwallet__pb2.RelayTransferTokenTxnReq.FromString,
                    response_serializer=qbitwallet__pb2.RelayTxnResp.SerializeToString,
            ),
            'RelayTransferTokenTxnBySlave': grpc.unary_unary_rpc_method_handler(
                    servicer.RelayTransferTokenTxnBySlave,
                    request_deserializer=qbitwallet__pb2.RelayTransferTokenTxnBySlaveReq.FromString,
                    response_serializer=qbitwallet__pb2.RelayTxnResp.SerializeToString,
            ),
            'RelaySlaveTxn': grpc.unary_unary_rpc_method_handler(
                    servicer.RelaySlaveTxn,
                    request_deserializer=qbitwallet__pb2.RelaySlaveTxnReq.FromString,
                    response_serializer=qbitwallet__pb2.RelayTxnResp.SerializeToString,
            ),
            'RelaySlaveTxnBySlave': grpc.unary_unary_rpc_method_handler(
                    servicer.RelaySlaveTxnBySlave,
                    request_deserializer=qbitwallet__pb2.RelaySlaveTxnBySlaveReq.FromString,
                    response_serializer=qbitwallet__pb2.RelayTxnResp.SerializeToString,
            ),
            'ChangePassphrase': grpc.unary_unary_rpc_method_handler(
                    servicer.ChangePassphrase,
                    request_deserializer=qbitwallet__pb2.ChangePassphraseReq.FromString,
                    response_serializer=qbitwallet__pb2.ChangePassphraseResp.SerializeToString,
            ),
            'GetTransactionsByAddress': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTransactionsByAddress,
                    request_deserializer=qbitwallet__pb2.TransactionsByAddressReq.FromString,
                    response_serializer=qbitwallet__pb2.TransactionsByAddressResp.SerializeToString,
            ),
            'GetPaginatedTransactionsByAddress': grpc.unary_unary_rpc_method_handler(
                    servicer.GetPaginatedTransactionsByAddress,
                    request_deserializer=qbitwallet__pb2.PaginatedTransactionsByAddressReq.FromString,
                    response_serializer=qbitwallet__pb2.PaginatedTransactionsByAddressResp.SerializeToString,
            ),
            'GetTransaction': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTransaction,
                    request_deserializer=qbitwallet__pb2.TransactionReq.FromString,
                    response_serializer=qbitwallet__pb2.TransactionResp.SerializeToString,
            ),
            'GetBalance': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBalance,
                    request_deserializer=qbitwallet__pb2.BalanceReq.FromString,
                    response_serializer=qbitwallet__pb2.BalanceResp.SerializeToString,
            ),
            'GetTotalBalance': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTotalBalance,
                    request_deserializer=qbitwallet__pb2.TotalBalanceReq.FromString,
                    response_serializer=qbitwallet__pb2.TotalBalanceResp.SerializeToString,
            ),
            'GetOTS': grpc.unary_unary_rpc_method_handler(
                    servicer.GetOTS,
                    request_deserializer=qbitwallet__pb2.OTSReq.FromString,
                    response_serializer=qbitwallet__pb2.OTSResp.SerializeToString,
            ),
            'GetHeight': grpc.unary_unary_rpc_method_handler(
                    servicer.GetHeight,
                    request_deserializer=qbitwallet__pb2.HeightReq.FromString,
                    response_serializer=qbitwallet__pb2.HeightResp.SerializeToString,
            ),
            'GetBlock': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBlock,
                    request_deserializer=qbitwallet__pb2.BlockReq.FromString,
                    response_serializer=qbitwallet__pb2.BlockResp.SerializeToString,
            ),
            'GetBlockByNumber': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBlockByNumber,
                    request_deserializer=qbitwallet__pb2.BlockByNumberReq.FromString,
                    response_serializer=qbitwallet__pb2.BlockResp.SerializeToString,
            ),
            'GetAddressFromPK': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAddressFromPK,
                    request_deserializer=qbitwallet__pb2.AddressFromPKReq.FromString,
                    response_serializer=qbitwallet__pb2.AddressFromPKResp.SerializeToString,
            ),
            'GetNodeInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.GetNodeInfo,
                    request_deserializer=qbitwallet__pb2.NodeInfoReq.FromString,
                    response_serializer=qbitwallet__pb2.NodeInfoResp.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'qrl.WalletAPI', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('qrl.WalletAPI', rpc_method_handlers)


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

    This service describes the Wallet API
    """

    @staticmethod
    def AddNewAddress(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.WalletAPI/AddNewAddress',
            qbitwallet__pb2.AddNewAddressReq.SerializeToString,
            qbitwallet__pb2.AddNewAddressResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AddNewAddressWithSlaves(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.WalletAPI/AddNewAddressWithSlaves',
            qbitwallet__pb2.AddNewAddressWithSlavesReq.SerializeToString,
            qbitwallet__pb2.AddNewAddressResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListAddresses(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.WalletAPI/ListAddresses',
            qbitwallet__pb2.ListAddressesReq.SerializeToString,
            qbitwallet__pb2.ListAddressesResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RemoveAddress(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.WalletAPI/RemoveAddress',
            qbitwallet__pb2.RemoveAddressReq.SerializeToString,
            qbitwallet__pb2.RemoveAddressResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def IsValidAddress(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.WalletAPI/IsValidAddress',
            qbitwallet__pb2.ValidAddressReq.SerializeToString,
            qbitwallet__pb2.ValidAddressResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def EncryptWallet(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.WalletAPI/EncryptWallet',
            qbitwallet__pb2.EncryptWalletReq.SerializeToString,
            qbitwallet__pb2.EncryptWalletResp.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,
            '/qrl.WalletAPI/LockWallet',
            qbitwallet__pb2.LockWalletReq.SerializeToString,
            qbitwallet__pb2.LockWalletResp.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,
            '/qrl.WalletAPI/UnlockWallet',
            qbitwallet__pb2.UnlockWalletReq.SerializeToString,
            qbitwallet__pb2.UnlockWalletResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetRecoverySeeds(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.WalletAPI/GetRecoverySeeds',
            qbitwallet__pb2.GetRecoverySeedsReq.SerializeToString,
            qbitwallet__pb2.GetRecoverySeedsResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetWalletInfo(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.WalletAPI/GetWalletInfo',
            qbitwallet__pb2.GetWalletInfoReq.SerializeToString,
            qbitwallet__pb2.GetWalletInfoResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RelayTransferTxn(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.WalletAPI/RelayTransferTxn',
            qbitwallet__pb2.RelayTransferTxnReq.SerializeToString,
            qbitwallet__pb2.RelayTxnResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RelayTransferTxnBySlave(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.WalletAPI/RelayTransferTxnBySlave',
            qbitwallet__pb2.RelayTransferTxnBySlaveReq.SerializeToString,
            qbitwallet__pb2.RelayTxnResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RelayMessageTxn(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.WalletAPI/RelayMessageTxn',
            qbitwallet__pb2.RelayMessageTxnReq.SerializeToString,
            qbitwallet__pb2.RelayTxnResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RelayMessageTxnBySlave(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.WalletAPI/RelayMessageTxnBySlave',
            qbitwallet__pb2.RelayMessageTxnBySlaveReq.SerializeToString,
            qbitwallet__pb2.RelayTxnResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RelayTokenTxn(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.WalletAPI/RelayTokenTxn',
            qbitwallet__pb2.RelayTokenTxnReq.SerializeToString,
            qbitwallet__pb2.RelayTxnResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RelayTokenTxnBySlave(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.WalletAPI/RelayTokenTxnBySlave',
            qbitwallet__pb2.RelayTokenTxnBySlaveReq.SerializeToString,
            qbitwallet__pb2.RelayTxnResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RelayTransferTokenTxn(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.WalletAPI/RelayTransferTokenTxn',
            qbitwallet__pb2.RelayTransferTokenTxnReq.SerializeToString,
            qbitwallet__pb2.RelayTxnResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RelayTransferTokenTxnBySlave(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.WalletAPI/RelayTransferTokenTxnBySlave',
            qbitwallet__pb2.RelayTransferTokenTxnBySlaveReq.SerializeToString,
            qbitwallet__pb2.RelayTxnResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RelaySlaveTxn(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.WalletAPI/RelaySlaveTxn',
            qbitwallet__pb2.RelaySlaveTxnReq.SerializeToString,
            qbitwallet__pb2.RelayTxnResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RelaySlaveTxnBySlave(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.WalletAPI/RelaySlaveTxnBySlave',
            qbitwallet__pb2.RelaySlaveTxnBySlaveReq.SerializeToString,
            qbitwallet__pb2.RelayTxnResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ChangePassphrase(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.WalletAPI/ChangePassphrase',
            qbitwallet__pb2.ChangePassphraseReq.SerializeToString,
            qbitwallet__pb2.ChangePassphraseResp.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.WalletAPI/GetTransactionsByAddress',
            qbitwallet__pb2.TransactionsByAddressReq.SerializeToString,
            qbitwallet__pb2.TransactionsByAddressResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetPaginatedTransactionsByAddress(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.WalletAPI/GetPaginatedTransactionsByAddress',
            qbitwallet__pb2.PaginatedTransactionsByAddressReq.SerializeToString,
            qbitwallet__pb2.PaginatedTransactionsByAddressResp.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.WalletAPI/GetTransaction',
            qbitwallet__pb2.TransactionReq.SerializeToString,
            qbitwallet__pb2.TransactionResp.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.WalletAPI/GetBalance',
            qbitwallet__pb2.BalanceReq.SerializeToString,
            qbitwallet__pb2.BalanceResp.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.WalletAPI/GetTotalBalance',
            qbitwallet__pb2.TotalBalanceReq.SerializeToString,
            qbitwallet__pb2.TotalBalanceResp.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.WalletAPI/GetOTS',
            qbitwallet__pb2.OTSReq.SerializeToString,
            qbitwallet__pb2.OTSResp.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.WalletAPI/GetHeight',
            qbitwallet__pb2.HeightReq.SerializeToString,
            qbitwallet__pb2.HeightResp.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.WalletAPI/GetBlock',
            qbitwallet__pb2.BlockReq.SerializeToString,
            qbitwallet__pb2.BlockResp.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.WalletAPI/GetBlockByNumber',
            qbitwallet__pb2.BlockByNumberReq.SerializeToString,
            qbitwallet__pb2.BlockResp.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.WalletAPI/GetAddressFromPK',
            qbitwallet__pb2.AddressFromPKReq.SerializeToString,
            qbitwallet__pb2.AddressFromPKResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetNodeInfo(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.WalletAPI/GetNodeInfo',
            qbitwallet__pb2.NodeInfoReq.SerializeToString,
            qbitwallet__pb2.NodeInfoResp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
