// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.2.0
// - protoc             (unknown)
// source: nebula/v1/service.proto

package nebulav1

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

// NebulaServiceClient is the client API for NebulaService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type NebulaServiceClient interface {
	// web3
	Sha3(ctx context.Context, in *Sha3Request, opts ...grpc.CallOption) (*Sha3Response, error)
	NodeVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NodeVersionResponse, error)
	// network info service
	NetVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetVersionResponse, error)
	NetPeerCount(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetPeerCountResponse, error)
	// node status
	ProtocolVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ProtocolVersionResponse, error)
	Syncing(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*SyncingResponse, error)
	Coinbase(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*CoinbaseResponse, error)
	Mining(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*MiningResponse, error)
	HashRate(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HashRateResponse, error)
	Accounts(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*AccountsResponse, error)
	// tx operatoration
	GasPrice(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GasPriceResponse, error)
	// block info service
	BlockNumber(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HeightResponse, error)
	BlockByHash(ctx context.Context, in *BlockByHashRequest, opts ...grpc.CallOption) (*BlockByHashResponse, error)
	BlockByNumber(ctx context.Context, in *BlockByNumberRequest, opts ...grpc.CallOption) (*BlockByNumberResponse, error)
	BlockTransactionCountByHash(ctx context.Context, in *BlockTransactionCountByHashRequest, opts ...grpc.CallOption) (*BlockTransactionCountByHashResponse, error)
	BlockTransactionCountByNumber(ctx context.Context, in *BlockTransactionCountByNumberRequest, opts ...grpc.CallOption) (*BlockTransactionCountByNumberResponse, error)
	UncleCountByHash(ctx context.Context, in *UncleCountByHashRequest, opts ...grpc.CallOption) (*UncleCountByHashResponse, error)
	UncleCountByNumber(ctx context.Context, in *UncleCountByNumberRequest, opts ...grpc.CallOption) (*UncleCountByNumberResponse, error)
	UncleByBlockHashAndIndex(ctx context.Context, in *UncleByBlockHashAndIndexRequest, opts ...grpc.CallOption) (*UncleByBlockHashAndIndexResponse, error)
	UncleByBlockNumberAndIndex(ctx context.Context, in *UncleByBlockNumberAndIndexRequest, opts ...grpc.CallOption) (*UncleByBlockNumberAndIndexResponse, error)
	// compiler
	Compilers(ctx context.Context, in *CompilersRequest, opts ...grpc.CallOption) (*CompilersResponse, error)
	CompileSolidity(ctx context.Context, in *CompileSolidityRequest, opts ...grpc.CallOption) (*CompileSolidityResponse, error)
	CompileLLL(ctx context.Context, in *CompileLLLRequest, opts ...grpc.CallOption) (*CompileLLLResponse, error)
	CompileSerpent(ctx context.Context, in *CompileSerpentRequest, opts ...grpc.CallOption) (*CompileSerpentResponse, error)
	// transaction info service
	EstimateGas(ctx context.Context, in *EstimateGasRequest, opts ...grpc.CallOption) (*EstimateGasResponse, error)
	TransactionByHash(ctx context.Context, in *TransactionByHashRequest, opts ...grpc.CallOption) (*TransactionByHashResponse, error)
	TransactionByBlockHashAndIndex(ctx context.Context, in *TransactionByBlockHashAndIndexRequest, opts ...grpc.CallOption) (*TransactionByBlockHashAndIndexResponse, error)
	TransactionByBlockNumberAndIndex(ctx context.Context, in *TransactionByBlockNumberAndIndexRequest, opts ...grpc.CallOption) (*TransactionByBlockNumberAndIndexResponse, error)
	TransactionReceipt(ctx context.Context, in *TransactionReceiptRequest, opts ...grpc.CallOption) (*TransactionReceiptResponse, error)
	// account info service
	Balance(ctx context.Context, in *BalanceRequest, opts ...grpc.CallOption) (*BalanceResponse, error)
	Storage(ctx context.Context, in *StorageRequest, opts ...grpc.CallOption) (*StorageResponse, error)
	Nonce(ctx context.Context, in *NonceRequest, opts ...grpc.CallOption) (*NonceResponse, error)
	RepeatedNonce(ctx context.Context, in *RepeatedNonceRequest, opts ...grpc.CallOption) (*RepeatedNonceResponse, error)
	TransactionCount(ctx context.Context, in *TransactionCountRequest, opts ...grpc.CallOption) (*TransactionCountResponse, error)
	GetCode(ctx context.Context, in *GetCodeRequest, opts ...grpc.CallOption) (*GetCodeResponse, error)
	Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error)
	SignTransaction(ctx context.Context, in *SignTransactionRequest, opts ...grpc.CallOption) (*SignTransactionResponse, error)
	SendTransaction(ctx context.Context, in *SendTransactionRequest, opts ...grpc.CallOption) (*SendTransactionResponse, error)
	SendRawTransaction(ctx context.Context, in *SendRawTransactionRequest, opts ...grpc.CallOption) (*SendRawTransactionResponse, error)
	Call(ctx context.Context, in *CallRequest, opts ...grpc.CallOption) (*CallResponse, error)
	// filter
	NewFilter(ctx context.Context, in *NewFilterRequest, opts ...grpc.CallOption) (*NewFilterResponse, error)
	NewBlockFilter(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NewBlockFilterResponse, error)
	PendingTransactionFilter(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*PendingTransactionFilterResponse, error)
	UninstallFilter(ctx context.Context, in *UninstallFilterRequest, opts ...grpc.CallOption) (*UninstallFilterResponse, error)
	FilterChanges(ctx context.Context, in *FilterChangesRequest, opts ...grpc.CallOption) (*FilterChangesResponse, error)
	FilterLogs(ctx context.Context, in *FilterLogsRequest, opts ...grpc.CallOption) (*FilterLogsResponse, error)
	Logs(ctx context.Context, in *LogsRequest, opts ...grpc.CallOption) (*LogsResponse, error)
}

type nebulaServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewNebulaServiceClient(cc grpc.ClientConnInterface) NebulaServiceClient {
	return &nebulaServiceClient{cc}
}

func (c *nebulaServiceClient) Sha3(ctx context.Context, in *Sha3Request, opts ...grpc.CallOption) (*Sha3Response, error) {
	out := new(Sha3Response)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Sha3", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) NodeVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NodeVersionResponse, error) {
	out := new(NodeVersionResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/NodeVersion", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) NetVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetVersionResponse, error) {
	out := new(NetVersionResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/NetVersion", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) NetPeerCount(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NetPeerCountResponse, error) {
	out := new(NetPeerCountResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/NetPeerCount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) ProtocolVersion(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ProtocolVersionResponse, error) {
	out := new(ProtocolVersionResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/ProtocolVersion", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) Syncing(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*SyncingResponse, error) {
	out := new(SyncingResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Syncing", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) Coinbase(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*CoinbaseResponse, error) {
	out := new(CoinbaseResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Coinbase", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) Mining(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*MiningResponse, error) {
	out := new(MiningResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Mining", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) HashRate(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HashRateResponse, error) {
	out := new(HashRateResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/HashRate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) Accounts(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*AccountsResponse, error) {
	out := new(AccountsResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Accounts", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) GasPrice(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GasPriceResponse, error) {
	out := new(GasPriceResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/GasPrice", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) BlockNumber(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HeightResponse, error) {
	out := new(HeightResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/BlockNumber", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) BlockByHash(ctx context.Context, in *BlockByHashRequest, opts ...grpc.CallOption) (*BlockByHashResponse, error) {
	out := new(BlockByHashResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/BlockByHash", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) BlockByNumber(ctx context.Context, in *BlockByNumberRequest, opts ...grpc.CallOption) (*BlockByNumberResponse, error) {
	out := new(BlockByNumberResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/BlockByNumber", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) BlockTransactionCountByHash(ctx context.Context, in *BlockTransactionCountByHashRequest, opts ...grpc.CallOption) (*BlockTransactionCountByHashResponse, error) {
	out := new(BlockTransactionCountByHashResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/BlockTransactionCountByHash", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) BlockTransactionCountByNumber(ctx context.Context, in *BlockTransactionCountByNumberRequest, opts ...grpc.CallOption) (*BlockTransactionCountByNumberResponse, error) {
	out := new(BlockTransactionCountByNumberResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/BlockTransactionCountByNumber", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) UncleCountByHash(ctx context.Context, in *UncleCountByHashRequest, opts ...grpc.CallOption) (*UncleCountByHashResponse, error) {
	out := new(UncleCountByHashResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/UncleCountByHash", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) UncleCountByNumber(ctx context.Context, in *UncleCountByNumberRequest, opts ...grpc.CallOption) (*UncleCountByNumberResponse, error) {
	out := new(UncleCountByNumberResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/UncleCountByNumber", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) UncleByBlockHashAndIndex(ctx context.Context, in *UncleByBlockHashAndIndexRequest, opts ...grpc.CallOption) (*UncleByBlockHashAndIndexResponse, error) {
	out := new(UncleByBlockHashAndIndexResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/UncleByBlockHashAndIndex", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) UncleByBlockNumberAndIndex(ctx context.Context, in *UncleByBlockNumberAndIndexRequest, opts ...grpc.CallOption) (*UncleByBlockNumberAndIndexResponse, error) {
	out := new(UncleByBlockNumberAndIndexResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/UncleByBlockNumberAndIndex", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) Compilers(ctx context.Context, in *CompilersRequest, opts ...grpc.CallOption) (*CompilersResponse, error) {
	out := new(CompilersResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Compilers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) CompileSolidity(ctx context.Context, in *CompileSolidityRequest, opts ...grpc.CallOption) (*CompileSolidityResponse, error) {
	out := new(CompileSolidityResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/CompileSolidity", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) CompileLLL(ctx context.Context, in *CompileLLLRequest, opts ...grpc.CallOption) (*CompileLLLResponse, error) {
	out := new(CompileLLLResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/CompileLLL", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) CompileSerpent(ctx context.Context, in *CompileSerpentRequest, opts ...grpc.CallOption) (*CompileSerpentResponse, error) {
	out := new(CompileSerpentResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/CompileSerpent", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) EstimateGas(ctx context.Context, in *EstimateGasRequest, opts ...grpc.CallOption) (*EstimateGasResponse, error) {
	out := new(EstimateGasResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/EstimateGas", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) TransactionByHash(ctx context.Context, in *TransactionByHashRequest, opts ...grpc.CallOption) (*TransactionByHashResponse, error) {
	out := new(TransactionByHashResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/TransactionByHash", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) TransactionByBlockHashAndIndex(ctx context.Context, in *TransactionByBlockHashAndIndexRequest, opts ...grpc.CallOption) (*TransactionByBlockHashAndIndexResponse, error) {
	out := new(TransactionByBlockHashAndIndexResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/TransactionByBlockHashAndIndex", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) TransactionByBlockNumberAndIndex(ctx context.Context, in *TransactionByBlockNumberAndIndexRequest, opts ...grpc.CallOption) (*TransactionByBlockNumberAndIndexResponse, error) {
	out := new(TransactionByBlockNumberAndIndexResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/TransactionByBlockNumberAndIndex", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) TransactionReceipt(ctx context.Context, in *TransactionReceiptRequest, opts ...grpc.CallOption) (*TransactionReceiptResponse, error) {
	out := new(TransactionReceiptResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/TransactionReceipt", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) Balance(ctx context.Context, in *BalanceRequest, opts ...grpc.CallOption) (*BalanceResponse, error) {
	out := new(BalanceResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Balance", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) Storage(ctx context.Context, in *StorageRequest, opts ...grpc.CallOption) (*StorageResponse, error) {
	out := new(StorageResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Storage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) Nonce(ctx context.Context, in *NonceRequest, opts ...grpc.CallOption) (*NonceResponse, error) {
	out := new(NonceResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Nonce", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) RepeatedNonce(ctx context.Context, in *RepeatedNonceRequest, opts ...grpc.CallOption) (*RepeatedNonceResponse, error) {
	out := new(RepeatedNonceResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/RepeatedNonce", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) TransactionCount(ctx context.Context, in *TransactionCountRequest, opts ...grpc.CallOption) (*TransactionCountResponse, error) {
	out := new(TransactionCountResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/TransactionCount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) GetCode(ctx context.Context, in *GetCodeRequest, opts ...grpc.CallOption) (*GetCodeResponse, error) {
	out := new(GetCodeResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/GetCode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error) {
	out := new(SignResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Sign", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) SignTransaction(ctx context.Context, in *SignTransactionRequest, opts ...grpc.CallOption) (*SignTransactionResponse, error) {
	out := new(SignTransactionResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/SignTransaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) SendTransaction(ctx context.Context, in *SendTransactionRequest, opts ...grpc.CallOption) (*SendTransactionResponse, error) {
	out := new(SendTransactionResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/SendTransaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) SendRawTransaction(ctx context.Context, in *SendRawTransactionRequest, opts ...grpc.CallOption) (*SendRawTransactionResponse, error) {
	out := new(SendRawTransactionResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/SendRawTransaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) Call(ctx context.Context, in *CallRequest, opts ...grpc.CallOption) (*CallResponse, error) {
	out := new(CallResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Call", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) NewFilter(ctx context.Context, in *NewFilterRequest, opts ...grpc.CallOption) (*NewFilterResponse, error) {
	out := new(NewFilterResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/NewFilter", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) NewBlockFilter(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*NewBlockFilterResponse, error) {
	out := new(NewBlockFilterResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/NewBlockFilter", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) PendingTransactionFilter(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*PendingTransactionFilterResponse, error) {
	out := new(PendingTransactionFilterResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/PendingTransactionFilter", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) UninstallFilter(ctx context.Context, in *UninstallFilterRequest, opts ...grpc.CallOption) (*UninstallFilterResponse, error) {
	out := new(UninstallFilterResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/UninstallFilter", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) FilterChanges(ctx context.Context, in *FilterChangesRequest, opts ...grpc.CallOption) (*FilterChangesResponse, error) {
	out := new(FilterChangesResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/FilterChanges", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) FilterLogs(ctx context.Context, in *FilterLogsRequest, opts ...grpc.CallOption) (*FilterLogsResponse, error) {
	out := new(FilterLogsResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/FilterLogs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nebulaServiceClient) Logs(ctx context.Context, in *LogsRequest, opts ...grpc.CallOption) (*LogsResponse, error) {
	out := new(LogsResponse)
	err := c.cc.Invoke(ctx, "/nebula.v1.NebulaService/Logs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// NebulaServiceServer is the server API for NebulaService service.
// All implementations must embed UnimplementedNebulaServiceServer
// for forward compatibility
type NebulaServiceServer interface {
	// web3
	Sha3(context.Context, *Sha3Request) (*Sha3Response, error)
	NodeVersion(context.Context, *emptypb.Empty) (*NodeVersionResponse, error)
	// network info service
	NetVersion(context.Context, *emptypb.Empty) (*NetVersionResponse, error)
	NetPeerCount(context.Context, *emptypb.Empty) (*NetPeerCountResponse, error)
	// node status
	ProtocolVersion(context.Context, *emptypb.Empty) (*ProtocolVersionResponse, error)
	Syncing(context.Context, *emptypb.Empty) (*SyncingResponse, error)
	Coinbase(context.Context, *emptypb.Empty) (*CoinbaseResponse, error)
	Mining(context.Context, *emptypb.Empty) (*MiningResponse, error)
	HashRate(context.Context, *emptypb.Empty) (*HashRateResponse, error)
	Accounts(context.Context, *emptypb.Empty) (*AccountsResponse, error)
	// tx operatoration
	GasPrice(context.Context, *emptypb.Empty) (*GasPriceResponse, error)
	// block info service
	BlockNumber(context.Context, *emptypb.Empty) (*HeightResponse, error)
	BlockByHash(context.Context, *BlockByHashRequest) (*BlockByHashResponse, error)
	BlockByNumber(context.Context, *BlockByNumberRequest) (*BlockByNumberResponse, error)
	BlockTransactionCountByHash(context.Context, *BlockTransactionCountByHashRequest) (*BlockTransactionCountByHashResponse, error)
	BlockTransactionCountByNumber(context.Context, *BlockTransactionCountByNumberRequest) (*BlockTransactionCountByNumberResponse, error)
	UncleCountByHash(context.Context, *UncleCountByHashRequest) (*UncleCountByHashResponse, error)
	UncleCountByNumber(context.Context, *UncleCountByNumberRequest) (*UncleCountByNumberResponse, error)
	UncleByBlockHashAndIndex(context.Context, *UncleByBlockHashAndIndexRequest) (*UncleByBlockHashAndIndexResponse, error)
	UncleByBlockNumberAndIndex(context.Context, *UncleByBlockNumberAndIndexRequest) (*UncleByBlockNumberAndIndexResponse, error)
	// compiler
	Compilers(context.Context, *CompilersRequest) (*CompilersResponse, error)
	CompileSolidity(context.Context, *CompileSolidityRequest) (*CompileSolidityResponse, error)
	CompileLLL(context.Context, *CompileLLLRequest) (*CompileLLLResponse, error)
	CompileSerpent(context.Context, *CompileSerpentRequest) (*CompileSerpentResponse, error)
	// transaction info service
	EstimateGas(context.Context, *EstimateGasRequest) (*EstimateGasResponse, error)
	TransactionByHash(context.Context, *TransactionByHashRequest) (*TransactionByHashResponse, error)
	TransactionByBlockHashAndIndex(context.Context, *TransactionByBlockHashAndIndexRequest) (*TransactionByBlockHashAndIndexResponse, error)
	TransactionByBlockNumberAndIndex(context.Context, *TransactionByBlockNumberAndIndexRequest) (*TransactionByBlockNumberAndIndexResponse, error)
	TransactionReceipt(context.Context, *TransactionReceiptRequest) (*TransactionReceiptResponse, error)
	// account info service
	Balance(context.Context, *BalanceRequest) (*BalanceResponse, error)
	Storage(context.Context, *StorageRequest) (*StorageResponse, error)
	Nonce(context.Context, *NonceRequest) (*NonceResponse, error)
	RepeatedNonce(context.Context, *RepeatedNonceRequest) (*RepeatedNonceResponse, error)
	TransactionCount(context.Context, *TransactionCountRequest) (*TransactionCountResponse, error)
	GetCode(context.Context, *GetCodeRequest) (*GetCodeResponse, error)
	Sign(context.Context, *SignRequest) (*SignResponse, error)
	SignTransaction(context.Context, *SignTransactionRequest) (*SignTransactionResponse, error)
	SendTransaction(context.Context, *SendTransactionRequest) (*SendTransactionResponse, error)
	SendRawTransaction(context.Context, *SendRawTransactionRequest) (*SendRawTransactionResponse, error)
	Call(context.Context, *CallRequest) (*CallResponse, error)
	// filter
	NewFilter(context.Context, *NewFilterRequest) (*NewFilterResponse, error)
	NewBlockFilter(context.Context, *emptypb.Empty) (*NewBlockFilterResponse, error)
	PendingTransactionFilter(context.Context, *emptypb.Empty) (*PendingTransactionFilterResponse, error)
	UninstallFilter(context.Context, *UninstallFilterRequest) (*UninstallFilterResponse, error)
	FilterChanges(context.Context, *FilterChangesRequest) (*FilterChangesResponse, error)
	FilterLogs(context.Context, *FilterLogsRequest) (*FilterLogsResponse, error)
	Logs(context.Context, *LogsRequest) (*LogsResponse, error)
	mustEmbedUnimplementedNebulaServiceServer()
}

// UnimplementedNebulaServiceServer must be embedded to have forward compatible implementations.
type UnimplementedNebulaServiceServer struct {
}

func (UnimplementedNebulaServiceServer) Sha3(context.Context, *Sha3Request) (*Sha3Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Sha3 not implemented")
}
func (UnimplementedNebulaServiceServer) NodeVersion(context.Context, *emptypb.Empty) (*NodeVersionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NodeVersion not implemented")
}
func (UnimplementedNebulaServiceServer) NetVersion(context.Context, *emptypb.Empty) (*NetVersionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NetVersion not implemented")
}
func (UnimplementedNebulaServiceServer) NetPeerCount(context.Context, *emptypb.Empty) (*NetPeerCountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NetPeerCount not implemented")
}
func (UnimplementedNebulaServiceServer) ProtocolVersion(context.Context, *emptypb.Empty) (*ProtocolVersionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProtocolVersion not implemented")
}
func (UnimplementedNebulaServiceServer) Syncing(context.Context, *emptypb.Empty) (*SyncingResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Syncing not implemented")
}
func (UnimplementedNebulaServiceServer) Coinbase(context.Context, *emptypb.Empty) (*CoinbaseResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Coinbase not implemented")
}
func (UnimplementedNebulaServiceServer) Mining(context.Context, *emptypb.Empty) (*MiningResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Mining not implemented")
}
func (UnimplementedNebulaServiceServer) HashRate(context.Context, *emptypb.Empty) (*HashRateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method HashRate not implemented")
}
func (UnimplementedNebulaServiceServer) Accounts(context.Context, *emptypb.Empty) (*AccountsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Accounts not implemented")
}
func (UnimplementedNebulaServiceServer) GasPrice(context.Context, *emptypb.Empty) (*GasPriceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GasPrice not implemented")
}
func (UnimplementedNebulaServiceServer) BlockNumber(context.Context, *emptypb.Empty) (*HeightResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BlockNumber not implemented")
}
func (UnimplementedNebulaServiceServer) BlockByHash(context.Context, *BlockByHashRequest) (*BlockByHashResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BlockByHash not implemented")
}
func (UnimplementedNebulaServiceServer) BlockByNumber(context.Context, *BlockByNumberRequest) (*BlockByNumberResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BlockByNumber not implemented")
}
func (UnimplementedNebulaServiceServer) BlockTransactionCountByHash(context.Context, *BlockTransactionCountByHashRequest) (*BlockTransactionCountByHashResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BlockTransactionCountByHash not implemented")
}
func (UnimplementedNebulaServiceServer) BlockTransactionCountByNumber(context.Context, *BlockTransactionCountByNumberRequest) (*BlockTransactionCountByNumberResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BlockTransactionCountByNumber not implemented")
}
func (UnimplementedNebulaServiceServer) UncleCountByHash(context.Context, *UncleCountByHashRequest) (*UncleCountByHashResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UncleCountByHash not implemented")
}
func (UnimplementedNebulaServiceServer) UncleCountByNumber(context.Context, *UncleCountByNumberRequest) (*UncleCountByNumberResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UncleCountByNumber not implemented")
}
func (UnimplementedNebulaServiceServer) UncleByBlockHashAndIndex(context.Context, *UncleByBlockHashAndIndexRequest) (*UncleByBlockHashAndIndexResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UncleByBlockHashAndIndex not implemented")
}
func (UnimplementedNebulaServiceServer) UncleByBlockNumberAndIndex(context.Context, *UncleByBlockNumberAndIndexRequest) (*UncleByBlockNumberAndIndexResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UncleByBlockNumberAndIndex not implemented")
}
func (UnimplementedNebulaServiceServer) Compilers(context.Context, *CompilersRequest) (*CompilersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Compilers not implemented")
}
func (UnimplementedNebulaServiceServer) CompileSolidity(context.Context, *CompileSolidityRequest) (*CompileSolidityResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CompileSolidity not implemented")
}
func (UnimplementedNebulaServiceServer) CompileLLL(context.Context, *CompileLLLRequest) (*CompileLLLResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CompileLLL not implemented")
}
func (UnimplementedNebulaServiceServer) CompileSerpent(context.Context, *CompileSerpentRequest) (*CompileSerpentResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CompileSerpent not implemented")
}
func (UnimplementedNebulaServiceServer) EstimateGas(context.Context, *EstimateGasRequest) (*EstimateGasResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EstimateGas not implemented")
}
func (UnimplementedNebulaServiceServer) TransactionByHash(context.Context, *TransactionByHashRequest) (*TransactionByHashResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TransactionByHash not implemented")
}
func (UnimplementedNebulaServiceServer) TransactionByBlockHashAndIndex(context.Context, *TransactionByBlockHashAndIndexRequest) (*TransactionByBlockHashAndIndexResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TransactionByBlockHashAndIndex not implemented")
}
func (UnimplementedNebulaServiceServer) TransactionByBlockNumberAndIndex(context.Context, *TransactionByBlockNumberAndIndexRequest) (*TransactionByBlockNumberAndIndexResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TransactionByBlockNumberAndIndex not implemented")
}
func (UnimplementedNebulaServiceServer) TransactionReceipt(context.Context, *TransactionReceiptRequest) (*TransactionReceiptResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TransactionReceipt not implemented")
}
func (UnimplementedNebulaServiceServer) Balance(context.Context, *BalanceRequest) (*BalanceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Balance not implemented")
}
func (UnimplementedNebulaServiceServer) Storage(context.Context, *StorageRequest) (*StorageResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Storage not implemented")
}
func (UnimplementedNebulaServiceServer) Nonce(context.Context, *NonceRequest) (*NonceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Nonce not implemented")
}
func (UnimplementedNebulaServiceServer) RepeatedNonce(context.Context, *RepeatedNonceRequest) (*RepeatedNonceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RepeatedNonce not implemented")
}
func (UnimplementedNebulaServiceServer) TransactionCount(context.Context, *TransactionCountRequest) (*TransactionCountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TransactionCount not implemented")
}
func (UnimplementedNebulaServiceServer) GetCode(context.Context, *GetCodeRequest) (*GetCodeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCode not implemented")
}
func (UnimplementedNebulaServiceServer) Sign(context.Context, *SignRequest) (*SignResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Sign not implemented")
}
func (UnimplementedNebulaServiceServer) SignTransaction(context.Context, *SignTransactionRequest) (*SignTransactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SignTransaction not implemented")
}
func (UnimplementedNebulaServiceServer) SendTransaction(context.Context, *SendTransactionRequest) (*SendTransactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendTransaction not implemented")
}
func (UnimplementedNebulaServiceServer) SendRawTransaction(context.Context, *SendRawTransactionRequest) (*SendRawTransactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendRawTransaction not implemented")
}
func (UnimplementedNebulaServiceServer) Call(context.Context, *CallRequest) (*CallResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Call not implemented")
}
func (UnimplementedNebulaServiceServer) NewFilter(context.Context, *NewFilterRequest) (*NewFilterResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NewFilter not implemented")
}
func (UnimplementedNebulaServiceServer) NewBlockFilter(context.Context, *emptypb.Empty) (*NewBlockFilterResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NewBlockFilter not implemented")
}
func (UnimplementedNebulaServiceServer) PendingTransactionFilter(context.Context, *emptypb.Empty) (*PendingTransactionFilterResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PendingTransactionFilter not implemented")
}
func (UnimplementedNebulaServiceServer) UninstallFilter(context.Context, *UninstallFilterRequest) (*UninstallFilterResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UninstallFilter not implemented")
}
func (UnimplementedNebulaServiceServer) FilterChanges(context.Context, *FilterChangesRequest) (*FilterChangesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FilterChanges not implemented")
}
func (UnimplementedNebulaServiceServer) FilterLogs(context.Context, *FilterLogsRequest) (*FilterLogsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FilterLogs not implemented")
}
func (UnimplementedNebulaServiceServer) Logs(context.Context, *LogsRequest) (*LogsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Logs not implemented")
}
func (UnimplementedNebulaServiceServer) mustEmbedUnimplementedNebulaServiceServer() {}

// UnsafeNebulaServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to NebulaServiceServer will
// result in compilation errors.
type UnsafeNebulaServiceServer interface {
	mustEmbedUnimplementedNebulaServiceServer()
}

func RegisterNebulaServiceServer(s grpc.ServiceRegistrar, srv NebulaServiceServer) {
	s.RegisterService(&NebulaService_ServiceDesc, srv)
}

func _NebulaService_Sha3_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Sha3Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).Sha3(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/Sha3",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).Sha3(ctx, req.(*Sha3Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_NodeVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).NodeVersion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/NodeVersion",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).NodeVersion(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_NetVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).NetVersion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/NetVersion",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).NetVersion(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_NetPeerCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).NetPeerCount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/NetPeerCount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).NetPeerCount(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_ProtocolVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).ProtocolVersion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/ProtocolVersion",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).ProtocolVersion(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_Syncing_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).Syncing(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/Syncing",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).Syncing(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_Coinbase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).Coinbase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/Coinbase",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).Coinbase(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_Mining_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).Mining(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/Mining",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).Mining(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_HashRate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).HashRate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/HashRate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).HashRate(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_Accounts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).Accounts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/Accounts",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).Accounts(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_GasPrice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).GasPrice(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/GasPrice",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).GasPrice(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_BlockNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).BlockNumber(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/BlockNumber",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).BlockNumber(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_BlockByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BlockByHashRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).BlockByHash(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/BlockByHash",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).BlockByHash(ctx, req.(*BlockByHashRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_BlockByNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BlockByNumberRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).BlockByNumber(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/BlockByNumber",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).BlockByNumber(ctx, req.(*BlockByNumberRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_BlockTransactionCountByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BlockTransactionCountByHashRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).BlockTransactionCountByHash(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/BlockTransactionCountByHash",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).BlockTransactionCountByHash(ctx, req.(*BlockTransactionCountByHashRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_BlockTransactionCountByNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BlockTransactionCountByNumberRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).BlockTransactionCountByNumber(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/BlockTransactionCountByNumber",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).BlockTransactionCountByNumber(ctx, req.(*BlockTransactionCountByNumberRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_UncleCountByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UncleCountByHashRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).UncleCountByHash(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/UncleCountByHash",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).UncleCountByHash(ctx, req.(*UncleCountByHashRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_UncleCountByNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UncleCountByNumberRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).UncleCountByNumber(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/UncleCountByNumber",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).UncleCountByNumber(ctx, req.(*UncleCountByNumberRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_UncleByBlockHashAndIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UncleByBlockHashAndIndexRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).UncleByBlockHashAndIndex(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/UncleByBlockHashAndIndex",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).UncleByBlockHashAndIndex(ctx, req.(*UncleByBlockHashAndIndexRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_UncleByBlockNumberAndIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UncleByBlockNumberAndIndexRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).UncleByBlockNumberAndIndex(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/UncleByBlockNumberAndIndex",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).UncleByBlockNumberAndIndex(ctx, req.(*UncleByBlockNumberAndIndexRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_Compilers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CompilersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).Compilers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/Compilers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).Compilers(ctx, req.(*CompilersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_CompileSolidity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CompileSolidityRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).CompileSolidity(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/CompileSolidity",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).CompileSolidity(ctx, req.(*CompileSolidityRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_CompileLLL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CompileLLLRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).CompileLLL(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/CompileLLL",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).CompileLLL(ctx, req.(*CompileLLLRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_CompileSerpent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CompileSerpentRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).CompileSerpent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/CompileSerpent",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).CompileSerpent(ctx, req.(*CompileSerpentRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_EstimateGas_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EstimateGasRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).EstimateGas(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/EstimateGas",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).EstimateGas(ctx, req.(*EstimateGasRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_TransactionByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TransactionByHashRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).TransactionByHash(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/TransactionByHash",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).TransactionByHash(ctx, req.(*TransactionByHashRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_TransactionByBlockHashAndIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TransactionByBlockHashAndIndexRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).TransactionByBlockHashAndIndex(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/TransactionByBlockHashAndIndex",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).TransactionByBlockHashAndIndex(ctx, req.(*TransactionByBlockHashAndIndexRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_TransactionByBlockNumberAndIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TransactionByBlockNumberAndIndexRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).TransactionByBlockNumberAndIndex(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/TransactionByBlockNumberAndIndex",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).TransactionByBlockNumberAndIndex(ctx, req.(*TransactionByBlockNumberAndIndexRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_TransactionReceipt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TransactionReceiptRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).TransactionReceipt(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/TransactionReceipt",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).TransactionReceipt(ctx, req.(*TransactionReceiptRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_Balance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BalanceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).Balance(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/Balance",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).Balance(ctx, req.(*BalanceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_Storage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StorageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).Storage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/Storage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).Storage(ctx, req.(*StorageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_Nonce_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NonceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).Nonce(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/Nonce",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).Nonce(ctx, req.(*NonceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_RepeatedNonce_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RepeatedNonceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).RepeatedNonce(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/RepeatedNonce",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).RepeatedNonce(ctx, req.(*RepeatedNonceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_TransactionCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TransactionCountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).TransactionCount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/TransactionCount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).TransactionCount(ctx, req.(*TransactionCountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_GetCode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCodeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).GetCode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/GetCode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).GetCode(ctx, req.(*GetCodeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_Sign_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).Sign(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/Sign",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).Sign(ctx, req.(*SignRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_SignTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignTransactionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).SignTransaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/SignTransaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).SignTransaction(ctx, req.(*SignTransactionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_SendTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SendTransactionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).SendTransaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/SendTransaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).SendTransaction(ctx, req.(*SendTransactionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_SendRawTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SendRawTransactionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).SendRawTransaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/SendRawTransaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).SendRawTransaction(ctx, req.(*SendRawTransactionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_Call_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CallRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).Call(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/Call",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).Call(ctx, req.(*CallRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_NewFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NewFilterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).NewFilter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/NewFilter",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).NewFilter(ctx, req.(*NewFilterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_NewBlockFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).NewBlockFilter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/NewBlockFilter",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).NewBlockFilter(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_PendingTransactionFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).PendingTransactionFilter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/PendingTransactionFilter",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).PendingTransactionFilter(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_UninstallFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UninstallFilterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).UninstallFilter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/UninstallFilter",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).UninstallFilter(ctx, req.(*UninstallFilterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_FilterChanges_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FilterChangesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).FilterChanges(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/FilterChanges",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).FilterChanges(ctx, req.(*FilterChangesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_FilterLogs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FilterLogsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).FilterLogs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/FilterLogs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).FilterLogs(ctx, req.(*FilterLogsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NebulaService_Logs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LogsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NebulaServiceServer).Logs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nebula.v1.NebulaService/Logs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NebulaServiceServer).Logs(ctx, req.(*LogsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// NebulaService_ServiceDesc is the grpc.ServiceDesc for NebulaService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var NebulaService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "nebula.v1.NebulaService",
	HandlerType: (*NebulaServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Sha3",
			Handler:    _NebulaService_Sha3_Handler,
		},
		{
			MethodName: "NodeVersion",
			Handler:    _NebulaService_NodeVersion_Handler,
		},
		{
			MethodName: "NetVersion",
			Handler:    _NebulaService_NetVersion_Handler,
		},
		{
			MethodName: "NetPeerCount",
			Handler:    _NebulaService_NetPeerCount_Handler,
		},
		{
			MethodName: "ProtocolVersion",
			Handler:    _NebulaService_ProtocolVersion_Handler,
		},
		{
			MethodName: "Syncing",
			Handler:    _NebulaService_Syncing_Handler,
		},
		{
			MethodName: "Coinbase",
			Handler:    _NebulaService_Coinbase_Handler,
		},
		{
			MethodName: "Mining",
			Handler:    _NebulaService_Mining_Handler,
		},
		{
			MethodName: "HashRate",
			Handler:    _NebulaService_HashRate_Handler,
		},
		{
			MethodName: "Accounts",
			Handler:    _NebulaService_Accounts_Handler,
		},
		{
			MethodName: "GasPrice",
			Handler:    _NebulaService_GasPrice_Handler,
		},
		{
			MethodName: "BlockNumber",
			Handler:    _NebulaService_BlockNumber_Handler,
		},
		{
			MethodName: "BlockByHash",
			Handler:    _NebulaService_BlockByHash_Handler,
		},
		{
			MethodName: "BlockByNumber",
			Handler:    _NebulaService_BlockByNumber_Handler,
		},
		{
			MethodName: "BlockTransactionCountByHash",
			Handler:    _NebulaService_BlockTransactionCountByHash_Handler,
		},
		{
			MethodName: "BlockTransactionCountByNumber",
			Handler:    _NebulaService_BlockTransactionCountByNumber_Handler,
		},
		{
			MethodName: "UncleCountByHash",
			Handler:    _NebulaService_UncleCountByHash_Handler,
		},
		{
			MethodName: "UncleCountByNumber",
			Handler:    _NebulaService_UncleCountByNumber_Handler,
		},
		{
			MethodName: "UncleByBlockHashAndIndex",
			Handler:    _NebulaService_UncleByBlockHashAndIndex_Handler,
		},
		{
			MethodName: "UncleByBlockNumberAndIndex",
			Handler:    _NebulaService_UncleByBlockNumberAndIndex_Handler,
		},
		{
			MethodName: "Compilers",
			Handler:    _NebulaService_Compilers_Handler,
		},
		{
			MethodName: "CompileSolidity",
			Handler:    _NebulaService_CompileSolidity_Handler,
		},
		{
			MethodName: "CompileLLL",
			Handler:    _NebulaService_CompileLLL_Handler,
		},
		{
			MethodName: "CompileSerpent",
			Handler:    _NebulaService_CompileSerpent_Handler,
		},
		{
			MethodName: "EstimateGas",
			Handler:    _NebulaService_EstimateGas_Handler,
		},
		{
			MethodName: "TransactionByHash",
			Handler:    _NebulaService_TransactionByHash_Handler,
		},
		{
			MethodName: "TransactionByBlockHashAndIndex",
			Handler:    _NebulaService_TransactionByBlockHashAndIndex_Handler,
		},
		{
			MethodName: "TransactionByBlockNumberAndIndex",
			Handler:    _NebulaService_TransactionByBlockNumberAndIndex_Handler,
		},
		{
			MethodName: "TransactionReceipt",
			Handler:    _NebulaService_TransactionReceipt_Handler,
		},
		{
			MethodName: "Balance",
			Handler:    _NebulaService_Balance_Handler,
		},
		{
			MethodName: "Storage",
			Handler:    _NebulaService_Storage_Handler,
		},
		{
			MethodName: "Nonce",
			Handler:    _NebulaService_Nonce_Handler,
		},
		{
			MethodName: "RepeatedNonce",
			Handler:    _NebulaService_RepeatedNonce_Handler,
		},
		{
			MethodName: "TransactionCount",
			Handler:    _NebulaService_TransactionCount_Handler,
		},
		{
			MethodName: "GetCode",
			Handler:    _NebulaService_GetCode_Handler,
		},
		{
			MethodName: "Sign",
			Handler:    _NebulaService_Sign_Handler,
		},
		{
			MethodName: "SignTransaction",
			Handler:    _NebulaService_SignTransaction_Handler,
		},
		{
			MethodName: "SendTransaction",
			Handler:    _NebulaService_SendTransaction_Handler,
		},
		{
			MethodName: "SendRawTransaction",
			Handler:    _NebulaService_SendRawTransaction_Handler,
		},
		{
			MethodName: "Call",
			Handler:    _NebulaService_Call_Handler,
		},
		{
			MethodName: "NewFilter",
			Handler:    _NebulaService_NewFilter_Handler,
		},
		{
			MethodName: "NewBlockFilter",
			Handler:    _NebulaService_NewBlockFilter_Handler,
		},
		{
			MethodName: "PendingTransactionFilter",
			Handler:    _NebulaService_PendingTransactionFilter_Handler,
		},
		{
			MethodName: "UninstallFilter",
			Handler:    _NebulaService_UninstallFilter_Handler,
		},
		{
			MethodName: "FilterChanges",
			Handler:    _NebulaService_FilterChanges_Handler,
		},
		{
			MethodName: "FilterLogs",
			Handler:    _NebulaService_FilterLogs_Handler,
		},
		{
			MethodName: "Logs",
			Handler:    _NebulaService_Logs_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "nebula/v1/service.proto",
}
