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

import ccdexplorer_fundamentals.GRPCClient.types_pb2 as types__pb2


class QueriesStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetBlocks = channel.unary_stream(
            "/concordium.v2.Queries/GetBlocks",
            request_serializer=types__pb2.Empty.SerializeToString,
            response_deserializer=types__pb2.ArrivedBlockInfo.FromString,
        )
        self.GetFinalizedBlocks = channel.unary_stream(
            "/concordium.v2.Queries/GetFinalizedBlocks",
            request_serializer=types__pb2.Empty.SerializeToString,
            response_deserializer=types__pb2.FinalizedBlockInfo.FromString,
        )
        self.GetAccountInfo = channel.unary_unary(
            "/concordium.v2.Queries/GetAccountInfo",
            request_serializer=types__pb2.AccountInfoRequest.SerializeToString,
            response_deserializer=types__pb2.AccountInfo.FromString,
        )
        self.GetAccountList = channel.unary_stream(
            "/concordium.v2.Queries/GetAccountList",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.AccountAddress.FromString,
        )
        self.GetModuleList = channel.unary_stream(
            "/concordium.v2.Queries/GetModuleList",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.ModuleRef.FromString,
        )
        self.GetAncestors = channel.unary_stream(
            "/concordium.v2.Queries/GetAncestors",
            request_serializer=types__pb2.AncestorsRequest.SerializeToString,
            response_deserializer=types__pb2.BlockHash.FromString,
        )
        self.GetModuleSource = channel.unary_unary(
            "/concordium.v2.Queries/GetModuleSource",
            request_serializer=types__pb2.ModuleSourceRequest.SerializeToString,
            response_deserializer=types__pb2.VersionedModuleSource.FromString,
        )
        self.GetInstanceList = channel.unary_stream(
            "/concordium.v2.Queries/GetInstanceList",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.ContractAddress.FromString,
        )
        self.GetInstanceInfo = channel.unary_unary(
            "/concordium.v2.Queries/GetInstanceInfo",
            request_serializer=types__pb2.InstanceInfoRequest.SerializeToString,
            response_deserializer=types__pb2.InstanceInfo.FromString,
        )
        self.GetInstanceState = channel.unary_stream(
            "/concordium.v2.Queries/GetInstanceState",
            request_serializer=types__pb2.InstanceInfoRequest.SerializeToString,
            response_deserializer=types__pb2.InstanceStateKVPair.FromString,
        )
        self.InstanceStateLookup = channel.unary_unary(
            "/concordium.v2.Queries/InstanceStateLookup",
            request_serializer=types__pb2.InstanceStateLookupRequest.SerializeToString,
            response_deserializer=types__pb2.InstanceStateValueAtKey.FromString,
        )
        self.GetNextAccountSequenceNumber = channel.unary_unary(
            "/concordium.v2.Queries/GetNextAccountSequenceNumber",
            request_serializer=types__pb2.AccountAddress.SerializeToString,
            response_deserializer=types__pb2.NextAccountSequenceNumber.FromString,
        )
        self.GetConsensusInfo = channel.unary_unary(
            "/concordium.v2.Queries/GetConsensusInfo",
            request_serializer=types__pb2.Empty.SerializeToString,
            response_deserializer=types__pb2.ConsensusInfo.FromString,
        )
        self.GetBlockItemStatus = channel.unary_unary(
            "/concordium.v2.Queries/GetBlockItemStatus",
            request_serializer=types__pb2.TransactionHash.SerializeToString,
            response_deserializer=types__pb2.BlockItemStatus.FromString,
        )
        self.GetCryptographicParameters = channel.unary_unary(
            "/concordium.v2.Queries/GetCryptographicParameters",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.CryptographicParameters.FromString,
        )
        self.GetBlockInfo = channel.unary_unary(
            "/concordium.v2.Queries/GetBlockInfo",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.BlockInfo.FromString,
        )
        self.GetBakerList = channel.unary_stream(
            "/concordium.v2.Queries/GetBakerList",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.BakerId.FromString,
        )
        self.GetPoolInfo = channel.unary_unary(
            "/concordium.v2.Queries/GetPoolInfo",
            request_serializer=types__pb2.PoolInfoRequest.SerializeToString,
            response_deserializer=types__pb2.PoolInfoResponse.FromString,
        )
        self.GetPassiveDelegationInfo = channel.unary_unary(
            "/concordium.v2.Queries/GetPassiveDelegationInfo",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.PassiveDelegationInfo.FromString,
        )
        self.GetBlocksAtHeight = channel.unary_unary(
            "/concordium.v2.Queries/GetBlocksAtHeight",
            request_serializer=types__pb2.BlocksAtHeightRequest.SerializeToString,
            response_deserializer=types__pb2.BlocksAtHeightResponse.FromString,
        )
        self.GetTokenomicsInfo = channel.unary_unary(
            "/concordium.v2.Queries/GetTokenomicsInfo",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.TokenomicsInfo.FromString,
        )
        self.InvokeInstance = channel.unary_unary(
            "/concordium.v2.Queries/InvokeInstance",
            request_serializer=types__pb2.InvokeInstanceRequest.SerializeToString,
            response_deserializer=types__pb2.InvokeInstanceResponse.FromString,
        )
        self.GetPoolDelegators = channel.unary_stream(
            "/concordium.v2.Queries/GetPoolDelegators",
            request_serializer=types__pb2.GetPoolDelegatorsRequest.SerializeToString,
            response_deserializer=types__pb2.DelegatorInfo.FromString,
        )
        self.GetPoolDelegatorsRewardPeriod = channel.unary_stream(
            "/concordium.v2.Queries/GetPoolDelegatorsRewardPeriod",
            request_serializer=types__pb2.GetPoolDelegatorsRequest.SerializeToString,
            response_deserializer=types__pb2.DelegatorRewardPeriodInfo.FromString,
        )
        self.GetPassiveDelegators = channel.unary_stream(
            "/concordium.v2.Queries/GetPassiveDelegators",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.DelegatorInfo.FromString,
        )
        self.GetPassiveDelegatorsRewardPeriod = channel.unary_stream(
            "/concordium.v2.Queries/GetPassiveDelegatorsRewardPeriod",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.DelegatorRewardPeriodInfo.FromString,
        )
        self.GetBranches = channel.unary_unary(
            "/concordium.v2.Queries/GetBranches",
            request_serializer=types__pb2.Empty.SerializeToString,
            response_deserializer=types__pb2.Branch.FromString,
        )
        self.GetElectionInfo = channel.unary_unary(
            "/concordium.v2.Queries/GetElectionInfo",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.ElectionInfo.FromString,
        )
        self.GetIdentityProviders = channel.unary_stream(
            "/concordium.v2.Queries/GetIdentityProviders",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.IpInfo.FromString,
        )
        self.GetAnonymityRevokers = channel.unary_stream(
            "/concordium.v2.Queries/GetAnonymityRevokers",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.ArInfo.FromString,
        )
        self.GetAccountNonFinalizedTransactions = channel.unary_stream(
            "/concordium.v2.Queries/GetAccountNonFinalizedTransactions",
            request_serializer=types__pb2.AccountAddress.SerializeToString,
            response_deserializer=types__pb2.TransactionHash.FromString,
        )
        self.GetBlockTransactionEvents = channel.unary_stream(
            "/concordium.v2.Queries/GetBlockTransactionEvents",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.BlockItemSummary.FromString,
        )
        self.GetBlockSpecialEvents = channel.unary_stream(
            "/concordium.v2.Queries/GetBlockSpecialEvents",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.BlockSpecialEvent.FromString,
        )
        self.GetBlockPendingUpdates = channel.unary_stream(
            "/concordium.v2.Queries/GetBlockPendingUpdates",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.PendingUpdate.FromString,
        )
        self.GetNextUpdateSequenceNumbers = channel.unary_unary(
            "/concordium.v2.Queries/GetNextUpdateSequenceNumbers",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.NextUpdateSequenceNumbers.FromString,
        )
        self.GetBakerEarliestWinTime = channel.unary_unary(
            "/concordium.v2.Queries/GetBakerEarliestWinTime",
            request_serializer=types__pb2.BakerId.SerializeToString,
            response_deserializer=types__pb2.Timestamp.FromString,
        )
        self.Shutdown = channel.unary_unary(
            "/concordium.v2.Queries/Shutdown",
            request_serializer=types__pb2.Empty.SerializeToString,
            response_deserializer=types__pb2.Empty.FromString,
        )
        self.PeerConnect = channel.unary_unary(
            "/concordium.v2.Queries/PeerConnect",
            request_serializer=types__pb2.IpSocketAddress.SerializeToString,
            response_deserializer=types__pb2.Empty.FromString,
        )
        self.PeerDisconnect = channel.unary_unary(
            "/concordium.v2.Queries/PeerDisconnect",
            request_serializer=types__pb2.IpSocketAddress.SerializeToString,
            response_deserializer=types__pb2.Empty.FromString,
        )
        self.GetBannedPeers = channel.unary_unary(
            "/concordium.v2.Queries/GetBannedPeers",
            request_serializer=types__pb2.Empty.SerializeToString,
            response_deserializer=types__pb2.BannedPeers.FromString,
        )
        self.BanPeer = channel.unary_unary(
            "/concordium.v2.Queries/BanPeer",
            request_serializer=types__pb2.PeerToBan.SerializeToString,
            response_deserializer=types__pb2.Empty.FromString,
        )
        self.UnbanPeer = channel.unary_unary(
            "/concordium.v2.Queries/UnbanPeer",
            request_serializer=types__pb2.BannedPeer.SerializeToString,
            response_deserializer=types__pb2.Empty.FromString,
        )
        self.DumpStart = channel.unary_unary(
            "/concordium.v2.Queries/DumpStart",
            request_serializer=types__pb2.DumpRequest.SerializeToString,
            response_deserializer=types__pb2.Empty.FromString,
        )
        self.DumpStop = channel.unary_unary(
            "/concordium.v2.Queries/DumpStop",
            request_serializer=types__pb2.Empty.SerializeToString,
            response_deserializer=types__pb2.Empty.FromString,
        )
        self.GetPeersInfo = channel.unary_unary(
            "/concordium.v2.Queries/GetPeersInfo",
            request_serializer=types__pb2.Empty.SerializeToString,
            response_deserializer=types__pb2.PeersInfo.FromString,
        )
        self.GetNodeInfo = channel.unary_unary(
            "/concordium.v2.Queries/GetNodeInfo",
            request_serializer=types__pb2.Empty.SerializeToString,
            response_deserializer=types__pb2.NodeInfo.FromString,
        )
        self.SendBlockItem = channel.unary_unary(
            "/concordium.v2.Queries/SendBlockItem",
            request_serializer=types__pb2.SendBlockItemRequest.SerializeToString,
            response_deserializer=types__pb2.TransactionHash.FromString,
        )
        self.GetAccountTransactionSignHash = channel.unary_unary(
            "/concordium.v2.Queries/GetAccountTransactionSignHash",
            request_serializer=types__pb2.PreAccountTransaction.SerializeToString,
            response_deserializer=types__pb2.AccountTransactionSignHash.FromString,
        )
        self.GetBlockChainParameters = channel.unary_unary(
            "/concordium.v2.Queries/GetBlockChainParameters",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.ChainParameters.FromString,
        )
        self.GetBlockFinalizationSummary = channel.unary_unary(
            "/concordium.v2.Queries/GetBlockFinalizationSummary",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.BlockFinalizationSummary.FromString,
        )
        self.GetBlockItems = channel.unary_stream(
            "/concordium.v2.Queries/GetBlockItems",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.BlockItem.FromString,
        )
        self.GetBakersRewardPeriod = channel.unary_stream(
            "/concordium.v2.Queries/GetBakersRewardPeriod",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.BakerRewardPeriodInfo.FromString,
        )
        self.GetBlockCertificates = channel.unary_unary(
            "/concordium.v2.Queries/GetBlockCertificates",
            request_serializer=types__pb2.BlockHashInput.SerializeToString,
            response_deserializer=types__pb2.BlockCertificates.FromString,
        )
        self.GetWinningBakersEpoch = channel.unary_stream(
            "/concordium.v2.Queries/GetWinningBakersEpoch",
            request_serializer=types__pb2.EpochRequest.SerializeToString,
            response_deserializer=types__pb2.WinningBaker.FromString,
        )
        self.GetFirstBlockEpoch = channel.unary_unary(
            "/concordium.v2.Queries/GetFirstBlockEpoch",
            request_serializer=types__pb2.EpochRequest.SerializeToString,
            response_deserializer=types__pb2.BlockHash.FromString,
        )
        self.DryRun = channel.stream_stream(
            "/concordium.v2.Queries/DryRun",
            request_serializer=types__pb2.DryRunRequest.SerializeToString,
            response_deserializer=types__pb2.DryRunResponse.FromString,
        )


