service

package
v1.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 26, 2021 License: GPL-3.0 Imports: 14 Imported by: 0

Documentation

Overview

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Package service contain services that was result from `submodule proto` files, its was genereted files and cannot to be modified.

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package service is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func RegisterAccountBalanceServiceHandler 

func RegisterAccountBalanceServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterAccountBalanceServiceHandler registers the http handlers for service AccountBalanceService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterAccountBalanceServiceHandlerClient 

func RegisterAccountBalanceServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client AccountBalanceServiceClient) error

RegisterAccountBalanceServiceHandlerClient registers the http handlers for service AccountBalanceService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "AccountBalanceServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "AccountBalanceServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "AccountBalanceServiceClient" to call the correct interceptors.

func RegisterAccountBalanceServiceHandlerFromEndpoint 

func RegisterAccountBalanceServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterAccountBalanceServiceHandlerFromEndpoint is same as RegisterAccountBalanceServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterAccountBalanceServiceServer 

func RegisterAccountBalanceServiceServer(s *grpc.Server, srv AccountBalanceServiceServer)

func RegisterAccountDatasetServiceHandler 

func RegisterAccountDatasetServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterAccountDatasetServiceHandler registers the http handlers for service AccountDatasetService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterAccountDatasetServiceHandlerClient 

func RegisterAccountDatasetServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client AccountDatasetServiceClient) error

RegisterAccountDatasetServiceHandlerClient registers the http handlers for service AccountDatasetService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "AccountDatasetServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "AccountDatasetServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "AccountDatasetServiceClient" to call the correct interceptors.

func RegisterAccountDatasetServiceHandlerFromEndpoint 

func RegisterAccountDatasetServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterAccountDatasetServiceHandlerFromEndpoint is same as RegisterAccountDatasetServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterAccountDatasetServiceServer 

func RegisterAccountDatasetServiceServer(s *grpc.Server, srv AccountDatasetServiceServer)

func RegisterAccountLedgerServiceHandler 

func RegisterAccountLedgerServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterAccountLedgerServiceHandler registers the http handlers for service AccountLedgerService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterAccountLedgerServiceHandlerClient 

func RegisterAccountLedgerServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client AccountLedgerServiceClient) error

RegisterAccountLedgerServiceHandlerClient registers the http handlers for service AccountLedgerService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "AccountLedgerServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "AccountLedgerServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "AccountLedgerServiceClient" to call the correct interceptors.

func RegisterAccountLedgerServiceHandlerFromEndpoint 

func RegisterAccountLedgerServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterAccountLedgerServiceHandlerFromEndpoint is same as RegisterAccountLedgerServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterAccountLedgerServiceServer 

func RegisterAccountLedgerServiceServer(s *grpc.Server, srv AccountLedgerServiceServer)

func RegisterBlockServiceHandler 

func RegisterBlockServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterBlockServiceHandler registers the http handlers for service BlockService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterBlockServiceHandlerClient 

func RegisterBlockServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client BlockServiceClient) error

RegisterBlockServiceHandlerClient registers the http handlers for service BlockService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "BlockServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "BlockServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "BlockServiceClient" to call the correct interceptors.

func RegisterBlockServiceHandlerFromEndpoint 

func RegisterBlockServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterBlockServiceHandlerFromEndpoint is same as RegisterBlockServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterBlockServiceServer 

func RegisterBlockServiceServer(s *grpc.Server, srv BlockServiceServer)

func RegisterEscrowTransactionServiceHandler 

func RegisterEscrowTransactionServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterEscrowTransactionServiceHandler registers the http handlers for service EscrowTransactionService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterEscrowTransactionServiceHandlerClient 

func RegisterEscrowTransactionServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client EscrowTransactionServiceClient) error

RegisterEscrowTransactionServiceHandlerClient registers the http handlers for service EscrowTransactionService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "EscrowTransactionServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "EscrowTransactionServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "EscrowTransactionServiceClient" to call the correct interceptors.

func RegisterEscrowTransactionServiceHandlerFromEndpoint 

func RegisterEscrowTransactionServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterEscrowTransactionServiceHandlerFromEndpoint is same as RegisterEscrowTransactionServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterEscrowTransactionServiceServer 

func RegisterEscrowTransactionServiceServer(s *grpc.Server, srv EscrowTransactionServiceServer)

func RegisterFileDownloadServiceHandler 

func RegisterFileDownloadServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterFileDownloadServiceHandler registers the http handlers for service FileDownloadService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterFileDownloadServiceHandlerClient 

func RegisterFileDownloadServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client FileDownloadServiceClient) error

RegisterFileDownloadServiceHandlerClient registers the http handlers for service FileDownloadService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "FileDownloadServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "FileDownloadServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "FileDownloadServiceClient" to call the correct interceptors.

func RegisterFileDownloadServiceHandlerFromEndpoint 

func RegisterFileDownloadServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterFileDownloadServiceHandlerFromEndpoint is same as RegisterFileDownloadServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterFileDownloadServiceServer 

func RegisterFileDownloadServiceServer(s *grpc.Server, srv FileDownloadServiceServer)

func RegisterHealthCheckServiceHandler 

func RegisterHealthCheckServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterHealthCheckServiceHandler registers the http handlers for service HealthCheckService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterHealthCheckServiceHandlerClient 

func RegisterHealthCheckServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client HealthCheckServiceClient) error

RegisterHealthCheckServiceHandlerClient registers the http handlers for service HealthCheckService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "HealthCheckServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "HealthCheckServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "HealthCheckServiceClient" to call the correct interceptors.

func RegisterHealthCheckServiceHandlerFromEndpoint 

func RegisterHealthCheckServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterHealthCheckServiceHandlerFromEndpoint is same as RegisterHealthCheckServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterHealthCheckServiceServer 

func RegisterHealthCheckServiceServer(s *grpc.Server, srv HealthCheckServiceServer)

func RegisterHostServiceHandler 

func RegisterHostServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterHostServiceHandler registers the http handlers for service HostService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterHostServiceHandlerClient 

func RegisterHostServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client HostServiceClient) error

RegisterHostServiceHandlerClient registers the http handlers for service HostService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "HostServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "HostServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "HostServiceClient" to call the correct interceptors.

func RegisterHostServiceHandlerFromEndpoint 

func RegisterHostServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterHostServiceHandlerFromEndpoint is same as RegisterHostServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterHostServiceServer 

func RegisterHostServiceServer(s *grpc.Server, srv HostServiceServer)

func RegisterLiquidPaymentServiceHandler 

func RegisterLiquidPaymentServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterLiquidPaymentServiceHandler registers the http handlers for service LiquidPaymentService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterLiquidPaymentServiceHandlerClient 

func RegisterLiquidPaymentServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client LiquidPaymentServiceClient) error

RegisterLiquidPaymentServiceHandlerClient registers the http handlers for service LiquidPaymentService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "LiquidPaymentServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "LiquidPaymentServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "LiquidPaymentServiceClient" to call the correct interceptors.

func RegisterLiquidPaymentServiceHandlerFromEndpoint 

func RegisterLiquidPaymentServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterLiquidPaymentServiceHandlerFromEndpoint is same as RegisterLiquidPaymentServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterLiquidPaymentServiceServer 

func RegisterLiquidPaymentServiceServer(s *grpc.Server, srv LiquidPaymentServiceServer)

func RegisterMempoolServiceHandler 

func RegisterMempoolServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterMempoolServiceHandler registers the http handlers for service MempoolService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterMempoolServiceHandlerClient 

func RegisterMempoolServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client MempoolServiceClient) error

