highperfocused/lnd
1
0
Fork 0
mirror of https://github.com/lightningnetwork/lnd.git synced 2025-03-26 01:33:02 +01:00
Code Issues Packages Projects Releases Wiki Activity

neutrinorpc: subserver functionality

Browse Source
This commit is contained in:
ErikEk 2021-08-23 05:04:47 +02:00
parent 635cffa871
commit 8c7be4ebf5
9 changed files with 3797 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
lnrpc/neutrinorpc/driver.go Normal file
View File

@ -0,0 +1,55 @@
//go:build neutrinorpc
// +build neutrinorpc
package neutrinorpc
import (
"fmt"
"github.com/lightningnetwork/lnd/lnrpc"
)
// createNewSubServer is a helper method that will create the new sub server
// given the main config dispatcher method. If we're unable to find the config
// that is meant for us in the config dispatcher, then we'll exit with an
// error.
func createNewSubServer(configRegistry lnrpc.SubServerConfigDispatcher) (
*Server, lnrpc.MacaroonPerms, error) {
// We'll attempt to look up the config that we expect, according to our
// subServerName name. If we can't find this, then we'll exit with an
// error, as we're unable to properly initialize ourselves without this
// config.
subServerConf, ok := configRegistry.FetchConfig(subServerName)
if !ok {
return nil, nil, fmt.Errorf("unable to find config for "+
"subserver type %s", subServerName)
}
// Now that we've found an object mapping to our service name, we'll
// ensure that it's the type we need.
config, ok := subServerConf.(*Config)
if !ok {
return nil, nil, fmt.Errorf("wrong type of config for "+
"subserver %s, expected %T got %T", subServerName,
&Config{}, subServerConf)
}
return New(config)
}
func init() {
subServer := &lnrpc.SubServerDriver{
SubServerName: subServerName,
NewGrpcHandler: func() lnrpc.GrpcHandler {
return &ServerShell{}
},
}
// If the build tag is active, then we'll register ourselves as a
// sub-RPC server within the global lnrpc package namespace.
if err := lnrpc.RegisterSubServer(subServer); err != nil {
panic(fmt.Sprintf("failed to register sub server driver "+
"'%s': %v", subServerName, err))
}
}

1343
lnrpc/neutrinorpc/neutrino.pb.go Normal file
View File

File diff suppressed because it is too large Load Diff

693
lnrpc/neutrinorpc/neutrino.pb.gw.go Normal file
View File

@ -0,0 +1,693 @@
// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
// source: neutrinorpc/neutrino.proto
/*
Package neutrinorpc is a reverse proxy.
It translates gRPC into RESTful JSON APIs.
*/
package neutrinorpc
import (
"context"
"io"
"net/http"
"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
"github.com/grpc-ecosystem/grpc-gateway/v2/utilities"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/grpclog"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/status"
"google.golang.org/protobuf/proto"
)
// Suppress "imported and not used" errors
var _ codes.Code
var _ io.Reader
var _ status.Status
var _ = runtime.String
var _ = utilities.NewDoubleArray
var _ = metadata.Join
func request_NeutrinoKit_Status_0(ctx context.Context, marshaler runtime.Marshaler, client NeutrinoKitClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq StatusRequest
var metadata runtime.ServerMetadata
msg, err := client.Status(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_NeutrinoKit_Status_0(ctx context.Context, marshaler runtime.Marshaler, server NeutrinoKitServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq StatusRequest
var metadata runtime.ServerMetadata
msg, err := server.Status(ctx, &protoReq)
return msg, metadata, err
}
func request_NeutrinoKit_AddPeer_0(ctx context.Context, marshaler runtime.Marshaler, client NeutrinoKitClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq AddPeerRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.AddPeer(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_NeutrinoKit_AddPeer_0(ctx context.Context, marshaler runtime.Marshaler, server NeutrinoKitServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq AddPeerRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.AddPeer(ctx, &protoReq)
return msg, metadata, err
}
func request_NeutrinoKit_DisconnectPeer_0(ctx context.Context, marshaler runtime.Marshaler, client NeutrinoKitClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq DisconnectPeerRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.DisconnectPeer(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_NeutrinoKit_DisconnectPeer_0(ctx context.Context, marshaler runtime.Marshaler, server NeutrinoKitServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq DisconnectPeerRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.DisconnectPeer(ctx, &protoReq)
return msg, metadata, err
}
var (
filter_NeutrinoKit_IsBanned_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
)
func request_NeutrinoKit_IsBanned_0(ctx context.Context, marshaler runtime.Marshaler, client NeutrinoKitClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq IsBannedRequest
var metadata runtime.ServerMetadata
if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_NeutrinoKit_IsBanned_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.IsBanned(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_NeutrinoKit_IsBanned_0(ctx context.Context, marshaler runtime.Marshaler, server NeutrinoKitServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq IsBannedRequest
var metadata runtime.ServerMetadata
if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_NeutrinoKit_IsBanned_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.IsBanned(ctx, &protoReq)
return msg, metadata, err
}
func request_NeutrinoKit_GetBlockHeader_0(ctx context.Context, marshaler runtime.Marshaler, client NeutrinoKitClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetBlockHeaderRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["hash"]
if !ok {
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "hash")
}
protoReq.Hash, err = runtime.String(val)
if err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "hash", err)
}
msg, err := client.GetBlockHeader(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_NeutrinoKit_GetBlockHeader_0(ctx context.Context, marshaler runtime.Marshaler, server NeutrinoKitServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetBlockHeaderRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["hash"]
if !ok {
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "hash")
}
protoReq.Hash, err = runtime.String(val)
if err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "hash", err)
}
msg, err := server.GetBlockHeader(ctx, &protoReq)
return msg, metadata, err
}
func request_NeutrinoKit_GetBlock_0(ctx context.Context, marshaler runtime.Marshaler, client NeutrinoKitClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetBlockRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["hash"]
if !ok {
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "hash")
}
protoReq.Hash, err = runtime.String(val)
if err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "hash", err)
}
msg, err := client.GetBlock(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_NeutrinoKit_GetBlock_0(ctx context.Context, marshaler runtime.Marshaler, server NeutrinoKitServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetBlockRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["hash"]
if !ok {
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "hash")
}
protoReq.Hash, err = runtime.String(val)
if err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "hash", err)
}
msg, err := server.GetBlock(ctx, &protoReq)
return msg, metadata, err
}
func request_NeutrinoKit_GetCFilter_0(ctx context.Context, marshaler runtime.Marshaler, client NeutrinoKitClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetCFilterRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["hash"]
if !ok {
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "hash")
}
protoReq.Hash, err = runtime.String(val)
if err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "hash", err)
}
msg, err := client.GetCFilter(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_NeutrinoKit_GetCFilter_0(ctx context.Context, marshaler runtime.Marshaler, server NeutrinoKitServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetCFilterRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["hash"]
if !ok {
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "hash")
}
protoReq.Hash, err = runtime.String(val)
if err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "hash", err)
}
msg, err := server.GetCFilter(ctx, &protoReq)
return msg, metadata, err
}
// RegisterNeutrinoKitHandlerServer registers the http handlers for service NeutrinoKit to "mux".
// UnaryRPC :call NeutrinoKitServer directly.
// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterNeutrinoKitHandlerFromEndpoint instead.
func RegisterNeutrinoKitHandlerServer(ctx context.Context, mux *runtime.ServeMux, server NeutrinoKitServer) error {
mux.Handle("GET", pattern_NeutrinoKit_Status_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/neutrinorpc.NeutrinoKit/Status", runtime.WithHTTPPathPattern("/v2/neutrino/status"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_NeutrinoKit_Status_0(rctx, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_NeutrinoKit_Status_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_NeutrinoKit_AddPeer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/neutrinorpc.NeutrinoKit/AddPeer", runtime.WithHTTPPathPattern("/v2/neutrino/addpeer"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_NeutrinoKit_AddPeer_0(rctx, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_NeutrinoKit_AddPeer_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_NeutrinoKit_DisconnectPeer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/neutrinorpc.NeutrinoKit/DisconnectPeer", runtime.WithHTTPPathPattern("/v2/neutrino/disconnect"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_NeutrinoKit_DisconnectPeer_0(rctx, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_NeutrinoKit_DisconnectPeer_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_NeutrinoKit_IsBanned_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/neutrinorpc.NeutrinoKit/IsBanned", runtime.WithHTTPPathPattern("/v2/neutrino/isbanned"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_NeutrinoKit_IsBanned_0(rctx, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_NeutrinoKit_IsBanned_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_NeutrinoKit_GetBlockHeader_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/neutrinorpc.NeutrinoKit/GetBlockHeader", runtime.WithHTTPPathPattern("/v2/neutrino/blockheader/{hash}"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_NeutrinoKit_GetBlockHeader_0(rctx, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_NeutrinoKit_GetBlockHeader_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_NeutrinoKit_GetBlock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/neutrinorpc.NeutrinoKit/GetBlock", runtime.WithHTTPPathPattern("/v2/neutrino/block/{hash}"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_NeutrinoKit_GetBlock_0(rctx, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_NeutrinoKit_GetBlock_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_NeutrinoKit_GetCFilter_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/neutrinorpc.NeutrinoKit/GetCFilter", runtime.WithHTTPPathPattern("/v2/neutrino/cfilter/{hash}"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_NeutrinoKit_GetCFilter_0(rctx, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_NeutrinoKit_GetCFilter_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
// RegisterNeutrinoKitHandlerFromEndpoint is same as RegisterNeutrinoKitHandler but
// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
func RegisterNeutrinoKitHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
conn, err := grpc.Dial(endpoint, opts...)
if err != nil {
return err
}
defer func() {
if err != nil {
if cerr := conn.Close(); cerr != nil {
grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
}
return
}
go func() {
<-ctx.Done()
if cerr := conn.Close(); cerr != nil {
grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
}
}()
}()
return RegisterNeutrinoKitHandler(ctx, mux, conn)
}
// RegisterNeutrinoKitHandler registers the http handlers for service NeutrinoKit to "mux".
// The handlers forward requests to the grpc endpoint over "conn".
func RegisterNeutrinoKitHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
return RegisterNeutrinoKitHandlerClient(ctx, mux, NewNeutrinoKitClient(conn))
}
// RegisterNeutrinoKitHandlerClient registers the http handlers for service NeutrinoKit
// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "NeutrinoKitClient".
// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "NeutrinoKitClient"
// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
// "NeutrinoKitClient" to call the correct interceptors.
func RegisterNeutrinoKitHandlerClient(ctx context.Context, mux *runtime.ServeMux, client NeutrinoKitClient) error {
mux.Handle("GET", pattern_NeutrinoKit_Status_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req, "/neutrinorpc.NeutrinoKit/Status", runtime.WithHTTPPathPattern("/v2/neutrino/status"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_NeutrinoKit_Status_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_NeutrinoKit_Status_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_NeutrinoKit_AddPeer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req, "/neutrinorpc.NeutrinoKit/AddPeer", runtime.WithHTTPPathPattern("/v2/neutrino/addpeer"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_NeutrinoKit_AddPeer_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_NeutrinoKit_AddPeer_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_NeutrinoKit_DisconnectPeer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req, "/neutrinorpc.NeutrinoKit/DisconnectPeer", runtime.WithHTTPPathPattern("/v2/neutrino/disconnect"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_NeutrinoKit_DisconnectPeer_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_NeutrinoKit_DisconnectPeer_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_NeutrinoKit_IsBanned_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req, "/neutrinorpc.NeutrinoKit/IsBanned", runtime.WithHTTPPathPattern("/v2/neutrino/isbanned"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_NeutrinoKit_IsBanned_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_NeutrinoKit_IsBanned_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_NeutrinoKit_GetBlockHeader_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req, "/neutrinorpc.NeutrinoKit/GetBlockHeader", runtime.WithHTTPPathPattern("/v2/neutrino/blockheader/{hash}"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_NeutrinoKit_GetBlockHeader_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_NeutrinoKit_GetBlockHeader_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_NeutrinoKit_GetBlock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req, "/neutrinorpc.NeutrinoKit/GetBlock", runtime.WithHTTPPathPattern("/v2/neutrino/block/{hash}"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_NeutrinoKit_GetBlock_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_NeutrinoKit_GetBlock_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_NeutrinoKit_GetCFilter_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req, "/neutrinorpc.NeutrinoKit/GetCFilter", runtime.WithHTTPPathPattern("/v2/neutrino/cfilter/{hash}"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_NeutrinoKit_GetCFilter_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_NeutrinoKit_GetCFilter_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
var (
pattern_NeutrinoKit_Status_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "neutrino", "status"}, ""))
pattern_NeutrinoKit_AddPeer_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "neutrino", "addpeer"}, ""))
pattern_NeutrinoKit_DisconnectPeer_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "neutrino", "disconnect"}, ""))
pattern_NeutrinoKit_IsBanned_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "neutrino", "isbanned"}, ""))
pattern_NeutrinoKit_GetBlockHeader_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v2", "neutrino", "blockheader", "hash"}, ""))
pattern_NeutrinoKit_GetBlock_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v2", "neutrino", "block", "hash"}, ""))
pattern_NeutrinoKit_GetCFilter_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v2", "neutrino", "cfilter", "hash"}, ""))
)
var (
forward_NeutrinoKit_Status_0 = runtime.ForwardResponseMessage
forward_NeutrinoKit_AddPeer_0 = runtime.ForwardResponseMessage
forward_NeutrinoKit_DisconnectPeer_0 = runtime.ForwardResponseMessage
forward_NeutrinoKit_IsBanned_0 = runtime.ForwardResponseMessage
forward_NeutrinoKit_GetBlockHeader_0 = runtime.ForwardResponseMessage
forward_NeutrinoKit_GetBlock_0 = runtime.ForwardResponseMessage
forward_NeutrinoKit_GetCFilter_0 = runtime.ForwardResponseMessage
)

210
lnrpc/neutrinorpc/neutrino.proto Normal file
View File

@ -0,0 +1,210 @@
syntax = "proto3";
package neutrinorpc;
option go_package = "github.com/lightningnetwork/lnd/lnrpc/neutrinorpc";
// NeutrinoKit is a service that can be used to get information about the
// current state of the neutrino instance, fetch blocks and add/remove peers.
service NeutrinoKit {
/*
Status returns the status of the light client neutrino instance,
along with height and hash of the best block, and a list of connected
peers.
*/
rpc Status (StatusRequest) returns (StatusResponse);
/*
AddPeer adds a new peer that has already been connected to the server.
*/
rpc AddPeer (AddPeerRequest) returns (AddPeerResponse);
/*
DisconnectPeer disconnects a peer by target address. Both outbound and
inbound nodes will be searched for the target node. An error message will
be returned if the peer was not found.
*/
rpc DisconnectPeer (DisconnectPeerRequest) returns (DisconnectPeerResponse);
/*
IsBanned returns true if the peer is banned, otherwise false.
*/
rpc IsBanned (IsBannedRequest) returns (IsBannedResponse);
/*
GetBlockHeader returns a block header with a particular block hash.
*/
rpc GetBlockHeader (GetBlockHeaderRequest) returns (GetBlockHeaderResponse);
/*
GetBlock returns a block with a particular block hash.
*/
rpc GetBlock (GetBlockRequest) returns (GetBlockResponse);
/*
GetCFilter returns a compact filter from a block.
*/
rpc GetCFilter (GetCFilterRequest) returns (GetCFilterResponse);
}
message StatusRequest {
}
message StatusResponse {
// Indicates whether the neutrino backend is active or not.
bool active = 1;
// Is fully synced.
bool synced = 2;
// Best block height.
int32 block_height = 3;
// Best block hash.
string block_hash = 4;
// Connected peers.
repeated string peers = 5;
}
message AddPeerRequest {
// Peer to add.
string peer_addrs = 1;
}
message AddPeerResponse {
}
message DisconnectPeerRequest {
// Peer to disconnect.
string peer_addrs = 1;
}
message DisconnectPeerResponse {
}
message IsBannedRequest {
// Peer to lookup.
string peer_addrs = 1;
}
message IsBannedResponse {
bool banned = 1;
}
message GetBlockHeaderRequest {
// Block hash in hex notation.
string hash = 1;
}
message GetBlockHeaderResponse {
// The block hash (same as provided).
string hash = 1;
// The number of confirmations.
int64 confirmations = 2;
// The block size excluding witness data.
int64 stripped_size = 3;
// The block size (bytes).
int64 size = 4;
// The block weight as defined in BIP 141.
int64 weight = 5;
// The block height or index.
int32 height = 6;
// The block version.
int32 version = 7;
// The block version.
string version_hex = 8;
// The merkle root.
string merkleroot = 9;
// The block time in seconds since epoch (Jan 1 1970 GMT).
int64 time = 10;
// The nonce.
uint32 nonce = 11;
// The bits in hex notation.
string bits = 12;
// The number of transactions in the block.
int32 ntx = 13;
// The hash of the previous block.
string previous_block_hash = 14;
// The raw hex of the block.
bytes raw_hex = 15;
}
message GetBlockRequest {
// Block hash in hex notation.
string hash = 1;
}
message GetBlockResponse {
// The block hash (same as provided).
string hash = 1;
// The number of confirmations.
int64 confirmations = 2;
// The block size excluding witness data.
int64 stripped_size = 3;
// The block size (bytes).
int64 size = 4;
// The block weight as defined in BIP 141.
int64 weight = 5;
// The block height or index.
int32 height = 6;
// The block version.
int32 version = 7;
// The block version.
string version_hex = 8;
// The merkle root.
string merkleroot = 9;
// List of transaction ids.
repeated string tx = 10;
// The block time in seconds since epoch (Jan 1 1970 GMT).
int64 time = 11;
// The nonce.
uint32 nonce = 12;
// The bits in hex notation.
string bits = 13;
// The number of transactions in the block.
int32 ntx = 14;
// The hash of the previous block.
string previous_block_hash = 15;
// The raw hex of the block.
bytes raw_hex = 16;
}
message GetCFilterRequest {
// Block hash in hex notation.
string hash = 1;
}
message GetCFilterResponse {
// GCS filter.
bytes filter = 1;
}

497
lnrpc/neutrinorpc/neutrino.swagger.json Normal file
View File

@ -0,0 +1,497 @@
{
"swagger": "2.0",
"info": {
"title": "neutrinorpc/neutrino.proto",
"version": "version not set"
},
"tags": [
{
"name": "NeutrinoKit"
}
],
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"paths": {
"/v2/neutrino/addpeer": {
"post": {
"summary": "AddPeer adds a new peer that has already been connected to the server.",
"operationId": "NeutrinoKit_AddPeer",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/neutrinorpcAddPeerResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"parameters": [
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/neutrinorpcAddPeerRequest"
}
}
],
"tags": [
"NeutrinoKit"
]
}
},
"/v2/neutrino/block/{hash}": {
"get": {
"summary": "GetBlock returns a block with a particular block hash.",
"operationId": "NeutrinoKit_GetBlock",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/neutrinorpcGetBlockResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"parameters": [
{
"name": "hash",
"description": "Block hash in hex notation.",
"in": "path",
"required": true,
"type": "string"
}
],
"tags": [
"NeutrinoKit"
]
}
},
"/v2/neutrino/blockheader/{hash}": {
"get": {
"summary": "GetBlockHeader returns a block header with a particular block hash.",
"operationId": "NeutrinoKit_GetBlockHeader",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/neutrinorpcGetBlockHeaderResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"parameters": [
{
"name": "hash",
"description": "Block hash in hex notation.",
"in": "path",
"required": true,
"type": "string"
}
],
"tags": [
"NeutrinoKit"
]
}
},
"/v2/neutrino/cfilter/{hash}": {
"get": {
"summary": "GetCFilter returns a compact filter from a block.",
"operationId": "NeutrinoKit_GetCFilter",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/neutrinorpcGetCFilterResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"parameters": [
{
"name": "hash",
"description": "Block hash in hex notation.",
"in": "path",
"required": true,
"type": "string"
}
],
"tags": [
"NeutrinoKit"
]
}
},
"/v2/neutrino/disconnect": {
"post": {
"summary": "DisconnectPeer disconnects a peer by target address. Both outbound and\ninbound nodes will be searched for the target node. An error message will\nbe returned if the peer was not found.",
"operationId": "NeutrinoKit_DisconnectPeer",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/neutrinorpcDisconnectPeerResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"parameters": [
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/neutrinorpcDisconnectPeerRequest"
}
}
],
"tags": [
"NeutrinoKit"
]
}
},
"/v2/neutrino/isbanned": {
"get": {
"summary": "IsBanned returns true if the peer is banned, otherwise false.",
"operationId": "NeutrinoKit_IsBanned",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/neutrinorpcIsBannedResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"parameters": [
{
"name": "peer_addrs",
"description": "Peer to lookup.",
"in": "query",
"required": false,
"type": "string"
}
],
"tags": [
"NeutrinoKit"
]
}
},
"/v2/neutrino/status": {
"get": {
"summary": "Status returns the status of the light client neutrino instance,\nalong with height and hash of the best block, and a list of connected\npeers.",
"operationId": "NeutrinoKit_Status",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/neutrinorpcStatusResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"tags": [
"NeutrinoKit"
]
}
}
},
"definitions": {
"neutrinorpcAddPeerRequest": {
"type": "object",
"properties": {
"peer_addrs": {
"type": "string",
"description": "Peer to add."
}
}
},
"neutrinorpcAddPeerResponse": {
"type": "object"
},
"neutrinorpcDisconnectPeerRequest": {
"type": "object",
"properties": {
"peer_addrs": {
"type": "string",
"description": "Peer to disconnect."
}
}
},
"neutrinorpcDisconnectPeerResponse": {
"type": "object"
},
"neutrinorpcGetBlockHeaderResponse": {
"type": "object",
"properties": {
"hash": {
"type": "string",
"description": "The block hash (same as provided)."
},
"confirmations": {
"type": "string",
"format": "int64",
"description": "The number of confirmations."
},
"stripped_size": {
"type": "string",
"format": "int64",
"description": "The block size excluding witness data."
},
"size": {
"type": "string",
"format": "int64",
"description": "The block size (bytes)."
},
"weight": {
"type": "string",
"format": "int64",
"description": "The block weight as defined in BIP 141."
},
"height": {
"type": "integer",
"format": "int32",
"description": "The block height or index."
},
"version": {
"type": "integer",
"format": "int32",
"description": "The block version."
},
"version_hex": {
"type": "string",
"description": "The block version."
},
"merkleroot": {
"type": "string",
"description": "The merkle root."
},
"time": {
"type": "string",
"format": "int64",
"description": "The block time in seconds since epoch (Jan 1 1970 GMT)."
},
"nonce": {
"type": "integer",
"format": "int64",
"description": "The nonce."
},
"bits": {
"type": "string",
"description": "The bits in hex notation."
},
"ntx": {
"type": "integer",
"format": "int32",
"description": "The number of transactions in the block."
},
"previous_block_hash": {
"type": "string",
"description": "The hash of the previous block."
},
"raw_hex": {
"type": "string",
"format": "byte",
"description": "The raw hex of the block."
}
}
},
"neutrinorpcGetBlockResponse": {
"type": "object",
"properties": {
"hash": {
"type": "string",
"description": "The block hash (same as provided)."
},
"confirmations": {
"type": "string",
"format": "int64",
"description": "The number of confirmations."
},
"stripped_size": {
"type": "string",
"format": "int64",
"description": "The block size excluding witness data."
},
"size": {
"type": "string",
"format": "int64",
"description": "The block size (bytes)."
},
"weight": {
"type": "string",
"format": "int64",
"description": "The block weight as defined in BIP 141."
},
"height": {
"type": "integer",
"format": "int32",
"description": "The block height or index."
},
"version": {
"type": "integer",
"format": "int32",
"description": "The block version."
},
"version_hex": {
"type": "string",
"description": "The block version."
},
"merkleroot": {
"type": "string",
"description": "The merkle root."
},
"tx": {
"type": "array",
"items": {
"type": "string"
},
"description": "List of transaction ids."
},
"time": {
"type": "string",
"format": "int64",
"description": "The block time in seconds since epoch (Jan 1 1970 GMT)."
},
"nonce": {
"type": "integer",
"format": "int64",
"description": "The nonce."
},
"bits": {
"type": "string",
"description": "The bits in hex notation."
},
"ntx": {
"type": "integer",
"format": "int32",
"description": "The number of transactions in the block."
},
"previous_block_hash": {
"type": "string",
"description": "The hash of the previous block."
},
"raw_hex": {
"type": "string",
"format": "byte",
"description": "The raw hex of the block."
}
}
},
"neutrinorpcGetCFilterResponse": {
"type": "object",
"properties": {
"filter": {
"type": "string",
"format": "byte",
"description": "GCS filter."
}
}
},
"neutrinorpcIsBannedResponse": {
"type": "object",
"properties": {
"banned": {
"type": "boolean"
}
}
},
"neutrinorpcStatusResponse": {
"type": "object",
"properties": {
"active": {
"type": "boolean",
"description": "Indicates whether the neutrino backend is active or not."
},
"synced": {
"type": "boolean",
"description": "Is fully synced."
},
"block_height": {
"type": "integer",
"format": "int32",
"description": "Best block height."
},
"block_hash": {
"type": "string",
"description": "Best block hash."
},
"peers": {
"type": "array",
"items": {
"type": "string"
},
"description": "Connected peers."
}
}
},
"protobufAny": {
"type": "object",
"properties": {
"type_url": {
"type": "string"
},
"value": {
"type": "string",
"format": "byte"
}
}
},
"rpcStatus": {
"type": "object",
"properties": {
"code": {
"type": "integer",
"format": "int32"
},
"message": {
"type": "string"
},
"details": {
"type": "array",
"items": {
"$ref": "#/definitions/protobufAny"
}
}
}
}
}
}

21
lnrpc/neutrinorpc/neutrino.yaml Normal file
View File

@ -0,0 +1,21 @@
type: google.api.Service
config_version: 3
http:
rules:
- selector: neutrinorpc.NeutrinoKit.Status
get: "/v2/neutrino/status"
- selector: neutrinorpc.NeutrinoKit.AddPeer
post: "/v2/neutrino/addpeer"
body: "*"
- selector: neutrinorpc.NeutrinoKit.DisconnectPeer
post: "/v2/neutrino/disconnect"
body: "*"
- selector: neutrinorpc.NeutrinoKit.IsBanned
get: "/v2/neutrino/isbanned"
- selector: neutrinorpc.NeutrinoKit.GetBlock
get: "/v2/neutrino/block/{hash}"
- selector: neutrinorpc.NeutrinoKit.GetBlockHeader
get: "/v2/neutrino/blockheader/{hash}"
- selector: neutrinorpc.NeutrinoKit.GetCFilter
get: "/v2/neutrino/cfilter/{hash}"

353
lnrpc/neutrinorpc/neutrino_grpc.pb.go Normal file
View File

@ -0,0 +1,353 @@
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
package neutrinorpc
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
)
// 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
// NeutrinoKitClient is the client API for NeutrinoKit 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 NeutrinoKitClient interface {
//
//Status returns the status of the light client neutrino instance,
//along with height and hash of the best block, and a list of connected
//peers.
Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error)
//
//AddPeer adds a new peer that has already been connected to the server.
AddPeer(ctx context.Context, in *AddPeerRequest, opts ...grpc.CallOption) (*AddPeerResponse, error)
//
//DisconnectPeer disconnects a peer by target address. Both outbound and
//inbound nodes will be searched for the target node. An error message will
//be returned if the peer was not found.
DisconnectPeer(ctx context.Context, in *DisconnectPeerRequest, opts ...grpc.CallOption) (*DisconnectPeerResponse, error)
//
//IsBanned returns true if the peer is banned, otherwise false.
IsBanned(ctx context.Context, in *IsBannedRequest, opts ...grpc.CallOption) (*IsBannedResponse, error)
//
//GetBlockHeader returns a block header with a particular block hash.
GetBlockHeader(ctx context.Context, in *GetBlockHeaderRequest, opts ...grpc.CallOption) (*GetBlockHeaderResponse, error)
//
//GetBlock returns a block with a particular block hash.
GetBlock(ctx context.Context, in *GetBlockRequest, opts ...grpc.CallOption) (*GetBlockResponse, error)
//
//GetCFilter returns a compact filter from a block.
GetCFilter(ctx context.Context, in *GetCFilterRequest, opts ...grpc.CallOption) (*GetCFilterResponse, error)
}
type neutrinoKitClient struct {
cc grpc.ClientConnInterface
}
func NewNeutrinoKitClient(cc grpc.ClientConnInterface) NeutrinoKitClient {
return &neutrinoKitClient{cc}
}
func (c *neutrinoKitClient) Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error) {
out := new(StatusResponse)
err := c.cc.Invoke(ctx, "/neutrinorpc.NeutrinoKit/Status", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *neutrinoKitClient) AddPeer(ctx context.Context, in *AddPeerRequest, opts ...grpc.CallOption) (*AddPeerResponse, error) {
out := new(AddPeerResponse)
err := c.cc.Invoke(ctx, "/neutrinorpc.NeutrinoKit/AddPeer", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *neutrinoKitClient) DisconnectPeer(ctx context.Context, in *DisconnectPeerRequest, opts ...grpc.CallOption) (*DisconnectPeerResponse, error) {
out := new(DisconnectPeerResponse)
err := c.cc.Invoke(ctx, "/neutrinorpc.NeutrinoKit/DisconnectPeer", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *neutrinoKitClient) IsBanned(ctx context.Context, in *IsBannedRequest, opts ...grpc.CallOption) (*IsBannedResponse, error) {
out := new(IsBannedResponse)
err := c.cc.Invoke(ctx, "/neutrinorpc.NeutrinoKit/IsBanned", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *neutrinoKitClient) GetBlockHeader(ctx context.Context, in *GetBlockHeaderRequest, opts ...grpc.CallOption) (*GetBlockHeaderResponse, error) {
out := new(GetBlockHeaderResponse)
err := c.cc.Invoke(ctx, "/neutrinorpc.NeutrinoKit/GetBlockHeader", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *neutrinoKitClient) GetBlock(ctx context.Context, in *GetBlockRequest, opts ...grpc.CallOption) (*GetBlockResponse, error) {
out := new(GetBlockResponse)
err := c.cc.Invoke(ctx, "/neutrinorpc.NeutrinoKit/GetBlock", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *neutrinoKitClient) GetCFilter(ctx context.Context, in *GetCFilterRequest, opts ...grpc.CallOption) (*GetCFilterResponse, error) {
out := new(GetCFilterResponse)
err := c.cc.Invoke(ctx, "/neutrinorpc.NeutrinoKit/GetCFilter", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// NeutrinoKitServer is the server API for NeutrinoKit service.
// All implementations must embed UnimplementedNeutrinoKitServer
// for forward compatibility
type NeutrinoKitServer interface {
//
//Status returns the status of the light client neutrino instance,
//along with height and hash of the best block, and a list of connected
//peers.
Status(context.Context, *StatusRequest) (*StatusResponse, error)
//
//AddPeer adds a new peer that has already been connected to the server.
AddPeer(context.Context, *AddPeerRequest) (*AddPeerResponse, error)
//
//DisconnectPeer disconnects a peer by target address. Both outbound and
//inbound nodes will be searched for the target node. An error message will
//be returned if the peer was not found.
DisconnectPeer(context.Context, *DisconnectPeerRequest) (*DisconnectPeerResponse, error)
//
//IsBanned returns true if the peer is banned, otherwise false.
IsBanned(context.Context, *IsBannedRequest) (*IsBannedResponse, error)
//
//GetBlockHeader returns a block header with a particular block hash.
GetBlockHeader(context.Context, *GetBlockHeaderRequest) (*GetBlockHeaderResponse, error)
//
//GetBlock returns a block with a particular block hash.
GetBlock(context.Context, *GetBlockRequest) (*GetBlockResponse, error)
//
//GetCFilter returns a compact filter from a block.
GetCFilter(context.Context, *GetCFilterRequest) (*GetCFilterResponse, error)
mustEmbedUnimplementedNeutrinoKitServer()
}
// UnimplementedNeutrinoKitServer must be embedded to have forward compatible implementations.
type UnimplementedNeutrinoKitServer struct {
}
func (UnimplementedNeutrinoKitServer) Status(context.Context, *StatusRequest) (*StatusResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Status not implemented")
}
func (UnimplementedNeutrinoKitServer) AddPeer(context.Context, *AddPeerRequest) (*AddPeerResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method AddPeer not implemented")
}
func (UnimplementedNeutrinoKitServer) DisconnectPeer(context.Context, *DisconnectPeerRequest) (*DisconnectPeerResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method DisconnectPeer not implemented")
}
func (UnimplementedNeutrinoKitServer) IsBanned(context.Context, *IsBannedRequest) (*IsBannedResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method IsBanned not implemented")
}
func (UnimplementedNeutrinoKitServer) GetBlockHeader(context.Context, *GetBlockHeaderRequest) (*GetBlockHeaderResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetBlockHeader not implemented")
}
func (UnimplementedNeutrinoKitServer) GetBlock(context.Context, *GetBlockRequest) (*GetBlockResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetBlock not implemented")
}
func (UnimplementedNeutrinoKitServer) GetCFilter(context.Context, *GetCFilterRequest) (*GetCFilterResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetCFilter not implemented")
}
func (UnimplementedNeutrinoKitServer) mustEmbedUnimplementedNeutrinoKitServer() {}
// UnsafeNeutrinoKitServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to NeutrinoKitServer will
// result in compilation errors.
type UnsafeNeutrinoKitServer interface {
mustEmbedUnimplementedNeutrinoKitServer()
}
func RegisterNeutrinoKitServer(s grpc.ServiceRegistrar, srv NeutrinoKitServer) {
s.RegisterService(&NeutrinoKit_ServiceDesc, srv)
}
func _NeutrinoKit_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(StatusRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(NeutrinoKitServer).Status(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/neutrinorpc.NeutrinoKit/Status",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NeutrinoKitServer).Status(ctx, req.(*StatusRequest))
}
return interceptor(ctx, in, info, handler)
}
func _NeutrinoKit_AddPeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(AddPeerRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(NeutrinoKitServer).AddPeer(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/neutrinorpc.NeutrinoKit/AddPeer",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NeutrinoKitServer).AddPeer(ctx, req.(*AddPeerRequest))
}
return interceptor(ctx, in, info, handler)
}
func _NeutrinoKit_DisconnectPeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DisconnectPeerRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(NeutrinoKitServer).DisconnectPeer(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/neutrinorpc.NeutrinoKit/DisconnectPeer",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NeutrinoKitServer).DisconnectPeer(ctx, req.(*DisconnectPeerRequest))
}
return interceptor(ctx, in, info, handler)
}
func _NeutrinoKit_IsBanned_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(IsBannedRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(NeutrinoKitServer).IsBanned(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/neutrinorpc.NeutrinoKit/IsBanned",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NeutrinoKitServer).IsBanned(ctx, req.(*IsBannedRequest))
}
return interceptor(ctx, in, info, handler)
}
func _NeutrinoKit_GetBlockHeader_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetBlockHeaderRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(NeutrinoKitServer).GetBlockHeader(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/neutrinorpc.NeutrinoKit/GetBlockHeader",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NeutrinoKitServer).GetBlockHeader(ctx, req.(*GetBlockHeaderRequest))
}
return interceptor(ctx, in, info, handler)
}
func _NeutrinoKit_GetBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetBlockRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(NeutrinoKitServer).GetBlock(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/neutrinorpc.NeutrinoKit/GetBlock",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NeutrinoKitServer).GetBlock(ctx, req.(*GetBlockRequest))
}
return interceptor(ctx, in, info, handler)
}
func _NeutrinoKit_GetCFilter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetCFilterRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(NeutrinoKitServer).GetCFilter(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/neutrinorpc.NeutrinoKit/GetCFilter",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NeutrinoKitServer).GetCFilter(ctx, req.(*GetCFilterRequest))
}
return interceptor(ctx, in, info, handler)
}
// NeutrinoKit_ServiceDesc is the grpc.ServiceDesc for NeutrinoKit service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var NeutrinoKit_ServiceDesc = grpc.ServiceDesc{
ServiceName: "neutrinorpc.NeutrinoKit",
HandlerType: (*NeutrinoKitServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Status",
Handler: _NeutrinoKit_Status_Handler,
},
{
MethodName: "AddPeer",
Handler: _NeutrinoKit_AddPeer_Handler,
},
{
MethodName: "DisconnectPeer",
Handler: _NeutrinoKit_DisconnectPeer_Handler,
},
{
MethodName: "IsBanned",
Handler: _NeutrinoKit_IsBanned_Handler,
},
{
MethodName: "GetBlockHeader",
Handler: _NeutrinoKit_GetBlockHeader_Handler,
},
{
MethodName: "GetBlock",
Handler: _NeutrinoKit_GetBlock_Handler,
},
{
MethodName: "GetCFilter",
Handler: _NeutrinoKit_GetCFilter_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "neutrinorpc/neutrino.proto",
}

425
lnrpc/neutrinorpc/neutrino_server.go Normal file
View File

@ -0,0 +1,425 @@
//go:build neutrinorpc
// +build neutrinorpc
package neutrinorpc
import (
"context"
"errors"
"fmt"
"google.golang.org/grpc"
"gopkg.in/macaroon-bakery.v2/bakery"
"github.com/btcsuite/btcd/chaincfg/chainhash"
"github.com/btcsuite/btcd/blockchain"
"github.com/btcsuite/btcd/wire"
"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
"github.com/lightningnetwork/lnd/lnrpc"
)
const (
// subServerName is the name of the sub rpc server. We'll use this name
// to register ourselves, and we also require that the main
// SubServerConfigDispatcher instance recognize it as the name of our
// RPC service.
subServerName = "NeutrinoKitRPC"
)
var (
// macPermissions maps RPC calls to the permissions they require.
macPermissions = map[string][]bakery.Op{
"/neutrinorpc.NeutrinoKit/Status": {{
Entity: "info",
Action: "read",
}},
"/neutrinorpc.NeutrinoKit/AddPeer": {{
Entity: "peers",
Action: "write",
}},
"/neutrinorpc.NeutrinoKit/DisconnectPeer": {{
Entity: "peers",
Action: "write",
}},
"/neutrinorpc.NeutrinoKit/IsBanned": {{
Entity: "info",
Action: "read",
}},
"/neutrinorpc.NeutrinoKit/GetBlock": {{
Entity: "onchain",
Action: "read",
}},
"/neutrinorpc.NeutrinoKit/GetBlockHeader": {{
Entity: "onchain",
Action: "read",
}},
"/neutrinorpc.NeutrinoKit/GetCFilter": {{
Entity: "onchain",
Action: "read",
}},
}
// ErrNeutrinoNotActive is an error returned when there is no running
// neutrino light client instance.
ErrNeutrinoNotActive = errors.New("no active neutrino instance")
)
// ServerShell is a shell struct holding a reference to the actual sub-server.
// It is used to register the gRPC sub-server with the root server before we
// have the necessary dependencies to populate the actual sub-server.
type ServerShell struct {
NeutrinoKitServer
}
// Server is a sub-server of the main RPC server: the neutrino RPC. This sub
// RPC server allows external callers to access the status of the neutrino
// currently active within lnd, as well as configuring it at runtime.
type Server struct {
// Required by the grpc-gateway/v2 library for forward compatibility.
// Must be after the atomically used variables to not break struct
// alignment.
UnimplementedNeutrinoKitServer
cfg *Config
}
// A compile time check to ensure that NeutrinoKit fully implements the
// NeutrinoServer gRPC service.
var _ NeutrinoKitServer = (*Server)(nil)
// New returns a new instance of the neutrinorpc Neutrino sub-server. We also
// return the set of permissions for the macaroons that we may create within
// this method. If the macaroons we need aren't found in the filepath, then
// we'll create them on start up. If we're unable to locate, or create the
// macaroons we need, then we'll return with an error.
func New(cfg *Config) (*Server, lnrpc.MacaroonPerms, error) {
// We don't create any new macaroons for this subserver, instead reuse
// existing onchain/offchain permissions.
server := &Server{
cfg: cfg,
}
return server, macPermissions, nil
}
// Start launches any helper goroutines required for the Server to function.
//
// NOTE: This is part of the lnrpc.SubServer interface.
func (s *Server) Start() error {
return nil
}
// Stop signals any active goroutines for a graceful closure.
//
// NOTE: This is part of the lnrpc.SubServer interface.
func (s *Server) Stop() error {
return nil
}
// Name returns a unique string representation of the sub-server. This can be
// used to identify the sub-server and also de-duplicate them.
//
// NOTE: This is part of the lnrpc.SubServer interface.
func (s *Server) Name() string {
return subServerName
}
// RegisterWithRootServer will be called by the root gRPC server to direct a
// sub RPC server to register itself with the main gRPC root server. Until this
// is called, each sub-server won't be able to have
// requests routed towards it.
//
// NOTE: This is part of the lnrpc.GrpcHandler interface.
func (r *ServerShell) RegisterWithRootServer(grpcServer *grpc.Server) error {
// We make sure that we register it with the main gRPC server to ensure
// all our methods are routed properly.
RegisterNeutrinoKitServer(grpcServer, r)
log.Debugf("Neutrino RPC server successfully register with root " +
"gRPC server")
return nil
}
// RegisterWithRestServer will be called by the root REST mux to direct a sub
// RPC server to register itself with the main REST mux server. Until this is
// called, each sub-server won't be able to have requests routed towards it.
//
// NOTE: This is part of the lnrpc.GrpcHandler interface.
func (r *ServerShell) RegisterWithRestServer(ctx context.Context,
mux *runtime.ServeMux, dest string, opts []grpc.DialOption) error {
// We make sure that we register it with the main REST server to ensure
// all our methods are routed properly.
err := RegisterNeutrinoKitHandlerFromEndpoint(ctx, mux, dest, opts)
if err != nil {
log.Errorf("Could not register Neutrino REST server "+
"with root REST server: %v", err)
return err
}
log.Debugf("Neutrino REST server successfully registered with " +
"root REST server")
return nil
}
// CreateSubServer populates the subserver's dependencies using the passed
// SubServerConfigDispatcher. This method should fully initialize the
// sub-server instance, making it ready for action. It returns the macaroon
// permissions that the sub-server wishes to pass on to the root server for all
// methods routed towards it.
//
// NOTE: This is part of the lnrpc.GrpcHandler interface.
func (r *ServerShell) CreateSubServer(configRegistry lnrpc.SubServerConfigDispatcher) (
lnrpc.SubServer, lnrpc.MacaroonPerms, error) {
subServer, macPermissions, err := createNewSubServer(configRegistry)
if err != nil {
return nil, nil, err
}
r.NeutrinoKitServer = subServer
return subServer, macPermissions, nil
}
// Status returns the current status, best block height and connected peers
// of the neutrino node.
//
// NOTE: Part of the NeutrinoServer interface.
func (s *Server) Status(ctx context.Context,
in *StatusRequest) (*StatusResponse, error) {
if s.cfg.NeutrinoCS == nil {
return &StatusResponse{}, nil
}
bestBlock, err := s.cfg.NeutrinoCS.BestBlock()
if err != nil {
return &StatusResponse{},
fmt.Errorf("could not get best block: %v", err)
}
peers := s.cfg.NeutrinoCS.Peers()
var Peers = make([]string, len(peers))
for i, p := range peers {
Peers[i] = p.Addr()
}
return &StatusResponse{
Active: s.cfg.NeutrinoCS != nil,
BlockHeight: bestBlock.Height,
BlockHash: bestBlock.Hash.String(),
Synced: s.cfg.NeutrinoCS.IsCurrent(),
Peers: Peers,
}, nil
}
// AddPeer adds a new peer that has already been connected to the server.
//
// NOTE: Part of the NeutrinoKitServer interface.
func (s *Server) AddPeer(ctx context.Context,
in *AddPeerRequest) (*AddPeerResponse, error) {
if s.cfg.NeutrinoCS == nil {
return &AddPeerResponse{}, ErrNeutrinoNotActive
}
peer := s.cfg.NeutrinoCS.PeerByAddr(in.PeerAddrs)
if peer == nil {
return &AddPeerResponse{},
fmt.Errorf("could not found peer: %s", in.PeerAddrs)
}
s.cfg.NeutrinoCS.AddPeer(peer)
return &AddPeerResponse{}, nil
}
// DisconnectPeer disconnects a peer by target address. Both outbound and
// inbound nodes will be searched for the target node. An error message will
// be returned if the peer was not found.
//
// NOTE: Part of the NeutrinoKitServer interface.
func (s *Server) DisconnectPeer(ctx context.Context,
in *DisconnectPeerRequest) (*DisconnectPeerResponse, error) {
if s.cfg.NeutrinoCS == nil {
return &DisconnectPeerResponse{}, ErrNeutrinoNotActive
}
peer := s.cfg.NeutrinoCS.PeerByAddr(in.PeerAddrs)
if peer == nil {
return &DisconnectPeerResponse{},
fmt.Errorf("could not found peer: %s", in.PeerAddrs)
}
err := s.cfg.NeutrinoCS.DisconnectNodeByAddr(peer.Addr())
if err != nil {
return &DisconnectPeerResponse{}, err
}
return &DisconnectPeerResponse{}, nil
}
// IsBanned returns true if the peer is banned, otherwise false.
//
// NOTE: Part of the NeutrinoKitServer interface.
func (s *Server) IsBanned(ctx context.Context,
in *IsBannedRequest) (*IsBannedResponse, error) {
if s.cfg.NeutrinoCS == nil {
return &IsBannedResponse{}, ErrNeutrinoNotActive
}
return &IsBannedResponse{
Banned: s.cfg.NeutrinoCS.IsBanned(in.PeerAddrs),
}, nil
}
// GetBlockHeader returns a block header with a particular block hash. If the
// block header is found in the cache, it will be returned immediately.
// Otherwise a block will be requested from the network, one peer at a time,
// until one answers.
//
// NOTE: Part of the NeutrinoKitServer interface.
func (s *Server) GetBlockHeader(ctx context.Context,
in *GetBlockHeaderRequest) (*GetBlockHeaderResponse, error) {
if s.cfg.NeutrinoCS == nil {
return &GetBlockHeaderResponse{}, ErrNeutrinoNotActive
}
var hash chainhash.Hash
if err := chainhash.Decode(&hash, in.Hash); err != nil {
return &GetBlockHeaderResponse{}, err
}
resp, err := s.getBlock(hash)
if err != nil {
return &GetBlockHeaderResponse{}, err
}
return &GetBlockHeaderResponse{
Hash: resp.Hash,
Confirmations: resp.Confirmations,
StrippedSize: resp.StrippedSize,
Size: resp.Size,
Weight: resp.Weight,
Height: resp.Height,
Version: resp.Version,
VersionHex: resp.VersionHex,
Merkleroot: resp.Merkleroot,
Time: resp.Time,
Nonce: resp.Nonce,
Bits: resp.Bits,
Ntx: resp.Ntx,
PreviousBlockHash: resp.PreviousBlockHash,
RawHex: resp.RawHex,
}, nil
}
// GetBlock returns a block with a particular block hash. If the block is
// found in the cache, it will be returned immediately. Otherwise a block will
// be requested from the network, one peer at a time, until one answers.
//
// NOTE: Part of the NeutrinoKitServer interface.
func (s *Server) GetBlock(ctx context.Context,
in *GetBlockRequest) (*GetBlockResponse, error) {
if s.cfg.NeutrinoCS == nil {
return &GetBlockResponse{}, ErrNeutrinoNotActive
}
var hash chainhash.Hash
if err := chainhash.Decode(&hash, in.Hash); err != nil {
return &GetBlockResponse{}, err
}
return s.getBlock(hash)
}
// GetCFilter returns a compact filter of a particular block.
// If found, only regular filters will be returned.
//
// NOTE: Part of the NeutrinoKitServer interface.
func (s *Server) GetCFilter(ctx context.Context,
in *GetCFilterRequest) (*GetCFilterResponse, error) {
if s.cfg.NeutrinoCS == nil {
return &GetCFilterResponse{}, ErrNeutrinoNotActive
}
var hash chainhash.Hash
if err := chainhash.Decode(&hash, in.Hash); err != nil {
return &GetCFilterResponse{}, err
}
// GetCFilter returns a compact filter from the database. If it is missing,
// it requests the compact filter from the network.
filter, err := s.cfg.NeutrinoCS.GetCFilter(hash, wire.GCSFilterRegular)
if err != nil {
return &GetCFilterResponse{}, err
}
filterlBytes, err := filter.Bytes()
if err != nil {
return &GetCFilterResponse{}, err
}
return &GetCFilterResponse{Filter: filterlBytes}, nil
}
func (s *Server) getBlock(hash chainhash.Hash) (*GetBlockResponse, error) {
block, err := s.cfg.NeutrinoCS.GetBlock(hash)
if err != nil {
return &GetBlockResponse{}, err
}
header, _, err := s.cfg.NeutrinoCS.BlockHeaders.FetchHeader(&hash)
if err != nil {
return &GetBlockResponse{}, err
}
blockData, err := block.Bytes()
if err != nil {
return &GetBlockResponse{}, err
}
strippedData, err := block.BytesNoWitness()
if err != nil {
return &GetBlockResponse{}, err
}
bestBlock, err := s.cfg.NeutrinoCS.BestBlock()
if err != nil {
return &GetBlockResponse{}, err
}
// Convert txids to a string array.
transactions := block.Transactions()
tx := make([]string, len(transactions))
for i := range transactions {
tx[i] = transactions[i].Hash().String()
}
return &GetBlockResponse{
Hash: block.Hash().String(),
Confirmations: int64(1 + bestBlock.Height - block.Height()),
StrippedSize: int64(len(strippedData)),
Size: int64(len(blockData)),
Weight: blockchain.GetBlockWeight(block),
Height: block.Height(),
Version: header.Version,
VersionHex: fmt.Sprintf("%0x", header.Version),
Merkleroot: header.MerkleRoot.String(),
Tx: tx,
Time: header.Timestamp.Unix(),
Nonce: header.Nonce,
// Format bits as a hex.
Bits: fmt.Sprintf("%0x", header.Bits),
Ntx: int32(len(block.Transactions())),
PreviousBlockHash: header.PrevBlock.String(),
RawHex: blockData,
}, nil
}

200
lnrpc/neutrinorpc/neutrinokit.pb.json.go Normal file
View File

@ -0,0 +1,200 @@
// Code generated by falafel 0.9.1. DO NOT EDIT.
// source: neutrino.proto
// +build js
package neutrinorpc
import (
"context"
gateway "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
"google.golang.org/grpc"
"google.golang.org/protobuf/encoding/protojson"
)
func RegisterNeutrinoKitJSONCallbacks(registry map[string]func(ctx context.Context,
conn *grpc.ClientConn, reqJSON string, callback func(string, error))) {
marshaler := &gateway.JSONPb{
MarshalOptions: protojson.MarshalOptions{
UseProtoNames: true,
EmitUnpopulated: true,
},
}
registry["neutrinorpc.NeutrinoKit.Status"] = func(ctx context.Context,
conn *grpc.ClientConn, reqJSON string, callback func(string, error)) {
req := &StatusRequest{}
err := marshaler.Unmarshal([]byte(reqJSON), req)
if err != nil {
callback("", err)
return
}
client := NewNeutrinoKitClient(conn)
resp, err := client.Status(ctx, req)
if err != nil {
callback("", err)
return
}
respBytes, err := marshaler.Marshal(resp)
if err != nil {
callback("", err)
return
}
callback(string(respBytes), nil)
}
registry["neutrinorpc.NeutrinoKit.AddPeer"] = func(ctx context.Context,
conn *grpc.ClientConn, reqJSON string, callback func(string, error)) {
req := &AddPeerRequest{}
err := marshaler.Unmarshal([]byte(reqJSON), req)
if err != nil {
callback("", err)
return
}
client := NewNeutrinoKitClient(conn)
resp, err := client.AddPeer(ctx, req)
if err != nil {
callback("", err)
return
}
respBytes, err := marshaler.Marshal(resp)
if err != nil {
callback("", err)
return
}
callback(string(respBytes), nil)
}
registry["neutrinorpc.NeutrinoKit.DisconnectPeer"] = func(ctx context.Context,
conn *grpc.ClientConn, reqJSON string, callback func(string, error)) {
req := &DisconnectPeerRequest{}
err := marshaler.Unmarshal([]byte(reqJSON), req)
if err != nil {
callback("", err)
return
}
client := NewNeutrinoKitClient(conn)
resp, err := client.DisconnectPeer(ctx, req)
if err != nil {
callback("", err)
return
}
respBytes, err := marshaler.Marshal(resp)
if err != nil {
callback("", err)
return
}
callback(string(respBytes), nil)
}
registry["neutrinorpc.NeutrinoKit.IsBanned"] = func(ctx context.Context,
conn *grpc.ClientConn, reqJSON string, callback func(string, error)) {
req := &IsBannedRequest{}
err := marshaler.Unmarshal([]byte(reqJSON), req)
if err != nil {
callback("", err)
return
}
client := NewNeutrinoKitClient(conn)
resp, err := client.IsBanned(ctx, req)
if err != nil {
callback("", err)
return
}
respBytes, err := marshaler.Marshal(resp)
if err != nil {
callback("", err)
return
}
callback(string(respBytes), nil)
}
registry["neutrinorpc.NeutrinoKit.GetBlockHeader"] = func(ctx context.Context,
conn *grpc.ClientConn, reqJSON string, callback func(string, error)) {
req := &GetBlockHeaderRequest{}
err := marshaler.Unmarshal([]byte(reqJSON), req)
if err != nil {
callback("", err)
return
}
client := NewNeutrinoKitClient(conn)
resp, err := client.GetBlockHeader(ctx, req)
if err != nil {
callback("", err)
return
}
respBytes, err := marshaler.Marshal(resp)
if err != nil {
callback("", err)
return
}
callback(string(respBytes), nil)
}
registry["neutrinorpc.NeutrinoKit.GetBlock"] = func(ctx context.Context,
conn *grpc.ClientConn, reqJSON string, callback func(string, error)) {
req := &GetBlockRequest{}
err := marshaler.Unmarshal([]byte(reqJSON), req)
if err != nil {
callback("", err)
return
}
client := NewNeutrinoKitClient(conn)
resp, err := client.GetBlock(ctx, req)
if err != nil {
callback("", err)
return
}
respBytes, err := marshaler.Marshal(resp)
if err != nil {
callback("", err)
return
}
callback(string(respBytes), nil)
}
registry["neutrinorpc.NeutrinoKit.GetCFilter"] = func(ctx context.Context,
conn *grpc.ClientConn, reqJSON string, callback func(string, error)) {
req := &GetCFilterRequest{}
err := marshaler.Unmarshal([]byte(reqJSON), req)
if err != nil {
callback("", err)
return
}
client := NewNeutrinoKitClient(conn)
resp, err := client.GetCFilter(ctx, req)
if err != nil {
callback("", err)
return
}
respBytes, err := marshaler.Marshal(resp)
if err != nil {
callback("", err)
return
}
callback(string(respBytes), nil)
}
}