class QueriesServicer(object):
    """Missing associated documentation comment in .proto file."""

    def GetBlocks(self, request, context):
        """Return a stream of blocks that arrive from the time the query is made onward.
        This can be used to listen for incoming blocks.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetFinalizedBlocks(self, request, context):
        """Return a stream of blocks that are finalized from the time the query is
        made onward. This can be used to listen for newly finalized blocks. Note
        that there is no guarantee that blocks will not be skipped if the client is
        too slow in processing the stream, however blocks will always be sent by
        increasing block height.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetAccountInfo(self, request, context):
        """Retrieve the information about the given account in the given block."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetAccountList(self, request, context):
        """Retrieve the list of accounts that exist at the end of the given block."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetModuleList(self, request, context):
        """Get a list of all smart contract modules. The stream will end
        when all modules that exist in the state at the end of the given
        block have been returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetAncestors(self, request, context):
        """Get a stream of ancestors for the provided block.
        Starting with the provided block itself, moving backwards until no more
        ancestors or the requested number of ancestors has been returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetModuleSource(self, request, context):
        """Get the source of a smart contract module."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetInstanceList(self, request, context):
        """Get a list of addresses for all smart contract instances. The stream
        will end when all instances that exist in the state at the end of the
        given block has been returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetInstanceInfo(self, request, context):
        """Get info about a smart contract instance as it appears at the end of the
        given block.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetInstanceState(self, request, context):
        """Get the exact state of a specific contract instance, streamed as a list of
        key-value pairs. The list is streamed in lexicographic order of keys.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def InstanceStateLookup(self, request, context):
        """Get the value at a specific key of a contract state. In contrast to
        `GetInstanceState` this is more efficient, but requires the user to know
        the specific key to look for.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetNextAccountSequenceNumber(self, request, context):
        """Get the best guess as to what the next account sequence number should be.
        If all account transactions are finalized then this information is reliable.
        Otherwise this is the best guess, assuming all other transactions will be
        committed to blocks and eventually finalized.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetConsensusInfo(self, request, context):
        """Get information about the current state of consensus."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetBlockItemStatus(self, request, context):
        """Get the status of and information about a specific block item (transaction)."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetCryptographicParameters(self, request, context):
        """Get the cryptographic parameters in a given block."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetBlockInfo(self, request, context):
        """Get information, such as height, timings, and transaction counts for the given block."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetBakerList(self, request, context):
        """Get all the bakers at the end of the given block."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetPoolInfo(self, request, context):
        """Get information about a given pool at the end of a given block."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetPassiveDelegationInfo(self, request, context):
        """Get information about the passive delegators at the end of a given block."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetBlocksAtHeight(self, request, context):
        """Get a list of live blocks at a given height."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetTokenomicsInfo(self, request, context):
        """Get information about tokenomics at the end of a given block."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def InvokeInstance(self, request, context):
        """Run the smart contract entrypoint in a given context and in the state at
        the end of the given block.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetPoolDelegators(self, request, context):
        """Get the registered delegators of a given pool at the end of a given block.
        In contrast to the `GetPoolDelegatorsRewardPeriod` which returns delegators
        that are fixed for the reward period of the block, this endpoint returns the
        list of delegators that are registered in the block. Any changes to delegators
        are immediately visible in this list.
        The stream will end when all the delegators has been returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetPoolDelegatorsRewardPeriod(self, request, context):
        """Get the fixed delegators of a given pool for the reward period of the given block.
        In contracts to the `GetPoolDelegators` which returns delegators registered
        for the given block, this endpoint returns the fixed delegators contributing
        stake in the reward period containing the given block.
        The stream will end when all the delegators has been returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetPassiveDelegators(self, request, context):
        """Get the registered passive delegators at the end of a given block.
        In contrast to the `GetPassiveDelegatorsRewardPeriod` which returns delegators
        that are fixed for the reward period of the block, this endpoint returns the
        list of delegators that are registered in the block. Any changes to delegators
        are immediately visible in this list.
        The stream will end when all the delegators has been returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetPassiveDelegatorsRewardPeriod(self, request, context):
        """Get the fixed passive delegators for the reward period of the given block.
        In contracts to the `GetPassiveDelegators` which returns delegators registered
        for the given block, this endpoint returns the fixed delegators contributing
        stake in the reward period containing the given block.
        The stream will end when all the delegators has been returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetBranches(self, request, context):
        """Get the current branches of blocks starting from and including the last finalized block."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetElectionInfo(self, request, context):
        """Get information related to the baker election for a particular block."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetIdentityProviders(self, request, context):
        """Get the identity providers registered as of the end of a given block.
        The stream will end when all the identity providers have been returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetAnonymityRevokers(self, request, context):
        """Get the anonymity revokers registered as of the end of a given block.
        The stream will end when all the anonymity revokers have been returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetAccountNonFinalizedTransactions(self, request, context):
        """Get a list of non-finalized transaction hashes for a given account. This
        endpoint is not expected to return a large amount of data in most cases,
        but in bad network condtions it might. The stream will end when all the
        non-finalized transaction hashes have been returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetBlockTransactionEvents(self, request, context):
        """Get a list of transaction events in a given block.
        The stream will end when all the transaction events for a given block have been returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetBlockSpecialEvents(self, request, context):
        """Get a list of special events in a given block. These are events generated
        by the protocol, such as minting and reward payouts. They are not directly
        generated by any transaction. The stream will end when all the special
        events for a given block have been returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetBlockPendingUpdates(self, request, context):
        """Get the pending updates to chain parameters at the end of a given block.
        The stream will end when all the pending updates for a given block have been returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetNextUpdateSequenceNumbers(self, request, context):
        """Get next available sequence numbers for updating chain parameters after a given block."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetBakerEarliestWinTime(self, request, context):
        """Get the projected earliest time at which a particular baker will be required to bake a block.
        If the current consensus version is 0, this returns the status 'Unavailable', as the endpoint
        is only supported by consensus version 1.

        If the baker is not a baker for the current reward period, this returns a timestamp at the
        start of the next reward period. If the baker is a baker for the current reward period, the
        earliest win time is projected from the current round forward, assuming that each round after
        the last finalized round will take the minimum block time. (If blocks take longer, or timeouts
        occur, the actual time may be later, and the reported time in subsequent queries may reflect
        this.) At the end of an epoch (or if the baker is not projected to bake before the end of the
        epoch) the earliest win time for a (current) baker will be projected as the start of the next
        epoch. This is because the seed for the leader election is updated at the epoch boundary, and
        so the winners cannot be predicted beyond that. Note that in some circumstances the returned
        timestamp can be in the past, especially at the end of an epoch.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def Shutdown(self, request, context):
        """Shut down the node.
        Return a GRPC error if the shutdown failed.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def PeerConnect(self, request, context):
        """Suggest to a peer to connect to the submitted peer details.
        This, if successful, adds the peer to the list of given addresses.
        Otherwise return a GRPC error.
        Note. The peer might not be connected to instantly, in that case
        the node will try to establish the connection in near future. This
        function returns a GRPC status 'Ok' in this case.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def PeerDisconnect(self, request, context):
        """Disconnect from the peer and remove them from the given addresses list
        if they are on it. Return if the request was processed successfully.
        Otherwise return a GRPC error.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetBannedPeers(self, request, context):
        """Get a list of banned peers."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def BanPeer(self, request, context):
        """Ban the given peer.
        Returns a GRPC error if the action failed.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def UnbanPeer(self, request, context):
        """Unban the banned peer.
        Returns a GRPC error if the action failed.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DumpStart(self, request, context):
        """Start dumping packages into the specified file.
        Only enabled if the node was built with the `network_dump` feature.
        Returns a GRPC error if the network dump failed to start.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DumpStop(self, request, context):
        """Stop dumping packages.
        Only enabled if the node was built with the `network_dump` feature.
        Returns a GRPC error if the network dump failed to be stopped.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetPeersInfo(self, request, context):
        """/ Get a list of the peers that the node is connected to
        / and assoicated network related information for each peer.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetNodeInfo(self, request, context):
        """Get information about the node.
        The `NodeInfo` includes information of
        * Meta information such as the, version of the node, type of the node, uptime and the local time of the node.
        * NetworkInfo which yields data such as the node id, packets sent/received,
        average bytes per second sent/received.
        * ConsensusInfo. The `ConsensusInfo` returned depends on if the node supports
        the protocol on chain and whether the node is configured as a baker or not.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def SendBlockItem(self, request, context):
        """Send a block item. A block item is either an `AccountTransaction`, which is
        a transaction signed and paid for by an account, a `CredentialDeployment`,
        which creates a new account, or `UpdateInstruction`, which is an
        instruction to change some parameters of the chain. Update instructions can
        only be sent by the governance committee.

        Returns a hash of the block item, which can be used with
        `GetBlockItemStatus`.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetAccountTransactionSignHash(self, request, context):
        """Get the hash to be signed for an account transaction. The hash returned
        should be signed and the signatures included as an
        AccountTransactionSignature when calling `SendBlockItem`. This is provided as
        a convenience to support cases where the right SDK is not available for
        interacting with the node. If an SDK is available then it is strongly
        recommended to compute this hash off-line using it. That reduces the trust
        in the node, removes networking failure modes, and will perform better.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetBlockChainParameters(self, request, context):
        """Get the values of chain parameters in effect in the given block."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetBlockFinalizationSummary(self, request, context):
        """Get the summary of the finalization data in a given block."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetBlockItems(self, request, context):
        """Get the items of a block."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetBakersRewardPeriod(self, request, context):
        """Get all bakers in the reward period of a block.
        This endpoint is only supported for protocol version 6 and onwards.
        If the protocol does not support the endpoint then an  'IllegalArgument' error is returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetBlockCertificates(self, request, context):
        """For a non-genesis block, this returns the quorum certificate, a timeout
        certificate (if present) and epoch finalization entry (if present).
        Note that, if the block being pointed to is not a product of ConcordiumBFT,
        then the response will be a grpc error (invalid argument).
        If the endpoint is not enabled by the node, then an 'unimplemented' error
        will be returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetWinningBakersEpoch(self, request, context):
        """Get the list of bakers that won the lottery in a particular historical epoch (i.e. the
        last finalized block is in a later epoch). This lists the winners for each round in the
        epoch, starting from the round after the last block in the previous epoch, running to
        the round before the first block in the next epoch. It also indicates if a block in each
        round was included in the finalized chain.

        The following error cases are possible:
        * `NOT_FOUND` if the query specifies an unknown block.
        * `UNAVAILABLE` if the query is for an epoch that is not finalized in the current genesis
        /    index, or is for a future genesis index.
        * `INVALID_ARGUMENT` if the query is for an epoch that is not finalized for a past genesis
        index.
        * `INVALID_ARGUMENT` if the query is for a genesis index at consensus version 0.
        * `INVALID_ARGUMENT` if the input `EpochRequest` is malformed.
        * `UNIMPLEMENTED` if the endpoint is disabled on the node.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetFirstBlockEpoch(self, request, context):
        """Get the block hash of the first finalized block in a specified epoch.

        The following error cases are possible:
        * `NOT_FOUND` if the query specifies an unknown block.
        * `UNAVAILABLE` if the query is for an epoch that is not finalized in the current genesis
        index, or is for a future genesis index.
        * `INVALID_ARGUMENT` if the query is for an epoch with no finalized blocks for a past genesis
        index.
        * `INVALID_ARGUMENT` if the input `EpochRequest` is malformed.
        * `UNIMPLEMENTED` if the endpoint is disabled on the node.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DryRun(self, request_iterator, context):
        """Dry run a series of transactions and operations on a state derived from a specified block.
        The server should send a single `DryRunResponse` for each `DryRunRequest` received, unless
        the call fails with an error status code. If a request produces a `DryRunErrorResponse`, then
        the server will still process subsequent requests, just as if the request causing the error
        did not happen.

        The first request should be `load_block_at_state` to determine the block state that will be
        used for the dry run.

        The server associates each request with an energy cost, and limits the total energy that may
        be expended in a single invocation of `DryRun`. This limit is reported as `quota` in the
        initial metadata returned by the server. If executing an operation exceeds the limit,
        the server terminates the session with `RESOURCE_EXHAUSTED`.

        The server also imposes a timeout for a dry-run session to complete. The server reports
        the timeout duration in milliseconds in the initial metadata field `timeout`. If the session
        is not completed before the timeout elapses, the server terminates the session with
        `DEADLINE_EXCEEDED`.

        The following error cases are possible:
        * `INVALID_ARGUMENT` if any `DryRunRequest` is malformed.
        * `RESOURCE_EXHAUSTED` if the energy quota is exceeded.
        * `DEADLINE_EXCEEDED` if the session does not complete before the server-imposed timeout.
        * `RESOURCE_EXHAUSTED` if the server is not currently accepting new `DryRun` sessions.
        (The server may impose a limit on the number of concurrent sessions.)
        * `INTERNAL` if an interal server error occurs. This should not happen, and likely indicates
        a bug.
        * `UNIMPLEMENTED` if the endpoint is disabled on the node.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")