RegisterMempoolServiceHandlerClient registers the http handlers for service MempoolService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "MempoolServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "MempoolServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "MempoolServiceClient" to call the correct interceptors.

func RegisterMempoolServiceHandlerFromEndpoint 

func RegisterMempoolServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterMempoolServiceHandlerFromEndpoint is same as RegisterMempoolServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterMempoolServiceServer 

func RegisterMempoolServiceServer(s *grpc.Server, srv MempoolServiceServer)

func RegisterMultisigServiceHandler 

func RegisterMultisigServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterMultisigServiceHandler registers the http handlers for service MultisigService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterMultisigServiceHandlerClient 

func RegisterMultisigServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client MultisigServiceClient) error

RegisterMultisigServiceHandlerClient registers the http handlers for service MultisigService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "MultisigServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "MultisigServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "MultisigServiceClient" to call the correct interceptors.

func RegisterMultisigServiceHandlerFromEndpoint 

func RegisterMultisigServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterMultisigServiceHandlerFromEndpoint is same as RegisterMultisigServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterMultisigServiceServer 

func RegisterMultisigServiceServer(s *grpc.Server, srv MultisigServiceServer)

func RegisterNodeAddressInfoServiceHandler 

func RegisterNodeAddressInfoServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterNodeAddressInfoServiceHandler registers the http handlers for service NodeAddressInfoService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterNodeAddressInfoServiceHandlerClient 

func RegisterNodeAddressInfoServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client NodeAddressInfoServiceClient) error

RegisterNodeAddressInfoServiceHandlerClient registers the http handlers for service NodeAddressInfoService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "NodeAddressInfoServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "NodeAddressInfoServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "NodeAddressInfoServiceClient" to call the correct interceptors.

func RegisterNodeAddressInfoServiceHandlerFromEndpoint 

func RegisterNodeAddressInfoServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterNodeAddressInfoServiceHandlerFromEndpoint is same as RegisterNodeAddressInfoServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterNodeAddressInfoServiceServer 

func RegisterNodeAddressInfoServiceServer(s *grpc.Server, srv NodeAddressInfoServiceServer)

func RegisterNodeAdminServiceHandler 

func RegisterNodeAdminServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterNodeAdminServiceHandler registers the http handlers for service NodeAdminService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterNodeAdminServiceHandlerClient 

func RegisterNodeAdminServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client NodeAdminServiceClient) error

RegisterNodeAdminServiceHandlerClient registers the http handlers for service NodeAdminService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "NodeAdminServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "NodeAdminServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "NodeAdminServiceClient" to call the correct interceptors.

func RegisterNodeAdminServiceHandlerFromEndpoint 

func RegisterNodeAdminServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterNodeAdminServiceHandlerFromEndpoint is same as RegisterNodeAdminServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterNodeAdminServiceServer 

func RegisterNodeAdminServiceServer(s *grpc.Server, srv NodeAdminServiceServer)

func RegisterNodeHardwareServiceHandler 

func RegisterNodeHardwareServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterNodeHardwareServiceHandler registers the http handlers for service NodeHardwareService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterNodeHardwareServiceHandlerClient 

func RegisterNodeHardwareServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client NodeHardwareServiceClient) error

RegisterNodeHardwareServiceHandlerClient registers the http handlers for service NodeHardwareService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "NodeHardwareServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "NodeHardwareServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "NodeHardwareServiceClient" to call the correct interceptors.

func RegisterNodeHardwareServiceHandlerFromEndpoint 

func RegisterNodeHardwareServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterNodeHardwareServiceHandlerFromEndpoint is same as RegisterNodeHardwareServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterNodeHardwareServiceServer 

func RegisterNodeHardwareServiceServer(s *grpc.Server, srv NodeHardwareServiceServer)

func RegisterNodeRegistrationServiceHandler 

func RegisterNodeRegistrationServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterNodeRegistrationServiceHandler registers the http handlers for service NodeRegistrationService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterNodeRegistrationServiceHandlerClient 

func RegisterNodeRegistrationServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client NodeRegistrationServiceClient) error

RegisterNodeRegistrationServiceHandlerClient registers the http handlers for service NodeRegistrationService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "NodeRegistrationServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "NodeRegistrationServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "NodeRegistrationServiceClient" to call the correct interceptors.

func RegisterNodeRegistrationServiceHandlerFromEndpoint 

func RegisterNodeRegistrationServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterNodeRegistrationServiceHandlerFromEndpoint is same as RegisterNodeRegistrationServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterNodeRegistrationServiceServer 

func RegisterNodeRegistrationServiceServer(s *grpc.Server, srv NodeRegistrationServiceServer)

func RegisterP2PCommunicationServer 

func RegisterP2PCommunicationServer(s *grpc.Server, srv P2PCommunicationServer)

func RegisterParticipationScoreServiceHandler 

func RegisterParticipationScoreServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterParticipationScoreServiceHandler registers the http handlers for service ParticipationScoreService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterParticipationScoreServiceHandlerClient 

func RegisterParticipationScoreServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ParticipationScoreServiceClient) error

RegisterParticipationScoreServiceHandlerClient registers the http handlers for service ParticipationScoreService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ParticipationScoreServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ParticipationScoreServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ParticipationScoreServiceClient" to call the correct interceptors.

func RegisterParticipationScoreServiceHandlerFromEndpoint 

func RegisterParticipationScoreServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterParticipationScoreServiceHandlerFromEndpoint is same as RegisterParticipationScoreServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterParticipationScoreServiceServer 

func RegisterParticipationScoreServiceServer(s *grpc.Server, srv ParticipationScoreServiceServer)

func RegisterPublishedReceiptServiceHandler 

func RegisterPublishedReceiptServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterPublishedReceiptServiceHandler registers the http handlers for service PublishedReceiptService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterPublishedReceiptServiceHandlerClient 

func RegisterPublishedReceiptServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client PublishedReceiptServiceClient) error

RegisterPublishedReceiptServiceHandlerClient registers the http handlers for service PublishedReceiptService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "PublishedReceiptServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "PublishedReceiptServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "PublishedReceiptServiceClient" to call the correct interceptors.

func RegisterPublishedReceiptServiceHandlerFromEndpoint 

func RegisterPublishedReceiptServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterPublishedReceiptServiceHandlerFromEndpoint is same as RegisterPublishedReceiptServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterPublishedReceiptServiceServer 

func RegisterPublishedReceiptServiceServer(s *grpc.Server, srv PublishedReceiptServiceServer)

func RegisterSkippedBlockSmithsServiceHandler 

func RegisterSkippedBlockSmithsServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterSkippedBlockSmithsServiceHandler registers the http handlers for service SkippedBlockSmithsService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterSkippedBlockSmithsServiceHandlerClient 

func RegisterSkippedBlockSmithsServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client SkippedBlockSmithsServiceClient) error

RegisterSkippedBlockSmithsServiceHandlerClient registers the http handlers for service SkippedBlockSmithsService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "SkippedBlockSmithsServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "SkippedBlockSmithsServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "SkippedBlockSmithsServiceClient" to call the correct interceptors.

func RegisterSkippedBlockSmithsServiceHandlerFromEndpoint 

func RegisterSkippedBlockSmithsServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterSkippedBlockSmithsServiceHandlerFromEndpoint is same as RegisterSkippedBlockSmithsServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterSkippedBlockSmithsServiceServer 

func RegisterSkippedBlockSmithsServiceServer(s *grpc.Server, srv SkippedBlockSmithsServiceServer)

func RegisterTransactionServiceHandler 

func RegisterTransactionServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterTransactionServiceHandler registers the http handlers for service TransactionService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterTransactionServiceHandlerClient 

func RegisterTransactionServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client TransactionServiceClient) error

RegisterTransactionServiceHandlerClient registers the http handlers for service TransactionService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "TransactionServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "TransactionServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "TransactionServiceClient" to call the correct interceptors.

func RegisterTransactionServiceHandlerFromEndpoint 

func RegisterTransactionServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterTransactionServiceHandlerFromEndpoint is same as RegisterTransactionServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterTransactionServiceServer 

func RegisterTransactionServiceServer(s *grpc.Server, srv TransactionServiceServer)

Types

type AccountBalanceServiceClient 

type AccountBalanceServiceClient interface {
	GetAccountBalances(ctx context.Context, in *model.GetAccountBalancesRequest, opts ...grpc.CallOption) (*model.GetAccountBalancesResponse, error)
	GetAccountBalance(ctx context.Context, in *model.GetAccountBalanceRequest, opts ...grpc.CallOption) (*model.GetAccountBalanceResponse, error)
}

AccountBalanceServiceClient is the client API for AccountBalanceService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewAccountBalanceServiceClient 

func NewAccountBalanceServiceClient(cc grpc.ClientConnInterface) AccountBalanceServiceClient

type AccountBalanceServiceServer 

type AccountBalanceServiceServer interface {
	GetAccountBalances(context.Context, *model.GetAccountBalancesRequest) (*model.GetAccountBalancesResponse, error)
	GetAccountBalance(context.Context, *model.GetAccountBalanceRequest) (*model.GetAccountBalanceResponse, error)
}

AccountBalanceServiceServer is the server API for AccountBalanceService service.

type AccountDatasetServiceClient 

type AccountDatasetServiceClient interface {
	GetAccountDatasets(ctx context.Context, in *model.GetAccountDatasetsRequest, opts ...grpc.CallOption) (*model.GetAccountDatasetsResponse, error)
	GetAccountDataset(ctx context.Context, in *model.GetAccountDatasetRequest, opts ...grpc.CallOption) (*model.AccountDataset, error)
}

AccountDatasetServiceClient is the client API for AccountDatasetService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewAccountDatasetServiceClient 

func NewAccountDatasetServiceClient(cc grpc.ClientConnInterface) AccountDatasetServiceClient

type AccountDatasetServiceServer 

type AccountDatasetServiceServer interface {
	GetAccountDatasets(context.Context, *model.GetAccountDatasetsRequest) (*model.GetAccountDatasetsResponse, error)
	GetAccountDataset(context.Context, *model.GetAccountDatasetRequest) (*model.AccountDataset, error)
}

AccountDatasetServiceServer is the server API for AccountDatasetService service.

type AccountLedgerServiceClient 

type AccountLedgerServiceClient interface {
	GetAccountLedgers(ctx context.Context, in *model.GetAccountLedgersRequest, opts ...grpc.CallOption) (*model.GetAccountLedgersResponse, error)
}

AccountLedgerServiceClient is the client API for AccountLedgerService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewAccountLedgerServiceClient 

func NewAccountLedgerServiceClient(cc grpc.ClientConnInterface) AccountLedgerServiceClient

type AccountLedgerServiceServer 

type AccountLedgerServiceServer interface {
	GetAccountLedgers(context.Context, *model.GetAccountLedgersRequest) (*model.GetAccountLedgersResponse, error)
}

AccountLedgerServiceServer is the server API for AccountLedgerService service.

type BlockServiceClient 

type BlockServiceClient interface {
	GetBlocks(ctx context.Context, in *model.GetBlocksRequest, opts ...grpc.CallOption) (*model.GetBlocksResponse, error)
	GetBlock(ctx context.Context, in *model.GetBlockRequest, opts ...grpc.CallOption) (*model.GetBlockResponse, error)
}

BlockServiceClient is the client API for BlockService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewBlockServiceClient 

func NewBlockServiceClient(cc grpc.ClientConnInterface) BlockServiceClient

type BlockServiceServer 

type BlockServiceServer interface {
	GetBlocks(context.Context, *model.GetBlocksRequest) (*model.GetBlocksResponse, error)
	GetBlock(context.Context, *model.GetBlockRequest) (*model.GetBlockResponse, error)
}

BlockServiceServer is the server API for BlockService service.

type EscrowTransactionServiceClient 

type EscrowTransactionServiceClient interface {
	GetEscrowTransactions(ctx context.Context, in *model.GetEscrowTransactionsRequest, opts ...grpc.CallOption) (*model.GetEscrowTransactionsResponse, error)
	GetEscrowTransaction(ctx context.Context, in *model.GetEscrowTransactionRequest, opts ...grpc.CallOption) (*model.Escrow, error)
}

EscrowTransactionServiceClient is the client API for EscrowTransactionService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewEscrowTransactionServiceClient 

func NewEscrowTransactionServiceClient(cc grpc.ClientConnInterface) EscrowTransactionServiceClient

type EscrowTransactionServiceServer 

type EscrowTransactionServiceServer interface {
	GetEscrowTransactions(context.Context, *model.GetEscrowTransactionsRequest) (*model.GetEscrowTransactionsResponse, error)
	GetEscrowTransaction(context.Context, *model.GetEscrowTransactionRequest) (*model.Escrow, error)
}

EscrowTransactionServiceServer is the server API for EscrowTransactionService service.

type FileDownloadServiceClient 

type FileDownloadServiceClient interface {
	FileDownload(ctx context.Context, in *model.FileDownloadRequest, opts ...grpc.CallOption) (*model.FileDownloadResponse, error)
}

FileDownloadServiceClient is the client API for FileDownloadService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewFileDownloadServiceClient 

func NewFileDownloadServiceClient(cc grpc.ClientConnInterface) FileDownloadServiceClient

type FileDownloadServiceServer 

type FileDownloadServiceServer interface {
	FileDownload(context.Context, *model.FileDownloadRequest) (*model.FileDownloadResponse, error)
}

FileDownloadServiceServer is the server API for FileDownloadService service.

type HealthCheckServiceClient 

type HealthCheckServiceClient interface {
	HealthCheck(ctx context.Context, in *model.Empty, opts ...grpc.CallOption) (*model.HealthCheckResponse, error)
}

HealthCheckServiceClient is the client API for HealthCheckService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewHealthCheckServiceClient 

func NewHealthCheckServiceClient(cc grpc.ClientConnInterface) HealthCheckServiceClient

type HealthCheckServiceServer 

type HealthCheckServiceServer interface {
	HealthCheck(context.Context, *model.Empty) (*model.HealthCheckResponse, error)
}

HealthCheckServiceServer is the server API for HealthCheckService service.

type HostServiceClient 

type HostServiceClient interface {
	GetHostInfo(ctx context.Context, in *model.Empty, opts ...grpc.CallOption) (*model.HostInfo, error)
	GetHostPeers(ctx context.Context, in *model.Empty, opts ...grpc.CallOption) (*model.GetHostPeersResponse, error)
}

HostServiceClient is the client API for HostService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewHostServiceClient 

func NewHostServiceClient(cc grpc.ClientConnInterface) HostServiceClient

type HostServiceServer 

type HostServiceServer interface {
	GetHostInfo(context.Context, *model.Empty) (*model.HostInfo, error)
	GetHostPeers(context.Context, *model.Empty) (*model.GetHostPeersResponse, error)
}

HostServiceServer is the server API for HostService service.

type LiquidPaymentServiceClient 

type LiquidPaymentServiceClient interface {
	GetLiquidTransactions(ctx context.Context, in *model.GetLiquidTransactionsRequest, opts ...grpc.CallOption) (*model.GetLiquidTransactionsResponse, error)
}

LiquidPaymentServiceClient is the client API for LiquidPaymentService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewLiquidPaymentServiceClient 

func NewLiquidPaymentServiceClient(cc grpc.ClientConnInterface) LiquidPaymentServiceClient

type LiquidPaymentServiceServer 

type LiquidPaymentServiceServer interface {
	GetLiquidTransactions(context.Context, *model.GetLiquidTransactionsRequest) (*model.GetLiquidTransactionsResponse, error)
}

LiquidPaymentServiceServer is the server API for LiquidPaymentService service.

type MempoolServiceClient 

type MempoolServiceClient interface {
	GetMempoolTransactions(ctx context.Context, in *model.GetMempoolTransactionsRequest, opts ...grpc.CallOption) (*model.GetMempoolTransactionsResponse, error)
	GetMempoolTransaction(ctx context.Context, in *model.GetMempoolTransactionRequest, opts ...grpc.CallOption) (*model.GetMempoolTransactionResponse, error)
}

MempoolServiceClient is the client API for MempoolService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewMempoolServiceClient 

func NewMempoolServiceClient(cc grpc.ClientConnInterface) MempoolServiceClient

type MempoolServiceServer 

type MempoolServiceServer interface {
	GetMempoolTransactions(context.Context, *model.GetMempoolTransactionsRequest) (*model.GetMempoolTransactionsResponse, error)
	GetMempoolTransaction(context.Context, *model.GetMempoolTransactionRequest) (*model.GetMempoolTransactionResponse, error)
}

MempoolServiceServer is the server API for MempoolService service.

type MultisigServiceClient 

type MultisigServiceClient interface {
	GetPendingTransactions(ctx context.Context, in *model.GetPendingTransactionsRequest, opts ...grpc.CallOption) (*model.GetPendingTransactionsResponse, error)
	GetPendingTransactionDetailByTransactionHash(ctx context.Context, in *model.GetPendingTransactionDetailByTransactionHashRequest, opts ...grpc.CallOption) (*model.GetPendingTransactionDetailByTransactionHashResponse, error)
	GetMultisignatureInfo(ctx context.Context, in *model.GetMultisignatureInfoRequest, opts ...grpc.CallOption) (*model.GetMultisignatureInfoResponse, error)
	GetMultisigAddressByParticipantAddress(ctx context.Context, in *model.GetMultisigAddressByParticipantAddressRequest, opts ...grpc.CallOption) (*model.GetMultisigAddressByParticipantAddressResponse, error)
	// GetPendingTransactionsByHeight fetch list of pending transactions (latest = 1 and latest = 0) within `fromHeight` and `toHeight`
	GetPendingTransactionsByHeight(ctx context.Context, in *model.GetPendingTransactionsByHeightRequest, opts ...grpc.CallOption) (*model.GetPendingTransactionsByHeightResponse, error)
	GetMultisigAddressesByBlockHeightRange(ctx context.Context, in *model.GetMultisigAddressesByBlockHeightRangeRequest, opts ...grpc.CallOption) (*model.GetMultisigAddressesByBlockHeightRangeResponse, error)
	GetParticipantsByMultisigAddresses(ctx context.Context, in *model.GetParticipantsByMultisigAddressesRequest, opts ...grpc.CallOption) (*model.GetParticipantsByMultisigAddressesResponse, error)
}

MultisigServiceClient is the client API for MultisigService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewMultisigServiceClient 

func NewMultisigServiceClient(cc grpc.ClientConnInterface) MultisigServiceClient

type MultisigServiceServer 

type MultisigServiceServer interface {
	GetPendingTransactions(context.Context, *model.GetPendingTransactionsRequest) (*model.GetPendingTransactionsResponse, error)
	GetPendingTransactionDetailByTransactionHash(context.Context, *model.GetPendingTransactionDetailByTransactionHashRequest) (*model.GetPendingTransactionDetailByTransactionHashResponse, error)
	GetMultisignatureInfo(context.Context, *model.GetMultisignatureInfoRequest) (*model.GetMultisignatureInfoResponse, error)
	GetMultisigAddressByParticipantAddress(context.Context, *model.GetMultisigAddressByParticipantAddressRequest) (*model.GetMultisigAddressByParticipantAddressResponse, error)
	// GetPendingTransactionsByHeight fetch list of pending transactions (latest = 1 and latest = 0) within `fromHeight` and `toHeight`
	GetPendingTransactionsByHeight(context.Context, *model.GetPendingTransactionsByHeightRequest) (*model.GetPendingTransactionsByHeightResponse, error)
	GetMultisigAddressesByBlockHeightRange(context.Context, *model.GetMultisigAddressesByBlockHeightRangeRequest) (*model.GetMultisigAddressesByBlockHeightRangeResponse, error)
	GetParticipantsByMultisigAddresses(context.Context, *model.GetParticipantsByMultisigAddressesRequest) (*model.GetParticipantsByMultisigAddressesResponse, error)
}

MultisigServiceServer is the server API for MultisigService service.

type NodeAddressInfoServiceClient 

type NodeAddressInfoServiceClient interface {
	GetNodeAddressInfo(ctx context.Context, in *model.GetNodeAddressesInfoRequest, opts ...grpc.CallOption) (*model.GetNodeAddressesInfoResponse, error)
}

NodeAddressInfoServiceClient is the client API for NodeAddressInfoService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewNodeAddressInfoServiceClient 

func NewNodeAddressInfoServiceClient(cc grpc.ClientConnInterface) NodeAddressInfoServiceClient

type NodeAddressInfoServiceServer 

type NodeAddressInfoServiceServer interface {
	GetNodeAddressInfo(context.Context, *model.GetNodeAddressesInfoRequest) (*model.GetNodeAddressesInfoResponse, error)
}

NodeAddressInfoServiceServer is the server API for NodeAddressInfoService service.

type NodeAdminServiceClient 

type NodeAdminServiceClient interface {
	GetProofOfOwnership(ctx context.Context, in *model.GetProofOfOwnershipRequest, opts ...grpc.CallOption) (*model.ProofOfOwnership, error)
	GenerateNodeKey(ctx context.Context, in *model.GenerateNodeKeyRequest, opts ...grpc.CallOption) (*model.GenerateNodeKeyResponse, error)
}

NodeAdminServiceClient is the client API for NodeAdminService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewNodeAdminServiceClient 

func NewNodeAdminServiceClient(cc grpc.ClientConnInterface) NodeAdminServiceClient

type NodeAdminServiceServer 

type NodeAdminServiceServer interface {
	GetProofOfOwnership(context.Context, *model.GetProofOfOwnershipRequest) (*model.ProofOfOwnership, error)
	GenerateNodeKey(context.Context, *model.GenerateNodeKeyRequest) (*model.GenerateNodeKeyResponse, error)
}

NodeAdminServiceServer is the server API for NodeAdminService service.

type NodeHardwareServiceClient 

type NodeHardwareServiceClient interface {
	GetNodeHardware(ctx context.Context, opts ...grpc.CallOption) (NodeHardwareService_GetNodeHardwareClient, error)
	// GetNodeTime return current UTC Time
	GetNodeTime(ctx context.Context, in *model.Empty, opts ...grpc.CallOption) (*model.GetNodeTimeResponse, error)
}

NodeHardwareServiceClient is the client API for NodeHardwareService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewNodeHardwareServiceClient 

func NewNodeHardwareServiceClient(cc grpc.ClientConnInterface) NodeHardwareServiceClient

type NodeHardwareServiceServer 

type NodeHardwareServiceServer interface {
	GetNodeHardware(NodeHardwareService_GetNodeHardwareServer) error
	// GetNodeTime return current UTC Time
	GetNodeTime(context.Context, *model.Empty) (*model.GetNodeTimeResponse, error)
}

NodeHardwareServiceServer is the server API for NodeHardwareService service.

type NodeHardwareService_GetNodeHardwareClient 

type NodeHardwareService_GetNodeHardwareClient interface {
	Send(*model.GetNodeHardwareRequest) error
	Recv() (*model.GetNodeHardwareResponse, error)
	grpc.ClientStream
}

type NodeHardwareService_GetNodeHardwareServer 

type NodeHardwareService_GetNodeHardwareServer interface {
	Send(*model.GetNodeHardwareResponse) error
	Recv() (*model.GetNodeHardwareRequest, error)
	grpc.ServerStream
}

type NodeRegistrationServiceClient 

type NodeRegistrationServiceClient interface {
	GetNodeRegistrations(ctx context.Context, in *model.GetNodeRegistrationsRequest, opts ...grpc.CallOption) (*model.GetNodeRegistrationsResponse, error)
	GetNodeRegistration(ctx context.Context, in *model.GetNodeRegistrationRequest, opts ...grpc.CallOption) (*model.GetNodeRegistrationResponse, error)
	GetNodeRegistrationsByNodePublicKeys(ctx context.Context, in *model.GetNodeRegistrationsByNodePublicKeysRequest, opts ...grpc.CallOption) (*model.GetNodeRegistrationsByNodePublicKeysResponse, error)
	GetPendingNodeRegistrations(ctx context.Context, opts ...grpc.CallOption) (NodeRegistrationService_GetPendingNodeRegistrationsClient, error)
	// GetMyNodePublicKey return the public key of the node
	GetMyNodePublicKey(ctx context.Context, in *model.Empty, opts ...grpc.CallOption) (*model.GetMyNodePublicKeyResponse, error)
}

NodeRegistrationServiceClient is the client API for NodeRegistrationService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewNodeRegistrationServiceClient 

func NewNodeRegistrationServiceClient(cc grpc.ClientConnInterface) NodeRegistrationServiceClient

type NodeRegistrationServiceServer 

type NodeRegistrationServiceServer interface {
	GetNodeRegistrations(context.Context, *model.GetNodeRegistrationsRequest) (*model.GetNodeRegistrationsResponse, error)
	GetNodeRegistration(context.Context, *model.GetNodeRegistrationRequest) (*model.GetNodeRegistrationResponse, error)
	GetNodeRegistrationsByNodePublicKeys(context.Context, *model.GetNodeRegistrationsByNodePublicKeysRequest) (*model.GetNodeRegistrationsByNodePublicKeysResponse, error)
	GetPendingNodeRegistrations(NodeRegistrationService_GetPendingNodeRegistrationsServer) error
	// GetMyNodePublicKey return the public key of the node
	GetMyNodePublicKey(context.Context, *model.Empty) (*model.GetMyNodePublicKeyResponse, error)
}

NodeRegistrationServiceServer is the server API for NodeRegistrationService service.

type NodeRegistrationService_GetPendingNodeRegistrationsClient 

type NodeRegistrationService_GetPendingNodeRegistrationsClient interface {
	Send(*model.GetPendingNodeRegistrationsRequest) error
	Recv() (*model.GetPendingNodeRegistrationsResponse, error)
	grpc.ClientStream
}

type NodeRegistrationService_GetPendingNodeRegistrationsServer 

type NodeRegistrationService_GetPendingNodeRegistrationsServer interface {
	Send(*model.GetPendingNodeRegistrationsResponse) error
	Recv() (*model.GetPendingNodeRegistrationsRequest, error)
	grpc.ServerStream
}

type P2PCommunicationClient 

type P2PCommunicationClient interface {
	GetNodeAddressesInfo(ctx context.Context, in *model.GetNodeAddressesInfoRequest, opts ...grpc.CallOption) (*model.GetNodeAddressesInfoResponse, error)
	SendNodeAddressInfo(ctx context.Context, in *model.SendNodeAddressInfoRequest, opts ...grpc.CallOption) (*model.Empty, error)
	GetNodeProofOfOrigin(ctx context.Context, in *model.GetNodeProofOfOriginRequest, opts ...grpc.CallOption) (*model.ProofOfOrigin, error)
	GetPeerInfo(ctx context.Context, in *model.GetPeerInfoRequest, opts ...grpc.CallOption) (*model.GetPeerInfoResponse, error)
	GetMorePeers(ctx context.Context, in *model.Empty, opts ...grpc.CallOption) (*model.GetMorePeersResponse, error)
	SendPeers(ctx context.Context, in *model.SendPeersRequest, opts ...grpc.CallOption) (*model.Empty, error)
	SendBlock(ctx context.Context, in *model.SendBlockRequest, opts ...grpc.CallOption) (*model.SendBlockResponse, error)
	SendTransaction(ctx context.Context, in *model.SendTransactionRequest, opts ...grpc.CallOption) (*model.SendTransactionResponse, error)
	SendBlockTransactions(ctx context.Context, in *model.SendBlockTransactionsRequest, opts ...grpc.CallOption) (*model.SendBlockTransactionsResponse, error)
	RequestBlockTransactions(ctx context.Context, in *model.RequestBlockTransactionsRequest, opts ...grpc.CallOption) (*model.Empty, error)
	GetCumulativeDifficulty(ctx context.Context, in *model.GetCumulativeDifficultyRequest, opts ...grpc.CallOption) (*model.GetCumulativeDifficultyResponse, error)
	GetCommonMilestoneBlockIDs(ctx context.Context, in *model.GetCommonMilestoneBlockIdsRequest, opts ...grpc.CallOption) (*model.GetCommonMilestoneBlockIdsResponse, error)
	GetNextBlockIDs(ctx context.Context, in *model.GetNextBlockIdsRequest, opts ...grpc.CallOption) (*model.BlockIdsResponse, error)
	GetNextBlocks(ctx context.Context, in *model.GetNextBlocksRequest, opts ...grpc.CallOption) (*model.BlocksData, error)
	RequestFileDownload(ctx context.Context, in *model.FileDownloadRequest, opts ...grpc.CallOption) (*model.FileDownloadResponse, error)
}

P2PCommunicationClient is the client API for P2PCommunication service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewP2PCommunicationClient 

func NewP2PCommunicationClient(cc grpc.ClientConnInterface) P2PCommunicationClient

type P2PCommunicationServer 

type P2PCommunicationServer interface {
	GetNodeAddressesInfo(context.Context, *model.GetNodeAddressesInfoRequest) (*model.GetNodeAddressesInfoResponse, error)
	SendNodeAddressInfo(context.Context, *model.SendNodeAddressInfoRequest) (*model.Empty, error)
	GetNodeProofOfOrigin(context.Context, *model.GetNodeProofOfOriginRequest) (*model.ProofOfOrigin, error)
	GetPeerInfo(context.Context, *model.GetPeerInfoRequest) (*model.GetPeerInfoResponse, error)
	GetMorePeers(context.Context, *model.Empty) (*model.GetMorePeersResponse, error)
	SendPeers(context.Context, *model.SendPeersRequest) (*model.Empty, error)
	SendBlock(context.Context, *model.SendBlockRequest) (*model.SendBlockResponse, error)
	SendTransaction(context.Context, *model.SendTransactionRequest) (*model.SendTransactionResponse, error)
	SendBlockTransactions(context.Context, *model.SendBlockTransactionsRequest) (*model.SendBlockTransactionsResponse, error)
	RequestBlockTransactions(context.Context, *model.RequestBlockTransactionsRequest) (*model.Empty, error)
	GetCumulativeDifficulty(context.Context, *model.GetCumulativeDifficultyRequest) (*model.GetCumulativeDifficultyResponse, error)
	GetCommonMilestoneBlockIDs(context.Context, *model.GetCommonMilestoneBlockIdsRequest) (*model.GetCommonMilestoneBlockIdsResponse, error)
	GetNextBlockIDs(context.Context, *model.GetNextBlockIdsRequest) (*model.BlockIdsResponse, error)
	GetNextBlocks(context.Context, *model.GetNextBlocksRequest) (*model.BlocksData, error)
	RequestFileDownload(context.Context, *model.FileDownloadRequest) (*model.FileDownloadResponse, error)
}

P2PCommunicationServer is the server API for P2PCommunication service.

type ParticipationScoreServiceClient 

type ParticipationScoreServiceClient interface {
	// GetParticipationScores return list of participation score history recorded by node
	GetParticipationScores(ctx context.Context, in *model.GetParticipationScoresRequest, opts ...grpc.CallOption) (*model.GetParticipationScoresResponse, error)
	// GetLatestParticipationScoreByNodeID returns the latest participation score accumulated by node
	GetLatestParticipationScoreByNodeID(ctx context.Context, in *model.GetLatestParticipationScoreByNodeIDRequest, opts ...grpc.CallOption) (*model.ParticipationScore, error)
}

ParticipationScoreServiceClient is the client API for ParticipationScoreService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewParticipationScoreServiceClient 

func NewParticipationScoreServiceClient(cc grpc.ClientConnInterface) ParticipationScoreServiceClient

type ParticipationScoreServiceServer 

type ParticipationScoreServiceServer interface {
	// GetParticipationScores return list of participation score history recorded by node
	GetParticipationScores(context.Context, *model.GetParticipationScoresRequest) (*model.GetParticipationScoresResponse, error)
	// GetLatestParticipationScoreByNodeID returns the latest participation score accumulated by node
	GetLatestParticipationScoreByNodeID(context.Context, *model.GetLatestParticipationScoreByNodeIDRequest) (*model.ParticipationScore, error)
}

ParticipationScoreServiceServer is the server API for ParticipationScoreService service.

type PublishedReceiptServiceClient 

type PublishedReceiptServiceClient interface {
	GetPublishedReceipts(ctx context.Context, in *model.GetPublishedReceiptsRequest, opts ...grpc.CallOption) (*model.GetPublishedReceiptsResponse, error)
}

PublishedReceiptServiceClient is the client API for PublishedReceiptService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewPublishedReceiptServiceClient 

func NewPublishedReceiptServiceClient(cc grpc.ClientConnInterface) PublishedReceiptServiceClient

type PublishedReceiptServiceServer 

type PublishedReceiptServiceServer interface {
	GetPublishedReceipts(context.Context, *model.GetPublishedReceiptsRequest) (*model.GetPublishedReceiptsResponse, error)
}

PublishedReceiptServiceServer is the server API for PublishedReceiptService service.

type SkippedBlockSmithsServiceClient 

type SkippedBlockSmithsServiceClient interface {
	GetSkippedBlockSmiths(ctx context.Context, in *model.GetSkippedBlocksmithsRequest, opts ...grpc.CallOption) (*model.GetSkippedBlocksmithsResponse, error)
}

SkippedBlockSmithsServiceClient is the client API for SkippedBlockSmithsService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewSkippedBlockSmithsServiceClient 

func NewSkippedBlockSmithsServiceClient(cc grpc.ClientConnInterface) SkippedBlockSmithsServiceClient

type SkippedBlockSmithsServiceServer 

type SkippedBlockSmithsServiceServer interface {
	GetSkippedBlockSmiths(context.Context, *model.GetSkippedBlocksmithsRequest) (*model.GetSkippedBlocksmithsResponse, error)
}

SkippedBlockSmithsServiceServer is the server API for SkippedBlockSmithsService service.

type TransactionServiceClient 

type TransactionServiceClient interface {
	GetTransactions(ctx context.Context, in *model.GetTransactionsRequest, opts ...grpc.CallOption) (*model.GetTransactionsResponse, error)
	GetTransaction(ctx context.Context, in *model.GetTransactionRequest, opts ...grpc.CallOption) (*model.Transaction, error)
	PostTransaction(ctx context.Context, in *model.PostTransactionRequest, opts ...grpc.CallOption) (*model.PostTransactionResponse, error)
	GetTransactionMinimumFee(ctx context.Context, in *model.GetTransactionMinimumFeeRequest, opts ...grpc.CallOption) (*model.GetTransactionMinimumFeeResponse, error)
}

TransactionServiceClient is the client API for TransactionService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewTransactionServiceClient 

func NewTransactionServiceClient(cc grpc.ClientConnInterface) TransactionServiceClient

type TransactionServiceServer 

type TransactionServiceServer interface {
	GetTransactions(context.Context, *model.GetTransactionsRequest) (*model.GetTransactionsResponse, error)
	GetTransaction(context.Context, *model.GetTransactionRequest) (*model.Transaction, error)
	PostTransaction(context.Context, *model.PostTransactionRequest) (*model.PostTransactionResponse, error)
	GetTransactionMinimumFee(context.Context, *model.GetTransactionMinimumFeeRequest) (*model.GetTransactionMinimumFeeResponse, error)
}

TransactionServiceServer is the server API for TransactionService service.

type UnimplementedAccountBalanceServiceServer 

type UnimplementedAccountBalanceServiceServer struct {
}

UnimplementedAccountBalanceServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedAccountBalanceServiceServer) GetAccountBalance 

func (*UnimplementedAccountBalanceServiceServer) GetAccountBalance(ctx context.Context, req *model.GetAccountBalanceRequest) (*model.GetAccountBalanceResponse, error)

func (*UnimplementedAccountBalanceServiceServer) GetAccountBalances 

func (*UnimplementedAccountBalanceServiceServer) GetAccountBalances(ctx context.Context, req *model.GetAccountBalancesRequest) (*model.GetAccountBalancesResponse, error)

type UnimplementedAccountDatasetServiceServer 

type UnimplementedAccountDatasetServiceServer struct {
}

UnimplementedAccountDatasetServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedAccountDatasetServiceServer) GetAccountDataset 

func (*UnimplementedAccountDatasetServiceServer) GetAccountDataset(ctx context.Context, req *model.GetAccountDatasetRequest) (*model.AccountDataset, error)

func (*UnimplementedAccountDatasetServiceServer) GetAccountDatasets 

func (*UnimplementedAccountDatasetServiceServer) GetAccountDatasets(ctx context.Context, req *model.GetAccountDatasetsRequest) (*model.GetAccountDatasetsResponse, error)

type UnimplementedAccountLedgerServiceServer 

type UnimplementedAccountLedgerServiceServer struct {
}

UnimplementedAccountLedgerServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedAccountLedgerServiceServer) GetAccountLedgers 

func (*UnimplementedAccountLedgerServiceServer) GetAccountLedgers(ctx context.Context, req *model.GetAccountLedgersRequest) (*model.GetAccountLedgersResponse, error)

type UnimplementedBlockServiceServer 

type UnimplementedBlockServiceServer struct {
}

UnimplementedBlockServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedBlockServiceServer) GetBlock 

func (*UnimplementedBlockServiceServer) GetBlock(ctx context.Context, req *model.GetBlockRequest) (*model.GetBlockResponse, error)

func (*UnimplementedBlockServiceServer) GetBlocks 

func (*UnimplementedBlockServiceServer) GetBlocks(ctx context.Context, req *model.GetBlocksRequest) (*model.GetBlocksResponse, error)

type UnimplementedEscrowTransactionServiceServer 

type UnimplementedEscrowTransactionServiceServer struct {
}

UnimplementedEscrowTransactionServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedEscrowTransactionServiceServer) GetEscrowTransaction 

func (*UnimplementedEscrowTransactionServiceServer) GetEscrowTransaction(ctx context.Context, req *model.GetEscrowTransactionRequest) (*model.Escrow, error)

func (*UnimplementedEscrowTransactionServiceServer) GetEscrowTransactions 

func (*UnimplementedEscrowTransactionServiceServer) GetEscrowTransactions(ctx context.Context, req *model.GetEscrowTransactionsRequest) (*model.GetEscrowTransactionsResponse, error)

type UnimplementedFileDownloadServiceServer 

type UnimplementedFileDownloadServiceServer struct {
}

UnimplementedFileDownloadServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedFileDownloadServiceServer) FileDownload 

func (*UnimplementedFileDownloadServiceServer) FileDownload(ctx context.Context, req *model.FileDownloadRequest) (*model.FileDownloadResponse, error)

type UnimplementedHealthCheckServiceServer 

type UnimplementedHealthCheckServiceServer struct {
}

UnimplementedHealthCheckServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedHealthCheckServiceServer) HealthCheck 

func (*UnimplementedHealthCheckServiceServer) HealthCheck(ctx context.Context, req *model.Empty) (*model.HealthCheckResponse, error)

type UnimplementedHostServiceServer 

type UnimplementedHostServiceServer struct {
}

UnimplementedHostServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedHostServiceServer) GetHostInfo 

func (*UnimplementedHostServiceServer) GetHostInfo(ctx context.Context, req *model.Empty) (*model.HostInfo, error)

func (*UnimplementedHostServiceServer) GetHostPeers 

func (*UnimplementedHostServiceServer) GetHostPeers(ctx context.Context, req *model.Empty) (*model.GetHostPeersResponse, error)

type UnimplementedLiquidPaymentServiceServer 

type UnimplementedLiquidPaymentServiceServer struct {
}

UnimplementedLiquidPaymentServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedLiquidPaymentServiceServer) GetLiquidTransactions 

func (*UnimplementedLiquidPaymentServiceServer) GetLiquidTransactions(ctx context.Context, req *model.GetLiquidTransactionsRequest) (*model.GetLiquidTransactionsResponse, error)

type UnimplementedMempoolServiceServer 

type UnimplementedMempoolServiceServer struct {
}

UnimplementedMempoolServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedMempoolServiceServer) GetMempoolTransaction 

func (*UnimplementedMempoolServiceServer) GetMempoolTransaction(ctx context.Context, req *model.GetMempoolTransactionRequest) (*model.GetMempoolTransactionResponse, error)

func (*UnimplementedMempoolServiceServer) GetMempoolTransactions 

func (*UnimplementedMempoolServiceServer) GetMempoolTransactions(ctx context.Context, req *model.GetMempoolTransactionsRequest) (*model.GetMempoolTransactionsResponse, error)

type UnimplementedMultisigServiceServer 

type UnimplementedMultisigServiceServer struct {
}

UnimplementedMultisigServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedMultisigServiceServer) GetMultisigAddressByParticipantAddress 

func (*UnimplementedMultisigServiceServer) GetMultisigAddressByParticipantAddress(ctx context.Context, req *model.GetMultisigAddressByParticipantAddressRequest) (*model.GetMultisigAddressByParticipantAddressResponse, error)

func (*UnimplementedMultisigServiceServer) GetMultisigAddressesByBlockHeightRange 

func (*UnimplementedMultisigServiceServer) GetMultisigAddressesByBlockHeightRange(ctx context.Context, req *model.GetMultisigAddressesByBlockHeightRangeRequest) (*model.GetMultisigAddressesByBlockHeightRangeResponse, error)

func (*UnimplementedMultisigServiceServer) GetMultisignatureInfo 

func (*UnimplementedMultisigServiceServer) GetMultisignatureInfo(ctx context.Context, req *model.GetMultisignatureInfoRequest) (*model.GetMultisignatureInfoResponse, error)

func (*UnimplementedMultisigServiceServer) GetParticipantsByMultisigAddresses 

func (*UnimplementedMultisigServiceServer) GetParticipantsByMultisigAddresses(ctx context.Context, req *model.GetParticipantsByMultisigAddressesRequest) (*model.GetParticipantsByMultisigAddressesResponse, error)

func (*UnimplementedMultisigServiceServer) GetPendingTransactionDetailByTransactionHash 

func (*UnimplementedMultisigServiceServer) GetPendingTransactionDetailByTransactionHash(ctx context.Context, req *model.GetPendingTransactionDetailByTransactionHashRequest) (*model.GetPendingTransactionDetailByTransactionHashResponse, error)

func (*UnimplementedMultisigServiceServer) GetPendingTransactions 

func (*UnimplementedMultisigServiceServer) GetPendingTransactions(ctx context.Context, req *model.GetPendingTransactionsRequest) (*model.GetPendingTransactionsResponse, error)

func (*UnimplementedMultisigServiceServer) GetPendingTransactionsByHeight 

func (*UnimplementedMultisigServiceServer) GetPendingTransactionsByHeight(ctx context.Context, req *model.GetPendingTransactionsByHeightRequest) (*model.GetPendingTransactionsByHeightResponse, error)

type UnimplementedNodeAddressInfoServiceServer 

type UnimplementedNodeAddressInfoServiceServer struct {
}

UnimplementedNodeAddressInfoServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedNodeAddressInfoServiceServer) GetNodeAddressInfo 

func (*UnimplementedNodeAddressInfoServiceServer) GetNodeAddressInfo(ctx context.Context, req *model.GetNodeAddressesInfoRequest) (*model.GetNodeAddressesInfoResponse, error)

type UnimplementedNodeAdminServiceServer 

type UnimplementedNodeAdminServiceServer struct {
}

UnimplementedNodeAdminServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedNodeAdminServiceServer) GenerateNodeKey 

func (*UnimplementedNodeAdminServiceServer) GenerateNodeKey(ctx context.Context, req *model.GenerateNodeKeyRequest) (*model.GenerateNodeKeyResponse, error)

func (*UnimplementedNodeAdminServiceServer) GetProofOfOwnership 

func (*UnimplementedNodeAdminServiceServer) GetProofOfOwnership(ctx context.Context, req *model.GetProofOfOwnershipRequest) (*model.ProofOfOwnership, error)

type UnimplementedNodeHardwareServiceServer 

type UnimplementedNodeHardwareServiceServer struct {
}

UnimplementedNodeHardwareServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedNodeHardwareServiceServer) GetNodeHardware 

func (*UnimplementedNodeHardwareServiceServer) GetNodeHardware(srv NodeHardwareService_GetNodeHardwareServer) error

func (*UnimplementedNodeHardwareServiceServer) GetNodeTime 

func (*UnimplementedNodeHardwareServiceServer) GetNodeTime(ctx context.Context, req *model.Empty) (*model.GetNodeTimeResponse, error)

type UnimplementedNodeRegistrationServiceServer 

type UnimplementedNodeRegistrationServiceServer struct {
}

UnimplementedNodeRegistrationServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedNodeRegistrationServiceServer) GetMyNodePublicKey 

func (*UnimplementedNodeRegistrationServiceServer) GetMyNodePublicKey(ctx context.Context, req *model.Empty) (*model.GetMyNodePublicKeyResponse, error)

func (*UnimplementedNodeRegistrationServiceServer) GetNodeRegistration 

func (*UnimplementedNodeRegistrationServiceServer) GetNodeRegistration(ctx context.Context, req *model.GetNodeRegistrationRequest) (*model.GetNodeRegistrationResponse, error)

func (*UnimplementedNodeRegistrationServiceServer) GetNodeRegistrations 

func (*UnimplementedNodeRegistrationServiceServer) GetNodeRegistrations(ctx context.Context, req *model.GetNodeRegistrationsRequest) (*model.GetNodeRegistrationsResponse, error)

func (*UnimplementedNodeRegistrationServiceServer) GetNodeRegistrationsByNodePublicKeys 

func (*UnimplementedNodeRegistrationServiceServer) GetNodeRegistrationsByNodePublicKeys(ctx context.Context, req *model.GetNodeRegistrationsByNodePublicKeysRequest) (*model.GetNodeRegistrationsByNodePublicKeysResponse, error)

func (*UnimplementedNodeRegistrationServiceServer) GetPendingNodeRegistrations 

func (*UnimplementedNodeRegistrationServiceServer) GetPendingNodeRegistrations(srv NodeRegistrationService_GetPendingNodeRegistrationsServer) error

type UnimplementedP2PCommunicationServer 

type UnimplementedP2PCommunicationServer struct {
}

UnimplementedP2PCommunicationServer can be embedded to have forward compatible implementations.

func (*UnimplementedP2PCommunicationServer) GetCommonMilestoneBlockIDs 

func (*UnimplementedP2PCommunicationServer) GetCommonMilestoneBlockIDs(ctx context.Context, req *model.GetCommonMilestoneBlockIdsRequest) (*model.GetCommonMilestoneBlockIdsResponse, error)

func (*UnimplementedP2PCommunicationServer) GetCumulativeDifficulty 

func (*UnimplementedP2PCommunicationServer) GetCumulativeDifficulty(ctx context.Context, req *model.GetCumulativeDifficultyRequest) (*model.GetCumulativeDifficultyResponse, error)

func (*UnimplementedP2PCommunicationServer) GetMorePeers 

func (*UnimplementedP2PCommunicationServer) GetMorePeers(ctx context.Context, req *model.Empty) (*model.GetMorePeersResponse, error)

func (*UnimplementedP2PCommunicationServer) GetNextBlockIDs 

func (*UnimplementedP2PCommunicationServer) GetNextBlockIDs(ctx context.Context, req *model.GetNextBlockIdsRequest) (*model.BlockIdsResponse, error)

func (*UnimplementedP2PCommunicationServer) GetNextBlocks 

func (*UnimplementedP2PCommunicationServer) GetNextBlocks(ctx context.Context, req *model.GetNextBlocksRequest) (*model.BlocksData, error)

func (*UnimplementedP2PCommunicationServer) GetNodeAddressesInfo 

func (*UnimplementedP2PCommunicationServer) GetNodeAddressesInfo(ctx context.Context, req *model.GetNodeAddressesInfoRequest) (*model.GetNodeAddressesInfoResponse, error)

func (*UnimplementedP2PCommunicationServer) GetNodeProofOfOrigin 

func (*UnimplementedP2PCommunicationServer) GetNodeProofOfOrigin(ctx context.Context, req *model.GetNodeProofOfOriginRequest) (*model.ProofOfOrigin, error)

func (*UnimplementedP2PCommunicationServer) GetPeerInfo 

func (*UnimplementedP2PCommunicationServer) GetPeerInfo(ctx context.Context, req *model.GetPeerInfoRequest) (*model.GetPeerInfoResponse, error)

func (*UnimplementedP2PCommunicationServer) RequestBlockTransactions 

func (*UnimplementedP2PCommunicationServer) RequestBlockTransactions(ctx context.Context, req *model.RequestBlockTransactionsRequest) (*model.Empty, error)

func (*UnimplementedP2PCommunicationServer) RequestFileDownload 

func (*UnimplementedP2PCommunicationServer) RequestFileDownload(ctx context.Context, req *model.FileDownloadRequest) (*model.FileDownloadResponse, error)

func (*UnimplementedP2PCommunicationServer) SendBlock 

func (*UnimplementedP2PCommunicationServer) SendBlock(ctx context.Context, req *model.SendBlockRequest) (*model.SendBlockResponse, error)

func (*UnimplementedP2PCommunicationServer) SendBlockTransactions 

func (*UnimplementedP2PCommunicationServer) SendBlockTransactions(ctx context.Context, req *model.SendBlockTransactionsRequest) (*model.SendBlockTransactionsResponse, error)

func (*UnimplementedP2PCommunicationServer) SendNodeAddressInfo 

func (*UnimplementedP2PCommunicationServer) SendNodeAddressInfo(ctx context.Context, req *model.SendNodeAddressInfoRequest) (*model.Empty, error)

func (*UnimplementedP2PCommunicationServer) SendPeers 

func (*UnimplementedP2PCommunicationServer) SendPeers(ctx context.Context, req *model.SendPeersRequest) (*model.Empty, error)

func (*UnimplementedP2PCommunicationServer) SendTransaction 

func (*UnimplementedP2PCommunicationServer) SendTransaction(ctx context.Context, req *model.SendTransactionRequest) (*model.SendTransactionResponse, error)

type UnimplementedParticipationScoreServiceServer 

type UnimplementedParticipationScoreServiceServer struct {
}

UnimplementedParticipationScoreServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedParticipationScoreServiceServer) GetLatestParticipationScoreByNodeID 

func (*UnimplementedParticipationScoreServiceServer) GetLatestParticipationScoreByNodeID(ctx context.Context, req *model.GetLatestParticipationScoreByNodeIDRequest) (*model.ParticipationScore, error)

func (*UnimplementedParticipationScoreServiceServer) GetParticipationScores 

func (*UnimplementedParticipationScoreServiceServer) GetParticipationScores(ctx context.Context, req *model.GetParticipationScoresRequest) (*model.GetParticipationScoresResponse, error)

type UnimplementedPublishedReceiptServiceServer 

type UnimplementedPublishedReceiptServiceServer struct {
}

UnimplementedPublishedReceiptServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedPublishedReceiptServiceServer) GetPublishedReceipts 

func (*UnimplementedPublishedReceiptServiceServer) GetPublishedReceipts(ctx context.Context, req *model.GetPublishedReceiptsRequest) (*model.GetPublishedReceiptsResponse, error)

type UnimplementedSkippedBlockSmithsServiceServer 

type UnimplementedSkippedBlockSmithsServiceServer struct {
}

UnimplementedSkippedBlockSmithsServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedSkippedBlockSmithsServiceServer) GetSkippedBlockSmiths 

func (*UnimplementedSkippedBlockSmithsServiceServer) GetSkippedBlockSmiths(ctx context.Context, req *model.GetSkippedBlocksmithsRequest) (*model.GetSkippedBlocksmithsResponse, error)

type UnimplementedTransactionServiceServer 

type UnimplementedTransactionServiceServer struct {
}

UnimplementedTransactionServiceServer can be embedded to have forward compatible implementations.

func (*UnimplementedTransactionServiceServer) GetTransaction 

func (*UnimplementedTransactionServiceServer) GetTransaction(ctx context.Context, req *model.GetTransactionRequest) (*model.Transaction, error)

func (*UnimplementedTransactionServiceServer) GetTransactionMinimumFee 

func (*UnimplementedTransactionServiceServer) GetTransactionMinimumFee(ctx context.Context, req *model.GetTransactionMinimumFeeRequest) (*model.GetTransactionMinimumFeeResponse, error)

func (*UnimplementedTransactionServiceServer) GetTransactions 

func (*UnimplementedTransactionServiceServer) GetTransactions(ctx context.Context, req *model.GetTransactionsRequest) (*model.GetTransactionsResponse, error)

func (*UnimplementedTransactionServiceServer) PostTransaction 

func (*UnimplementedTransactionServiceServer) PostTransaction(ctx context.Context, req *model.PostTransactionRequest) (*model.PostTransactionResponse, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.