// Generated by the gRPC C++ plugin.
// If you make any local change, they will be lost.
// source: base_node.proto

#include "base_node.pb.h"
#include "base_node.grpc.pb.h"

#include <functional>
#include <grpcpp/support/async_stream.h>
#include <grpcpp/support/async_unary_call.h>
#include <grpcpp/impl/channel_interface.h>
#include <grpcpp/impl/client_unary_call.h>
#include <grpcpp/support/client_callback.h>
#include <grpcpp/support/message_allocator.h>
#include <grpcpp/support/method_handler.h>
#include <grpcpp/impl/rpc_service_method.h>
#include <grpcpp/support/server_callback.h>
#include <grpcpp/impl/server_callback_handlers.h>
#include <grpcpp/server_context.h>
#include <grpcpp/impl/service_type.h>
#include <grpcpp/support/sync_stream.h>
namespace tari {
namespace rpc {

static const char* BaseNode_method_names[] = {
  "/tari.rpc.BaseNode/ListHeaders",
  "/tari.rpc.BaseNode/GetHeaderByHash",
  "/tari.rpc.BaseNode/GetBlocks",
  "/tari.rpc.BaseNode/GetBlockTiming",
  "/tari.rpc.BaseNode/GetConstants",
  "/tari.rpc.BaseNode/GetBlockSize",
  "/tari.rpc.BaseNode/GetBlockFees",
  "/tari.rpc.BaseNode/GetVersion",
  "/tari.rpc.BaseNode/CheckForUpdates",
  "/tari.rpc.BaseNode/GetTokensInCirculation",
  "/tari.rpc.BaseNode/GetNetworkDifficulty",
  "/tari.rpc.BaseNode/GetNewBlockTemplate",
  "/tari.rpc.BaseNode/GetNewBlock",
  "/tari.rpc.BaseNode/GetNewBlockWithCoinbases",
  "/tari.rpc.BaseNode/GetNewBlockTemplateWithCoinbases",
  "/tari.rpc.BaseNode/GetNewBlockBlob",
  "/tari.rpc.BaseNode/SubmitBlock",
  "/tari.rpc.BaseNode/SubmitBlockBlob",
  "/tari.rpc.BaseNode/SubmitTransaction",
  "/tari.rpc.BaseNode/GetSyncInfo",
  "/tari.rpc.BaseNode/GetSyncProgress",
  "/tari.rpc.BaseNode/GetTipInfo",
  "/tari.rpc.BaseNode/SearchKernels",
  "/tari.rpc.BaseNode/SearchUtxos",
  "/tari.rpc.BaseNode/FetchMatchingUtxos",
  "/tari.rpc.BaseNode/GetPeers",
  "/tari.rpc.BaseNode/GetMempoolTransactions",
  "/tari.rpc.BaseNode/TransactionState",
  "/tari.rpc.BaseNode/Identify",
  "/tari.rpc.BaseNode/GetNetworkStatus",
  "/tari.rpc.BaseNode/ListConnectedPeers",
  "/tari.rpc.BaseNode/GetMempoolStats",
  "/tari.rpc.BaseNode/GetActiveValidatorNodes",
  "/tari.rpc.BaseNode/GetShardKey",
  "/tari.rpc.BaseNode/GetTemplateRegistrations",
  "/tari.rpc.BaseNode/GetSideChainUtxos",
};

std::unique_ptr< BaseNode::Stub> BaseNode::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
  (void)options;
  std::unique_ptr< BaseNode::Stub> stub(new BaseNode::Stub(channel, options));
  return stub;
}

BaseNode::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
  : channel_(channel), rpcmethod_ListHeaders_(BaseNode_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_GetHeaderByHash_(BaseNode_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetBlocks_(BaseNode_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_GetBlockTiming_(BaseNode_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetConstants_(BaseNode_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetBlockSize_(BaseNode_method_names[5], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetBlockFees_(BaseNode_method_names[6], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetVersion_(BaseNode_method_names[7], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_CheckForUpdates_(BaseNode_method_names[8], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetTokensInCirculation_(BaseNode_method_names[9], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_GetNetworkDifficulty_(BaseNode_method_names[10], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_GetNewBlockTemplate_(BaseNode_method_names[11], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetNewBlock_(BaseNode_method_names[12], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetNewBlockWithCoinbases_(BaseNode_method_names[13], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetNewBlockTemplateWithCoinbases_(BaseNode_method_names[14], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetNewBlockBlob_(BaseNode_method_names[15], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_SubmitBlock_(BaseNode_method_names[16], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_SubmitBlockBlob_(BaseNode_method_names[17], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_SubmitTransaction_(BaseNode_method_names[18], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetSyncInfo_(BaseNode_method_names[19], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetSyncProgress_(BaseNode_method_names[20], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetTipInfo_(BaseNode_method_names[21], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_SearchKernels_(BaseNode_method_names[22], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_SearchUtxos_(BaseNode_method_names[23], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_FetchMatchingUtxos_(BaseNode_method_names[24], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_GetPeers_(BaseNode_method_names[25], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_GetMempoolTransactions_(BaseNode_method_names[26], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_TransactionState_(BaseNode_method_names[27], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_Identify_(BaseNode_method_names[28], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetNetworkStatus_(BaseNode_method_names[29], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ListConnectedPeers_(BaseNode_method_names[30], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetMempoolStats_(BaseNode_method_names[31], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetActiveValidatorNodes_(BaseNode_method_names[32], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_GetShardKey_(BaseNode_method_names[33], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetTemplateRegistrations_(BaseNode_method_names[34], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_GetSideChainUtxos_(BaseNode_method_names[35], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  {}

::grpc::ClientReader< ::tari::rpc::BlockHeaderResponse>* BaseNode::Stub::ListHeadersRaw(::grpc::ClientContext* context, const ::tari::rpc::ListHeadersRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::tari::rpc::BlockHeaderResponse>::Create(channel_.get(), rpcmethod_ListHeaders_, context, request);
}

void BaseNode::Stub::async::ListHeaders(::grpc::ClientContext* context, const ::tari::rpc::ListHeadersRequest* request, ::grpc::ClientReadReactor< ::tari::rpc::BlockHeaderResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::tari::rpc::BlockHeaderResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_ListHeaders_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::tari::rpc::BlockHeaderResponse>* BaseNode::Stub::AsyncListHeadersRaw(::grpc::ClientContext* context, const ::tari::rpc::ListHeadersRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::BlockHeaderResponse>::Create(channel_.get(), cq, rpcmethod_ListHeaders_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::tari::rpc::BlockHeaderResponse>* BaseNode::Stub::PrepareAsyncListHeadersRaw(::grpc::ClientContext* context, const ::tari::rpc::ListHeadersRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::BlockHeaderResponse>::Create(channel_.get(), cq, rpcmethod_ListHeaders_, context, request, false, nullptr);
}

::grpc::Status BaseNode::Stub::GetHeaderByHash(::grpc::ClientContext* context, const ::tari::rpc::GetHeaderByHashRequest& request, ::tari::rpc::BlockHeaderResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::GetHeaderByHashRequest, ::tari::rpc::BlockHeaderResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetHeaderByHash_, context, request, response);
}

void BaseNode::Stub::async::GetHeaderByHash(::grpc::ClientContext* context, const ::tari::rpc::GetHeaderByHashRequest* request, ::tari::rpc::BlockHeaderResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::GetHeaderByHashRequest, ::tari::rpc::BlockHeaderResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetHeaderByHash_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::GetHeaderByHash(::grpc::ClientContext* context, const ::tari::rpc::GetHeaderByHashRequest* request, ::tari::rpc::BlockHeaderResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetHeaderByHash_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::BlockHeaderResponse>* BaseNode::Stub::PrepareAsyncGetHeaderByHashRaw(::grpc::ClientContext* context, const ::tari::rpc::GetHeaderByHashRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::BlockHeaderResponse, ::tari::rpc::GetHeaderByHashRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetHeaderByHash_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::BlockHeaderResponse>* BaseNode::Stub::AsyncGetHeaderByHashRaw(::grpc::ClientContext* context, const ::tari::rpc::GetHeaderByHashRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetHeaderByHashRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::tari::rpc::HistoricalBlock>* BaseNode::Stub::GetBlocksRaw(::grpc::ClientContext* context, const ::tari::rpc::GetBlocksRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::tari::rpc::HistoricalBlock>::Create(channel_.get(), rpcmethod_GetBlocks_, context, request);
}

void BaseNode::Stub::async::GetBlocks(::grpc::ClientContext* context, const ::tari::rpc::GetBlocksRequest* request, ::grpc::ClientReadReactor< ::tari::rpc::HistoricalBlock>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::tari::rpc::HistoricalBlock>::Create(stub_->channel_.get(), stub_->rpcmethod_GetBlocks_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::tari::rpc::HistoricalBlock>* BaseNode::Stub::AsyncGetBlocksRaw(::grpc::ClientContext* context, const ::tari::rpc::GetBlocksRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::HistoricalBlock>::Create(channel_.get(), cq, rpcmethod_GetBlocks_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::tari::rpc::HistoricalBlock>* BaseNode::Stub::PrepareAsyncGetBlocksRaw(::grpc::ClientContext* context, const ::tari::rpc::GetBlocksRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::HistoricalBlock>::Create(channel_.get(), cq, rpcmethod_GetBlocks_, context, request, false, nullptr);
}

::grpc::Status BaseNode::Stub::GetBlockTiming(::grpc::ClientContext* context, const ::tari::rpc::HeightRequest& request, ::tari::rpc::BlockTimingResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::HeightRequest, ::tari::rpc::BlockTimingResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetBlockTiming_, context, request, response);
}

void BaseNode::Stub::async::GetBlockTiming(::grpc::ClientContext* context, const ::tari::rpc::HeightRequest* request, ::tari::rpc::BlockTimingResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::HeightRequest, ::tari::rpc::BlockTimingResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetBlockTiming_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::GetBlockTiming(::grpc::ClientContext* context, const ::tari::rpc::HeightRequest* request, ::tari::rpc::BlockTimingResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetBlockTiming_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::BlockTimingResponse>* BaseNode::Stub::PrepareAsyncGetBlockTimingRaw(::grpc::ClientContext* context, const ::tari::rpc::HeightRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::BlockTimingResponse, ::tari::rpc::HeightRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetBlockTiming_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::BlockTimingResponse>* BaseNode::Stub::AsyncGetBlockTimingRaw(::grpc::ClientContext* context, const ::tari::rpc::HeightRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetBlockTimingRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::GetConstants(::grpc::ClientContext* context, const ::tari::rpc::BlockHeight& request, ::tari::rpc::ConsensusConstants* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::BlockHeight, ::tari::rpc::ConsensusConstants, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetConstants_, context, request, response);
}

void BaseNode::Stub::async::GetConstants(::grpc::ClientContext* context, const ::tari::rpc::BlockHeight* request, ::tari::rpc::ConsensusConstants* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::BlockHeight, ::tari::rpc::ConsensusConstants, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetConstants_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::GetConstants(::grpc::ClientContext* context, const ::tari::rpc::BlockHeight* request, ::tari::rpc::ConsensusConstants* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetConstants_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::ConsensusConstants>* BaseNode::Stub::PrepareAsyncGetConstantsRaw(::grpc::ClientContext* context, const ::tari::rpc::BlockHeight& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::ConsensusConstants, ::tari::rpc::BlockHeight, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetConstants_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::ConsensusConstants>* BaseNode::Stub::AsyncGetConstantsRaw(::grpc::ClientContext* context, const ::tari::rpc::BlockHeight& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetConstantsRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::GetBlockSize(::grpc::ClientContext* context, const ::tari::rpc::BlockGroupRequest& request, ::tari::rpc::BlockGroupResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::BlockGroupRequest, ::tari::rpc::BlockGroupResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetBlockSize_, context, request, response);
}

void BaseNode::Stub::async::GetBlockSize(::grpc::ClientContext* context, const ::tari::rpc::BlockGroupRequest* request, ::tari::rpc::BlockGroupResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::BlockGroupRequest, ::tari::rpc::BlockGroupResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetBlockSize_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::GetBlockSize(::grpc::ClientContext* context, const ::tari::rpc::BlockGroupRequest* request, ::tari::rpc::BlockGroupResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetBlockSize_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::BlockGroupResponse>* BaseNode::Stub::PrepareAsyncGetBlockSizeRaw(::grpc::ClientContext* context, const ::tari::rpc::BlockGroupRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::BlockGroupResponse, ::tari::rpc::BlockGroupRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetBlockSize_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::BlockGroupResponse>* BaseNode::Stub::AsyncGetBlockSizeRaw(::grpc::ClientContext* context, const ::tari::rpc::BlockGroupRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetBlockSizeRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::GetBlockFees(::grpc::ClientContext* context, const ::tari::rpc::BlockGroupRequest& request, ::tari::rpc::BlockGroupResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::BlockGroupRequest, ::tari::rpc::BlockGroupResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetBlockFees_, context, request, response);
}

void BaseNode::Stub::async::GetBlockFees(::grpc::ClientContext* context, const ::tari::rpc::BlockGroupRequest* request, ::tari::rpc::BlockGroupResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::BlockGroupRequest, ::tari::rpc::BlockGroupResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetBlockFees_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::GetBlockFees(::grpc::ClientContext* context, const ::tari::rpc::BlockGroupRequest* request, ::tari::rpc::BlockGroupResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetBlockFees_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::BlockGroupResponse>* BaseNode::Stub::PrepareAsyncGetBlockFeesRaw(::grpc::ClientContext* context, const ::tari::rpc::BlockGroupRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::BlockGroupResponse, ::tari::rpc::BlockGroupRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetBlockFees_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::BlockGroupResponse>* BaseNode::Stub::AsyncGetBlockFeesRaw(::grpc::ClientContext* context, const ::tari::rpc::BlockGroupRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetBlockFeesRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::GetVersion(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::tari::rpc::StringValue* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::Empty, ::tari::rpc::StringValue, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetVersion_, context, request, response);
}

void BaseNode::Stub::async::GetVersion(::grpc::ClientContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::StringValue* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::Empty, ::tari::rpc::StringValue, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetVersion_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::GetVersion(::grpc::ClientContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::StringValue* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetVersion_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::StringValue>* BaseNode::Stub::PrepareAsyncGetVersionRaw(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::StringValue, ::tari::rpc::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetVersion_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::StringValue>* BaseNode::Stub::AsyncGetVersionRaw(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetVersionRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::CheckForUpdates(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::tari::rpc::SoftwareUpdate* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::Empty, ::tari::rpc::SoftwareUpdate, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_CheckForUpdates_, context, request, response);
}

void BaseNode::Stub::async::CheckForUpdates(::grpc::ClientContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::SoftwareUpdate* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::Empty, ::tari::rpc::SoftwareUpdate, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CheckForUpdates_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::CheckForUpdates(::grpc::ClientContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::SoftwareUpdate* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CheckForUpdates_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::SoftwareUpdate>* BaseNode::Stub::PrepareAsyncCheckForUpdatesRaw(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::SoftwareUpdate, ::tari::rpc::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_CheckForUpdates_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::SoftwareUpdate>* BaseNode::Stub::AsyncCheckForUpdatesRaw(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncCheckForUpdatesRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::tari::rpc::ValueAtHeightResponse>* BaseNode::Stub::GetTokensInCirculationRaw(::grpc::ClientContext* context, const ::tari::rpc::GetBlocksRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::tari::rpc::ValueAtHeightResponse>::Create(channel_.get(), rpcmethod_GetTokensInCirculation_, context, request);
}

void BaseNode::Stub::async::GetTokensInCirculation(::grpc::ClientContext* context, const ::tari::rpc::GetBlocksRequest* request, ::grpc::ClientReadReactor< ::tari::rpc::ValueAtHeightResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::tari::rpc::ValueAtHeightResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_GetTokensInCirculation_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::tari::rpc::ValueAtHeightResponse>* BaseNode::Stub::AsyncGetTokensInCirculationRaw(::grpc::ClientContext* context, const ::tari::rpc::GetBlocksRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::ValueAtHeightResponse>::Create(channel_.get(), cq, rpcmethod_GetTokensInCirculation_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::tari::rpc::ValueAtHeightResponse>* BaseNode::Stub::PrepareAsyncGetTokensInCirculationRaw(::grpc::ClientContext* context, const ::tari::rpc::GetBlocksRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::ValueAtHeightResponse>::Create(channel_.get(), cq, rpcmethod_GetTokensInCirculation_, context, request, false, nullptr);
}

::grpc::ClientReader< ::tari::rpc::NetworkDifficultyResponse>* BaseNode::Stub::GetNetworkDifficultyRaw(::grpc::ClientContext* context, const ::tari::rpc::HeightRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::tari::rpc::NetworkDifficultyResponse>::Create(channel_.get(), rpcmethod_GetNetworkDifficulty_, context, request);
}

void BaseNode::Stub::async::GetNetworkDifficulty(::grpc::ClientContext* context, const ::tari::rpc::HeightRequest* request, ::grpc::ClientReadReactor< ::tari::rpc::NetworkDifficultyResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::tari::rpc::NetworkDifficultyResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_GetNetworkDifficulty_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::tari::rpc::NetworkDifficultyResponse>* BaseNode::Stub::AsyncGetNetworkDifficultyRaw(::grpc::ClientContext* context, const ::tari::rpc::HeightRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::NetworkDifficultyResponse>::Create(channel_.get(), cq, rpcmethod_GetNetworkDifficulty_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::tari::rpc::NetworkDifficultyResponse>* BaseNode::Stub::PrepareAsyncGetNetworkDifficultyRaw(::grpc::ClientContext* context, const ::tari::rpc::HeightRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::NetworkDifficultyResponse>::Create(channel_.get(), cq, rpcmethod_GetNetworkDifficulty_, context, request, false, nullptr);
}

::grpc::Status BaseNode::Stub::GetNewBlockTemplate(::grpc::ClientContext* context, const ::tari::rpc::NewBlockTemplateRequest& request, ::tari::rpc::NewBlockTemplateResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::NewBlockTemplateRequest, ::tari::rpc::NewBlockTemplateResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetNewBlockTemplate_, context, request, response);
}

void BaseNode::Stub::async::GetNewBlockTemplate(::grpc::ClientContext* context, const ::tari::rpc::NewBlockTemplateRequest* request, ::tari::rpc::NewBlockTemplateResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::NewBlockTemplateRequest, ::tari::rpc::NewBlockTemplateResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetNewBlockTemplate_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::GetNewBlockTemplate(::grpc::ClientContext* context, const ::tari::rpc::NewBlockTemplateRequest* request, ::tari::rpc::NewBlockTemplateResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetNewBlockTemplate_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::NewBlockTemplateResponse>* BaseNode::Stub::PrepareAsyncGetNewBlockTemplateRaw(::grpc::ClientContext* context, const ::tari::rpc::NewBlockTemplateRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::NewBlockTemplateResponse, ::tari::rpc::NewBlockTemplateRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetNewBlockTemplate_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::NewBlockTemplateResponse>* BaseNode::Stub::AsyncGetNewBlockTemplateRaw(::grpc::ClientContext* context, const ::tari::rpc::NewBlockTemplateRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetNewBlockTemplateRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::GetNewBlock(::grpc::ClientContext* context, const ::tari::rpc::NewBlockTemplate& request, ::tari::rpc::GetNewBlockResult* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::NewBlockTemplate, ::tari::rpc::GetNewBlockResult, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetNewBlock_, context, request, response);
}

void BaseNode::Stub::async::GetNewBlock(::grpc::ClientContext* context, const ::tari::rpc::NewBlockTemplate* request, ::tari::rpc::GetNewBlockResult* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::NewBlockTemplate, ::tari::rpc::GetNewBlockResult, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetNewBlock_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::GetNewBlock(::grpc::ClientContext* context, const ::tari::rpc::NewBlockTemplate* request, ::tari::rpc::GetNewBlockResult* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetNewBlock_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::GetNewBlockResult>* BaseNode::Stub::PrepareAsyncGetNewBlockRaw(::grpc::ClientContext* context, const ::tari::rpc::NewBlockTemplate& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::GetNewBlockResult, ::tari::rpc::NewBlockTemplate, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetNewBlock_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::GetNewBlockResult>* BaseNode::Stub::AsyncGetNewBlockRaw(::grpc::ClientContext* context, const ::tari::rpc::NewBlockTemplate& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetNewBlockRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::GetNewBlockWithCoinbases(::grpc::ClientContext* context, const ::tari::rpc::GetNewBlockWithCoinbasesRequest& request, ::tari::rpc::GetNewBlockResult* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::GetNewBlockWithCoinbasesRequest, ::tari::rpc::GetNewBlockResult, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetNewBlockWithCoinbases_, context, request, response);
}

void BaseNode::Stub::async::GetNewBlockWithCoinbases(::grpc::ClientContext* context, const ::tari::rpc::GetNewBlockWithCoinbasesRequest* request, ::tari::rpc::GetNewBlockResult* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::GetNewBlockWithCoinbasesRequest, ::tari::rpc::GetNewBlockResult, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetNewBlockWithCoinbases_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::GetNewBlockWithCoinbases(::grpc::ClientContext* context, const ::tari::rpc::GetNewBlockWithCoinbasesRequest* request, ::tari::rpc::GetNewBlockResult* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetNewBlockWithCoinbases_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::GetNewBlockResult>* BaseNode::Stub::PrepareAsyncGetNewBlockWithCoinbasesRaw(::grpc::ClientContext* context, const ::tari::rpc::GetNewBlockWithCoinbasesRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::GetNewBlockResult, ::tari::rpc::GetNewBlockWithCoinbasesRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetNewBlockWithCoinbases_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::GetNewBlockResult>* BaseNode::Stub::AsyncGetNewBlockWithCoinbasesRaw(::grpc::ClientContext* context, const ::tari::rpc::GetNewBlockWithCoinbasesRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetNewBlockWithCoinbasesRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::GetNewBlockTemplateWithCoinbases(::grpc::ClientContext* context, const ::tari::rpc::GetNewBlockTemplateWithCoinbasesRequest& request, ::tari::rpc::GetNewBlockResult* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::GetNewBlockTemplateWithCoinbasesRequest, ::tari::rpc::GetNewBlockResult, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetNewBlockTemplateWithCoinbases_, context, request, response);
}

void BaseNode::Stub::async::GetNewBlockTemplateWithCoinbases(::grpc::ClientContext* context, const ::tari::rpc::GetNewBlockTemplateWithCoinbasesRequest* request, ::tari::rpc::GetNewBlockResult* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::GetNewBlockTemplateWithCoinbasesRequest, ::tari::rpc::GetNewBlockResult, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetNewBlockTemplateWithCoinbases_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::GetNewBlockTemplateWithCoinbases(::grpc::ClientContext* context, const ::tari::rpc::GetNewBlockTemplateWithCoinbasesRequest* request, ::tari::rpc::GetNewBlockResult* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetNewBlockTemplateWithCoinbases_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::GetNewBlockResult>* BaseNode::Stub::PrepareAsyncGetNewBlockTemplateWithCoinbasesRaw(::grpc::ClientContext* context, const ::tari::rpc::GetNewBlockTemplateWithCoinbasesRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::GetNewBlockResult, ::tari::rpc::GetNewBlockTemplateWithCoinbasesRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetNewBlockTemplateWithCoinbases_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::GetNewBlockResult>* BaseNode::Stub::AsyncGetNewBlockTemplateWithCoinbasesRaw(::grpc::ClientContext* context, const ::tari::rpc::GetNewBlockTemplateWithCoinbasesRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetNewBlockTemplateWithCoinbasesRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::GetNewBlockBlob(::grpc::ClientContext* context, const ::tari::rpc::NewBlockTemplate& request, ::tari::rpc::GetNewBlockBlobResult* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::NewBlockTemplate, ::tari::rpc::GetNewBlockBlobResult, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetNewBlockBlob_, context, request, response);
}

void BaseNode::Stub::async::GetNewBlockBlob(::grpc::ClientContext* context, const ::tari::rpc::NewBlockTemplate* request, ::tari::rpc::GetNewBlockBlobResult* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::NewBlockTemplate, ::tari::rpc::GetNewBlockBlobResult, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetNewBlockBlob_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::GetNewBlockBlob(::grpc::ClientContext* context, const ::tari::rpc::NewBlockTemplate* request, ::tari::rpc::GetNewBlockBlobResult* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetNewBlockBlob_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::GetNewBlockBlobResult>* BaseNode::Stub::PrepareAsyncGetNewBlockBlobRaw(::grpc::ClientContext* context, const ::tari::rpc::NewBlockTemplate& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::GetNewBlockBlobResult, ::tari::rpc::NewBlockTemplate, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetNewBlockBlob_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::GetNewBlockBlobResult>* BaseNode::Stub::AsyncGetNewBlockBlobRaw(::grpc::ClientContext* context, const ::tari::rpc::NewBlockTemplate& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetNewBlockBlobRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::SubmitBlock(::grpc::ClientContext* context, const ::tari::rpc::Block& request, ::tari::rpc::SubmitBlockResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::Block, ::tari::rpc::SubmitBlockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SubmitBlock_, context, request, response);
}

void BaseNode::Stub::async::SubmitBlock(::grpc::ClientContext* context, const ::tari::rpc::Block* request, ::tari::rpc::SubmitBlockResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::Block, ::tari::rpc::SubmitBlockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SubmitBlock_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::SubmitBlock(::grpc::ClientContext* context, const ::tari::rpc::Block* request, ::tari::rpc::SubmitBlockResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SubmitBlock_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::SubmitBlockResponse>* BaseNode::Stub::PrepareAsyncSubmitBlockRaw(::grpc::ClientContext* context, const ::tari::rpc::Block& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::SubmitBlockResponse, ::tari::rpc::Block, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SubmitBlock_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::SubmitBlockResponse>* BaseNode::Stub::AsyncSubmitBlockRaw(::grpc::ClientContext* context, const ::tari::rpc::Block& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncSubmitBlockRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::SubmitBlockBlob(::grpc::ClientContext* context, const ::tari::rpc::BlockBlobRequest& request, ::tari::rpc::SubmitBlockResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::BlockBlobRequest, ::tari::rpc::SubmitBlockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SubmitBlockBlob_, context, request, response);
}

void BaseNode::Stub::async::SubmitBlockBlob(::grpc::ClientContext* context, const ::tari::rpc::BlockBlobRequest* request, ::tari::rpc::SubmitBlockResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::BlockBlobRequest, ::tari::rpc::SubmitBlockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SubmitBlockBlob_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::SubmitBlockBlob(::grpc::ClientContext* context, const ::tari::rpc::BlockBlobRequest* request, ::tari::rpc::SubmitBlockResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SubmitBlockBlob_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::SubmitBlockResponse>* BaseNode::Stub::PrepareAsyncSubmitBlockBlobRaw(::grpc::ClientContext* context, const ::tari::rpc::BlockBlobRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::SubmitBlockResponse, ::tari::rpc::BlockBlobRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SubmitBlockBlob_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::SubmitBlockResponse>* BaseNode::Stub::AsyncSubmitBlockBlobRaw(::grpc::ClientContext* context, const ::tari::rpc::BlockBlobRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncSubmitBlockBlobRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::SubmitTransaction(::grpc::ClientContext* context, const ::tari::rpc::SubmitTransactionRequest& request, ::tari::rpc::SubmitTransactionResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::SubmitTransactionRequest, ::tari::rpc::SubmitTransactionResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SubmitTransaction_, context, request, response);
}

void BaseNode::Stub::async::SubmitTransaction(::grpc::ClientContext* context, const ::tari::rpc::SubmitTransactionRequest* request, ::tari::rpc::SubmitTransactionResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::SubmitTransactionRequest, ::tari::rpc::SubmitTransactionResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SubmitTransaction_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::SubmitTransaction(::grpc::ClientContext* context, const ::tari::rpc::SubmitTransactionRequest* request, ::tari::rpc::SubmitTransactionResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SubmitTransaction_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::SubmitTransactionResponse>* BaseNode::Stub::PrepareAsyncSubmitTransactionRaw(::grpc::ClientContext* context, const ::tari::rpc::SubmitTransactionRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::SubmitTransactionResponse, ::tari::rpc::SubmitTransactionRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SubmitTransaction_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::SubmitTransactionResponse>* BaseNode::Stub::AsyncSubmitTransactionRaw(::grpc::ClientContext* context, const ::tari::rpc::SubmitTransactionRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncSubmitTransactionRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::GetSyncInfo(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::tari::rpc::SyncInfoResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::Empty, ::tari::rpc::SyncInfoResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetSyncInfo_, context, request, response);
}

void BaseNode::Stub::async::GetSyncInfo(::grpc::ClientContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::SyncInfoResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::Empty, ::tari::rpc::SyncInfoResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetSyncInfo_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::GetSyncInfo(::grpc::ClientContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::SyncInfoResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetSyncInfo_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::SyncInfoResponse>* BaseNode::Stub::PrepareAsyncGetSyncInfoRaw(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::SyncInfoResponse, ::tari::rpc::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetSyncInfo_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::SyncInfoResponse>* BaseNode::Stub::AsyncGetSyncInfoRaw(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetSyncInfoRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::GetSyncProgress(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::tari::rpc::SyncProgressResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::Empty, ::tari::rpc::SyncProgressResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetSyncProgress_, context, request, response);
}

void BaseNode::Stub::async::GetSyncProgress(::grpc::ClientContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::SyncProgressResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::Empty, ::tari::rpc::SyncProgressResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetSyncProgress_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::GetSyncProgress(::grpc::ClientContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::SyncProgressResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetSyncProgress_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::SyncProgressResponse>* BaseNode::Stub::PrepareAsyncGetSyncProgressRaw(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::SyncProgressResponse, ::tari::rpc::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetSyncProgress_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::SyncProgressResponse>* BaseNode::Stub::AsyncGetSyncProgressRaw(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetSyncProgressRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::GetTipInfo(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::tari::rpc::TipInfoResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::Empty, ::tari::rpc::TipInfoResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetTipInfo_, context, request, response);
}

void BaseNode::Stub::async::GetTipInfo(::grpc::ClientContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::TipInfoResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::Empty, ::tari::rpc::TipInfoResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetTipInfo_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::GetTipInfo(::grpc::ClientContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::TipInfoResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetTipInfo_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::TipInfoResponse>* BaseNode::Stub::PrepareAsyncGetTipInfoRaw(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::TipInfoResponse, ::tari::rpc::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetTipInfo_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::TipInfoResponse>* BaseNode::Stub::AsyncGetTipInfoRaw(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetTipInfoRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::tari::rpc::HistoricalBlock>* BaseNode::Stub::SearchKernelsRaw(::grpc::ClientContext* context, const ::tari::rpc::SearchKernelsRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::tari::rpc::HistoricalBlock>::Create(channel_.get(), rpcmethod_SearchKernels_, context, request);
}

void BaseNode::Stub::async::SearchKernels(::grpc::ClientContext* context, const ::tari::rpc::SearchKernelsRequest* request, ::grpc::ClientReadReactor< ::tari::rpc::HistoricalBlock>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::tari::rpc::HistoricalBlock>::Create(stub_->channel_.get(), stub_->rpcmethod_SearchKernels_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::tari::rpc::HistoricalBlock>* BaseNode::Stub::AsyncSearchKernelsRaw(::grpc::ClientContext* context, const ::tari::rpc::SearchKernelsRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::HistoricalBlock>::Create(channel_.get(), cq, rpcmethod_SearchKernels_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::tari::rpc::HistoricalBlock>* BaseNode::Stub::PrepareAsyncSearchKernelsRaw(::grpc::ClientContext* context, const ::tari::rpc::SearchKernelsRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::HistoricalBlock>::Create(channel_.get(), cq, rpcmethod_SearchKernels_, context, request, false, nullptr);
}

::grpc::ClientReader< ::tari::rpc::HistoricalBlock>* BaseNode::Stub::SearchUtxosRaw(::grpc::ClientContext* context, const ::tari::rpc::SearchUtxosRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::tari::rpc::HistoricalBlock>::Create(channel_.get(), rpcmethod_SearchUtxos_, context, request);
}

void BaseNode::Stub::async::SearchUtxos(::grpc::ClientContext* context, const ::tari::rpc::SearchUtxosRequest* request, ::grpc::ClientReadReactor< ::tari::rpc::HistoricalBlock>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::tari::rpc::HistoricalBlock>::Create(stub_->channel_.get(), stub_->rpcmethod_SearchUtxos_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::tari::rpc::HistoricalBlock>* BaseNode::Stub::AsyncSearchUtxosRaw(::grpc::ClientContext* context, const ::tari::rpc::SearchUtxosRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::HistoricalBlock>::Create(channel_.get(), cq, rpcmethod_SearchUtxos_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::tari::rpc::HistoricalBlock>* BaseNode::Stub::PrepareAsyncSearchUtxosRaw(::grpc::ClientContext* context, const ::tari::rpc::SearchUtxosRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::HistoricalBlock>::Create(channel_.get(), cq, rpcmethod_SearchUtxos_, context, request, false, nullptr);
}

::grpc::ClientReader< ::tari::rpc::FetchMatchingUtxosResponse>* BaseNode::Stub::FetchMatchingUtxosRaw(::grpc::ClientContext* context, const ::tari::rpc::FetchMatchingUtxosRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::tari::rpc::FetchMatchingUtxosResponse>::Create(channel_.get(), rpcmethod_FetchMatchingUtxos_, context, request);
}

void BaseNode::Stub::async::FetchMatchingUtxos(::grpc::ClientContext* context, const ::tari::rpc::FetchMatchingUtxosRequest* request, ::grpc::ClientReadReactor< ::tari::rpc::FetchMatchingUtxosResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::tari::rpc::FetchMatchingUtxosResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_FetchMatchingUtxos_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::tari::rpc::FetchMatchingUtxosResponse>* BaseNode::Stub::AsyncFetchMatchingUtxosRaw(::grpc::ClientContext* context, const ::tari::rpc::FetchMatchingUtxosRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::FetchMatchingUtxosResponse>::Create(channel_.get(), cq, rpcmethod_FetchMatchingUtxos_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::tari::rpc::FetchMatchingUtxosResponse>* BaseNode::Stub::PrepareAsyncFetchMatchingUtxosRaw(::grpc::ClientContext* context, const ::tari::rpc::FetchMatchingUtxosRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::FetchMatchingUtxosResponse>::Create(channel_.get(), cq, rpcmethod_FetchMatchingUtxos_, context, request, false, nullptr);
}

::grpc::ClientReader< ::tari::rpc::GetPeersResponse>* BaseNode::Stub::GetPeersRaw(::grpc::ClientContext* context, const ::tari::rpc::GetPeersRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::tari::rpc::GetPeersResponse>::Create(channel_.get(), rpcmethod_GetPeers_, context, request);
}

void BaseNode::Stub::async::GetPeers(::grpc::ClientContext* context, const ::tari::rpc::GetPeersRequest* request, ::grpc::ClientReadReactor< ::tari::rpc::GetPeersResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::tari::rpc::GetPeersResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_GetPeers_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::tari::rpc::GetPeersResponse>* BaseNode::Stub::AsyncGetPeersRaw(::grpc::ClientContext* context, const ::tari::rpc::GetPeersRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::GetPeersResponse>::Create(channel_.get(), cq, rpcmethod_GetPeers_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::tari::rpc::GetPeersResponse>* BaseNode::Stub::PrepareAsyncGetPeersRaw(::grpc::ClientContext* context, const ::tari::rpc::GetPeersRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::GetPeersResponse>::Create(channel_.get(), cq, rpcmethod_GetPeers_, context, request, false, nullptr);
}

::grpc::ClientReader< ::tari::rpc::GetMempoolTransactionsResponse>* BaseNode::Stub::GetMempoolTransactionsRaw(::grpc::ClientContext* context, const ::tari::rpc::GetMempoolTransactionsRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::tari::rpc::GetMempoolTransactionsResponse>::Create(channel_.get(), rpcmethod_GetMempoolTransactions_, context, request);
}

void BaseNode::Stub::async::GetMempoolTransactions(::grpc::ClientContext* context, const ::tari::rpc::GetMempoolTransactionsRequest* request, ::grpc::ClientReadReactor< ::tari::rpc::GetMempoolTransactionsResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::tari::rpc::GetMempoolTransactionsResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_GetMempoolTransactions_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::tari::rpc::GetMempoolTransactionsResponse>* BaseNode::Stub::AsyncGetMempoolTransactionsRaw(::grpc::ClientContext* context, const ::tari::rpc::GetMempoolTransactionsRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::GetMempoolTransactionsResponse>::Create(channel_.get(), cq, rpcmethod_GetMempoolTransactions_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::tari::rpc::GetMempoolTransactionsResponse>* BaseNode::Stub::PrepareAsyncGetMempoolTransactionsRaw(::grpc::ClientContext* context, const ::tari::rpc::GetMempoolTransactionsRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::GetMempoolTransactionsResponse>::Create(channel_.get(), cq, rpcmethod_GetMempoolTransactions_, context, request, false, nullptr);
}

::grpc::Status BaseNode::Stub::TransactionState(::grpc::ClientContext* context, const ::tari::rpc::TransactionStateRequest& request, ::tari::rpc::TransactionStateResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::TransactionStateRequest, ::tari::rpc::TransactionStateResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_TransactionState_, context, request, response);
}

void BaseNode::Stub::async::TransactionState(::grpc::ClientContext* context, const ::tari::rpc::TransactionStateRequest* request, ::tari::rpc::TransactionStateResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::TransactionStateRequest, ::tari::rpc::TransactionStateResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_TransactionState_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::TransactionState(::grpc::ClientContext* context, const ::tari::rpc::TransactionStateRequest* request, ::tari::rpc::TransactionStateResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_TransactionState_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::TransactionStateResponse>* BaseNode::Stub::PrepareAsyncTransactionStateRaw(::grpc::ClientContext* context, const ::tari::rpc::TransactionStateRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::TransactionStateResponse, ::tari::rpc::TransactionStateRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_TransactionState_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::TransactionStateResponse>* BaseNode::Stub::AsyncTransactionStateRaw(::grpc::ClientContext* context, const ::tari::rpc::TransactionStateRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncTransactionStateRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::Identify(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::tari::rpc::NodeIdentity* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::Empty, ::tari::rpc::NodeIdentity, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Identify_, context, request, response);
}

void BaseNode::Stub::async::Identify(::grpc::ClientContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::NodeIdentity* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::Empty, ::tari::rpc::NodeIdentity, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Identify_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::Identify(::grpc::ClientContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::NodeIdentity* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Identify_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::NodeIdentity>* BaseNode::Stub::PrepareAsyncIdentifyRaw(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::NodeIdentity, ::tari::rpc::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Identify_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::NodeIdentity>* BaseNode::Stub::AsyncIdentifyRaw(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncIdentifyRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::GetNetworkStatus(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::tari::rpc::NetworkStatusResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::Empty, ::tari::rpc::NetworkStatusResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetNetworkStatus_, context, request, response);
}

void BaseNode::Stub::async::GetNetworkStatus(::grpc::ClientContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::NetworkStatusResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::Empty, ::tari::rpc::NetworkStatusResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetNetworkStatus_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::GetNetworkStatus(::grpc::ClientContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::NetworkStatusResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetNetworkStatus_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::NetworkStatusResponse>* BaseNode::Stub::PrepareAsyncGetNetworkStatusRaw(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::NetworkStatusResponse, ::tari::rpc::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetNetworkStatus_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::NetworkStatusResponse>* BaseNode::Stub::AsyncGetNetworkStatusRaw(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetNetworkStatusRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::ListConnectedPeers(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::tari::rpc::ListConnectedPeersResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::Empty, ::tari::rpc::ListConnectedPeersResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_ListConnectedPeers_, context, request, response);
}

void BaseNode::Stub::async::ListConnectedPeers(::grpc::ClientContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::ListConnectedPeersResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::Empty, ::tari::rpc::ListConnectedPeersResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ListConnectedPeers_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::ListConnectedPeers(::grpc::ClientContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::ListConnectedPeersResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ListConnectedPeers_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::ListConnectedPeersResponse>* BaseNode::Stub::PrepareAsyncListConnectedPeersRaw(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::ListConnectedPeersResponse, ::tari::rpc::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_ListConnectedPeers_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::ListConnectedPeersResponse>* BaseNode::Stub::AsyncListConnectedPeersRaw(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncListConnectedPeersRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status BaseNode::Stub::GetMempoolStats(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::tari::rpc::MempoolStatsResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::Empty, ::tari::rpc::MempoolStatsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetMempoolStats_, context, request, response);
}

void BaseNode::Stub::async::GetMempoolStats(::grpc::ClientContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::MempoolStatsResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::Empty, ::tari::rpc::MempoolStatsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetMempoolStats_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::GetMempoolStats(::grpc::ClientContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::MempoolStatsResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetMempoolStats_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::MempoolStatsResponse>* BaseNode::Stub::PrepareAsyncGetMempoolStatsRaw(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::MempoolStatsResponse, ::tari::rpc::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetMempoolStats_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::MempoolStatsResponse>* BaseNode::Stub::AsyncGetMempoolStatsRaw(::grpc::ClientContext* context, const ::tari::rpc::Empty& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetMempoolStatsRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::tari::rpc::GetActiveValidatorNodesResponse>* BaseNode::Stub::GetActiveValidatorNodesRaw(::grpc::ClientContext* context, const ::tari::rpc::GetActiveValidatorNodesRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::tari::rpc::GetActiveValidatorNodesResponse>::Create(channel_.get(), rpcmethod_GetActiveValidatorNodes_, context, request);
}

void BaseNode::Stub::async::GetActiveValidatorNodes(::grpc::ClientContext* context, const ::tari::rpc::GetActiveValidatorNodesRequest* request, ::grpc::ClientReadReactor< ::tari::rpc::GetActiveValidatorNodesResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::tari::rpc::GetActiveValidatorNodesResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_GetActiveValidatorNodes_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::tari::rpc::GetActiveValidatorNodesResponse>* BaseNode::Stub::AsyncGetActiveValidatorNodesRaw(::grpc::ClientContext* context, const ::tari::rpc::GetActiveValidatorNodesRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::GetActiveValidatorNodesResponse>::Create(channel_.get(), cq, rpcmethod_GetActiveValidatorNodes_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::tari::rpc::GetActiveValidatorNodesResponse>* BaseNode::Stub::PrepareAsyncGetActiveValidatorNodesRaw(::grpc::ClientContext* context, const ::tari::rpc::GetActiveValidatorNodesRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::GetActiveValidatorNodesResponse>::Create(channel_.get(), cq, rpcmethod_GetActiveValidatorNodes_, context, request, false, nullptr);
}

::grpc::Status BaseNode::Stub::GetShardKey(::grpc::ClientContext* context, const ::tari::rpc::GetShardKeyRequest& request, ::tari::rpc::GetShardKeyResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::tari::rpc::GetShardKeyRequest, ::tari::rpc::GetShardKeyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetShardKey_, context, request, response);
}

void BaseNode::Stub::async::GetShardKey(::grpc::ClientContext* context, const ::tari::rpc::GetShardKeyRequest* request, ::tari::rpc::GetShardKeyResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::tari::rpc::GetShardKeyRequest, ::tari::rpc::GetShardKeyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetShardKey_, context, request, response, std::move(f));
}

void BaseNode::Stub::async::GetShardKey(::grpc::ClientContext* context, const ::tari::rpc::GetShardKeyRequest* request, ::tari::rpc::GetShardKeyResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetShardKey_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::GetShardKeyResponse>* BaseNode::Stub::PrepareAsyncGetShardKeyRaw(::grpc::ClientContext* context, const ::tari::rpc::GetShardKeyRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::tari::rpc::GetShardKeyResponse, ::tari::rpc::GetShardKeyRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetShardKey_, context, request);
}

::grpc::ClientAsyncResponseReader< ::tari::rpc::GetShardKeyResponse>* BaseNode::Stub::AsyncGetShardKeyRaw(::grpc::ClientContext* context, const ::tari::rpc::GetShardKeyRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetShardKeyRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::tari::rpc::GetTemplateRegistrationResponse>* BaseNode::Stub::GetTemplateRegistrationsRaw(::grpc::ClientContext* context, const ::tari::rpc::GetTemplateRegistrationsRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::tari::rpc::GetTemplateRegistrationResponse>::Create(channel_.get(), rpcmethod_GetTemplateRegistrations_, context, request);
}

void BaseNode::Stub::async::GetTemplateRegistrations(::grpc::ClientContext* context, const ::tari::rpc::GetTemplateRegistrationsRequest* request, ::grpc::ClientReadReactor< ::tari::rpc::GetTemplateRegistrationResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::tari::rpc::GetTemplateRegistrationResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_GetTemplateRegistrations_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::tari::rpc::GetTemplateRegistrationResponse>* BaseNode::Stub::AsyncGetTemplateRegistrationsRaw(::grpc::ClientContext* context, const ::tari::rpc::GetTemplateRegistrationsRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::GetTemplateRegistrationResponse>::Create(channel_.get(), cq, rpcmethod_GetTemplateRegistrations_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::tari::rpc::GetTemplateRegistrationResponse>* BaseNode::Stub::PrepareAsyncGetTemplateRegistrationsRaw(::grpc::ClientContext* context, const ::tari::rpc::GetTemplateRegistrationsRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::GetTemplateRegistrationResponse>::Create(channel_.get(), cq, rpcmethod_GetTemplateRegistrations_, context, request, false, nullptr);
}

::grpc::ClientReader< ::tari::rpc::GetSideChainUtxosResponse>* BaseNode::Stub::GetSideChainUtxosRaw(::grpc::ClientContext* context, const ::tari::rpc::GetSideChainUtxosRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::tari::rpc::GetSideChainUtxosResponse>::Create(channel_.get(), rpcmethod_GetSideChainUtxos_, context, request);
}

void BaseNode::Stub::async::GetSideChainUtxos(::grpc::ClientContext* context, const ::tari::rpc::GetSideChainUtxosRequest* request, ::grpc::ClientReadReactor< ::tari::rpc::GetSideChainUtxosResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::tari::rpc::GetSideChainUtxosResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_GetSideChainUtxos_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::tari::rpc::GetSideChainUtxosResponse>* BaseNode::Stub::AsyncGetSideChainUtxosRaw(::grpc::ClientContext* context, const ::tari::rpc::GetSideChainUtxosRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::GetSideChainUtxosResponse>::Create(channel_.get(), cq, rpcmethod_GetSideChainUtxos_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::tari::rpc::GetSideChainUtxosResponse>* BaseNode::Stub::PrepareAsyncGetSideChainUtxosRaw(::grpc::ClientContext* context, const ::tari::rpc::GetSideChainUtxosRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::tari::rpc::GetSideChainUtxosResponse>::Create(channel_.get(), cq, rpcmethod_GetSideChainUtxos_, context, request, false, nullptr);
}

BaseNode::Service::Service() {
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[0],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< BaseNode::Service, ::tari::rpc::ListHeadersRequest, ::tari::rpc::BlockHeaderResponse>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::ListHeadersRequest* req,
             ::grpc::ServerWriter<::tari::rpc::BlockHeaderResponse>* writer) {
               return service->ListHeaders(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[1],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::GetHeaderByHashRequest, ::tari::rpc::BlockHeaderResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::GetHeaderByHashRequest* req,
             ::tari::rpc::BlockHeaderResponse* resp) {
               return service->GetHeaderByHash(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[2],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< BaseNode::Service, ::tari::rpc::GetBlocksRequest, ::tari::rpc::HistoricalBlock>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::GetBlocksRequest* req,
             ::grpc::ServerWriter<::tari::rpc::HistoricalBlock>* writer) {
               return service->GetBlocks(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[3],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::HeightRequest, ::tari::rpc::BlockTimingResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::HeightRequest* req,
             ::tari::rpc::BlockTimingResponse* resp) {
               return service->GetBlockTiming(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[4],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::BlockHeight, ::tari::rpc::ConsensusConstants, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::BlockHeight* req,
             ::tari::rpc::ConsensusConstants* resp) {
               return service->GetConstants(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[5],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::BlockGroupRequest, ::tari::rpc::BlockGroupResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::BlockGroupRequest* req,
             ::tari::rpc::BlockGroupResponse* resp) {
               return service->GetBlockSize(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[6],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::BlockGroupRequest, ::tari::rpc::BlockGroupResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::BlockGroupRequest* req,
             ::tari::rpc::BlockGroupResponse* resp) {
               return service->GetBlockFees(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[7],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::Empty, ::tari::rpc::StringValue, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::Empty* req,
             ::tari::rpc::StringValue* resp) {
               return service->GetVersion(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[8],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::Empty, ::tari::rpc::SoftwareUpdate, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::Empty* req,
             ::tari::rpc::SoftwareUpdate* resp) {
               return service->CheckForUpdates(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[9],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< BaseNode::Service, ::tari::rpc::GetBlocksRequest, ::tari::rpc::ValueAtHeightResponse>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::GetBlocksRequest* req,
             ::grpc::ServerWriter<::tari::rpc::ValueAtHeightResponse>* writer) {
               return service->GetTokensInCirculation(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[10],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< BaseNode::Service, ::tari::rpc::HeightRequest, ::tari::rpc::NetworkDifficultyResponse>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::HeightRequest* req,
             ::grpc::ServerWriter<::tari::rpc::NetworkDifficultyResponse>* writer) {
               return service->GetNetworkDifficulty(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[11],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::NewBlockTemplateRequest, ::tari::rpc::NewBlockTemplateResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::NewBlockTemplateRequest* req,
             ::tari::rpc::NewBlockTemplateResponse* resp) {
               return service->GetNewBlockTemplate(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[12],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::NewBlockTemplate, ::tari::rpc::GetNewBlockResult, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::NewBlockTemplate* req,
             ::tari::rpc::GetNewBlockResult* resp) {
               return service->GetNewBlock(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[13],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::GetNewBlockWithCoinbasesRequest, ::tari::rpc::GetNewBlockResult, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::GetNewBlockWithCoinbasesRequest* req,
             ::tari::rpc::GetNewBlockResult* resp) {
               return service->GetNewBlockWithCoinbases(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[14],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::GetNewBlockTemplateWithCoinbasesRequest, ::tari::rpc::GetNewBlockResult, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::GetNewBlockTemplateWithCoinbasesRequest* req,
             ::tari::rpc::GetNewBlockResult* resp) {
               return service->GetNewBlockTemplateWithCoinbases(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[15],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::NewBlockTemplate, ::tari::rpc::GetNewBlockBlobResult, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::NewBlockTemplate* req,
             ::tari::rpc::GetNewBlockBlobResult* resp) {
               return service->GetNewBlockBlob(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[16],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::Block, ::tari::rpc::SubmitBlockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::Block* req,
             ::tari::rpc::SubmitBlockResponse* resp) {
               return service->SubmitBlock(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[17],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::BlockBlobRequest, ::tari::rpc::SubmitBlockResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::BlockBlobRequest* req,
             ::tari::rpc::SubmitBlockResponse* resp) {
               return service->SubmitBlockBlob(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[18],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::SubmitTransactionRequest, ::tari::rpc::SubmitTransactionResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::SubmitTransactionRequest* req,
             ::tari::rpc::SubmitTransactionResponse* resp) {
               return service->SubmitTransaction(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[19],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::Empty, ::tari::rpc::SyncInfoResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::Empty* req,
             ::tari::rpc::SyncInfoResponse* resp) {
               return service->GetSyncInfo(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[20],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::Empty, ::tari::rpc::SyncProgressResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::Empty* req,
             ::tari::rpc::SyncProgressResponse* resp) {
               return service->GetSyncProgress(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[21],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::Empty, ::tari::rpc::TipInfoResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::Empty* req,
             ::tari::rpc::TipInfoResponse* resp) {
               return service->GetTipInfo(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[22],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< BaseNode::Service, ::tari::rpc::SearchKernelsRequest, ::tari::rpc::HistoricalBlock>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::SearchKernelsRequest* req,
             ::grpc::ServerWriter<::tari::rpc::HistoricalBlock>* writer) {
               return service->SearchKernels(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[23],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< BaseNode::Service, ::tari::rpc::SearchUtxosRequest, ::tari::rpc::HistoricalBlock>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::SearchUtxosRequest* req,
             ::grpc::ServerWriter<::tari::rpc::HistoricalBlock>* writer) {
               return service->SearchUtxos(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[24],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< BaseNode::Service, ::tari::rpc::FetchMatchingUtxosRequest, ::tari::rpc::FetchMatchingUtxosResponse>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::FetchMatchingUtxosRequest* req,
             ::grpc::ServerWriter<::tari::rpc::FetchMatchingUtxosResponse>* writer) {
               return service->FetchMatchingUtxos(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[25],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< BaseNode::Service, ::tari::rpc::GetPeersRequest, ::tari::rpc::GetPeersResponse>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::GetPeersRequest* req,
             ::grpc::ServerWriter<::tari::rpc::GetPeersResponse>* writer) {
               return service->GetPeers(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[26],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< BaseNode::Service, ::tari::rpc::GetMempoolTransactionsRequest, ::tari::rpc::GetMempoolTransactionsResponse>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::GetMempoolTransactionsRequest* req,
             ::grpc::ServerWriter<::tari::rpc::GetMempoolTransactionsResponse>* writer) {
               return service->GetMempoolTransactions(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[27],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::TransactionStateRequest, ::tari::rpc::TransactionStateResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::TransactionStateRequest* req,
             ::tari::rpc::TransactionStateResponse* resp) {
               return service->TransactionState(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[28],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::Empty, ::tari::rpc::NodeIdentity, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::Empty* req,
             ::tari::rpc::NodeIdentity* resp) {
               return service->Identify(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[29],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::Empty, ::tari::rpc::NetworkStatusResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::Empty* req,
             ::tari::rpc::NetworkStatusResponse* resp) {
               return service->GetNetworkStatus(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[30],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::Empty, ::tari::rpc::ListConnectedPeersResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::Empty* req,
             ::tari::rpc::ListConnectedPeersResponse* resp) {
               return service->ListConnectedPeers(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[31],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::Empty, ::tari::rpc::MempoolStatsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::Empty* req,
             ::tari::rpc::MempoolStatsResponse* resp) {
               return service->GetMempoolStats(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[32],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< BaseNode::Service, ::tari::rpc::GetActiveValidatorNodesRequest, ::tari::rpc::GetActiveValidatorNodesResponse>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::GetActiveValidatorNodesRequest* req,
             ::grpc::ServerWriter<::tari::rpc::GetActiveValidatorNodesResponse>* writer) {
               return service->GetActiveValidatorNodes(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[33],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< BaseNode::Service, ::tari::rpc::GetShardKeyRequest, ::tari::rpc::GetShardKeyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::GetShardKeyRequest* req,
             ::tari::rpc::GetShardKeyResponse* resp) {
               return service->GetShardKey(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[34],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< BaseNode::Service, ::tari::rpc::GetTemplateRegistrationsRequest, ::tari::rpc::GetTemplateRegistrationResponse>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::GetTemplateRegistrationsRequest* req,
             ::grpc::ServerWriter<::tari::rpc::GetTemplateRegistrationResponse>* writer) {
               return service->GetTemplateRegistrations(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      BaseNode_method_names[35],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< BaseNode::Service, ::tari::rpc::GetSideChainUtxosRequest, ::tari::rpc::GetSideChainUtxosResponse>(
          [](BaseNode::Service* service,
             ::grpc::ServerContext* ctx,
             const ::tari::rpc::GetSideChainUtxosRequest* req,
             ::grpc::ServerWriter<::tari::rpc::GetSideChainUtxosResponse>* writer) {
               return service->GetSideChainUtxos(ctx, req, writer);
             }, this)));
}

BaseNode::Service::~Service() {
}

::grpc::Status BaseNode::Service::ListHeaders(::grpc::ServerContext* context, const ::tari::rpc::ListHeadersRequest* request, ::grpc::ServerWriter< ::tari::rpc::BlockHeaderResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetHeaderByHash(::grpc::ServerContext* context, const ::tari::rpc::GetHeaderByHashRequest* request, ::tari::rpc::BlockHeaderResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetBlocks(::grpc::ServerContext* context, const ::tari::rpc::GetBlocksRequest* request, ::grpc::ServerWriter< ::tari::rpc::HistoricalBlock>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetBlockTiming(::grpc::ServerContext* context, const ::tari::rpc::HeightRequest* request, ::tari::rpc::BlockTimingResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetConstants(::grpc::ServerContext* context, const ::tari::rpc::BlockHeight* request, ::tari::rpc::ConsensusConstants* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetBlockSize(::grpc::ServerContext* context, const ::tari::rpc::BlockGroupRequest* request, ::tari::rpc::BlockGroupResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetBlockFees(::grpc::ServerContext* context, const ::tari::rpc::BlockGroupRequest* request, ::tari::rpc::BlockGroupResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetVersion(::grpc::ServerContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::StringValue* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::CheckForUpdates(::grpc::ServerContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::SoftwareUpdate* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetTokensInCirculation(::grpc::ServerContext* context, const ::tari::rpc::GetBlocksRequest* request, ::grpc::ServerWriter< ::tari::rpc::ValueAtHeightResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetNetworkDifficulty(::grpc::ServerContext* context, const ::tari::rpc::HeightRequest* request, ::grpc::ServerWriter< ::tari::rpc::NetworkDifficultyResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetNewBlockTemplate(::grpc::ServerContext* context, const ::tari::rpc::NewBlockTemplateRequest* request, ::tari::rpc::NewBlockTemplateResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetNewBlock(::grpc::ServerContext* context, const ::tari::rpc::NewBlockTemplate* request, ::tari::rpc::GetNewBlockResult* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetNewBlockWithCoinbases(::grpc::ServerContext* context, const ::tari::rpc::GetNewBlockWithCoinbasesRequest* request, ::tari::rpc::GetNewBlockResult* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetNewBlockTemplateWithCoinbases(::grpc::ServerContext* context, const ::tari::rpc::GetNewBlockTemplateWithCoinbasesRequest* request, ::tari::rpc::GetNewBlockResult* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetNewBlockBlob(::grpc::ServerContext* context, const ::tari::rpc::NewBlockTemplate* request, ::tari::rpc::GetNewBlockBlobResult* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::SubmitBlock(::grpc::ServerContext* context, const ::tari::rpc::Block* request, ::tari::rpc::SubmitBlockResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::SubmitBlockBlob(::grpc::ServerContext* context, const ::tari::rpc::BlockBlobRequest* request, ::tari::rpc::SubmitBlockResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::SubmitTransaction(::grpc::ServerContext* context, const ::tari::rpc::SubmitTransactionRequest* request, ::tari::rpc::SubmitTransactionResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetSyncInfo(::grpc::ServerContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::SyncInfoResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetSyncProgress(::grpc::ServerContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::SyncProgressResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetTipInfo(::grpc::ServerContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::TipInfoResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::SearchKernels(::grpc::ServerContext* context, const ::tari::rpc::SearchKernelsRequest* request, ::grpc::ServerWriter< ::tari::rpc::HistoricalBlock>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::SearchUtxos(::grpc::ServerContext* context, const ::tari::rpc::SearchUtxosRequest* request, ::grpc::ServerWriter< ::tari::rpc::HistoricalBlock>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::FetchMatchingUtxos(::grpc::ServerContext* context, const ::tari::rpc::FetchMatchingUtxosRequest* request, ::grpc::ServerWriter< ::tari::rpc::FetchMatchingUtxosResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetPeers(::grpc::ServerContext* context, const ::tari::rpc::GetPeersRequest* request, ::grpc::ServerWriter< ::tari::rpc::GetPeersResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetMempoolTransactions(::grpc::ServerContext* context, const ::tari::rpc::GetMempoolTransactionsRequest* request, ::grpc::ServerWriter< ::tari::rpc::GetMempoolTransactionsResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::TransactionState(::grpc::ServerContext* context, const ::tari::rpc::TransactionStateRequest* request, ::tari::rpc::TransactionStateResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::Identify(::grpc::ServerContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::NodeIdentity* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetNetworkStatus(::grpc::ServerContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::NetworkStatusResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::ListConnectedPeers(::grpc::ServerContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::ListConnectedPeersResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetMempoolStats(::grpc::ServerContext* context, const ::tari::rpc::Empty* request, ::tari::rpc::MempoolStatsResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetActiveValidatorNodes(::grpc::ServerContext* context, const ::tari::rpc::GetActiveValidatorNodesRequest* request, ::grpc::ServerWriter< ::tari::rpc::GetActiveValidatorNodesResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetShardKey(::grpc::ServerContext* context, const ::tari::rpc::GetShardKeyRequest* request, ::tari::rpc::GetShardKeyResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetTemplateRegistrations(::grpc::ServerContext* context, const ::tari::rpc::GetTemplateRegistrationsRequest* request, ::grpc::ServerWriter< ::tari::rpc::GetTemplateRegistrationResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status BaseNode::Service::GetSideChainUtxos(::grpc::ServerContext* context, const ::tari::rpc::GetSideChainUtxosRequest* request, ::grpc::ServerWriter< ::tari::rpc::GetSideChainUtxosResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}


}  // namespace tari
}  // namespace rpc