def add_QueriesServicer_to_server(servicer, server):
    rpc_method_handlers = {
        "GetBlocks": grpc.unary_stream_rpc_method_handler(
            servicer.GetBlocks,
            request_deserializer=types__pb2.Empty.FromString,
            response_serializer=types__pb2.ArrivedBlockInfo.SerializeToString,
        ),
        "GetFinalizedBlocks": grpc.unary_stream_rpc_method_handler(
            servicer.GetFinalizedBlocks,
            request_deserializer=types__pb2.Empty.FromString,
            response_serializer=types__pb2.FinalizedBlockInfo.SerializeToString,
        ),
        "GetAccountInfo": grpc.unary_unary_rpc_method_handler(
            servicer.GetAccountInfo,
            request_deserializer=types__pb2.AccountInfoRequest.FromString,
            response_serializer=types__pb2.AccountInfo.SerializeToString,
        ),
        "GetAccountList": grpc.unary_stream_rpc_method_handler(
            servicer.GetAccountList,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.AccountAddress.SerializeToString,
        ),
        "GetModuleList": grpc.unary_stream_rpc_method_handler(
            servicer.GetModuleList,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.ModuleRef.SerializeToString,
        ),
        "GetAncestors": grpc.unary_stream_rpc_method_handler(
            servicer.GetAncestors,
            request_deserializer=types__pb2.AncestorsRequest.FromString,
            response_serializer=types__pb2.BlockHash.SerializeToString,
        ),
        "GetModuleSource": grpc.unary_unary_rpc_method_handler(
            servicer.GetModuleSource,
            request_deserializer=types__pb2.ModuleSourceRequest.FromString,
            response_serializer=types__pb2.VersionedModuleSource.SerializeToString,
        ),
        "GetInstanceList": grpc.unary_stream_rpc_method_handler(
            servicer.GetInstanceList,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.ContractAddress.SerializeToString,
        ),
        "GetInstanceInfo": grpc.unary_unary_rpc_method_handler(
            servicer.GetInstanceInfo,
            request_deserializer=types__pb2.InstanceInfoRequest.FromString,
            response_serializer=types__pb2.InstanceInfo.SerializeToString,
        ),
        "GetInstanceState": grpc.unary_stream_rpc_method_handler(
            servicer.GetInstanceState,
            request_deserializer=types__pb2.InstanceInfoRequest.FromString,
            response_serializer=types__pb2.InstanceStateKVPair.SerializeToString,
        ),
        "InstanceStateLookup": grpc.unary_unary_rpc_method_handler(
            servicer.InstanceStateLookup,
            request_deserializer=types__pb2.InstanceStateLookupRequest.FromString,
            response_serializer=types__pb2.InstanceStateValueAtKey.SerializeToString,
        ),
        "GetNextAccountSequenceNumber": grpc.unary_unary_rpc_method_handler(
            servicer.GetNextAccountSequenceNumber,
            request_deserializer=types__pb2.AccountAddress.FromString,
            response_serializer=types__pb2.NextAccountSequenceNumber.SerializeToString,
        ),
        "GetConsensusInfo": grpc.unary_unary_rpc_method_handler(
            servicer.GetConsensusInfo,
            request_deserializer=types__pb2.Empty.FromString,
            response_serializer=types__pb2.ConsensusInfo.SerializeToString,
        ),
        "GetBlockItemStatus": grpc.unary_unary_rpc_method_handler(
            servicer.GetBlockItemStatus,
            request_deserializer=types__pb2.TransactionHash.FromString,
            response_serializer=types__pb2.BlockItemStatus.SerializeToString,
        ),
        "GetCryptographicParameters": grpc.unary_unary_rpc_method_handler(
            servicer.GetCryptographicParameters,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.CryptographicParameters.SerializeToString,
        ),
        "GetBlockInfo": grpc.unary_unary_rpc_method_handler(
            servicer.GetBlockInfo,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.BlockInfo.SerializeToString,
        ),
        "GetBakerList": grpc.unary_stream_rpc_method_handler(
            servicer.GetBakerList,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.BakerId.SerializeToString,
        ),
        "GetPoolInfo": grpc.unary_unary_rpc_method_handler(
            servicer.GetPoolInfo,
            request_deserializer=types__pb2.PoolInfoRequest.FromString,
            response_serializer=types__pb2.PoolInfoResponse.SerializeToString,
        ),
        "GetPassiveDelegationInfo": grpc.unary_unary_rpc_method_handler(
            servicer.GetPassiveDelegationInfo,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.PassiveDelegationInfo.SerializeToString,
        ),
        "GetBlocksAtHeight": grpc.unary_unary_rpc_method_handler(
            servicer.GetBlocksAtHeight,
            request_deserializer=types__pb2.BlocksAtHeightRequest.FromString,
            response_serializer=types__pb2.BlocksAtHeightResponse.SerializeToString,
        ),
        "GetTokenomicsInfo": grpc.unary_unary_rpc_method_handler(
            servicer.GetTokenomicsInfo,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.TokenomicsInfo.SerializeToString,
        ),
        "InvokeInstance": grpc.unary_unary_rpc_method_handler(
            servicer.InvokeInstance,
            request_deserializer=types__pb2.InvokeInstanceRequest.FromString,
            response_serializer=types__pb2.InvokeInstanceResponse.SerializeToString,
        ),
        "GetPoolDelegators": grpc.unary_stream_rpc_method_handler(
            servicer.GetPoolDelegators,
            request_deserializer=types__pb2.GetPoolDelegatorsRequest.FromString,
            response_serializer=types__pb2.DelegatorInfo.SerializeToString,
        ),
        "GetPoolDelegatorsRewardPeriod": grpc.unary_stream_rpc_method_handler(
            servicer.GetPoolDelegatorsRewardPeriod,
            request_deserializer=types__pb2.GetPoolDelegatorsRequest.FromString,
            response_serializer=types__pb2.DelegatorRewardPeriodInfo.SerializeToString,
        ),
        "GetPassiveDelegators": grpc.unary_stream_rpc_method_handler(
            servicer.GetPassiveDelegators,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.DelegatorInfo.SerializeToString,
        ),
        "GetPassiveDelegatorsRewardPeriod": grpc.unary_stream_rpc_method_handler(
            servicer.GetPassiveDelegatorsRewardPeriod,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.DelegatorRewardPeriodInfo.SerializeToString,
        ),
        "GetBranches": grpc.unary_unary_rpc_method_handler(
            servicer.GetBranches,
            request_deserializer=types__pb2.Empty.FromString,
            response_serializer=types__pb2.Branch.SerializeToString,
        ),
        "GetElectionInfo": grpc.unary_unary_rpc_method_handler(
            servicer.GetElectionInfo,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.ElectionInfo.SerializeToString,
        ),
        "GetIdentityProviders": grpc.unary_stream_rpc_method_handler(
            servicer.GetIdentityProviders,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.IpInfo.SerializeToString,
        ),
        "GetAnonymityRevokers": grpc.unary_stream_rpc_method_handler(
            servicer.GetAnonymityRevokers,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.ArInfo.SerializeToString,
        ),
        "GetAccountNonFinalizedTransactions": grpc.unary_stream_rpc_method_handler(
            servicer.GetAccountNonFinalizedTransactions,
            request_deserializer=types__pb2.AccountAddress.FromString,
            response_serializer=types__pb2.TransactionHash.SerializeToString,
        ),
        "GetBlockTransactionEvents": grpc.unary_stream_rpc_method_handler(
            servicer.GetBlockTransactionEvents,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.BlockItemSummary.SerializeToString,
        ),
        "GetBlockSpecialEvents": grpc.unary_stream_rpc_method_handler(
            servicer.GetBlockSpecialEvents,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.BlockSpecialEvent.SerializeToString,
        ),
        "GetBlockPendingUpdates": grpc.unary_stream_rpc_method_handler(
            servicer.GetBlockPendingUpdates,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.PendingUpdate.SerializeToString,
        ),
        "GetNextUpdateSequenceNumbers": grpc.unary_unary_rpc_method_handler(
            servicer.GetNextUpdateSequenceNumbers,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.NextUpdateSequenceNumbers.SerializeToString,
        ),
        "GetBakerEarliestWinTime": grpc.unary_unary_rpc_method_handler(
            servicer.GetBakerEarliestWinTime,
            request_deserializer=types__pb2.BakerId.FromString,
            response_serializer=types__pb2.Timestamp.SerializeToString,
        ),
        "Shutdown": grpc.unary_unary_rpc_method_handler(
            servicer.Shutdown,
            request_deserializer=types__pb2.Empty.FromString,
            response_serializer=types__pb2.Empty.SerializeToString,
        ),
        "PeerConnect": grpc.unary_unary_rpc_method_handler(
            servicer.PeerConnect,
            request_deserializer=types__pb2.IpSocketAddress.FromString,
            response_serializer=types__pb2.Empty.SerializeToString,
        ),
        "PeerDisconnect": grpc.unary_unary_rpc_method_handler(
            servicer.PeerDisconnect,
            request_deserializer=types__pb2.IpSocketAddress.FromString,
            response_serializer=types__pb2.Empty.SerializeToString,
        ),
        "GetBannedPeers": grpc.unary_unary_rpc_method_handler(
            servicer.GetBannedPeers,
            request_deserializer=types__pb2.Empty.FromString,
            response_serializer=types__pb2.BannedPeers.SerializeToString,
        ),
        "BanPeer": grpc.unary_unary_rpc_method_handler(
            servicer.BanPeer,
            request_deserializer=types__pb2.PeerToBan.FromString,
            response_serializer=types__pb2.Empty.SerializeToString,
        ),
        "UnbanPeer": grpc.unary_unary_rpc_method_handler(
            servicer.UnbanPeer,
            request_deserializer=types__pb2.BannedPeer.FromString,
            response_serializer=types__pb2.Empty.SerializeToString,
        ),
        "DumpStart": grpc.unary_unary_rpc_method_handler(
            servicer.DumpStart,
            request_deserializer=types__pb2.DumpRequest.FromString,
            response_serializer=types__pb2.Empty.SerializeToString,
        ),
        "DumpStop": grpc.unary_unary_rpc_method_handler(
            servicer.DumpStop,
            request_deserializer=types__pb2.Empty.FromString,
            response_serializer=types__pb2.Empty.SerializeToString,
        ),
        "GetPeersInfo": grpc.unary_unary_rpc_method_handler(
            servicer.GetPeersInfo,
            request_deserializer=types__pb2.Empty.FromString,
            response_serializer=types__pb2.PeersInfo.SerializeToString,
        ),
        "GetNodeInfo": grpc.unary_unary_rpc_method_handler(
            servicer.GetNodeInfo,
            request_deserializer=types__pb2.Empty.FromString,
            response_serializer=types__pb2.NodeInfo.SerializeToString,
        ),
        "SendBlockItem": grpc.unary_unary_rpc_method_handler(
            servicer.SendBlockItem,
            request_deserializer=types__pb2.SendBlockItemRequest.FromString,
            response_serializer=types__pb2.TransactionHash.SerializeToString,
        ),
        "GetAccountTransactionSignHash": grpc.unary_unary_rpc_method_handler(
            servicer.GetAccountTransactionSignHash,
            request_deserializer=types__pb2.PreAccountTransaction.FromString,
            response_serializer=types__pb2.AccountTransactionSignHash.SerializeToString,
        ),
        "GetBlockChainParameters": grpc.unary_unary_rpc_method_handler(
            servicer.GetBlockChainParameters,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.ChainParameters.SerializeToString,
        ),
        "GetBlockFinalizationSummary": grpc.unary_unary_rpc_method_handler(
            servicer.GetBlockFinalizationSummary,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.BlockFinalizationSummary.SerializeToString,
        ),
        "GetBlockItems": grpc.unary_stream_rpc_method_handler(
            servicer.GetBlockItems,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.BlockItem.SerializeToString,
        ),
        "GetBakersRewardPeriod": grpc.unary_stream_rpc_method_handler(
            servicer.GetBakersRewardPeriod,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.BakerRewardPeriodInfo.SerializeToString,
        ),
        "GetBlockCertificates": grpc.unary_unary_rpc_method_handler(
            servicer.GetBlockCertificates,
            request_deserializer=types__pb2.BlockHashInput.FromString,
            response_serializer=types__pb2.BlockCertificates.SerializeToString,
        ),
        "GetWinningBakersEpoch": grpc.unary_stream_rpc_method_handler(
            servicer.GetWinningBakersEpoch,
            request_deserializer=types__pb2.EpochRequest.FromString,
            response_serializer=types__pb2.WinningBaker.SerializeToString,
        ),
        "GetFirstBlockEpoch": grpc.unary_unary_rpc_method_handler(
            servicer.GetFirstBlockEpoch,
            request_deserializer=types__pb2.EpochRequest.FromString,
            response_serializer=types__pb2.BlockHash.SerializeToString,
        ),
        "DryRun": grpc.stream_stream_rpc_method_handler(
            servicer.DryRun,
            request_deserializer=types__pb2.DryRunRequest.FromString,
            response_serializer=types__pb2.DryRunResponse.SerializeToString,
        ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
        "concordium.v2.Queries", rpc_method_handlers
    )
    server.add_generic_rpc_handlers((generic_handler,))


# This class is part of an EXPERIMENTAL API.
class Queries(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def GetBlocks(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetBlocks",
            types__pb2.Empty.SerializeToString,
            types__pb2.ArrivedBlockInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetFinalizedBlocks(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetFinalizedBlocks",
            types__pb2.Empty.SerializeToString,
            types__pb2.FinalizedBlockInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetAccountInfo(
        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,
            "/concordium.v2.Queries/GetAccountInfo",
            types__pb2.AccountInfoRequest.SerializeToString,
            types__pb2.AccountInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetAccountList(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetAccountList",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.AccountAddress.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetModuleList(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetModuleList",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.ModuleRef.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetAncestors(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetAncestors",
            types__pb2.AncestorsRequest.SerializeToString,
            types__pb2.BlockHash.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetModuleSource(
        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,
            "/concordium.v2.Queries/GetModuleSource",
            types__pb2.ModuleSourceRequest.SerializeToString,
            types__pb2.VersionedModuleSource.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetInstanceList(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetInstanceList",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.ContractAddress.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetInstanceInfo(
        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,
            "/concordium.v2.Queries/GetInstanceInfo",
            types__pb2.InstanceInfoRequest.SerializeToString,
            types__pb2.InstanceInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetInstanceState(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetInstanceState",
            types__pb2.InstanceInfoRequest.SerializeToString,
            types__pb2.InstanceStateKVPair.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def InstanceStateLookup(
        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,
            "/concordium.v2.Queries/InstanceStateLookup",
            types__pb2.InstanceStateLookupRequest.SerializeToString,
            types__pb2.InstanceStateValueAtKey.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetNextAccountSequenceNumber(
        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,
            "/concordium.v2.Queries/GetNextAccountSequenceNumber",
            types__pb2.AccountAddress.SerializeToString,
            types__pb2.NextAccountSequenceNumber.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetConsensusInfo(
        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,
            "/concordium.v2.Queries/GetConsensusInfo",
            types__pb2.Empty.SerializeToString,
            types__pb2.ConsensusInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetBlockItemStatus(
        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,
            "/concordium.v2.Queries/GetBlockItemStatus",
            types__pb2.TransactionHash.SerializeToString,
            types__pb2.BlockItemStatus.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetCryptographicParameters(
        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,
            "/concordium.v2.Queries/GetCryptographicParameters",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.CryptographicParameters.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetBlockInfo(
        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,
            "/concordium.v2.Queries/GetBlockInfo",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.BlockInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetBakerList(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetBakerList",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.BakerId.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetPoolInfo(
        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,
            "/concordium.v2.Queries/GetPoolInfo",
            types__pb2.PoolInfoRequest.SerializeToString,
            types__pb2.PoolInfoResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetPassiveDelegationInfo(
        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,
            "/concordium.v2.Queries/GetPassiveDelegationInfo",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.PassiveDelegationInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetBlocksAtHeight(
        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,
            "/concordium.v2.Queries/GetBlocksAtHeight",
            types__pb2.BlocksAtHeightRequest.SerializeToString,
            types__pb2.BlocksAtHeightResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetTokenomicsInfo(
        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,
            "/concordium.v2.Queries/GetTokenomicsInfo",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.TokenomicsInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def InvokeInstance(
        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,
            "/concordium.v2.Queries/InvokeInstance",
            types__pb2.InvokeInstanceRequest.SerializeToString,
            types__pb2.InvokeInstanceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetPoolDelegators(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetPoolDelegators",
            types__pb2.GetPoolDelegatorsRequest.SerializeToString,
            types__pb2.DelegatorInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetPoolDelegatorsRewardPeriod(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetPoolDelegatorsRewardPeriod",
            types__pb2.GetPoolDelegatorsRequest.SerializeToString,
            types__pb2.DelegatorRewardPeriodInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetPassiveDelegators(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetPassiveDelegators",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.DelegatorInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetPassiveDelegatorsRewardPeriod(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetPassiveDelegatorsRewardPeriod",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.DelegatorRewardPeriodInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetBranches(
        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,
            "/concordium.v2.Queries/GetBranches",
            types__pb2.Empty.SerializeToString,
            types__pb2.Branch.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetElectionInfo(
        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,
            "/concordium.v2.Queries/GetElectionInfo",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.ElectionInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetIdentityProviders(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetIdentityProviders",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.IpInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetAnonymityRevokers(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetAnonymityRevokers",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.ArInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetAccountNonFinalizedTransactions(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetAccountNonFinalizedTransactions",
            types__pb2.AccountAddress.SerializeToString,
            types__pb2.TransactionHash.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetBlockTransactionEvents(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetBlockTransactionEvents",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.BlockItemSummary.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetBlockSpecialEvents(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetBlockSpecialEvents",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.BlockSpecialEvent.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetBlockPendingUpdates(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetBlockPendingUpdates",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.PendingUpdate.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetNextUpdateSequenceNumbers(
        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,
            "/concordium.v2.Queries/GetNextUpdateSequenceNumbers",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.NextUpdateSequenceNumbers.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetBakerEarliestWinTime(
        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,
            "/concordium.v2.Queries/GetBakerEarliestWinTime",
            types__pb2.BakerId.SerializeToString,
            types__pb2.Timestamp.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def Shutdown(
        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,
            "/concordium.v2.Queries/Shutdown",
            types__pb2.Empty.SerializeToString,
            types__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def PeerConnect(
        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,
            "/concordium.v2.Queries/PeerConnect",
            types__pb2.IpSocketAddress.SerializeToString,
            types__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def PeerDisconnect(
        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,
            "/concordium.v2.Queries/PeerDisconnect",
            types__pb2.IpSocketAddress.SerializeToString,
            types__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetBannedPeers(
        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,
            "/concordium.v2.Queries/GetBannedPeers",
            types__pb2.Empty.SerializeToString,
            types__pb2.BannedPeers.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def BanPeer(
        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,
            "/concordium.v2.Queries/BanPeer",
            types__pb2.PeerToBan.SerializeToString,
            types__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def UnbanPeer(
        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,
            "/concordium.v2.Queries/UnbanPeer",
            types__pb2.BannedPeer.SerializeToString,
            types__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DumpStart(
        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,
            "/concordium.v2.Queries/DumpStart",
            types__pb2.DumpRequest.SerializeToString,
            types__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DumpStop(
        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,
            "/concordium.v2.Queries/DumpStop",
            types__pb2.Empty.SerializeToString,
            types__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetPeersInfo(
        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,
            "/concordium.v2.Queries/GetPeersInfo",
            types__pb2.Empty.SerializeToString,
            types__pb2.PeersInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @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,
            "/concordium.v2.Queries/GetNodeInfo",
            types__pb2.Empty.SerializeToString,
            types__pb2.NodeInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def SendBlockItem(
        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,
            "/concordium.v2.Queries/SendBlockItem",
            types__pb2.SendBlockItemRequest.SerializeToString,
            types__pb2.TransactionHash.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetAccountTransactionSignHash(
        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,
            "/concordium.v2.Queries/GetAccountTransactionSignHash",
            types__pb2.PreAccountTransaction.SerializeToString,
            types__pb2.AccountTransactionSignHash.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetBlockChainParameters(
        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,
            "/concordium.v2.Queries/GetBlockChainParameters",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.ChainParameters.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetBlockFinalizationSummary(
        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,
            "/concordium.v2.Queries/GetBlockFinalizationSummary",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.BlockFinalizationSummary.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetBlockItems(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetBlockItems",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.BlockItem.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetBakersRewardPeriod(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetBakersRewardPeriod",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.BakerRewardPeriodInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetBlockCertificates(
        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,
            "/concordium.v2.Queries/GetBlockCertificates",
            types__pb2.BlockHashInput.SerializeToString,
            types__pb2.BlockCertificates.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetWinningBakersEpoch(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_stream(
            request,
            target,
            "/concordium.v2.Queries/GetWinningBakersEpoch",
            types__pb2.EpochRequest.SerializeToString,
            types__pb2.WinningBaker.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetFirstBlockEpoch(
        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,
            "/concordium.v2.Queries/GetFirstBlockEpoch",
            types__pb2.EpochRequest.SerializeToString,
            types__pb2.BlockHash.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DryRun(
        request_iterator,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.stream_stream(
            request_iterator,
            target,
            "/concordium.v2.Queries/DryRun",
            types__pb2.DryRunRequest.SerializeToString,
            types__pb2.DryRunResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )
