George Tsagkarelis
f14190c02d
Add the new RPC method that looks up the base scid for a given alias. Given the previous stepping stones this commit is fairly simple, we just call into the alias manager and return the lookup result.
1541 lines
67 KiB
Go
1541 lines
67 KiB
Go
// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
|
|
// source: routerrpc/router.proto
|
|
|
|
/*
|
|
Package routerrpc is a reverse proxy.
|
|
|
|
It translates gRPC into RESTful JSON APIs.
|
|
*/
|
|
package routerrpc
|
|
|
|
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_Router_SendPaymentV2_0(ctx context.Context, marshaler runtime.Marshaler, client RouterClient, req *http.Request, pathParams map[string]string) (Router_SendPaymentV2Client, runtime.ServerMetadata, error) {
|
|
var protoReq SendPaymentRequest
|
|
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)
|
|
}
|
|
|
|
stream, err := client.SendPaymentV2(ctx, &protoReq)
|
|
if err != nil {
|
|
return nil, metadata, err
|
|
}
|
|
header, err := stream.Header()
|
|
if err != nil {
|
|
return nil, metadata, err
|
|
}
|
|
metadata.HeaderMD = header
|
|
return stream, metadata, nil
|
|
|
|
}
|
|
|
|
var (
|
|
filter_Router_TrackPaymentV2_0 = &utilities.DoubleArray{Encoding: map[string]int{"payment_hash": 0, "paymentHash": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
)
|
|
|
|
func request_Router_TrackPaymentV2_0(ctx context.Context, marshaler runtime.Marshaler, client RouterClient, req *http.Request, pathParams map[string]string) (Router_TrackPaymentV2Client, runtime.ServerMetadata, error) {
|
|
var protoReq TrackPaymentRequest
|
|
var metadata runtime.ServerMetadata
|
|
|
|
var (
|
|
val string
|
|
ok bool
|
|
err error
|
|
_ = err
|
|
)
|
|
|
|
val, ok = pathParams["payment_hash"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "payment_hash")
|
|
}
|
|
|
|
protoReq.PaymentHash, err = runtime.Bytes(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "payment_hash", err)
|
|
}
|
|
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Router_TrackPaymentV2_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
|
|
stream, err := client.TrackPaymentV2(ctx, &protoReq)
|
|
if err != nil {
|
|
return nil, metadata, err
|
|
}
|
|
header, err := stream.Header()
|
|
if err != nil {
|
|
return nil, metadata, err
|
|
}
|
|
metadata.HeaderMD = header
|
|
return stream, metadata, nil
|
|
|
|
}
|
|
|
|
var (
|
|
filter_Router_TrackPayments_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
|
|
)
|
|
|
|
func request_Router_TrackPayments_0(ctx context.Context, marshaler runtime.Marshaler, client RouterClient, req *http.Request, pathParams map[string]string) (Router_TrackPaymentsClient, runtime.ServerMetadata, error) {
|
|
var protoReq TrackPaymentsRequest
|
|
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_Router_TrackPayments_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
|
|
stream, err := client.TrackPayments(ctx, &protoReq)
|
|
if err != nil {
|
|
return nil, metadata, err
|
|
}
|
|
header, err := stream.Header()
|
|
if err != nil {
|
|
return nil, metadata, err
|
|
}
|
|
metadata.HeaderMD = header
|
|
return stream, metadata, nil
|
|
|
|
}
|
|
|
|
func request_Router_EstimateRouteFee_0(ctx context.Context, marshaler runtime.Marshaler, client RouterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq RouteFeeRequest
|
|
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.EstimateRouteFee(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func local_request_Router_EstimateRouteFee_0(ctx context.Context, marshaler runtime.Marshaler, server RouterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq RouteFeeRequest
|
|
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.EstimateRouteFee(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func request_Router_SendToRouteV2_0(ctx context.Context, marshaler runtime.Marshaler, client RouterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq SendToRouteRequest
|
|
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.SendToRouteV2(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func local_request_Router_SendToRouteV2_0(ctx context.Context, marshaler runtime.Marshaler, server RouterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq SendToRouteRequest
|
|
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.SendToRouteV2(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func request_Router_ResetMissionControl_0(ctx context.Context, marshaler runtime.Marshaler, client RouterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq ResetMissionControlRequest
|
|
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.ResetMissionControl(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func local_request_Router_ResetMissionControl_0(ctx context.Context, marshaler runtime.Marshaler, server RouterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq ResetMissionControlRequest
|
|
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.ResetMissionControl(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func request_Router_QueryMissionControl_0(ctx context.Context, marshaler runtime.Marshaler, client RouterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq QueryMissionControlRequest
|
|
var metadata runtime.ServerMetadata
|
|
|
|
msg, err := client.QueryMissionControl(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func local_request_Router_QueryMissionControl_0(ctx context.Context, marshaler runtime.Marshaler, server RouterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq QueryMissionControlRequest
|
|
var metadata runtime.ServerMetadata
|
|
|
|
msg, err := server.QueryMissionControl(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func request_Router_XImportMissionControl_0(ctx context.Context, marshaler runtime.Marshaler, client RouterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq XImportMissionControlRequest
|
|
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.XImportMissionControl(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func local_request_Router_XImportMissionControl_0(ctx context.Context, marshaler runtime.Marshaler, server RouterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq XImportMissionControlRequest
|
|
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.XImportMissionControl(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func request_Router_GetMissionControlConfig_0(ctx context.Context, marshaler runtime.Marshaler, client RouterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq GetMissionControlConfigRequest
|
|
var metadata runtime.ServerMetadata
|
|
|
|
msg, err := client.GetMissionControlConfig(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func local_request_Router_GetMissionControlConfig_0(ctx context.Context, marshaler runtime.Marshaler, server RouterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq GetMissionControlConfigRequest
|
|
var metadata runtime.ServerMetadata
|
|
|
|
msg, err := server.GetMissionControlConfig(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func request_Router_SetMissionControlConfig_0(ctx context.Context, marshaler runtime.Marshaler, client RouterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq SetMissionControlConfigRequest
|
|
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.SetMissionControlConfig(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func local_request_Router_SetMissionControlConfig_0(ctx context.Context, marshaler runtime.Marshaler, server RouterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq SetMissionControlConfigRequest
|
|
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.SetMissionControlConfig(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func request_Router_QueryProbability_0(ctx context.Context, marshaler runtime.Marshaler, client RouterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq QueryProbabilityRequest
|
|
var metadata runtime.ServerMetadata
|
|
|
|
var (
|
|
val string
|
|
ok bool
|
|
err error
|
|
_ = err
|
|
)
|
|
|
|
val, ok = pathParams["from_node"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "from_node")
|
|
}
|
|
|
|
protoReq.FromNode, err = runtime.Bytes(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "from_node", err)
|
|
}
|
|
|
|
val, ok = pathParams["to_node"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "to_node")
|
|
}
|
|
|
|
protoReq.ToNode, err = runtime.Bytes(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "to_node", err)
|
|
}
|
|
|
|
val, ok = pathParams["amt_msat"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "amt_msat")
|
|
}
|
|
|
|
protoReq.AmtMsat, err = runtime.Int64(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "amt_msat", err)
|
|
}
|
|
|
|
msg, err := client.QueryProbability(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func local_request_Router_QueryProbability_0(ctx context.Context, marshaler runtime.Marshaler, server RouterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq QueryProbabilityRequest
|
|
var metadata runtime.ServerMetadata
|
|
|
|
var (
|
|
val string
|
|
ok bool
|
|
err error
|
|
_ = err
|
|
)
|
|
|
|
val, ok = pathParams["from_node"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "from_node")
|
|
}
|
|
|
|
protoReq.FromNode, err = runtime.Bytes(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "from_node", err)
|
|
}
|
|
|
|
val, ok = pathParams["to_node"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "to_node")
|
|
}
|
|
|
|
protoReq.ToNode, err = runtime.Bytes(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "to_node", err)
|
|
}
|
|
|
|
val, ok = pathParams["amt_msat"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "amt_msat")
|
|
}
|
|
|
|
protoReq.AmtMsat, err = runtime.Int64(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "amt_msat", err)
|
|
}
|
|
|
|
msg, err := server.QueryProbability(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func request_Router_BuildRoute_0(ctx context.Context, marshaler runtime.Marshaler, client RouterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq BuildRouteRequest
|
|
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.BuildRoute(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func local_request_Router_BuildRoute_0(ctx context.Context, marshaler runtime.Marshaler, server RouterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq BuildRouteRequest
|
|
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.BuildRoute(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func request_Router_SubscribeHtlcEvents_0(ctx context.Context, marshaler runtime.Marshaler, client RouterClient, req *http.Request, pathParams map[string]string) (Router_SubscribeHtlcEventsClient, runtime.ServerMetadata, error) {
|
|
var protoReq SubscribeHtlcEventsRequest
|
|
var metadata runtime.ServerMetadata
|
|
|
|
stream, err := client.SubscribeHtlcEvents(ctx, &protoReq)
|
|
if err != nil {
|
|
return nil, metadata, err
|
|
}
|
|
header, err := stream.Header()
|
|
if err != nil {
|
|
return nil, metadata, err
|
|
}
|
|
metadata.HeaderMD = header
|
|
return stream, metadata, nil
|
|
|
|
}
|
|
|
|
func request_Router_HtlcInterceptor_0(ctx context.Context, marshaler runtime.Marshaler, client RouterClient, req *http.Request, pathParams map[string]string) (Router_HtlcInterceptorClient, runtime.ServerMetadata, error) {
|
|
var metadata runtime.ServerMetadata
|
|
stream, err := client.HtlcInterceptor(ctx)
|
|
if err != nil {
|
|
grpclog.Infof("Failed to start streaming: %v", err)
|
|
return nil, metadata, err
|
|
}
|
|
dec := marshaler.NewDecoder(req.Body)
|
|
handleSend := func() error {
|
|
var protoReq ForwardHtlcInterceptResponse
|
|
err := dec.Decode(&protoReq)
|
|
if err == io.EOF {
|
|
return err
|
|
}
|
|
if err != nil {
|
|
grpclog.Infof("Failed to decode request: %v", err)
|
|
return err
|
|
}
|
|
if err := stream.Send(&protoReq); err != nil {
|
|
grpclog.Infof("Failed to send request: %v", err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
go func() {
|
|
for {
|
|
if err := handleSend(); err != nil {
|
|
break
|
|
}
|
|
}
|
|
if err := stream.CloseSend(); err != nil {
|
|
grpclog.Infof("Failed to terminate client stream: %v", err)
|
|
}
|
|
}()
|
|
header, err := stream.Header()
|
|
if err != nil {
|
|
grpclog.Infof("Failed to get header from client: %v", err)
|
|
return nil, metadata, err
|
|
}
|
|
metadata.HeaderMD = header
|
|
return stream, metadata, nil
|
|
}
|
|
|
|
func request_Router_UpdateChanStatus_0(ctx context.Context, marshaler runtime.Marshaler, client RouterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq UpdateChanStatusRequest
|
|
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.UpdateChanStatus(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func local_request_Router_UpdateChanStatus_0(ctx context.Context, marshaler runtime.Marshaler, server RouterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq UpdateChanStatusRequest
|
|
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.UpdateChanStatus(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func request_Router_XAddLocalChanAliases_0(ctx context.Context, marshaler runtime.Marshaler, client RouterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq AddAliasesRequest
|
|
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.XAddLocalChanAliases(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func local_request_Router_XAddLocalChanAliases_0(ctx context.Context, marshaler runtime.Marshaler, server RouterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq AddAliasesRequest
|
|
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.XAddLocalChanAliases(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func request_Router_XDeleteLocalChanAliases_0(ctx context.Context, marshaler runtime.Marshaler, client RouterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq DeleteAliasesRequest
|
|
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.XDeleteLocalChanAliases(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func local_request_Router_XDeleteLocalChanAliases_0(ctx context.Context, marshaler runtime.Marshaler, server RouterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq DeleteAliasesRequest
|
|
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.XDeleteLocalChanAliases(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func request_Router_XFindBaseLocalChanAlias_0(ctx context.Context, marshaler runtime.Marshaler, client RouterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq FindBaseAliasRequest
|
|
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.XFindBaseLocalChanAlias(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
func local_request_Router_XFindBaseLocalChanAlias_0(ctx context.Context, marshaler runtime.Marshaler, server RouterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var protoReq FindBaseAliasRequest
|
|
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.XFindBaseLocalChanAlias(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
|
|
}
|
|
|
|
// RegisterRouterHandlerServer registers the http handlers for service Router to "mux".
|
|
// UnaryRPC :call RouterServer 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 RegisterRouterHandlerFromEndpoint instead.
|
|
func RegisterRouterHandlerServer(ctx context.Context, mux *runtime.ServeMux, server RouterServer) error {
|
|
|
|
mux.Handle("POST", pattern_Router_SendPaymentV2_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
|
|
_, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
})
|
|
|
|
mux.Handle("GET", pattern_Router_TrackPaymentV2_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
|
|
_, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
})
|
|
|
|
mux.Handle("GET", pattern_Router_TrackPayments_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
|
|
_, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_EstimateRouteFee_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/routerrpc.Router/EstimateRouteFee", runtime.WithHTTPPathPattern("/v2/router/route/estimatefee"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Router_EstimateRouteFee_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_EstimateRouteFee_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_SendToRouteV2_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/routerrpc.Router/SendToRouteV2", runtime.WithHTTPPathPattern("/v2/router/route/send"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Router_SendToRouteV2_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_SendToRouteV2_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_ResetMissionControl_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/routerrpc.Router/ResetMissionControl", runtime.WithHTTPPathPattern("/v2/router/mc/reset"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Router_ResetMissionControl_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_ResetMissionControl_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("GET", pattern_Router_QueryMissionControl_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/routerrpc.Router/QueryMissionControl", runtime.WithHTTPPathPattern("/v2/router/mc"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Router_QueryMissionControl_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_QueryMissionControl_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_XImportMissionControl_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/routerrpc.Router/XImportMissionControl", runtime.WithHTTPPathPattern("/v2/router/x/importhistory"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Router_XImportMissionControl_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_XImportMissionControl_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("GET", pattern_Router_GetMissionControlConfig_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/routerrpc.Router/GetMissionControlConfig", runtime.WithHTTPPathPattern("/v2/router/mccfg"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Router_GetMissionControlConfig_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_GetMissionControlConfig_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_SetMissionControlConfig_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/routerrpc.Router/SetMissionControlConfig", runtime.WithHTTPPathPattern("/v2/router/mccfg"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Router_SetMissionControlConfig_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_SetMissionControlConfig_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("GET", pattern_Router_QueryProbability_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/routerrpc.Router/QueryProbability", runtime.WithHTTPPathPattern("/v2/router/mc/probability/{from_node}/{to_node}/{amt_msat}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Router_QueryProbability_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_QueryProbability_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_BuildRoute_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/routerrpc.Router/BuildRoute", runtime.WithHTTPPathPattern("/v2/router/route"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Router_BuildRoute_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_BuildRoute_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("GET", pattern_Router_SubscribeHtlcEvents_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
|
|
_, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_HtlcInterceptor_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
|
|
_, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_UpdateChanStatus_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/routerrpc.Router/UpdateChanStatus", runtime.WithHTTPPathPattern("/v2/router/updatechanstatus"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Router_UpdateChanStatus_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_UpdateChanStatus_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_XAddLocalChanAliases_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/routerrpc.Router/XAddLocalChanAliases", runtime.WithHTTPPathPattern("/v2/router/x/addaliases"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Router_XAddLocalChanAliases_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_XAddLocalChanAliases_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_XDeleteLocalChanAliases_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/routerrpc.Router/XDeleteLocalChanAliases", runtime.WithHTTPPathPattern("/v2/router/x/deletealiases"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Router_XDeleteLocalChanAliases_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_XDeleteLocalChanAliases_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_XFindBaseLocalChanAlias_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/routerrpc.Router/XFindBaseLocalChanAlias", runtime.WithHTTPPathPattern("/v2/router/x/findbasealias"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Router_XFindBaseLocalChanAlias_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_XFindBaseLocalChanAlias_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
return nil
|
|
}
|
|
|
|
// RegisterRouterHandlerFromEndpoint is same as RegisterRouterHandler but
|
|
// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
|
|
func RegisterRouterHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
|
|
conn, err := grpc.DialContext(ctx, 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 RegisterRouterHandler(ctx, mux, conn)
|
|
}
|
|
|
|
// RegisterRouterHandler registers the http handlers for service Router to "mux".
|
|
// The handlers forward requests to the grpc endpoint over "conn".
|
|
func RegisterRouterHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
|
|
return RegisterRouterHandlerClient(ctx, mux, NewRouterClient(conn))
|
|
}
|
|
|
|
// RegisterRouterHandlerClient registers the http handlers for service Router
|
|
// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "RouterClient".
|
|
// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "RouterClient"
|
|
// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
|
|
// "RouterClient" to call the correct interceptors.
|
|
func RegisterRouterHandlerClient(ctx context.Context, mux *runtime.ServeMux, client RouterClient) error {
|
|
|
|
mux.Handle("POST", pattern_Router_SendPaymentV2_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/routerrpc.Router/SendPaymentV2", runtime.WithHTTPPathPattern("/v2/router/send"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Router_SendPaymentV2_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_SendPaymentV2_0(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("GET", pattern_Router_TrackPaymentV2_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/routerrpc.Router/TrackPaymentV2", runtime.WithHTTPPathPattern("/v2/router/track/{payment_hash}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Router_TrackPaymentV2_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_TrackPaymentV2_0(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("GET", pattern_Router_TrackPayments_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/routerrpc.Router/TrackPayments", runtime.WithHTTPPathPattern("/v2/router/payments"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Router_TrackPayments_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_TrackPayments_0(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_EstimateRouteFee_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/routerrpc.Router/EstimateRouteFee", runtime.WithHTTPPathPattern("/v2/router/route/estimatefee"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Router_EstimateRouteFee_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_EstimateRouteFee_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_SendToRouteV2_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/routerrpc.Router/SendToRouteV2", runtime.WithHTTPPathPattern("/v2/router/route/send"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Router_SendToRouteV2_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_SendToRouteV2_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_ResetMissionControl_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/routerrpc.Router/ResetMissionControl", runtime.WithHTTPPathPattern("/v2/router/mc/reset"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Router_ResetMissionControl_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_ResetMissionControl_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("GET", pattern_Router_QueryMissionControl_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/routerrpc.Router/QueryMissionControl", runtime.WithHTTPPathPattern("/v2/router/mc"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Router_QueryMissionControl_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_QueryMissionControl_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_XImportMissionControl_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/routerrpc.Router/XImportMissionControl", runtime.WithHTTPPathPattern("/v2/router/x/importhistory"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Router_XImportMissionControl_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_XImportMissionControl_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("GET", pattern_Router_GetMissionControlConfig_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/routerrpc.Router/GetMissionControlConfig", runtime.WithHTTPPathPattern("/v2/router/mccfg"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Router_GetMissionControlConfig_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_GetMissionControlConfig_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_SetMissionControlConfig_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/routerrpc.Router/SetMissionControlConfig", runtime.WithHTTPPathPattern("/v2/router/mccfg"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Router_SetMissionControlConfig_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_SetMissionControlConfig_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("GET", pattern_Router_QueryProbability_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/routerrpc.Router/QueryProbability", runtime.WithHTTPPathPattern("/v2/router/mc/probability/{from_node}/{to_node}/{amt_msat}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Router_QueryProbability_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_QueryProbability_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_BuildRoute_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/routerrpc.Router/BuildRoute", runtime.WithHTTPPathPattern("/v2/router/route"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Router_BuildRoute_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_BuildRoute_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("GET", pattern_Router_SubscribeHtlcEvents_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/routerrpc.Router/SubscribeHtlcEvents", runtime.WithHTTPPathPattern("/v2/router/htlcevents"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Router_SubscribeHtlcEvents_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_SubscribeHtlcEvents_0(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_HtlcInterceptor_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/routerrpc.Router/HtlcInterceptor", runtime.WithHTTPPathPattern("/v2/router/htlcinterceptor"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Router_HtlcInterceptor_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_HtlcInterceptor_0(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_UpdateChanStatus_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/routerrpc.Router/UpdateChanStatus", runtime.WithHTTPPathPattern("/v2/router/updatechanstatus"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Router_UpdateChanStatus_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_UpdateChanStatus_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_XAddLocalChanAliases_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/routerrpc.Router/XAddLocalChanAliases", runtime.WithHTTPPathPattern("/v2/router/x/addaliases"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Router_XAddLocalChanAliases_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_XAddLocalChanAliases_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_XDeleteLocalChanAliases_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/routerrpc.Router/XDeleteLocalChanAliases", runtime.WithHTTPPathPattern("/v2/router/x/deletealiases"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Router_XDeleteLocalChanAliases_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_XDeleteLocalChanAliases_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
mux.Handle("POST", pattern_Router_XFindBaseLocalChanAlias_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)
|
|
var err error
|
|
var annotatedContext context.Context
|
|
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/routerrpc.Router/XFindBaseLocalChanAlias", runtime.WithHTTPPathPattern("/v2/router/x/findbasealias"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Router_XFindBaseLocalChanAlias_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
|
|
forward_Router_XFindBaseLocalChanAlias_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
|
|
})
|
|
|
|
return nil
|
|
}
|
|
|
|
var (
|
|
pattern_Router_SendPaymentV2_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "router", "send"}, ""))
|
|
|
|
pattern_Router_TrackPaymentV2_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v2", "router", "track", "payment_hash"}, ""))
|
|
|
|
pattern_Router_TrackPayments_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "router", "payments"}, ""))
|
|
|
|
pattern_Router_EstimateRouteFee_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "router", "route", "estimatefee"}, ""))
|
|
|
|
pattern_Router_SendToRouteV2_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "router", "route", "send"}, ""))
|
|
|
|
pattern_Router_ResetMissionControl_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "router", "mc", "reset"}, ""))
|
|
|
|
pattern_Router_QueryMissionControl_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "router", "mc"}, ""))
|
|
|
|
pattern_Router_XImportMissionControl_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "router", "x", "importhistory"}, ""))
|
|
|
|
pattern_Router_GetMissionControlConfig_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "router", "mccfg"}, ""))
|
|
|
|
pattern_Router_SetMissionControlConfig_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "router", "mccfg"}, ""))
|
|
|
|
pattern_Router_QueryProbability_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5, 1, 0, 4, 1, 5, 6}, []string{"v2", "router", "mc", "probability", "from_node", "to_node", "amt_msat"}, ""))
|
|
|
|
pattern_Router_BuildRoute_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "router", "route"}, ""))
|
|
|
|
pattern_Router_SubscribeHtlcEvents_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "router", "htlcevents"}, ""))
|
|
|
|
pattern_Router_HtlcInterceptor_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "router", "htlcinterceptor"}, ""))
|
|
|
|
pattern_Router_UpdateChanStatus_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "router", "updatechanstatus"}, ""))
|
|
|
|
pattern_Router_XAddLocalChanAliases_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "router", "x", "addaliases"}, ""))
|
|
|
|
pattern_Router_XDeleteLocalChanAliases_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "router", "x", "deletealiases"}, ""))
|
|
|
|
pattern_Router_XFindBaseLocalChanAlias_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "router", "x", "findbasealias"}, ""))
|
|
)
|
|
|
|
var (
|
|
forward_Router_SendPaymentV2_0 = runtime.ForwardResponseStream
|
|
|
|
forward_Router_TrackPaymentV2_0 = runtime.ForwardResponseStream
|
|
|
|
forward_Router_TrackPayments_0 = runtime.ForwardResponseStream
|
|
|
|
forward_Router_EstimateRouteFee_0 = runtime.ForwardResponseMessage
|
|
|
|
forward_Router_SendToRouteV2_0 = runtime.ForwardResponseMessage
|
|
|
|
forward_Router_ResetMissionControl_0 = runtime.ForwardResponseMessage
|
|
|
|
forward_Router_QueryMissionControl_0 = runtime.ForwardResponseMessage
|
|
|
|
forward_Router_XImportMissionControl_0 = runtime.ForwardResponseMessage
|
|
|
|
forward_Router_GetMissionControlConfig_0 = runtime.ForwardResponseMessage
|
|
|
|
forward_Router_SetMissionControlConfig_0 = runtime.ForwardResponseMessage
|
|
|
|
forward_Router_QueryProbability_0 = runtime.ForwardResponseMessage
|
|
|
|
forward_Router_BuildRoute_0 = runtime.ForwardResponseMessage
|
|
|
|
forward_Router_SubscribeHtlcEvents_0 = runtime.ForwardResponseStream
|
|
|
|
forward_Router_HtlcInterceptor_0 = runtime.ForwardResponseStream
|
|
|
|
forward_Router_UpdateChanStatus_0 = runtime.ForwardResponseMessage
|
|
|
|
forward_Router_XAddLocalChanAliases_0 = runtime.ForwardResponseMessage
|
|
|
|
forward_Router_XDeleteLocalChanAliases_0 = runtime.ForwardResponseMessage
|
|
|
|
forward_Router_XFindBaseLocalChanAlias_0 = runtime.ForwardResponseMessage
|
|
)
|