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

from ...api.v2 import (
    trading_data_pb2 as data__node_dot_api_dot_v2_dot_trading__data__pb2,
)
from google.api import httpbody_pb2 as google_dot_api_dot_httpbody__pb2


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.ListAccounts = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListAccounts",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAccountsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAccountsResponse.FromString,
        )
        self.ObserveAccounts = channel.unary_stream(
            "/datanode.api.v2.TradingDataService/ObserveAccounts",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveAccountsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveAccountsResponse.FromString,
        )
        self.Info = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/Info",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.InfoRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.InfoResponse.FromString,
        )
        self.GetOrder = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetOrder",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetOrderRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetOrderResponse.FromString,
        )
        self.ListOrders = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListOrders",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOrdersRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOrdersResponse.FromString,
        )
        self.ListOrderVersions = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListOrderVersions",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOrderVersionsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOrderVersionsResponse.FromString,
        )
        self.ObserveOrders = channel.unary_stream(
            "/datanode.api.v2.TradingDataService/ObserveOrders",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveOrdersRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveOrdersResponse.FromString,
        )
        self.GetStopOrder = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetStopOrder",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetStopOrderRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetStopOrderResponse.FromString,
        )
        self.ListStopOrders = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListStopOrders",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListStopOrdersRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListStopOrdersResponse.FromString,
        )
        self.ListPositions = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListPositions",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListPositionsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListPositionsResponse.FromString,
        )
        self.ListAllPositions = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListAllPositions",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAllPositionsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAllPositionsResponse.FromString,
        )
        self.ObservePositions = channel.unary_stream(
            "/datanode.api.v2.TradingDataService/ObservePositions",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObservePositionsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObservePositionsResponse.FromString,
        )
        self.ListLedgerEntries = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListLedgerEntries",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListLedgerEntriesRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListLedgerEntriesResponse.FromString,
        )
        self.ExportLedgerEntries = channel.unary_stream(
            "/datanode.api.v2.TradingDataService/ExportLedgerEntries",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ExportLedgerEntriesRequest.SerializeToString,
            response_deserializer=google_dot_api_dot_httpbody__pb2.HttpBody.FromString,
        )
        self.ListBalanceChanges = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListBalanceChanges",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListBalanceChangesRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListBalanceChangesResponse.FromString,
        )
        self.GetLatestMarketData = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetLatestMarketData",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetLatestMarketDataRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetLatestMarketDataResponse.FromString,
        )
        self.ListLatestMarketData = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListLatestMarketData",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListLatestMarketDataRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListLatestMarketDataResponse.FromString,
        )
        self.GetLatestMarketDepth = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetLatestMarketDepth",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetLatestMarketDepthRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetLatestMarketDepthResponse.FromString,
        )
        self.ObserveMarketsDepth = channel.unary_stream(
            "/datanode.api.v2.TradingDataService/ObserveMarketsDepth",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarketsDepthRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarketsDepthResponse.FromString,
        )
        self.ObserveMarketsDepthUpdates = channel.unary_stream(
            "/datanode.api.v2.TradingDataService/ObserveMarketsDepthUpdates",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarketsDepthUpdatesRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarketsDepthUpdatesResponse.FromString,
        )
        self.ObserveMarketsData = channel.unary_stream(
            "/datanode.api.v2.TradingDataService/ObserveMarketsData",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarketsDataRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarketsDataResponse.FromString,
        )
        self.GetMarketDataHistoryByID = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetMarketDataHistoryByID",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetMarketDataHistoryByIDRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetMarketDataHistoryByIDResponse.FromString,
        )
        self.ListTransfers = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListTransfers",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListTransfersRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListTransfersResponse.FromString,
        )
        self.GetNetworkLimits = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetNetworkLimits",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkLimitsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkLimitsResponse.FromString,
        )
        self.ListCandleData = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListCandleData",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCandleDataRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCandleDataResponse.FromString,
        )
        self.ObserveCandleData = channel.unary_stream(
            "/datanode.api.v2.TradingDataService/ObserveCandleData",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveCandleDataRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveCandleDataResponse.FromString,
        )
        self.ListCandleIntervals = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListCandleIntervals",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCandleIntervalsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCandleIntervalsResponse.FromString,
        )
        self.ListVotes = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListVotes",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListVotesRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListVotesResponse.FromString,
        )
        self.ObserveVotes = channel.unary_stream(
            "/datanode.api.v2.TradingDataService/ObserveVotes",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveVotesRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveVotesResponse.FromString,
        )
        self.ListERC20MultiSigSignerAddedBundles = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListERC20MultiSigSignerAddedBundles",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListERC20MultiSigSignerAddedBundlesRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListERC20MultiSigSignerAddedBundlesResponse.FromString,
        )
        self.ListERC20MultiSigSignerRemovedBundles = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListERC20MultiSigSignerRemovedBundles",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListERC20MultiSigSignerRemovedBundlesRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListERC20MultiSigSignerRemovedBundlesResponse.FromString,
        )
        self.GetERC20ListAssetBundle = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetERC20ListAssetBundle",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetERC20ListAssetBundleRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetERC20ListAssetBundleResponse.FromString,
        )
        self.GetERC20SetAssetLimitsBundle = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetERC20SetAssetLimitsBundle",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetERC20SetAssetLimitsBundleRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetERC20SetAssetLimitsBundleResponse.FromString,
        )
        self.GetERC20WithdrawalApproval = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetERC20WithdrawalApproval",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetERC20WithdrawalApprovalRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetERC20WithdrawalApprovalResponse.FromString,
        )
        self.GetLastTrade = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetLastTrade",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetLastTradeRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetLastTradeResponse.FromString,
        )
        self.ListTrades = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListTrades",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListTradesRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListTradesResponse.FromString,
        )
        self.ObserveTrades = channel.unary_stream(
            "/datanode.api.v2.TradingDataService/ObserveTrades",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveTradesRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveTradesResponse.FromString,
        )
        self.GetOracleSpec = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetOracleSpec",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetOracleSpecRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetOracleSpecResponse.FromString,
        )
        self.ListOracleSpecs = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListOracleSpecs",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOracleSpecsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOracleSpecsResponse.FromString,
        )
        self.ListOracleData = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListOracleData",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOracleDataRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOracleDataResponse.FromString,
        )
        self.GetMarket = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetMarket",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetMarketRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetMarketResponse.FromString,
        )
        self.ListMarkets = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListMarkets",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListMarketsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListMarketsResponse.FromString,
        )
        self.ListSuccessorMarkets = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListSuccessorMarkets",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListSuccessorMarketsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListSuccessorMarketsResponse.FromString,
        )
        self.GetParty = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetParty",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetPartyRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetPartyResponse.FromString,
        )
        self.ListParties = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListParties",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListPartiesRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListPartiesResponse.FromString,
        )
        self.ListMarginLevels = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListMarginLevels",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListMarginLevelsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListMarginLevelsResponse.FromString,
        )
        self.ObserveMarginLevels = channel.unary_stream(
            "/datanode.api.v2.TradingDataService/ObserveMarginLevels",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarginLevelsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarginLevelsResponse.FromString,
        )
        self.ListRewards = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListRewards",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListRewardsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListRewardsResponse.FromString,
        )
        self.ListRewardSummaries = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListRewardSummaries",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListRewardSummariesRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListRewardSummariesResponse.FromString,
        )
        self.ListEpochRewardSummaries = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListEpochRewardSummaries",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListEpochRewardSummariesRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListEpochRewardSummariesResponse.FromString,
        )
        self.GetDeposit = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetDeposit",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetDepositRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetDepositResponse.FromString,
        )
        self.ListDeposits = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListDeposits",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListDepositsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListDepositsResponse.FromString,
        )
        self.GetWithdrawal = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetWithdrawal",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetWithdrawalRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetWithdrawalResponse.FromString,
        )
        self.ListWithdrawals = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListWithdrawals",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListWithdrawalsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListWithdrawalsResponse.FromString,
        )
        self.GetAsset = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetAsset",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetAssetRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetAssetResponse.FromString,
        )
        self.ListAssets = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListAssets",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAssetsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAssetsResponse.FromString,
        )
        self.ListLiquidityProvisions = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListLiquidityProvisions",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListLiquidityProvisionsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListLiquidityProvisionsResponse.FromString,
        )
        self.ObserveLiquidityProvisions = channel.unary_stream(
            "/datanode.api.v2.TradingDataService/ObserveLiquidityProvisions",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveLiquidityProvisionsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveLiquidityProvisionsResponse.FromString,
        )
        self.GetGovernanceData = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetGovernanceData",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetGovernanceDataRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetGovernanceDataResponse.FromString,
        )
        self.ListGovernanceData = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListGovernanceData",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListGovernanceDataRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListGovernanceDataResponse.FromString,
        )
        self.ObserveGovernance = channel.unary_stream(
            "/datanode.api.v2.TradingDataService/ObserveGovernance",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveGovernanceRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveGovernanceResponse.FromString,
        )
        self.ListDelegations = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListDelegations",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListDelegationsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListDelegationsResponse.FromString,
        )
        self.GetNetworkData = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetNetworkData",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkDataRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkDataResponse.FromString,
        )
        self.GetNode = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetNode",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNodeRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNodeResponse.FromString,
        )
        self.ListNodes = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListNodes",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListNodesRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListNodesResponse.FromString,
        )
        self.ListNodeSignatures = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListNodeSignatures",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListNodeSignaturesRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListNodeSignaturesResponse.FromString,
        )
        self.GetEpoch = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetEpoch",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetEpochRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetEpochResponse.FromString,
        )
        self.EstimateFee = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/EstimateFee",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.EstimateFeeRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.EstimateFeeResponse.FromString,
        )
        self.EstimateMargin = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/EstimateMargin",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.EstimateMarginRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.EstimateMarginResponse.FromString,
        )
        self.EstimatePosition = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/EstimatePosition",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.EstimatePositionRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.EstimatePositionResponse.FromString,
        )
        self.ListNetworkParameters = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListNetworkParameters",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListNetworkParametersRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListNetworkParametersResponse.FromString,
        )
        self.GetNetworkParameter = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetNetworkParameter",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkParameterRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkParameterResponse.FromString,
        )
        self.ListCheckpoints = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListCheckpoints",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCheckpointsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCheckpointsResponse.FromString,
        )
        self.GetStake = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetStake",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetStakeRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetStakeResponse.FromString,
        )
        self.GetRiskFactors = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetRiskFactors",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetRiskFactorsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetRiskFactorsResponse.FromString,
        )
        self.ObserveEventBus = channel.stream_stream(
            "/datanode.api.v2.TradingDataService/ObserveEventBus",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveEventBusRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveEventBusResponse.FromString,
        )
        self.ObserveLedgerMovements = channel.unary_stream(
            "/datanode.api.v2.TradingDataService/ObserveLedgerMovements",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveLedgerMovementsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveLedgerMovementsResponse.FromString,
        )
        self.ListKeyRotations = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListKeyRotations",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListKeyRotationsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListKeyRotationsResponse.FromString,
        )
        self.ListEthereumKeyRotations = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListEthereumKeyRotations",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListEthereumKeyRotationsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListEthereumKeyRotationsResponse.FromString,
        )
        self.GetVegaTime = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetVegaTime",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetVegaTimeRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetVegaTimeResponse.FromString,
        )
        self.GetProtocolUpgradeStatus = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetProtocolUpgradeStatus",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetProtocolUpgradeStatusRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetProtocolUpgradeStatusResponse.FromString,
        )
        self.ListProtocolUpgradeProposals = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListProtocolUpgradeProposals",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListProtocolUpgradeProposalsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListProtocolUpgradeProposalsResponse.FromString,
        )
        self.ListCoreSnapshots = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListCoreSnapshots",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCoreSnapshotsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCoreSnapshotsResponse.FromString,
        )
        self.GetMostRecentNetworkHistorySegment = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetMostRecentNetworkHistorySegment",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetMostRecentNetworkHistorySegmentRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetMostRecentNetworkHistorySegmentResponse.FromString,
        )
        self.ListAllNetworkHistorySegments = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListAllNetworkHistorySegments",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAllNetworkHistorySegmentsRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAllNetworkHistorySegmentsResponse.FromString,
        )
        self.GetActiveNetworkHistoryPeerAddresses = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetActiveNetworkHistoryPeerAddresses",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetActiveNetworkHistoryPeerAddressesRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetActiveNetworkHistoryPeerAddressesResponse.FromString,
        )
        self.GetNetworkHistoryStatus = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetNetworkHistoryStatus",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkHistoryStatusRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkHistoryStatusResponse.FromString,
        )
        self.GetNetworkHistoryBootstrapPeers = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/GetNetworkHistoryBootstrapPeers",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkHistoryBootstrapPeersRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkHistoryBootstrapPeersResponse.FromString,
        )
        self.ListEntities = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/ListEntities",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListEntitiesRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListEntitiesResponse.FromString,
        )
        self.ExportNetworkHistory = channel.unary_stream(
            "/datanode.api.v2.TradingDataService/ExportNetworkHistory",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ExportNetworkHistoryRequest.SerializeToString,
            response_deserializer=google_dot_api_dot_httpbody__pb2.HttpBody.FromString,
        )
        self.Ping = channel.unary_unary(
            "/datanode.api.v2.TradingDataService/Ping",
            request_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.PingRequest.SerializeToString,
            response_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.PingResponse.FromString,
        )


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

    def ListAccounts(self, request, context):
        """List accounts

        Get a list of accounts matching the supplied filter, including their current balances.
        If a given account has never had a balance, it will be absent from the list.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ObserveAccounts(self, request, context):
        """Accounts subscription

        Subscribe to a stream of accounts
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def Info(self, request, context):
        """Data node information

        Get information about the data node.
        Response contains a semver formatted version of the data node and the commit hash, from which the data node was built
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetOrder(self, request, context):
        """Get order

        Get an order by its ID. An order's ID will be the SHA3-256 hash of the signature that the order was submitted with
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListOrders(self, request, context):
        """List orders

        Get a list of orders that match the given filters
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListOrderVersions(self, request, context):
        """List order versions

        Get a list of all versions of an order in the order history
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ObserveOrders(self, request, context):
        """Observe orders

        Subscribe to a stream of orders
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetStopOrder(self, request, context):
        """Get stop order

        Get a stop order by its ID. A stop order's ID will be the SHA3-256 hash of the signature that the order was submitted with.
        A stop order's ID is likely to be different from the ID of the order that will be submitted when the stop is triggered.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListStopOrders(self, request, context):
        """List stop orders

        Get a list of stop orders that match the given filters
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListPositions(self, request, context):
        """Deprecated: List positions

        Get a list of positions by party's public key using cursor based pagination
        Deprecated: use ListAllPositions instead
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListAllPositions(self, request, context):
        """List positions

        Get a list of all of a party's positions
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ObservePositions(self, request, context):
        """Observe positions

        Subscribe to a stream of position updates. The first messages sent through the stream will contain
        information about current positions, followed by updates to those positions.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListLedgerEntries(self, request, context):
        """List ledger entries

        Get a list of ledger entries within the given date range.
        This query requests and sums the number of ledger entries from a given subset of accounts, specified via the 'filter' argument.
        It returns a time series - implemented as a list of AggregateLedgerEntry structs - with a row for every time
        the summed ledger entries of the set of specified accounts changes.
        Each account filter must contain no more than one party ID.

        Entries can be filtered by:
        - the sending account (market ID, asset ID, account type)
        - receiving account (market ID, asset ID, account type)
        - sending AND receiving account
        - transfer type either in addition to the above filters or as a standalone option
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ExportLedgerEntries(self, request, context):
        """Export ledger entries

        Export ledger entries records ledger entries to a csv file.
        May or may not contain a date range - if no date range is provided, list all records for all times.

        Ledger entries can be exported by:
        - export ledger entries for a single party for a given asset within a given time range
        - export ledger entries for a single party for a given asset for all times
        buf:lint:ignore RPC_RESPONSE_STANDARD_NAME
        buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListBalanceChanges(self, request, context):
        """List balance changes

        Get a list of the changes in account balances over a period of time.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetLatestMarketData(self, request, context):
        """Get latest market data

        Get the latest market data for a given market
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListLatestMarketData(self, request, context):
        """List latest market data

        Get a list of the latest market data for every market
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetLatestMarketDepth(self, request, context):
        """Get latest market depth

        Get the latest market depth for a given market
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ObserveMarketsDepth(self, request, context):
        """Observe markets depth

        Subscribe to a stream of the latest market depth for a given market
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ObserveMarketsDepthUpdates(self, request, context):
        """Observe markets depth updates

        Subscribe to a stream of updates on market depth for a given market
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ObserveMarketsData(self, request, context):
        """Observe markets data

        Subscribe to a stream of data about a given market
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetMarketDataHistoryByID(self, request, context):
        """Get market data history

        Get market data history for a market ID from between a given date range
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListTransfers(self, request, context):
        """List transfers

        Get a list of transfers between public keys. A valid value for public key can be one of:
        - a party ID
        - "network"
        - "0000000000000000000000000000000000000000000000000000000000000000", the public key for the global rewards account
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetNetworkLimits(self, request, context):
        """Get network limits

        Get the network limits relating to asset and market creation
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListCandleData(self, request, context):
        """List candle data

        Get a list of candle data for a given candle ID. Candle IDs can be obtained by calling list-candle-intervals
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ObserveCandleData(self, request, context):
        """Observe candle data

        Subscribe to a stream of candle updates
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListCandleIntervals(self, request, context):
        """List candle intervals

        Get a list of all available intervals for a given market along with the corresponding candle ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListVotes(self, request, context):
        """List votes

        Get a list of votes. A party ID or a proposal ID must be provided.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ObserveVotes(self, request, context):
        """Observe votes

        Subscribe to a stream of votes cast on a given proposal, or by all votes made by a given party
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListERC20MultiSigSignerAddedBundles(self, request, context):
        """List ERC20 multi-sig signer added bundles

        Get a list of the signature bundles to add a particular validator to the signer list of the multisig contract
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListERC20MultiSigSignerRemovedBundles(self, request, context):
        """List ERC20 multi-sig signer removed bundles

        Get a list of the signature bundles to remove a particular validator from signer list of the multisig contract
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetERC20ListAssetBundle(self, request, context):
        """Get ERC20 list asset bundle

        Get the signatures bundle to allowlist an ERC20 token in the collateral bridge
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetERC20SetAssetLimitsBundle(self, request, context):
        """Get ERC20 set asset limits bundle

        Get the signature bundle to update the token limits. These are `maxLifetimeDeposit` and `withdrawThreshold` for a given ERC20 token that is
        already allowlisted in the collateral bridge.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetERC20WithdrawalApproval(self, request, context):
        """Get ERC20 withdrawal approval

        Get the signature bundle to finalise a withdrawal on Ethereum
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetLastTrade(self, request, context):
        """Get last trade

        Get the last trade made for a given market.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListTrades(self, request, context):
        """List trades

        Get a list of all trades, optionally filtered by party/market/order
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ObserveTrades(self, request, context):
        """Observe trades

        Subscribe to a stream of trades, optionally filtered by party/market
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetOracleSpec(self, request, context):
        """Get oracle spec

        Get an oracle spec by ID. Oracle spec IDs can be found by querying markets that use them as a data source
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListOracleSpecs(self, request, context):
        """List oracle specs

        Get a list of all oracles specs that are defined against all markets
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListOracleData(self, request, context):
        """List oracle data

        Get a list of all oracle data that have been broadcast to any market
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetMarket(self, request, context):
        """Get market

        Get information about a specific market using its ID. A market's ID will be the same as the ID of the proposal that
        generated it
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListMarkets(self, request, context):
        """List markets

        Get a list of markets
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListSuccessorMarkets(self, request, context):
        """List successor markets

        Given a market ID, return the full lineage of markets since inception, or all successor markets since and including
        the given market ID. The markets will be returned in succession order, i.e. the market at position i will be the parent
        of the market at position i+1.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetParty(self, request, context):
        """Get party

        Get a single party
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListParties(self, request, context):
        """List parties

        Get a list of parties
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListMarginLevels(self, request, context):
        """List margin levels

        Get a list margin levels that match the provided criteria. If no filter is provided, all margin levels will be returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ObserveMarginLevels(self, request, context):
        """Observe margin levels

        Subscribe to a stream of margin levels updates
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListRewards(self, request, context):
        """List rewards

        Get a list of rewards that match the provided criteria. If no filter is provided, all rewards will be returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListRewardSummaries(self, request, context):
        """List reward summaries

        Get a list of reward summaries where the reward amount is the total rewards received over all epochs
        per party ID and asset ID.
        Request parameters are optional party ID and asset ID.
        If no data is provided, all reward summaries will be returned grouped by party and asset ID.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListEpochRewardSummaries(self, request, context):
        """List epoch reward summaries

        Get a list of reward summaries by epoch for a given range of epochs.
        The result is filtered by list of asset IDs, market IDs and starting and ending epochs, for which to return rewards.
        If no data is provided, all reward summaries will be returned, grouped by epochs, market IDs, asset IDs and reward type.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetDeposit(self, request, context):
        """Get deposit

        Get a deposit by its ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListDeposits(self, request, context):
        """List deposits

        Get a list of deposits for a given party.
        If a date range is provided, filtering will be based on the last time the deposit
        has been updated in Vega time.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetWithdrawal(self, request, context):
        """Get withdrawal

        Get a withdrawal by its ID. A withdrawal's ID will be the SHA3-256 hash of the signature that the withdrawal was submitted with
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListWithdrawals(self, request, context):
        """List withdrawals

        Get a list of withdrawals for a given party
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetAsset(self, request, context):
        """Get asset

        Get a single asset using its ID. Use the assets list query to get an asset's ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListAssets(self, request, context):
        """List assets

        Get a list of assets available on the Vega network
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListLiquidityProvisions(self, request, context):
        """List liquidity provisions

        Get a list of liquidity provisions for a given market
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ObserveLiquidityProvisions(self, request, context):
        """Observe liquidity provisions

        Subscribe to a stream of liquidity provision events for a given market and party
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetGovernanceData(self, request, context):
        """Get governance data

        Get a single proposal's details either by proposal ID or by reference
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListGovernanceData(self, request, context):
        """List governance data

        Get a list of proposals
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ObserveGovernance(self, request, context):
        """Observe governance

        Subscribe to a stream of updates to governance proposals
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListDelegations(self, request, context):
        """List delegations

        Get a list of the token delegations on the network
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetNetworkData(self, request, context):
        """Get network data

        Get data regarding the nodes of the network
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetNode(self, request, context):
        """Get node

        Get information about a given node
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListNodes(self, request, context):
        """List nodes

        Get a list of the nodes on the network along with the related information.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListNodeSignatures(self, request, context):
        """List node signatures

        Get a list of aggregate signatures from all the nodes of the network
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetEpoch(self, request, context):
        """Get epoch

        Get data for a specific epoch, if ID is omitted, it retrieves the current epoch
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def EstimateFee(self, request, context):
        """Estimate fee

        Estimate the fee that would be incurred for submitting an order
        with the specified price and size on the market.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def EstimateMargin(self, request, context):
        """Estimate margin

        Estimate the margin that would be required for submitting this order
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def EstimatePosition(self, request, context):
        """Estimate position

        Estimate the margin that would be required for maintaining the specified position.
        If the optional collateral available argument is supplied, the response also contains the estimate of the liquidation price.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListNetworkParameters(self, request, context):
        """List network parameters

        Get a list of the network parameter keys and their values
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetNetworkParameter(self, request, context):
        """Get network parameter

        Get a network parameter's value by its key
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListCheckpoints(self, request, context):
        """List checkpoints

        Get a list of information about checkpoints generated by the network
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetStake(self, request, context):
        """Get stake

        Get staking information for a given party
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetRiskFactors(self, request, context):
        """Get risk factors

        Get risk factor data for a given market
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ObserveEventBus(self, request_iterator, context):
        """Observe event bus

        Subscribe to a stream of events from the core
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ObserveLedgerMovements(self, request, context):
        """Observe ledger movements

        Subscribe to a stream of transfer responses
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListKeyRotations(self, request, context):
        """List key rotations

        Get a list of information about Vega key rotations that have been performed by validator nodes
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListEthereumKeyRotations(self, request, context):
        """List Ethereum key rotations

        Get a list of information about Ethereum key rotations that have been performed by validator nodes
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetVegaTime(self, request, context):
        """Get Vega time

        Get the current time of the network in Unix nanoseconds
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetProtocolUpgradeStatus(self, request, context):
        """Get protocol upgrade status

        Get status of a protocol upgrade
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListProtocolUpgradeProposals(self, request, context):
        """List protocol upgrade proposals

        Get a list of protocol upgrade proposals, optionally filtering on status or approver.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListCoreSnapshots(self, request, context):
        """List snapshots

        Get a list of core snapshots taken
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetMostRecentNetworkHistorySegment(self, request, context):
        """Network History

        Network history allows the data node to reach out to peer nodes and fetch the most recent history, as well as
        older history if desired, such that it can quickly get itself up to the latest block height of the network and start
        to consume events for the latest block from the Vega core.
        See https://github.com/vegaprotocol/vega/tree/develop/datanode/networkhistory/README.md for a full description of network history

        Get most recent network history segment

        Get the network's most recently history segment
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListAllNetworkHistorySegments(self, request, context):
        """List all network history segments

        Get a list of all history segments stored by the data node currently connected to
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetActiveNetworkHistoryPeerAddresses(self, request, context):
        """Get active network history peer addresses

        Get a list of the addresses of all active network history peers
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetNetworkHistoryStatus(self, request, context):
        """Network history status

        Get information about the current state of network history's IPFS swarm
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetNetworkHistoryBootstrapPeers(self, request, context):
        """Network history bootstrap peers

        Get a list of IPFS peers that can be used to initialise a new data node with network history
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListEntities(self, request, context):
        """List entities

        Get a list of all entities created by transaction hash
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ExportNetworkHistory(self, request, context):
        """Export network history as CSV

        Export CSV table data from network history between two block heights.

        The requested block heights must fall on network history segment boundaries, which can
        be discovered by calling the API to list all network history segments. By default
        segments contain 1000 blocks. In that case ranges such as (1, 1000), (1001, 2000), (1, 3000)
        would all fall on segment boundaries and be valid.

        The generated CSV file is compressed into a ZIP file and returned, with the file name
        in the following format: `[chain id]-[table name]-[start block]-[end block].zip`

        In gRPC, results are returned in a chunked stream of base64 encoded data.

        Through the REST gateway, the base64 data chunks are decoded and streamed as a
        `content-type: application/zip` HTTP response.

        The CSV exported data uses a comma as a DELIMITER between fields, and " for QUOTE-ing fields.

        If a value contains any of: DELIMITER, QUOTE, carriage return, or line feed then the whole
        value is prefixed and suffixed by the QUOTE character and any occurrence within
        the value of a QUOTE character preceded by another QUOTE.

        A NULL is output as the NULL parameter string and is not quoted, while a non-NULL value
        matching the NULL parameter string is quoted.

        For example, with the default settings, a NULL is written as an unquoted empty string,
        while an empty string data value is written with double quotes.

        Note that CSV files produced may contain quoted values containing embedded carriage returns and line feeds.
        Thus the files are not strictly one line per table row like text-format files.

        The first row of the CSV file is a header that describes the contents of each column
        in subsequent rows.

        Usually the ZIP file will contain only a single CSV file. However it is possible that
        the (from_block, to_block) request spans over a range of blocks in which the underlying
        schema of the database changes. For example, a column may have been added, removed, or renamed.

        If this happens, the CSV file will be split at the point of the schema change and the zip
        file will contain multiple CSV files, with a potentially different set of headers. The
        'version' number of the database schema is part of the in the CSV filename:

        `[chain id]-[table name]-[schema version]-[start block]-[end block].zip`

        For example, a zip file might be called mainnet-sometable-000001-003000.zip

        And contain two CSV files: `mainnet-sometable-1-000001-002000.csv`:

        timestamp, value
        1, foo
        2, bar

        And `mainnet-sometable-2-002001-003000.csv`:

        timestamp, value, extra_value
        3, baz, apple

        It is worth noting that the schema will not change within a single network history segment.
        buf:lint:ignore RPC_RESPONSE_STANDARD_NAME
        buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def Ping(self, request, context):
        """Ping

        Ping the data node
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")


def add_TradingDataServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
        "ListAccounts": grpc.unary_unary_rpc_method_handler(
            servicer.ListAccounts,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAccountsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAccountsResponse.SerializeToString,
        ),
        "ObserveAccounts": grpc.unary_stream_rpc_method_handler(
            servicer.ObserveAccounts,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveAccountsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveAccountsResponse.SerializeToString,
        ),
        "Info": grpc.unary_unary_rpc_method_handler(
            servicer.Info,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.InfoRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.InfoResponse.SerializeToString,
        ),
        "GetOrder": grpc.unary_unary_rpc_method_handler(
            servicer.GetOrder,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetOrderRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetOrderResponse.SerializeToString,
        ),
        "ListOrders": grpc.unary_unary_rpc_method_handler(
            servicer.ListOrders,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOrdersRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOrdersResponse.SerializeToString,
        ),
        "ListOrderVersions": grpc.unary_unary_rpc_method_handler(
            servicer.ListOrderVersions,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOrderVersionsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOrderVersionsResponse.SerializeToString,
        ),
        "ObserveOrders": grpc.unary_stream_rpc_method_handler(
            servicer.ObserveOrders,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveOrdersRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveOrdersResponse.SerializeToString,
        ),
        "GetStopOrder": grpc.unary_unary_rpc_method_handler(
            servicer.GetStopOrder,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetStopOrderRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetStopOrderResponse.SerializeToString,
        ),
        "ListStopOrders": grpc.unary_unary_rpc_method_handler(
            servicer.ListStopOrders,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListStopOrdersRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListStopOrdersResponse.SerializeToString,
        ),
        "ListPositions": grpc.unary_unary_rpc_method_handler(
            servicer.ListPositions,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListPositionsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListPositionsResponse.SerializeToString,
        ),
        "ListAllPositions": grpc.unary_unary_rpc_method_handler(
            servicer.ListAllPositions,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAllPositionsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAllPositionsResponse.SerializeToString,
        ),
        "ObservePositions": grpc.unary_stream_rpc_method_handler(
            servicer.ObservePositions,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObservePositionsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObservePositionsResponse.SerializeToString,
        ),
        "ListLedgerEntries": grpc.unary_unary_rpc_method_handler(
            servicer.ListLedgerEntries,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListLedgerEntriesRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListLedgerEntriesResponse.SerializeToString,
        ),
        "ExportLedgerEntries": grpc.unary_stream_rpc_method_handler(
            servicer.ExportLedgerEntries,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ExportLedgerEntriesRequest.FromString,
            response_serializer=google_dot_api_dot_httpbody__pb2.HttpBody.SerializeToString,
        ),
        "ListBalanceChanges": grpc.unary_unary_rpc_method_handler(
            servicer.ListBalanceChanges,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListBalanceChangesRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListBalanceChangesResponse.SerializeToString,
        ),
        "GetLatestMarketData": grpc.unary_unary_rpc_method_handler(
            servicer.GetLatestMarketData,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetLatestMarketDataRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetLatestMarketDataResponse.SerializeToString,
        ),
        "ListLatestMarketData": grpc.unary_unary_rpc_method_handler(
            servicer.ListLatestMarketData,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListLatestMarketDataRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListLatestMarketDataResponse.SerializeToString,
        ),
        "GetLatestMarketDepth": grpc.unary_unary_rpc_method_handler(
            servicer.GetLatestMarketDepth,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetLatestMarketDepthRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetLatestMarketDepthResponse.SerializeToString,
        ),
        "ObserveMarketsDepth": grpc.unary_stream_rpc_method_handler(
            servicer.ObserveMarketsDepth,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarketsDepthRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarketsDepthResponse.SerializeToString,
        ),
        "ObserveMarketsDepthUpdates": grpc.unary_stream_rpc_method_handler(
            servicer.ObserveMarketsDepthUpdates,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarketsDepthUpdatesRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarketsDepthUpdatesResponse.SerializeToString,
        ),
        "ObserveMarketsData": grpc.unary_stream_rpc_method_handler(
            servicer.ObserveMarketsData,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarketsDataRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarketsDataResponse.SerializeToString,
        ),
        "GetMarketDataHistoryByID": grpc.unary_unary_rpc_method_handler(
            servicer.GetMarketDataHistoryByID,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetMarketDataHistoryByIDRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetMarketDataHistoryByIDResponse.SerializeToString,
        ),
        "ListTransfers": grpc.unary_unary_rpc_method_handler(
            servicer.ListTransfers,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListTransfersRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListTransfersResponse.SerializeToString,
        ),
        "GetNetworkLimits": grpc.unary_unary_rpc_method_handler(
            servicer.GetNetworkLimits,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkLimitsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkLimitsResponse.SerializeToString,
        ),
        "ListCandleData": grpc.unary_unary_rpc_method_handler(
            servicer.ListCandleData,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCandleDataRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCandleDataResponse.SerializeToString,
        ),
        "ObserveCandleData": grpc.unary_stream_rpc_method_handler(
            servicer.ObserveCandleData,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveCandleDataRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveCandleDataResponse.SerializeToString,
        ),
        "ListCandleIntervals": grpc.unary_unary_rpc_method_handler(
            servicer.ListCandleIntervals,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCandleIntervalsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCandleIntervalsResponse.SerializeToString,
        ),
        "ListVotes": grpc.unary_unary_rpc_method_handler(
            servicer.ListVotes,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListVotesRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListVotesResponse.SerializeToString,
        ),
        "ObserveVotes": grpc.unary_stream_rpc_method_handler(
            servicer.ObserveVotes,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveVotesRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveVotesResponse.SerializeToString,
        ),
        "ListERC20MultiSigSignerAddedBundles": grpc.unary_unary_rpc_method_handler(
            servicer.ListERC20MultiSigSignerAddedBundles,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListERC20MultiSigSignerAddedBundlesRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListERC20MultiSigSignerAddedBundlesResponse.SerializeToString,
        ),
        "ListERC20MultiSigSignerRemovedBundles": grpc.unary_unary_rpc_method_handler(
            servicer.ListERC20MultiSigSignerRemovedBundles,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListERC20MultiSigSignerRemovedBundlesRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListERC20MultiSigSignerRemovedBundlesResponse.SerializeToString,
        ),
        "GetERC20ListAssetBundle": grpc.unary_unary_rpc_method_handler(
            servicer.GetERC20ListAssetBundle,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetERC20ListAssetBundleRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetERC20ListAssetBundleResponse.SerializeToString,
        ),
        "GetERC20SetAssetLimitsBundle": grpc.unary_unary_rpc_method_handler(
            servicer.GetERC20SetAssetLimitsBundle,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetERC20SetAssetLimitsBundleRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetERC20SetAssetLimitsBundleResponse.SerializeToString,
        ),
        "GetERC20WithdrawalApproval": grpc.unary_unary_rpc_method_handler(
            servicer.GetERC20WithdrawalApproval,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetERC20WithdrawalApprovalRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetERC20WithdrawalApprovalResponse.SerializeToString,
        ),
        "GetLastTrade": grpc.unary_unary_rpc_method_handler(
            servicer.GetLastTrade,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetLastTradeRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetLastTradeResponse.SerializeToString,
        ),
        "ListTrades": grpc.unary_unary_rpc_method_handler(
            servicer.ListTrades,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListTradesRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListTradesResponse.SerializeToString,
        ),
        "ObserveTrades": grpc.unary_stream_rpc_method_handler(
            servicer.ObserveTrades,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveTradesRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveTradesResponse.SerializeToString,
        ),
        "GetOracleSpec": grpc.unary_unary_rpc_method_handler(
            servicer.GetOracleSpec,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetOracleSpecRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetOracleSpecResponse.SerializeToString,
        ),
        "ListOracleSpecs": grpc.unary_unary_rpc_method_handler(
            servicer.ListOracleSpecs,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOracleSpecsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOracleSpecsResponse.SerializeToString,
        ),
        "ListOracleData": grpc.unary_unary_rpc_method_handler(
            servicer.ListOracleData,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOracleDataRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOracleDataResponse.SerializeToString,
        ),
        "GetMarket": grpc.unary_unary_rpc_method_handler(
            servicer.GetMarket,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetMarketRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetMarketResponse.SerializeToString,
        ),
        "ListMarkets": grpc.unary_unary_rpc_method_handler(
            servicer.ListMarkets,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListMarketsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListMarketsResponse.SerializeToString,
        ),
        "ListSuccessorMarkets": grpc.unary_unary_rpc_method_handler(
            servicer.ListSuccessorMarkets,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListSuccessorMarketsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListSuccessorMarketsResponse.SerializeToString,
        ),
        "GetParty": grpc.unary_unary_rpc_method_handler(
            servicer.GetParty,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetPartyRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetPartyResponse.SerializeToString,
        ),
        "ListParties": grpc.unary_unary_rpc_method_handler(
            servicer.ListParties,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListPartiesRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListPartiesResponse.SerializeToString,
        ),
        "ListMarginLevels": grpc.unary_unary_rpc_method_handler(
            servicer.ListMarginLevels,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListMarginLevelsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListMarginLevelsResponse.SerializeToString,
        ),
        "ObserveMarginLevels": grpc.unary_stream_rpc_method_handler(
            servicer.ObserveMarginLevels,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarginLevelsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarginLevelsResponse.SerializeToString,
        ),
        "ListRewards": grpc.unary_unary_rpc_method_handler(
            servicer.ListRewards,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListRewardsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListRewardsResponse.SerializeToString,
        ),
        "ListRewardSummaries": grpc.unary_unary_rpc_method_handler(
            servicer.ListRewardSummaries,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListRewardSummariesRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListRewardSummariesResponse.SerializeToString,
        ),
        "ListEpochRewardSummaries": grpc.unary_unary_rpc_method_handler(
            servicer.ListEpochRewardSummaries,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListEpochRewardSummariesRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListEpochRewardSummariesResponse.SerializeToString,
        ),
        "GetDeposit": grpc.unary_unary_rpc_method_handler(
            servicer.GetDeposit,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetDepositRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetDepositResponse.SerializeToString,
        ),
        "ListDeposits": grpc.unary_unary_rpc_method_handler(
            servicer.ListDeposits,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListDepositsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListDepositsResponse.SerializeToString,
        ),
        "GetWithdrawal": grpc.unary_unary_rpc_method_handler(
            servicer.GetWithdrawal,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetWithdrawalRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetWithdrawalResponse.SerializeToString,
        ),
        "ListWithdrawals": grpc.unary_unary_rpc_method_handler(
            servicer.ListWithdrawals,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListWithdrawalsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListWithdrawalsResponse.SerializeToString,
        ),
        "GetAsset": grpc.unary_unary_rpc_method_handler(
            servicer.GetAsset,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetAssetRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetAssetResponse.SerializeToString,
        ),
        "ListAssets": grpc.unary_unary_rpc_method_handler(
            servicer.ListAssets,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAssetsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAssetsResponse.SerializeToString,
        ),
        "ListLiquidityProvisions": grpc.unary_unary_rpc_method_handler(
            servicer.ListLiquidityProvisions,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListLiquidityProvisionsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListLiquidityProvisionsResponse.SerializeToString,
        ),
        "ObserveLiquidityProvisions": grpc.unary_stream_rpc_method_handler(
            servicer.ObserveLiquidityProvisions,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveLiquidityProvisionsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveLiquidityProvisionsResponse.SerializeToString,
        ),
        "GetGovernanceData": grpc.unary_unary_rpc_method_handler(
            servicer.GetGovernanceData,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetGovernanceDataRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetGovernanceDataResponse.SerializeToString,
        ),
        "ListGovernanceData": grpc.unary_unary_rpc_method_handler(
            servicer.ListGovernanceData,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListGovernanceDataRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListGovernanceDataResponse.SerializeToString,
        ),
        "ObserveGovernance": grpc.unary_stream_rpc_method_handler(
            servicer.ObserveGovernance,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveGovernanceRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveGovernanceResponse.SerializeToString,
        ),
        "ListDelegations": grpc.unary_unary_rpc_method_handler(
            servicer.ListDelegations,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListDelegationsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListDelegationsResponse.SerializeToString,
        ),
        "GetNetworkData": grpc.unary_unary_rpc_method_handler(
            servicer.GetNetworkData,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkDataRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkDataResponse.SerializeToString,
        ),
        "GetNode": grpc.unary_unary_rpc_method_handler(
            servicer.GetNode,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNodeRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNodeResponse.SerializeToString,
        ),
        "ListNodes": grpc.unary_unary_rpc_method_handler(
            servicer.ListNodes,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListNodesRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListNodesResponse.SerializeToString,
        ),
        "ListNodeSignatures": grpc.unary_unary_rpc_method_handler(
            servicer.ListNodeSignatures,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListNodeSignaturesRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListNodeSignaturesResponse.SerializeToString,
        ),
        "GetEpoch": grpc.unary_unary_rpc_method_handler(
            servicer.GetEpoch,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetEpochRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetEpochResponse.SerializeToString,
        ),
        "EstimateFee": grpc.unary_unary_rpc_method_handler(
            servicer.EstimateFee,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.EstimateFeeRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.EstimateFeeResponse.SerializeToString,
        ),
        "EstimateMargin": grpc.unary_unary_rpc_method_handler(
            servicer.EstimateMargin,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.EstimateMarginRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.EstimateMarginResponse.SerializeToString,
        ),
        "EstimatePosition": grpc.unary_unary_rpc_method_handler(
            servicer.EstimatePosition,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.EstimatePositionRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.EstimatePositionResponse.SerializeToString,
        ),
        "ListNetworkParameters": grpc.unary_unary_rpc_method_handler(
            servicer.ListNetworkParameters,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListNetworkParametersRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListNetworkParametersResponse.SerializeToString,
        ),
        "GetNetworkParameter": grpc.unary_unary_rpc_method_handler(
            servicer.GetNetworkParameter,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkParameterRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkParameterResponse.SerializeToString,
        ),
        "ListCheckpoints": grpc.unary_unary_rpc_method_handler(
            servicer.ListCheckpoints,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCheckpointsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCheckpointsResponse.SerializeToString,
        ),
        "GetStake": grpc.unary_unary_rpc_method_handler(
            servicer.GetStake,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetStakeRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetStakeResponse.SerializeToString,
        ),
        "GetRiskFactors": grpc.unary_unary_rpc_method_handler(
            servicer.GetRiskFactors,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetRiskFactorsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetRiskFactorsResponse.SerializeToString,
        ),
        "ObserveEventBus": grpc.stream_stream_rpc_method_handler(
            servicer.ObserveEventBus,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveEventBusRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveEventBusResponse.SerializeToString,
        ),
        "ObserveLedgerMovements": grpc.unary_stream_rpc_method_handler(
            servicer.ObserveLedgerMovements,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveLedgerMovementsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveLedgerMovementsResponse.SerializeToString,
        ),
        "ListKeyRotations": grpc.unary_unary_rpc_method_handler(
            servicer.ListKeyRotations,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListKeyRotationsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListKeyRotationsResponse.SerializeToString,
        ),
        "ListEthereumKeyRotations": grpc.unary_unary_rpc_method_handler(
            servicer.ListEthereumKeyRotations,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListEthereumKeyRotationsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListEthereumKeyRotationsResponse.SerializeToString,
        ),
        "GetVegaTime": grpc.unary_unary_rpc_method_handler(
            servicer.GetVegaTime,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetVegaTimeRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetVegaTimeResponse.SerializeToString,
        ),
        "GetProtocolUpgradeStatus": grpc.unary_unary_rpc_method_handler(
            servicer.GetProtocolUpgradeStatus,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetProtocolUpgradeStatusRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetProtocolUpgradeStatusResponse.SerializeToString,
        ),
        "ListProtocolUpgradeProposals": grpc.unary_unary_rpc_method_handler(
            servicer.ListProtocolUpgradeProposals,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListProtocolUpgradeProposalsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListProtocolUpgradeProposalsResponse.SerializeToString,
        ),
        "ListCoreSnapshots": grpc.unary_unary_rpc_method_handler(
            servicer.ListCoreSnapshots,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCoreSnapshotsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCoreSnapshotsResponse.SerializeToString,
        ),
        "GetMostRecentNetworkHistorySegment": grpc.unary_unary_rpc_method_handler(
            servicer.GetMostRecentNetworkHistorySegment,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetMostRecentNetworkHistorySegmentRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetMostRecentNetworkHistorySegmentResponse.SerializeToString,
        ),
        "ListAllNetworkHistorySegments": grpc.unary_unary_rpc_method_handler(
            servicer.ListAllNetworkHistorySegments,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAllNetworkHistorySegmentsRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAllNetworkHistorySegmentsResponse.SerializeToString,
        ),
        "GetActiveNetworkHistoryPeerAddresses": grpc.unary_unary_rpc_method_handler(
            servicer.GetActiveNetworkHistoryPeerAddresses,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetActiveNetworkHistoryPeerAddressesRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetActiveNetworkHistoryPeerAddressesResponse.SerializeToString,
        ),
        "GetNetworkHistoryStatus": grpc.unary_unary_rpc_method_handler(
            servicer.GetNetworkHistoryStatus,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkHistoryStatusRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkHistoryStatusResponse.SerializeToString,
        ),
        "GetNetworkHistoryBootstrapPeers": grpc.unary_unary_rpc_method_handler(
            servicer.GetNetworkHistoryBootstrapPeers,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkHistoryBootstrapPeersRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkHistoryBootstrapPeersResponse.SerializeToString,
        ),
        "ListEntities": grpc.unary_unary_rpc_method_handler(
            servicer.ListEntities,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListEntitiesRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ListEntitiesResponse.SerializeToString,
        ),
        "ExportNetworkHistory": grpc.unary_stream_rpc_method_handler(
            servicer.ExportNetworkHistory,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.ExportNetworkHistoryRequest.FromString,
            response_serializer=google_dot_api_dot_httpbody__pb2.HttpBody.SerializeToString,
        ),
        "Ping": grpc.unary_unary_rpc_method_handler(
            servicer.Ping,
            request_deserializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.PingRequest.FromString,
            response_serializer=data__node_dot_api_dot_v2_dot_trading__data__pb2.PingResponse.SerializeToString,
        ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
        "datanode.api.v2.TradingDataService", rpc_method_handlers
    )
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def ListAccounts(
        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,
            "/datanode.api.v2.TradingDataService/ListAccounts",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAccountsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAccountsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ObserveAccounts(
        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,
            "/datanode.api.v2.TradingDataService/ObserveAccounts",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveAccountsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveAccountsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def Info(
        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,
            "/datanode.api.v2.TradingDataService/Info",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.InfoRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.InfoResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetOrder(
        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,
            "/datanode.api.v2.TradingDataService/GetOrder",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetOrderRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetOrderResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListOrders(
        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,
            "/datanode.api.v2.TradingDataService/ListOrders",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOrdersRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOrdersResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListOrderVersions(
        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,
            "/datanode.api.v2.TradingDataService/ListOrderVersions",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOrderVersionsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOrderVersionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ObserveOrders(
        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,
            "/datanode.api.v2.TradingDataService/ObserveOrders",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveOrdersRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveOrdersResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetStopOrder(
        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,
            "/datanode.api.v2.TradingDataService/GetStopOrder",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetStopOrderRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetStopOrderResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListStopOrders(
        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,
            "/datanode.api.v2.TradingDataService/ListStopOrders",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListStopOrdersRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListStopOrdersResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListPositions(
        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,
            "/datanode.api.v2.TradingDataService/ListPositions",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListPositionsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListPositionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListAllPositions(
        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,
            "/datanode.api.v2.TradingDataService/ListAllPositions",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAllPositionsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAllPositionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ObservePositions(
        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,
            "/datanode.api.v2.TradingDataService/ObservePositions",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObservePositionsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObservePositionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListLedgerEntries(
        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,
            "/datanode.api.v2.TradingDataService/ListLedgerEntries",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListLedgerEntriesRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListLedgerEntriesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ExportLedgerEntries(
        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,
            "/datanode.api.v2.TradingDataService/ExportLedgerEntries",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ExportLedgerEntriesRequest.SerializeToString,
            google_dot_api_dot_httpbody__pb2.HttpBody.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListBalanceChanges(
        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,
            "/datanode.api.v2.TradingDataService/ListBalanceChanges",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListBalanceChangesRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListBalanceChangesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetLatestMarketData(
        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,
            "/datanode.api.v2.TradingDataService/GetLatestMarketData",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetLatestMarketDataRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetLatestMarketDataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListLatestMarketData(
        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,
            "/datanode.api.v2.TradingDataService/ListLatestMarketData",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListLatestMarketDataRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListLatestMarketDataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetLatestMarketDepth(
        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,
            "/datanode.api.v2.TradingDataService/GetLatestMarketDepth",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetLatestMarketDepthRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetLatestMarketDepthResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ObserveMarketsDepth(
        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,
            "/datanode.api.v2.TradingDataService/ObserveMarketsDepth",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarketsDepthRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarketsDepthResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ObserveMarketsDepthUpdates(
        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,
            "/datanode.api.v2.TradingDataService/ObserveMarketsDepthUpdates",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarketsDepthUpdatesRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarketsDepthUpdatesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ObserveMarketsData(
        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,
            "/datanode.api.v2.TradingDataService/ObserveMarketsData",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarketsDataRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarketsDataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetMarketDataHistoryByID(
        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,
            "/datanode.api.v2.TradingDataService/GetMarketDataHistoryByID",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetMarketDataHistoryByIDRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetMarketDataHistoryByIDResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListTransfers(
        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,
            "/datanode.api.v2.TradingDataService/ListTransfers",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListTransfersRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListTransfersResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetNetworkLimits(
        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,
            "/datanode.api.v2.TradingDataService/GetNetworkLimits",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkLimitsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkLimitsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListCandleData(
        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,
            "/datanode.api.v2.TradingDataService/ListCandleData",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCandleDataRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCandleDataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ObserveCandleData(
        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,
            "/datanode.api.v2.TradingDataService/ObserveCandleData",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveCandleDataRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveCandleDataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListCandleIntervals(
        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,
            "/datanode.api.v2.TradingDataService/ListCandleIntervals",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCandleIntervalsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCandleIntervalsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListVotes(
        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,
            "/datanode.api.v2.TradingDataService/ListVotes",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListVotesRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListVotesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ObserveVotes(
        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,
            "/datanode.api.v2.TradingDataService/ObserveVotes",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveVotesRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveVotesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListERC20MultiSigSignerAddedBundles(
        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,
            "/datanode.api.v2.TradingDataService/ListERC20MultiSigSignerAddedBundles",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListERC20MultiSigSignerAddedBundlesRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListERC20MultiSigSignerAddedBundlesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListERC20MultiSigSignerRemovedBundles(
        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,
            "/datanode.api.v2.TradingDataService/ListERC20MultiSigSignerRemovedBundles",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListERC20MultiSigSignerRemovedBundlesRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListERC20MultiSigSignerRemovedBundlesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetERC20ListAssetBundle(
        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,
            "/datanode.api.v2.TradingDataService/GetERC20ListAssetBundle",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetERC20ListAssetBundleRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetERC20ListAssetBundleResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetERC20SetAssetLimitsBundle(
        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,
            "/datanode.api.v2.TradingDataService/GetERC20SetAssetLimitsBundle",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetERC20SetAssetLimitsBundleRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetERC20SetAssetLimitsBundleResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetERC20WithdrawalApproval(
        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,
            "/datanode.api.v2.TradingDataService/GetERC20WithdrawalApproval",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetERC20WithdrawalApprovalRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetERC20WithdrawalApprovalResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetLastTrade(
        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,
            "/datanode.api.v2.TradingDataService/GetLastTrade",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetLastTradeRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetLastTradeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListTrades(
        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,
            "/datanode.api.v2.TradingDataService/ListTrades",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListTradesRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListTradesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ObserveTrades(
        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,
            "/datanode.api.v2.TradingDataService/ObserveTrades",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveTradesRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveTradesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetOracleSpec(
        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,
            "/datanode.api.v2.TradingDataService/GetOracleSpec",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetOracleSpecRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetOracleSpecResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListOracleSpecs(
        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,
            "/datanode.api.v2.TradingDataService/ListOracleSpecs",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOracleSpecsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOracleSpecsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListOracleData(
        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,
            "/datanode.api.v2.TradingDataService/ListOracleData",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOracleDataRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListOracleDataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetMarket(
        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,
            "/datanode.api.v2.TradingDataService/GetMarket",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetMarketRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetMarketResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListMarkets(
        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,
            "/datanode.api.v2.TradingDataService/ListMarkets",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListMarketsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListMarketsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListSuccessorMarkets(
        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,
            "/datanode.api.v2.TradingDataService/ListSuccessorMarkets",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListSuccessorMarketsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListSuccessorMarketsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetParty(
        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,
            "/datanode.api.v2.TradingDataService/GetParty",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetPartyRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetPartyResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListParties(
        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,
            "/datanode.api.v2.TradingDataService/ListParties",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListPartiesRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListPartiesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListMarginLevels(
        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,
            "/datanode.api.v2.TradingDataService/ListMarginLevels",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListMarginLevelsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListMarginLevelsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ObserveMarginLevels(
        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,
            "/datanode.api.v2.TradingDataService/ObserveMarginLevels",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarginLevelsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveMarginLevelsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListRewards(
        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,
            "/datanode.api.v2.TradingDataService/ListRewards",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListRewardsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListRewardsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListRewardSummaries(
        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,
            "/datanode.api.v2.TradingDataService/ListRewardSummaries",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListRewardSummariesRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListRewardSummariesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListEpochRewardSummaries(
        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,
            "/datanode.api.v2.TradingDataService/ListEpochRewardSummaries",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListEpochRewardSummariesRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListEpochRewardSummariesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetDeposit(
        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,
            "/datanode.api.v2.TradingDataService/GetDeposit",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetDepositRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetDepositResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListDeposits(
        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,
            "/datanode.api.v2.TradingDataService/ListDeposits",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListDepositsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListDepositsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetWithdrawal(
        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,
            "/datanode.api.v2.TradingDataService/GetWithdrawal",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetWithdrawalRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetWithdrawalResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListWithdrawals(
        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,
            "/datanode.api.v2.TradingDataService/ListWithdrawals",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListWithdrawalsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListWithdrawalsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetAsset(
        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,
            "/datanode.api.v2.TradingDataService/GetAsset",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetAssetRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetAssetResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListAssets(
        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,
            "/datanode.api.v2.TradingDataService/ListAssets",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAssetsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAssetsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListLiquidityProvisions(
        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,
            "/datanode.api.v2.TradingDataService/ListLiquidityProvisions",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListLiquidityProvisionsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListLiquidityProvisionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ObserveLiquidityProvisions(
        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,
            "/datanode.api.v2.TradingDataService/ObserveLiquidityProvisions",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveLiquidityProvisionsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveLiquidityProvisionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetGovernanceData(
        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,
            "/datanode.api.v2.TradingDataService/GetGovernanceData",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetGovernanceDataRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetGovernanceDataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListGovernanceData(
        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,
            "/datanode.api.v2.TradingDataService/ListGovernanceData",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListGovernanceDataRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListGovernanceDataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ObserveGovernance(
        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,
            "/datanode.api.v2.TradingDataService/ObserveGovernance",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveGovernanceRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveGovernanceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListDelegations(
        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,
            "/datanode.api.v2.TradingDataService/ListDelegations",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListDelegationsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListDelegationsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetNetworkData(
        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,
            "/datanode.api.v2.TradingDataService/GetNetworkData",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkDataRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkDataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetNode(
        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,
            "/datanode.api.v2.TradingDataService/GetNode",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNodeRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNodeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListNodes(
        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,
            "/datanode.api.v2.TradingDataService/ListNodes",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListNodesRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListNodesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListNodeSignatures(
        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,
            "/datanode.api.v2.TradingDataService/ListNodeSignatures",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListNodeSignaturesRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListNodeSignaturesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetEpoch(
        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,
            "/datanode.api.v2.TradingDataService/GetEpoch",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetEpochRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetEpochResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def EstimateFee(
        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,
            "/datanode.api.v2.TradingDataService/EstimateFee",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.EstimateFeeRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.EstimateFeeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def EstimateMargin(
        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,
            "/datanode.api.v2.TradingDataService/EstimateMargin",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.EstimateMarginRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.EstimateMarginResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def EstimatePosition(
        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,
            "/datanode.api.v2.TradingDataService/EstimatePosition",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.EstimatePositionRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.EstimatePositionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListNetworkParameters(
        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,
            "/datanode.api.v2.TradingDataService/ListNetworkParameters",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListNetworkParametersRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListNetworkParametersResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetNetworkParameter(
        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,
            "/datanode.api.v2.TradingDataService/GetNetworkParameter",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkParameterRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkParameterResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListCheckpoints(
        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,
            "/datanode.api.v2.TradingDataService/ListCheckpoints",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCheckpointsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCheckpointsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetStake(
        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,
            "/datanode.api.v2.TradingDataService/GetStake",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetStakeRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetStakeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetRiskFactors(
        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,
            "/datanode.api.v2.TradingDataService/GetRiskFactors",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetRiskFactorsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetRiskFactorsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ObserveEventBus(
        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,
            "/datanode.api.v2.TradingDataService/ObserveEventBus",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveEventBusRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveEventBusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ObserveLedgerMovements(
        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,
            "/datanode.api.v2.TradingDataService/ObserveLedgerMovements",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveLedgerMovementsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ObserveLedgerMovementsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListKeyRotations(
        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,
            "/datanode.api.v2.TradingDataService/ListKeyRotations",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListKeyRotationsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListKeyRotationsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListEthereumKeyRotations(
        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,
            "/datanode.api.v2.TradingDataService/ListEthereumKeyRotations",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListEthereumKeyRotationsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListEthereumKeyRotationsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetVegaTime(
        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,
            "/datanode.api.v2.TradingDataService/GetVegaTime",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetVegaTimeRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetVegaTimeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetProtocolUpgradeStatus(
        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,
            "/datanode.api.v2.TradingDataService/GetProtocolUpgradeStatus",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetProtocolUpgradeStatusRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetProtocolUpgradeStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListProtocolUpgradeProposals(
        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,
            "/datanode.api.v2.TradingDataService/ListProtocolUpgradeProposals",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListProtocolUpgradeProposalsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListProtocolUpgradeProposalsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListCoreSnapshots(
        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,
            "/datanode.api.v2.TradingDataService/ListCoreSnapshots",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCoreSnapshotsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListCoreSnapshotsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetMostRecentNetworkHistorySegment(
        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,
            "/datanode.api.v2.TradingDataService/GetMostRecentNetworkHistorySegment",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetMostRecentNetworkHistorySegmentRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetMostRecentNetworkHistorySegmentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListAllNetworkHistorySegments(
        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,
            "/datanode.api.v2.TradingDataService/ListAllNetworkHistorySegments",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAllNetworkHistorySegmentsRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListAllNetworkHistorySegmentsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetActiveNetworkHistoryPeerAddresses(
        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,
            "/datanode.api.v2.TradingDataService/GetActiveNetworkHistoryPeerAddresses",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetActiveNetworkHistoryPeerAddressesRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetActiveNetworkHistoryPeerAddressesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetNetworkHistoryStatus(
        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,
            "/datanode.api.v2.TradingDataService/GetNetworkHistoryStatus",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkHistoryStatusRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkHistoryStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetNetworkHistoryBootstrapPeers(
        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,
            "/datanode.api.v2.TradingDataService/GetNetworkHistoryBootstrapPeers",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkHistoryBootstrapPeersRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.GetNetworkHistoryBootstrapPeersResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListEntities(
        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,
            "/datanode.api.v2.TradingDataService/ListEntities",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListEntitiesRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ListEntitiesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ExportNetworkHistory(
        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,
            "/datanode.api.v2.TradingDataService/ExportNetworkHistory",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.ExportNetworkHistoryRequest.SerializeToString,
            google_dot_api_dot_httpbody__pb2.HttpBody.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def Ping(
        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,
            "/datanode.api.v2.TradingDataService/Ping",
            data__node_dot_api_dot_v2_dot_trading__data__pb2.PingRequest.SerializeToString,
            data__node_dot_api_dot_v2_dot_trading__data__pb2.PingResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )
