lightningnetwork / lnd / 13412100018

coverage: 44.914% (-13.9%) from 58.794%
13412100018

Pull #9521

github

web-flow 
Merge 861d6970e into 0e8786348
Pull Request #9521: unit: remove GOACC, use Go 1.20 native coverage functionality

101023 of 224923 relevant lines covered (44.91%)

19479.4 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0
/lnrpc/lightning.pb.gw.go
1 
// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
2 
// source: lightning.proto
3 









4



/*










5



Package lnrpc is a reverse proxy.










6












7



It translates gRPC into RESTful JSON APIs.










8



*/










9



package lnrpc










10












11



import (










12



        "context"










13



        "io"










14



        "net/http"










15












16



        "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"










17



        "github.com/grpc-ecosystem/grpc-gateway/v2/utilities"










18



        "google.golang.org/grpc"










19



        "google.golang.org/grpc/codes"










20



        "google.golang.org/grpc/grpclog"










21



        "google.golang.org/grpc/metadata"










22



        "google.golang.org/grpc/status"










23



        "google.golang.org/protobuf/proto"










24



)










25












26



// Suppress "imported and not used" errors










27



var _ codes.Code










28



var _ io.Reader










29



var _ status.Status










30



var _ = runtime.String










31



var _ = utilities.NewDoubleArray










32



var _ = metadata.Join










33












34



var (










35



        filter_Lightning_WalletBalance_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}










36



)










37












38



func request_Lightning_WalletBalance_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







39



        var protoReq WalletBalanceRequest




×







40



        var metadata runtime.ServerMetadata




×







41






×







42



        if err := req.ParseForm(); err != nil {




×







43



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







44



        }




×







45



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_WalletBalance_0); err != nil {




×







46



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







47



        }




×







48












49



        msg, err := client.WalletBalance(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







50



        return msg, metadata, err




×







51












52



}










53












54



func local_request_Lightning_WalletBalance_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







55



        var protoReq WalletBalanceRequest




×







56



        var metadata runtime.ServerMetadata




×







57






×







58



        if err := req.ParseForm(); err != nil {




×







59



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







60



        }




×







61



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_WalletBalance_0); err != nil {




×







62



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







63



        }




×







64












65



        msg, err := server.WalletBalance(ctx, &protoReq)




×







66



        return msg, metadata, err




×







67












68



}










69












70



func request_Lightning_ChannelBalance_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







71



        var protoReq ChannelBalanceRequest




×







72



        var metadata runtime.ServerMetadata




×







73






×







74



        msg, err := client.ChannelBalance(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







75



        return msg, metadata, err




×







76






×







77



}




×







78












79



func local_request_Lightning_ChannelBalance_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







80



        var protoReq ChannelBalanceRequest




×







81



        var metadata runtime.ServerMetadata




×







82






×







83



        msg, err := server.ChannelBalance(ctx, &protoReq)




×







84



        return msg, metadata, err




×







85






×







86



}




×







87












88



var (










89



        filter_Lightning_GetTransactions_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}










90



)










91












92



func request_Lightning_GetTransactions_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







93



        var protoReq GetTransactionsRequest




×







94



        var metadata runtime.ServerMetadata




×







95






×







96



        if err := req.ParseForm(); err != nil {




×







97



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







98



        }




×







99



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_GetTransactions_0); err != nil {




×







100



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







101



        }




×







102












103



        msg, err := client.GetTransactions(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







104



        return msg, metadata, err




×







105












106



}










107












108



func local_request_Lightning_GetTransactions_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







109



        var protoReq GetTransactionsRequest




×







110



        var metadata runtime.ServerMetadata




×







111






×







112



        if err := req.ParseForm(); err != nil {




×







113



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







114



        }




×







115



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_GetTransactions_0); err != nil {




×







116



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







117



        }




×







118












119



        msg, err := server.GetTransactions(ctx, &protoReq)




×







120



        return msg, metadata, err




×







121












122



}










123












124



var (










125



        filter_Lightning_EstimateFee_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}










126



)










127












128



func request_Lightning_EstimateFee_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







129



        var protoReq EstimateFeeRequest




×







130



        var metadata runtime.ServerMetadata




×







131






×







132



        if err := req.ParseForm(); err != nil {




×







133



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







134



        }




×







135



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_EstimateFee_0); err != nil {




×







136



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







137



        }




×







138












139



        msg, err := client.EstimateFee(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







140



        return msg, metadata, err




×







141












142



}










143












144



func local_request_Lightning_EstimateFee_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







145



        var protoReq EstimateFeeRequest




×







146



        var metadata runtime.ServerMetadata




×







147






×







148



        if err := req.ParseForm(); err != nil {




×







149



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







150



        }




×







151



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_EstimateFee_0); err != nil {




×







152



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







153



        }




×







154












155



        msg, err := server.EstimateFee(ctx, &protoReq)




×







156



        return msg, metadata, err




×







157












158



}










159












160



func request_Lightning_SendCoins_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







161



        var protoReq SendCoinsRequest




×







162



        var metadata runtime.ServerMetadata




×







163






×







164



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







165



        if berr != nil {




×







166



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







167



        }




×







168



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







169



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







170



        }




×







171












172



        msg, err := client.SendCoins(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







173



        return msg, metadata, err




×







174












175



}










176












177



func local_request_Lightning_SendCoins_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







178



        var protoReq SendCoinsRequest




×







179



        var metadata runtime.ServerMetadata




×







180






×







181



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







182



        if berr != nil {




×







183



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







184



        }




×







185



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







186



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







187



        }




×







188












189



        msg, err := server.SendCoins(ctx, &protoReq)




×







190



        return msg, metadata, err




×







191












192



}










193












194



var (










195



        filter_Lightning_ListUnspent_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}










196



)










197












198



func request_Lightning_ListUnspent_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







199



        var protoReq ListUnspentRequest




×







200



        var metadata runtime.ServerMetadata




×







201






×







202



        if err := req.ParseForm(); err != nil {




×







203



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







204



        }




×







205



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_ListUnspent_0); err != nil {




×







206



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







207



        }




×







208












209



        msg, err := client.ListUnspent(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







210



        return msg, metadata, err




×







211












212



}










213












214



func local_request_Lightning_ListUnspent_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







215



        var protoReq ListUnspentRequest




×







216



        var metadata runtime.ServerMetadata




×







217






×







218



        if err := req.ParseForm(); err != nil {




×







219



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







220



        }




×







221



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_ListUnspent_0); err != nil {




×







222



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







223



        }




×







224












225



        msg, err := server.ListUnspent(ctx, &protoReq)




×







226



        return msg, metadata, err




×







227












228



}










229












230



var (










231



        filter_Lightning_SubscribeTransactions_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}










232



)










233












234



func request_Lightning_SubscribeTransactions_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (Lightning_SubscribeTransactionsClient, runtime.ServerMetadata, error) {




×







235



        var protoReq GetTransactionsRequest




×







236



        var metadata runtime.ServerMetadata




×







237






×







238



        if err := req.ParseForm(); err != nil {




×







239



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







240



        }




×







241



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_SubscribeTransactions_0); err != nil {




×







242



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







243



        }




×







244












245



        stream, err := client.SubscribeTransactions(ctx, &protoReq)




×







246



        if err != nil {




×







247



                return nil, metadata, err




×







248



        }




×







249



        header, err := stream.Header()




×







250



        if err != nil {




×







251



                return nil, metadata, err




×







252



        }




×







253



        metadata.HeaderMD = header




×







254



        return stream, metadata, nil




×







255












256



}










257












258



func request_Lightning_SendMany_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







259



        var protoReq SendManyRequest




×







260



        var metadata runtime.ServerMetadata




×







261






×







262



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







263



        if berr != nil {




×







264



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







265



        }




×







266



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







267



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







268



        }




×







269












270



        msg, err := client.SendMany(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







271



        return msg, metadata, err




×







272












273



}










274












275



func local_request_Lightning_SendMany_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







276



        var protoReq SendManyRequest




×







277



        var metadata runtime.ServerMetadata




×







278






×







279



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







280



        if berr != nil {




×







281



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







282



        }




×







283



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







284



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







285



        }




×







286












287



        msg, err := server.SendMany(ctx, &protoReq)




×







288



        return msg, metadata, err




×







289












290



}










291












292



var (










293



        filter_Lightning_NewAddress_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}










294



)










295












296



func request_Lightning_NewAddress_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







297



        var protoReq NewAddressRequest




×







298



        var metadata runtime.ServerMetadata




×







299






×







300



        if err := req.ParseForm(); err != nil {




×







301



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







302



        }




×







303



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_NewAddress_0); err != nil {




×







304



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







305



        }




×







306












307



        msg, err := client.NewAddress(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







308



        return msg, metadata, err




×







309












310



}










311












312



func local_request_Lightning_NewAddress_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







313



        var protoReq NewAddressRequest




×







314



        var metadata runtime.ServerMetadata




×







315






×







316



        if err := req.ParseForm(); err != nil {




×







317



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







318



        }




×







319



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_NewAddress_0); err != nil {




×







320



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







321



        }




×







322












323



        msg, err := server.NewAddress(ctx, &protoReq)




×







324



        return msg, metadata, err




×







325












326



}










327












328



func request_Lightning_SignMessage_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







329



        var protoReq SignMessageRequest




×







330



        var metadata runtime.ServerMetadata




×







331






×







332



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







333



        if berr != nil {




×







334



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







335



        }




×







336



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







337



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







338



        }




×







339












340



        msg, err := client.SignMessage(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







341



        return msg, metadata, err




×







342












343



}










344












345



func local_request_Lightning_SignMessage_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







346



        var protoReq SignMessageRequest




×







347



        var metadata runtime.ServerMetadata




×







348






×







349



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







350



        if berr != nil {




×







351



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







352



        }




×







353



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







354



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







355



        }




×







356












357



        msg, err := server.SignMessage(ctx, &protoReq)




×







358



        return msg, metadata, err




×







359












360



}










361












362



func request_Lightning_VerifyMessage_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







363



        var protoReq VerifyMessageRequest




×







364



        var metadata runtime.ServerMetadata




×







365






×







366



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







367



        if berr != nil {




×







368



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







369



        }




×







370



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







371



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







372



        }




×







373












374



        msg, err := client.VerifyMessage(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







375



        return msg, metadata, err




×







376












377



}










378












379



func local_request_Lightning_VerifyMessage_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







380



        var protoReq VerifyMessageRequest




×







381



        var metadata runtime.ServerMetadata




×







382






×







383



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







384



        if berr != nil {




×







385



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







386



        }




×







387



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







388



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







389



        }




×







390












391



        msg, err := server.VerifyMessage(ctx, &protoReq)




×







392



        return msg, metadata, err




×







393












394



}










395












396



func request_Lightning_ConnectPeer_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







397



        var protoReq ConnectPeerRequest




×







398



        var metadata runtime.ServerMetadata




×







399






×







400



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







401



        if berr != nil {




×







402



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







403



        }




×







404



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







405



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







406



        }




×







407












408



        msg, err := client.ConnectPeer(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







409



        return msg, metadata, err




×







410












411



}










412












413



func local_request_Lightning_ConnectPeer_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







414



        var protoReq ConnectPeerRequest




×







415



        var metadata runtime.ServerMetadata




×







416






×







417



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







418



        if berr != nil {




×







419



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







420



        }




×







421



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







422



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







423



        }




×







424












425



        msg, err := server.ConnectPeer(ctx, &protoReq)




×







426



        return msg, metadata, err




×







427












428



}










429












430



func request_Lightning_DisconnectPeer_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







431



        var protoReq DisconnectPeerRequest




×







432



        var metadata runtime.ServerMetadata




×







433






×







434



        var (




×







435



                val string




×







436



                ok  bool




×







437



                err error




×







438



                _   = err




×







439



        )




×







440






×







441



        val, ok = pathParams["pub_key"]




×







442



        if !ok {




×







443



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "pub_key")




×







444



        }




×







445












446



        protoReq.PubKey, err = runtime.String(val)




×







447



        if err != nil {




×







448



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pub_key", err)




×







449



        }




×







450












451



        msg, err := client.DisconnectPeer(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







452



        return msg, metadata, err




×







453












454



}










455












456



func local_request_Lightning_DisconnectPeer_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







457



        var protoReq DisconnectPeerRequest




×







458



        var metadata runtime.ServerMetadata




×







459






×







460



        var (




×







461



                val string




×







462



                ok  bool




×







463



                err error




×







464



                _   = err




×







465



        )




×







466






×







467



        val, ok = pathParams["pub_key"]




×







468



        if !ok {




×







469



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "pub_key")




×







470



        }




×







471












472



        protoReq.PubKey, err = runtime.String(val)




×







473



        if err != nil {




×







474



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pub_key", err)




×







475



        }




×







476












477



        msg, err := server.DisconnectPeer(ctx, &protoReq)




×







478



        return msg, metadata, err




×







479












480



}










481












482



var (










483



        filter_Lightning_ListPeers_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}










484



)










485












486



func request_Lightning_ListPeers_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







487



        var protoReq ListPeersRequest




×







488



        var metadata runtime.ServerMetadata




×







489






×







490



        if err := req.ParseForm(); err != nil {




×







491



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







492



        }




×







493



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_ListPeers_0); err != nil {




×







494



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







495



        }




×







496












497



        msg, err := client.ListPeers(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







498



        return msg, metadata, err




×







499












500



}










501












502



func local_request_Lightning_ListPeers_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







503



        var protoReq ListPeersRequest




×







504



        var metadata runtime.ServerMetadata




×







505






×







506



        if err := req.ParseForm(); err != nil {




×







507



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







508



        }




×







509



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_ListPeers_0); err != nil {




×







510



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







511



        }




×







512












513



        msg, err := server.ListPeers(ctx, &protoReq)




×







514



        return msg, metadata, err




×







515












516



}










517












518



func request_Lightning_SubscribePeerEvents_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (Lightning_SubscribePeerEventsClient, runtime.ServerMetadata, error) {




×







519



        var protoReq PeerEventSubscription




×







520



        var metadata runtime.ServerMetadata




×







521






×







522



        stream, err := client.SubscribePeerEvents(ctx, &protoReq)




×







523



        if err != nil {




×







524



                return nil, metadata, err




×







525



        }




×







526



        header, err := stream.Header()




×







527



        if err != nil {




×







528



                return nil, metadata, err




×







529



        }




×







530



        metadata.HeaderMD = header




×







531



        return stream, metadata, nil




×







532












533



}










534












535



func request_Lightning_GetInfo_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







536



        var protoReq GetInfoRequest




×







537



        var metadata runtime.ServerMetadata




×







538






×







539



        msg, err := client.GetInfo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







540



        return msg, metadata, err




×







541






×







542



}




×







543












544



func local_request_Lightning_GetInfo_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







545



        var protoReq GetInfoRequest




×







546



        var metadata runtime.ServerMetadata




×







547






×







548



        msg, err := server.GetInfo(ctx, &protoReq)




×







549



        return msg, metadata, err




×







550






×







551



}




×







552












553



func request_Lightning_GetDebugInfo_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







554



        var protoReq GetDebugInfoRequest




×







555



        var metadata runtime.ServerMetadata




×







556






×







557



        msg, err := client.GetDebugInfo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







558



        return msg, metadata, err




×







559






×







560



}




×







561












562



func local_request_Lightning_GetDebugInfo_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







563



        var protoReq GetDebugInfoRequest




×







564



        var metadata runtime.ServerMetadata




×







565






×







566



        msg, err := server.GetDebugInfo(ctx, &protoReq)




×







567



        return msg, metadata, err




×







568






×







569



}




×







570












571



func request_Lightning_GetRecoveryInfo_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







572



        var protoReq GetRecoveryInfoRequest




×







573



        var metadata runtime.ServerMetadata




×







574






×







575



        msg, err := client.GetRecoveryInfo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







576



        return msg, metadata, err




×







577






×







578



}




×







579












580



func local_request_Lightning_GetRecoveryInfo_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







581



        var protoReq GetRecoveryInfoRequest




×







582



        var metadata runtime.ServerMetadata




×







583






×







584



        msg, err := server.GetRecoveryInfo(ctx, &protoReq)




×







585



        return msg, metadata, err




×







586






×







587



}




×







588












589



var (










590



        filter_Lightning_PendingChannels_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}










591



)










592












593



func request_Lightning_PendingChannels_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







594



        var protoReq PendingChannelsRequest




×







595



        var metadata runtime.ServerMetadata




×







596






×







597



        if err := req.ParseForm(); err != nil {




×







598



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







599



        }




×







600



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_PendingChannels_0); err != nil {




×







601



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







602



        }




×







603












604



        msg, err := client.PendingChannels(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







605



        return msg, metadata, err




×







606












607



}










608












609



func local_request_Lightning_PendingChannels_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







610



        var protoReq PendingChannelsRequest




×







611



        var metadata runtime.ServerMetadata




×







612






×







613



        if err := req.ParseForm(); err != nil {




×







614



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







615



        }




×







616



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_PendingChannels_0); err != nil {




×







617



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







618



        }




×







619












620



        msg, err := server.PendingChannels(ctx, &protoReq)




×







621



        return msg, metadata, err




×







622












623



}










624












625



var (










626



        filter_Lightning_ListChannels_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}










627



)










628












629



func request_Lightning_ListChannels_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







630



        var protoReq ListChannelsRequest




×







631



        var metadata runtime.ServerMetadata




×







632






×







633



        if err := req.ParseForm(); err != nil {




×







634



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







635



        }




×







636



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_ListChannels_0); err != nil {




×







637



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







638



        }




×







639












640



        msg, err := client.ListChannels(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







641



        return msg, metadata, err




×







642












643



}










644












645



func local_request_Lightning_ListChannels_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







646



        var protoReq ListChannelsRequest




×







647



        var metadata runtime.ServerMetadata




×







648






×







649



        if err := req.ParseForm(); err != nil {




×







650



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







651



        }




×







652



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_ListChannels_0); err != nil {




×







653



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







654



        }




×







655












656



        msg, err := server.ListChannels(ctx, &protoReq)




×







657



        return msg, metadata, err




×







658












659



}










660












661



func request_Lightning_SubscribeChannelEvents_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (Lightning_SubscribeChannelEventsClient, runtime.ServerMetadata, error) {




×







662



        var protoReq ChannelEventSubscription




×







663



        var metadata runtime.ServerMetadata




×







664






×







665



        stream, err := client.SubscribeChannelEvents(ctx, &protoReq)




×







666



        if err != nil {




×







667



                return nil, metadata, err




×







668



        }




×







669



        header, err := stream.Header()




×







670



        if err != nil {




×







671



                return nil, metadata, err




×







672



        }




×







673



        metadata.HeaderMD = header




×







674



        return stream, metadata, nil




×







675












676



}










677












678



var (










679



        filter_Lightning_ClosedChannels_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}










680



)










681












682



func request_Lightning_ClosedChannels_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







683



        var protoReq ClosedChannelsRequest




×







684



        var metadata runtime.ServerMetadata




×







685






×







686



        if err := req.ParseForm(); err != nil {




×







687



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







688



        }




×







689



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_ClosedChannels_0); err != nil {




×







690



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







691



        }




×







692












693



        msg, err := client.ClosedChannels(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







694



        return msg, metadata, err




×







695












696



}










697












698



func local_request_Lightning_ClosedChannels_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







699



        var protoReq ClosedChannelsRequest




×







700



        var metadata runtime.ServerMetadata




×







701






×







702



        if err := req.ParseForm(); err != nil {




×







703



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







704



        }




×







705



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_ClosedChannels_0); err != nil {




×







706



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







707



        }




×







708












709



        msg, err := server.ClosedChannels(ctx, &protoReq)




×







710



        return msg, metadata, err




×







711












712



}










713












714



func request_Lightning_OpenChannelSync_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







715



        var protoReq OpenChannelRequest




×







716



        var metadata runtime.ServerMetadata




×







717






×







718



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







719



        if berr != nil {




×







720



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







721



        }




×







722



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







723



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







724



        }




×







725












726



        msg, err := client.OpenChannelSync(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







727



        return msg, metadata, err




×







728












729



}










730












731



func local_request_Lightning_OpenChannelSync_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







732



        var protoReq OpenChannelRequest




×







733



        var metadata runtime.ServerMetadata




×







734






×







735



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







736



        if berr != nil {




×







737



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







738



        }




×







739



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







740



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







741



        }




×







742












743



        msg, err := server.OpenChannelSync(ctx, &protoReq)




×







744



        return msg, metadata, err




×







745












746



}










747












748



func request_Lightning_OpenChannel_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (Lightning_OpenChannelClient, runtime.ServerMetadata, error) {




×







749



        var protoReq OpenChannelRequest




×







750



        var metadata runtime.ServerMetadata




×







751






×







752



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







753



        if berr != nil {




×







754



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







755



        }




×







756



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







757



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







758



        }




×







759












760



        stream, err := client.OpenChannel(ctx, &protoReq)




×







761



        if err != nil {




×







762



                return nil, metadata, err




×







763



        }




×







764



        header, err := stream.Header()




×







765



        if err != nil {




×







766



                return nil, metadata, err




×







767



        }




×







768



        metadata.HeaderMD = header




×







769



        return stream, metadata, nil




×







770












771



}










772












773



func request_Lightning_BatchOpenChannel_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







774



        var protoReq BatchOpenChannelRequest




×







775



        var metadata runtime.ServerMetadata




×







776






×







777



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







778



        if berr != nil {




×







779



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







780



        }




×







781



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







782



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







783



        }




×







784












785



        msg, err := client.BatchOpenChannel(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







786



        return msg, metadata, err




×







787












788



}










789












790



func local_request_Lightning_BatchOpenChannel_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







791



        var protoReq BatchOpenChannelRequest




×







792



        var metadata runtime.ServerMetadata




×







793






×







794



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







795



        if berr != nil {




×







796



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







797



        }




×







798



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







799



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







800



        }




×







801












802



        msg, err := server.BatchOpenChannel(ctx, &protoReq)




×







803



        return msg, metadata, err




×







804












805



}










806












807



func request_Lightning_FundingStateStep_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







808



        var protoReq FundingTransitionMsg




×







809



        var metadata runtime.ServerMetadata




×







810






×







811



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







812



        if berr != nil {




×







813



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







814



        }




×







815



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







816



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







817



        }




×







818












819



        msg, err := client.FundingStateStep(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







820



        return msg, metadata, err




×







821












822



}










823












824



func local_request_Lightning_FundingStateStep_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







825



        var protoReq FundingTransitionMsg




×







826



        var metadata runtime.ServerMetadata




×







827






×







828



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







829



        if berr != nil {




×







830



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







831



        }




×







832



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







833



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







834



        }




×







835












836



        msg, err := server.FundingStateStep(ctx, &protoReq)




×







837



        return msg, metadata, err




×







838












839



}










840












841



func request_Lightning_ChannelAcceptor_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (Lightning_ChannelAcceptorClient, runtime.ServerMetadata, error) {




×







842



        var metadata runtime.ServerMetadata




×







843



        stream, err := client.ChannelAcceptor(ctx)




×







844



        if err != nil {




×







845



                grpclog.Infof("Failed to start streaming: %v", err)




×







846



                return nil, metadata, err




×







847



        }




×







848



        dec := marshaler.NewDecoder(req.Body)




×







849



        handleSend := func() error {




×







850



                var protoReq ChannelAcceptResponse




×







851



                err := dec.Decode(&protoReq)




×







852



                if err == io.EOF {




×







853



                        return err




×







854



                }




×







855



                if err != nil {




×







856



                        grpclog.Infof("Failed to decode request: %v", err)




×







857



                        return err




×







858



                }




×







859



                if err := stream.Send(&protoReq); err != nil {




×







860



                        grpclog.Infof("Failed to send request: %v", err)




×







861



                        return err




×







862



                }




×







863



                return nil




×







864



        }










865



        if err := handleSend(); err != nil {




×







866



                if cerr := stream.CloseSend(); cerr != nil {




×







867



                        grpclog.Infof("Failed to terminate client stream: %v", cerr)




×







868



                }




×







869



                if err == io.EOF {




×







870



                        return stream, metadata, nil




×







871



                }




×







872



                return nil, metadata, err




×







873



        }










874



        go func() {




×







875



                for {




×







876



                        if err := handleSend(); err != nil {




×







877



                                break




×







878



                        }










879



                }










880



                if err := stream.CloseSend(); err != nil {




×







881



                        grpclog.Infof("Failed to terminate client stream: %v", err)




×







882



                }




×







883



        }()










884



        header, err := stream.Header()




×







885



        if err != nil {




×







886



                grpclog.Infof("Failed to get header from client: %v", err)




×







887



                return nil, metadata, err




×







888



        }




×







889



        metadata.HeaderMD = header




×







890



        return stream, metadata, nil




×







891



}










892












893



var (










894



        filter_Lightning_CloseChannel_0 = &utilities.DoubleArray{Encoding: map[string]int{"channel_point": 0, "funding_txid_str": 1, "output_index": 2}, Base: []int{1, 1, 1, 2, 0, 0}, Check: []int{0, 1, 2, 2, 3, 4}}










895



)










896












897



func request_Lightning_CloseChannel_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (Lightning_CloseChannelClient, runtime.ServerMetadata, error) {




×







898



        var protoReq CloseChannelRequest




×







899



        var metadata runtime.ServerMetadata




×







900






×







901



        var (




×







902



                val string




×







903



                ok  bool




×







904



                err error




×







905



                _   = err




×







906



        )




×







907






×







908



        val, ok = pathParams["channel_point.funding_txid_str"]




×







909



        if !ok {




×







910



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channel_point.funding_txid_str")




×







911



        }




×







912












913



        err = runtime.PopulateFieldFromPath(&protoReq, "channel_point.funding_txid_str", val)




×







914



        if err != nil {




×







915



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channel_point.funding_txid_str", err)




×







916



        }




×







917












918



        val, ok = pathParams["channel_point.output_index"]




×







919



        if !ok {




×







920



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channel_point.output_index")




×







921



        }




×







922












923



        err = runtime.PopulateFieldFromPath(&protoReq, "channel_point.output_index", val)




×







924



        if err != nil {




×







925



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channel_point.output_index", err)




×







926



        }




×







927












928



        if err := req.ParseForm(); err != nil {




×







929



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







930



        }




×







931



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_CloseChannel_0); err != nil {




×







932



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







933



        }




×







934












935



        stream, err := client.CloseChannel(ctx, &protoReq)




×







936



        if err != nil {




×







937



                return nil, metadata, err




×







938



        }




×







939



        header, err := stream.Header()




×







940



        if err != nil {




×







941



                return nil, metadata, err




×







942



        }




×







943



        metadata.HeaderMD = header




×







944



        return stream, metadata, nil




×







945












946



}










947












948



var (










949



        filter_Lightning_AbandonChannel_0 = &utilities.DoubleArray{Encoding: map[string]int{"channel_point": 0, "funding_txid_str": 1, "output_index": 2}, Base: []int{1, 1, 1, 2, 0, 0}, Check: []int{0, 1, 2, 2, 3, 4}}










950



)










951












952



func request_Lightning_AbandonChannel_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







953



        var protoReq AbandonChannelRequest




×







954



        var metadata runtime.ServerMetadata




×







955






×







956



        var (




×







957



                val string




×







958



                ok  bool




×







959



                err error




×







960



                _   = err




×







961



        )




×







962






×







963



        val, ok = pathParams["channel_point.funding_txid_str"]




×







964



        if !ok {




×







965



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channel_point.funding_txid_str")




×







966



        }




×







967












968



        err = runtime.PopulateFieldFromPath(&protoReq, "channel_point.funding_txid_str", val)




×







969



        if err != nil {




×







970



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channel_point.funding_txid_str", err)




×







971



        }




×







972












973



        val, ok = pathParams["channel_point.output_index"]




×







974



        if !ok {




×







975



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channel_point.output_index")




×







976



        }




×







977












978



        err = runtime.PopulateFieldFromPath(&protoReq, "channel_point.output_index", val)




×







979



        if err != nil {




×







980



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channel_point.output_index", err)




×







981



        }




×







982












983



        if err := req.ParseForm(); err != nil {




×







984



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







985



        }




×







986



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_AbandonChannel_0); err != nil {




×







987



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







988



        }




×







989












990



        msg, err := client.AbandonChannel(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







991



        return msg, metadata, err




×







992












993



}










994












995



func local_request_Lightning_AbandonChannel_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







996



        var protoReq AbandonChannelRequest




×







997



        var metadata runtime.ServerMetadata




×







998






×







999



        var (




×







1000



                val string




×







1001



                ok  bool




×







1002



                err error




×







1003



                _   = err




×







1004



        )




×







1005






×







1006



        val, ok = pathParams["channel_point.funding_txid_str"]




×







1007



        if !ok {




×







1008



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channel_point.funding_txid_str")




×







1009



        }




×







1010












1011



        err = runtime.PopulateFieldFromPath(&protoReq, "channel_point.funding_txid_str", val)




×







1012



        if err != nil {




×







1013



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channel_point.funding_txid_str", err)




×







1014



        }




×







1015












1016



        val, ok = pathParams["channel_point.output_index"]




×







1017



        if !ok {




×







1018



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channel_point.output_index")




×







1019



        }




×







1020












1021



        err = runtime.PopulateFieldFromPath(&protoReq, "channel_point.output_index", val)




×







1022



        if err != nil {




×







1023



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channel_point.output_index", err)




×







1024



        }




×







1025












1026



        if err := req.ParseForm(); err != nil {




×







1027



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1028



        }




×







1029



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_AbandonChannel_0); err != nil {




×







1030



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1031



        }




×







1032












1033



        msg, err := server.AbandonChannel(ctx, &protoReq)




×







1034



        return msg, metadata, err




×







1035












1036



}










1037












1038



func request_Lightning_SendPayment_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (Lightning_SendPaymentClient, runtime.ServerMetadata, error) {




×







1039



        var metadata runtime.ServerMetadata




×







1040



        stream, err := client.SendPayment(ctx)




×







1041



        if err != nil {




×







1042



                grpclog.Infof("Failed to start streaming: %v", err)




×







1043



                return nil, metadata, err




×







1044



        }




×







1045



        dec := marshaler.NewDecoder(req.Body)




×







1046



        handleSend := func() error {




×







1047



                var protoReq SendRequest




×







1048



                err := dec.Decode(&protoReq)




×







1049



                if err == io.EOF {




×







1050



                        return err




×







1051



                }




×







1052



                if err != nil {




×







1053



                        grpclog.Infof("Failed to decode request: %v", err)




×







1054



                        return err




×







1055



                }




×







1056



                if err := stream.Send(&protoReq); err != nil {




×







1057



                        grpclog.Infof("Failed to send request: %v", err)




×







1058



                        return err




×







1059



                }




×







1060



                return nil




×







1061



        }










1062



        if err := handleSend(); err != nil {




×







1063



                if cerr := stream.CloseSend(); cerr != nil {




×







1064



                        grpclog.Infof("Failed to terminate client stream: %v", cerr)




×







1065



                }




×







1066



                if err == io.EOF {




×







1067



                        return stream, metadata, nil




×







1068



                }




×







1069



                return nil, metadata, err




×







1070



        }










1071



        go func() {




×







1072



                for {




×







1073



                        if err := handleSend(); err != nil {




×







1074



                                break




×







1075



                        }










1076



                }










1077



                if err := stream.CloseSend(); err != nil {




×







1078



                        grpclog.Infof("Failed to terminate client stream: %v", err)




×







1079



                }




×







1080



        }()










1081



        header, err := stream.Header()




×







1082



        if err != nil {




×







1083



                grpclog.Infof("Failed to get header from client: %v", err)




×







1084



                return nil, metadata, err




×







1085



        }




×







1086



        metadata.HeaderMD = header




×







1087



        return stream, metadata, nil




×







1088



}










1089












1090



func request_Lightning_SendPaymentSync_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1091



        var protoReq SendRequest




×







1092



        var metadata runtime.ServerMetadata




×







1093






×







1094



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







1095



        if berr != nil {




×







1096



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







1097



        }




×







1098



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







1099



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1100



        }




×







1101












1102



        msg, err := client.SendPaymentSync(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1103



        return msg, metadata, err




×







1104












1105



}










1106












1107



func local_request_Lightning_SendPaymentSync_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1108



        var protoReq SendRequest




×







1109



        var metadata runtime.ServerMetadata




×







1110






×







1111



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







1112



        if berr != nil {




×







1113



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







1114



        }




×







1115



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







1116



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1117



        }




×







1118












1119



        msg, err := server.SendPaymentSync(ctx, &protoReq)




×







1120



        return msg, metadata, err




×







1121












1122



}










1123












1124



func request_Lightning_SendToRouteSync_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1125



        var protoReq SendToRouteRequest




×







1126



        var metadata runtime.ServerMetadata




×







1127






×







1128



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







1129



        if berr != nil {




×







1130



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







1131



        }




×







1132



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







1133



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1134



        }




×







1135












1136



        msg, err := client.SendToRouteSync(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1137



        return msg, metadata, err




×







1138












1139



}










1140












1141



func local_request_Lightning_SendToRouteSync_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1142



        var protoReq SendToRouteRequest




×







1143



        var metadata runtime.ServerMetadata




×







1144






×







1145



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







1146



        if berr != nil {




×







1147



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







1148



        }




×







1149



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







1150



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1151



        }




×







1152












1153



        msg, err := server.SendToRouteSync(ctx, &protoReq)




×







1154



        return msg, metadata, err




×







1155












1156



}










1157












1158



func request_Lightning_AddInvoice_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1159



        var protoReq Invoice




×







1160



        var metadata runtime.ServerMetadata




×







1161






×







1162



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







1163



        if berr != nil {




×







1164



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







1165



        }




×







1166



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







1167



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1168



        }




×







1169












1170



        msg, err := client.AddInvoice(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1171



        return msg, metadata, err




×







1172












1173



}










1174












1175



func local_request_Lightning_AddInvoice_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1176



        var protoReq Invoice




×







1177



        var metadata runtime.ServerMetadata




×







1178






×







1179



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







1180



        if berr != nil {




×







1181



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







1182



        }




×







1183



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







1184



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1185



        }




×







1186












1187



        msg, err := server.AddInvoice(ctx, &protoReq)




×







1188



        return msg, metadata, err




×







1189












1190



}










1191












1192



var (










1193



        filter_Lightning_ListInvoices_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}










1194



)










1195












1196



func request_Lightning_ListInvoices_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1197



        var protoReq ListInvoiceRequest




×







1198



        var metadata runtime.ServerMetadata




×







1199






×







1200



        if err := req.ParseForm(); err != nil {




×







1201



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1202



        }




×







1203



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_ListInvoices_0); err != nil {




×







1204



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1205



        }




×







1206












1207



        msg, err := client.ListInvoices(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1208



        return msg, metadata, err




×







1209












1210



}










1211












1212



func local_request_Lightning_ListInvoices_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1213



        var protoReq ListInvoiceRequest




×







1214



        var metadata runtime.ServerMetadata




×







1215






×







1216



        if err := req.ParseForm(); err != nil {




×







1217



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1218



        }




×







1219



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_ListInvoices_0); err != nil {




×







1220



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1221



        }




×







1222












1223



        msg, err := server.ListInvoices(ctx, &protoReq)




×







1224



        return msg, metadata, err




×







1225












1226



}










1227












1228



var (










1229



        filter_Lightning_LookupInvoice_0 = &utilities.DoubleArray{Encoding: map[string]int{"r_hash_str": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}










1230



)










1231












1232



func request_Lightning_LookupInvoice_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1233



        var protoReq PaymentHash




×







1234



        var metadata runtime.ServerMetadata




×







1235






×







1236



        var (




×







1237



                val string




×







1238



                ok  bool




×







1239



                err error




×







1240



                _   = err




×







1241



        )




×







1242






×







1243



        val, ok = pathParams["r_hash_str"]




×







1244



        if !ok {




×







1245



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "r_hash_str")




×







1246



        }




×







1247












1248



        protoReq.RHashStr, err = runtime.String(val)




×







1249



        if err != nil {




×







1250



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "r_hash_str", err)




×







1251



        }




×







1252












1253



        if err := req.ParseForm(); err != nil {




×







1254



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1255



        }




×







1256



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_LookupInvoice_0); err != nil {




×







1257



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1258



        }




×







1259












1260



        msg, err := client.LookupInvoice(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1261



        return msg, metadata, err




×







1262












1263



}










1264












1265



func local_request_Lightning_LookupInvoice_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1266



        var protoReq PaymentHash




×







1267



        var metadata runtime.ServerMetadata




×







1268






×







1269



        var (




×







1270



                val string




×







1271



                ok  bool




×







1272



                err error




×







1273



                _   = err




×







1274



        )




×







1275






×







1276



        val, ok = pathParams["r_hash_str"]




×







1277



        if !ok {




×







1278



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "r_hash_str")




×







1279



        }




×







1280












1281



        protoReq.RHashStr, err = runtime.String(val)




×







1282



        if err != nil {




×







1283



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "r_hash_str", err)




×







1284



        }




×







1285












1286



        if err := req.ParseForm(); err != nil {




×







1287



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1288



        }




×







1289



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_LookupInvoice_0); err != nil {




×







1290



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1291



        }




×







1292












1293



        msg, err := server.LookupInvoice(ctx, &protoReq)




×







1294



        return msg, metadata, err




×







1295












1296



}










1297












1298



var (










1299



        filter_Lightning_SubscribeInvoices_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}










1300



)










1301












1302



func request_Lightning_SubscribeInvoices_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (Lightning_SubscribeInvoicesClient, runtime.ServerMetadata, error) {




×







1303



        var protoReq InvoiceSubscription




×







1304



        var metadata runtime.ServerMetadata




×







1305






×







1306



        if err := req.ParseForm(); err != nil {




×







1307



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1308



        }




×







1309



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_SubscribeInvoices_0); err != nil {




×







1310



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1311



        }




×







1312












1313



        stream, err := client.SubscribeInvoices(ctx, &protoReq)




×







1314



        if err != nil {




×







1315



                return nil, metadata, err




×







1316



        }




×







1317



        header, err := stream.Header()




×







1318



        if err != nil {




×







1319



                return nil, metadata, err




×







1320



        }




×







1321



        metadata.HeaderMD = header




×







1322



        return stream, metadata, nil




×







1323












1324



}










1325












1326



func request_Lightning_DecodePayReq_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1327



        var protoReq PayReqString




×







1328



        var metadata runtime.ServerMetadata




×







1329






×







1330



        var (




×







1331



                val string




×







1332



                ok  bool




×







1333



                err error




×







1334



                _   = err




×







1335



        )




×







1336






×







1337



        val, ok = pathParams["pay_req"]




×







1338



        if !ok {




×







1339



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "pay_req")




×







1340



        }




×







1341












1342



        protoReq.PayReq, err = runtime.String(val)




×







1343



        if err != nil {




×







1344



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pay_req", err)




×







1345



        }




×







1346












1347



        msg, err := client.DecodePayReq(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1348



        return msg, metadata, err




×







1349












1350



}










1351












1352



func local_request_Lightning_DecodePayReq_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1353



        var protoReq PayReqString




×







1354



        var metadata runtime.ServerMetadata




×







1355






×







1356



        var (




×







1357



                val string




×







1358



                ok  bool




×







1359



                err error




×







1360



                _   = err




×







1361



        )




×







1362






×







1363



        val, ok = pathParams["pay_req"]




×







1364



        if !ok {




×







1365



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "pay_req")




×







1366



        }




×







1367












1368



        protoReq.PayReq, err = runtime.String(val)




×







1369



        if err != nil {




×







1370



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pay_req", err)




×







1371



        }




×







1372












1373



        msg, err := server.DecodePayReq(ctx, &protoReq)




×







1374



        return msg, metadata, err




×







1375












1376



}










1377












1378



var (










1379



        filter_Lightning_ListPayments_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}










1380



)










1381












1382



func request_Lightning_ListPayments_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1383



        var protoReq ListPaymentsRequest




×







1384



        var metadata runtime.ServerMetadata




×







1385






×







1386



        if err := req.ParseForm(); err != nil {




×







1387



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1388



        }




×







1389



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_ListPayments_0); err != nil {




×







1390



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1391



        }




×







1392












1393



        msg, err := client.ListPayments(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1394



        return msg, metadata, err




×







1395












1396



}










1397












1398



func local_request_Lightning_ListPayments_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1399



        var protoReq ListPaymentsRequest




×







1400



        var metadata runtime.ServerMetadata




×







1401






×







1402



        if err := req.ParseForm(); err != nil {




×







1403



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1404



        }




×







1405



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_ListPayments_0); err != nil {




×







1406



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1407



        }




×







1408












1409



        msg, err := server.ListPayments(ctx, &protoReq)




×







1410



        return msg, metadata, err




×







1411












1412



}










1413












1414



var (










1415



        filter_Lightning_DeletePayment_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}










1416



)










1417












1418



func request_Lightning_DeletePayment_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1419



        var protoReq DeletePaymentRequest




×







1420



        var metadata runtime.ServerMetadata




×







1421






×







1422



        if err := req.ParseForm(); err != nil {




×







1423



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1424



        }




×







1425



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_DeletePayment_0); err != nil {




×







1426



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1427



        }




×







1428












1429



        msg, err := client.DeletePayment(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1430



        return msg, metadata, err




×







1431












1432



}










1433












1434



func local_request_Lightning_DeletePayment_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1435



        var protoReq DeletePaymentRequest




×







1436



        var metadata runtime.ServerMetadata




×







1437






×







1438



        if err := req.ParseForm(); err != nil {




×







1439



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1440



        }




×







1441



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_DeletePayment_0); err != nil {




×







1442



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1443



        }




×







1444












1445



        msg, err := server.DeletePayment(ctx, &protoReq)




×







1446



        return msg, metadata, err




×







1447












1448



}










1449












1450



var (










1451



        filter_Lightning_DeleteAllPayments_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}










1452



)










1453












1454



func request_Lightning_DeleteAllPayments_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1455



        var protoReq DeleteAllPaymentsRequest




×







1456



        var metadata runtime.ServerMetadata




×







1457






×







1458



        if err := req.ParseForm(); err != nil {




×







1459



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1460



        }




×







1461



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_DeleteAllPayments_0); err != nil {




×







1462



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1463



        }




×







1464












1465



        msg, err := client.DeleteAllPayments(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1466



        return msg, metadata, err




×







1467












1468



}










1469












1470



func local_request_Lightning_DeleteAllPayments_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1471



        var protoReq DeleteAllPaymentsRequest




×







1472



        var metadata runtime.ServerMetadata




×







1473






×







1474



        if err := req.ParseForm(); err != nil {




×







1475



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1476



        }




×







1477



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_DeleteAllPayments_0); err != nil {




×







1478



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1479



        }




×







1480












1481



        msg, err := server.DeleteAllPayments(ctx, &protoReq)




×







1482



        return msg, metadata, err




×







1483












1484



}










1485












1486



var (










1487



        filter_Lightning_DescribeGraph_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}










1488



)










1489












1490



func request_Lightning_DescribeGraph_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1491



        var protoReq ChannelGraphRequest




×







1492



        var metadata runtime.ServerMetadata




×







1493






×







1494



        if err := req.ParseForm(); err != nil {




×







1495



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1496



        }




×







1497



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_DescribeGraph_0); err != nil {




×







1498



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1499



        }




×







1500












1501



        msg, err := client.DescribeGraph(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1502



        return msg, metadata, err




×







1503












1504



}










1505












1506



func local_request_Lightning_DescribeGraph_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1507



        var protoReq ChannelGraphRequest




×







1508



        var metadata runtime.ServerMetadata




×







1509






×







1510



        if err := req.ParseForm(); err != nil {




×







1511



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1512



        }




×







1513



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_DescribeGraph_0); err != nil {




×







1514



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1515



        }




×







1516












1517



        msg, err := server.DescribeGraph(ctx, &protoReq)




×







1518



        return msg, metadata, err




×







1519












1520



}










1521












1522



var (










1523



        filter_Lightning_GetNodeMetrics_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}










1524



)










1525












1526



func request_Lightning_GetNodeMetrics_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1527



        var protoReq NodeMetricsRequest




×







1528



        var metadata runtime.ServerMetadata




×







1529






×







1530



        if err := req.ParseForm(); err != nil {




×







1531



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1532



        }




×







1533



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_GetNodeMetrics_0); err != nil {




×







1534



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1535



        }




×







1536












1537



        msg, err := client.GetNodeMetrics(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1538



        return msg, metadata, err




×







1539












1540



}










1541












1542



func local_request_Lightning_GetNodeMetrics_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1543



        var protoReq NodeMetricsRequest




×







1544



        var metadata runtime.ServerMetadata




×







1545






×







1546



        if err := req.ParseForm(); err != nil {




×







1547



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1548



        }




×







1549



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_GetNodeMetrics_0); err != nil {




×







1550



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1551



        }




×







1552












1553



        msg, err := server.GetNodeMetrics(ctx, &protoReq)




×







1554



        return msg, metadata, err




×







1555












1556



}










1557












1558



var (










1559



        filter_Lightning_GetChanInfo_0 = &utilities.DoubleArray{Encoding: map[string]int{"chan_id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}










1560



)










1561












1562



func request_Lightning_GetChanInfo_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1563



        var protoReq ChanInfoRequest




×







1564



        var metadata runtime.ServerMetadata




×







1565






×







1566



        var (




×







1567



                val string




×







1568



                ok  bool




×







1569



                err error




×







1570



                _   = err




×







1571



        )




×







1572






×







1573



        val, ok = pathParams["chan_id"]




×







1574



        if !ok {




×







1575



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "chan_id")




×







1576



        }




×







1577












1578



        protoReq.ChanId, err = runtime.Uint64(val)




×







1579



        if err != nil {




×







1580



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "chan_id", err)




×







1581



        }




×







1582












1583



        if err := req.ParseForm(); err != nil {




×







1584



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1585



        }




×







1586



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_GetChanInfo_0); err != nil {




×







1587



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1588



        }




×







1589












1590



        msg, err := client.GetChanInfo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1591



        return msg, metadata, err




×







1592












1593



}










1594












1595



func local_request_Lightning_GetChanInfo_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1596



        var protoReq ChanInfoRequest




×







1597



        var metadata runtime.ServerMetadata




×







1598






×







1599



        var (




×







1600



                val string




×







1601



                ok  bool




×







1602



                err error




×







1603



                _   = err




×







1604



        )




×







1605






×







1606



        val, ok = pathParams["chan_id"]




×







1607



        if !ok {




×







1608



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "chan_id")




×







1609



        }




×







1610












1611



        protoReq.ChanId, err = runtime.Uint64(val)




×







1612



        if err != nil {




×







1613



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "chan_id", err)




×







1614



        }




×







1615












1616



        if err := req.ParseForm(); err != nil {




×







1617



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1618



        }




×







1619



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_GetChanInfo_0); err != nil {




×







1620



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1621



        }




×







1622












1623



        msg, err := server.GetChanInfo(ctx, &protoReq)




×







1624



        return msg, metadata, err




×







1625












1626



}










1627












1628



var (










1629



        filter_Lightning_GetNodeInfo_0 = &utilities.DoubleArray{Encoding: map[string]int{"pub_key": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}










1630



)










1631












1632



func request_Lightning_GetNodeInfo_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1633



        var protoReq NodeInfoRequest




×







1634



        var metadata runtime.ServerMetadata




×







1635






×







1636



        var (




×







1637



                val string




×







1638



                ok  bool




×







1639



                err error




×







1640



                _   = err




×







1641



        )




×







1642






×







1643



        val, ok = pathParams["pub_key"]




×







1644



        if !ok {




×







1645



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "pub_key")




×







1646



        }




×







1647












1648



        protoReq.PubKey, err = runtime.String(val)




×







1649



        if err != nil {




×







1650



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pub_key", err)




×







1651



        }




×







1652












1653



        if err := req.ParseForm(); err != nil {




×







1654



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1655



        }




×







1656



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_GetNodeInfo_0); err != nil {




×







1657



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1658



        }




×







1659












1660



        msg, err := client.GetNodeInfo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1661



        return msg, metadata, err




×







1662












1663



}










1664












1665



func local_request_Lightning_GetNodeInfo_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1666



        var protoReq NodeInfoRequest




×







1667



        var metadata runtime.ServerMetadata




×







1668






×







1669



        var (




×







1670



                val string




×







1671



                ok  bool




×







1672



                err error




×







1673



                _   = err




×







1674



        )




×







1675






×







1676



        val, ok = pathParams["pub_key"]




×







1677



        if !ok {




×







1678



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "pub_key")




×







1679



        }




×







1680












1681



        protoReq.PubKey, err = runtime.String(val)




×







1682



        if err != nil {




×







1683



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pub_key", err)




×







1684



        }




×







1685












1686



        if err := req.ParseForm(); err != nil {




×







1687



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1688



        }




×







1689



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_GetNodeInfo_0); err != nil {




×







1690



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1691



        }




×







1692












1693



        msg, err := server.GetNodeInfo(ctx, &protoReq)




×







1694



        return msg, metadata, err




×







1695












1696



}










1697












1698



var (










1699



        filter_Lightning_QueryRoutes_0 = &utilities.DoubleArray{Encoding: map[string]int{"pub_key": 0, "amt": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}










1700



)










1701












1702



func request_Lightning_QueryRoutes_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1703



        var protoReq QueryRoutesRequest




×







1704



        var metadata runtime.ServerMetadata




×







1705






×







1706



        var (




×







1707



                val string




×







1708



                ok  bool




×







1709



                err error




×







1710



                _   = err




×







1711



        )




×







1712






×







1713



        val, ok = pathParams["pub_key"]




×







1714



        if !ok {




×







1715



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "pub_key")




×







1716



        }




×







1717












1718



        protoReq.PubKey, err = runtime.String(val)




×







1719



        if err != nil {




×







1720



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pub_key", err)




×







1721



        }




×







1722












1723



        val, ok = pathParams["amt"]




×







1724



        if !ok {




×







1725



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "amt")




×







1726



        }




×







1727












1728



        protoReq.Amt, err = runtime.Int64(val)




×







1729



        if err != nil {




×







1730



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "amt", err)




×







1731



        }




×







1732












1733



        if err := req.ParseForm(); err != nil {




×







1734



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1735



        }




×







1736



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_QueryRoutes_0); err != nil {




×







1737



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1738



        }




×







1739












1740



        msg, err := client.QueryRoutes(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1741



        return msg, metadata, err




×







1742












1743



}










1744












1745



func local_request_Lightning_QueryRoutes_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1746



        var protoReq QueryRoutesRequest




×







1747



        var metadata runtime.ServerMetadata




×







1748






×







1749



        var (




×







1750



                val string




×







1751



                ok  bool




×







1752



                err error




×







1753



                _   = err




×







1754



        )




×







1755






×







1756



        val, ok = pathParams["pub_key"]




×







1757



        if !ok {




×







1758



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "pub_key")




×







1759



        }




×







1760












1761



        protoReq.PubKey, err = runtime.String(val)




×







1762



        if err != nil {




×







1763



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pub_key", err)




×







1764



        }




×







1765












1766



        val, ok = pathParams["amt"]




×







1767



        if !ok {




×







1768



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "amt")




×







1769



        }




×







1770












1771



        protoReq.Amt, err = runtime.Int64(val)




×







1772



        if err != nil {




×







1773



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "amt", err)




×







1774



        }




×







1775












1776



        if err := req.ParseForm(); err != nil {




×







1777



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1778



        }




×







1779



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_QueryRoutes_0); err != nil {




×







1780



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1781



        }




×







1782












1783



        msg, err := server.QueryRoutes(ctx, &protoReq)




×







1784



        return msg, metadata, err




×







1785












1786



}










1787












1788



func request_Lightning_QueryRoutes_1(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1789



        var protoReq QueryRoutesRequest




×







1790



        var metadata runtime.ServerMetadata




×







1791






×







1792



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







1793



        if berr != nil {




×







1794



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







1795



        }




×







1796



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







1797



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1798



        }




×







1799












1800



        var (




×







1801



                val string




×







1802



                ok  bool




×







1803



                err error




×







1804



                _   = err




×







1805



        )




×







1806






×







1807



        val, ok = pathParams["pub_key"]




×







1808



        if !ok {




×







1809



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "pub_key")




×







1810



        }




×







1811












1812



        protoReq.PubKey, err = runtime.String(val)




×







1813



        if err != nil {




×







1814



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pub_key", err)




×







1815



        }




×







1816












1817



        val, ok = pathParams["amt"]




×







1818



        if !ok {




×







1819



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "amt")




×







1820



        }




×







1821












1822



        protoReq.Amt, err = runtime.Int64(val)




×







1823



        if err != nil {




×







1824



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "amt", err)




×







1825



        }




×







1826












1827



        msg, err := client.QueryRoutes(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1828



        return msg, metadata, err




×







1829












1830



}










1831












1832



func local_request_Lightning_QueryRoutes_1(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1833



        var protoReq QueryRoutesRequest




×







1834



        var metadata runtime.ServerMetadata




×







1835






×







1836



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







1837



        if berr != nil {




×







1838



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







1839



        }




×







1840



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







1841



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1842



        }




×







1843












1844



        var (




×







1845



                val string




×







1846



                ok  bool




×







1847



                err error




×







1848



                _   = err




×







1849



        )




×







1850






×







1851



        val, ok = pathParams["pub_key"]




×







1852



        if !ok {




×







1853



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "pub_key")




×







1854



        }




×







1855












1856



        protoReq.PubKey, err = runtime.String(val)




×







1857



        if err != nil {




×







1858



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pub_key", err)




×







1859



        }




×







1860












1861



        val, ok = pathParams["amt"]




×







1862



        if !ok {




×







1863



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "amt")




×







1864



        }




×







1865












1866



        protoReq.Amt, err = runtime.Int64(val)




×







1867



        if err != nil {




×







1868



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "amt", err)




×







1869



        }




×







1870












1871



        msg, err := server.QueryRoutes(ctx, &protoReq)




×







1872



        return msg, metadata, err




×







1873












1874



}










1875












1876



func request_Lightning_GetNetworkInfo_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1877



        var protoReq NetworkInfoRequest




×







1878



        var metadata runtime.ServerMetadata




×







1879






×







1880



        msg, err := client.GetNetworkInfo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1881



        return msg, metadata, err




×







1882






×







1883



}




×







1884












1885



func local_request_Lightning_GetNetworkInfo_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1886



        var protoReq NetworkInfoRequest




×







1887



        var metadata runtime.ServerMetadata




×







1888






×







1889



        msg, err := server.GetNetworkInfo(ctx, &protoReq)




×







1890



        return msg, metadata, err




×







1891






×







1892



}




×







1893












1894



func request_Lightning_StopDaemon_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1895



        var protoReq StopRequest




×







1896



        var metadata runtime.ServerMetadata




×







1897






×







1898



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







1899



        if berr != nil {




×







1900



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







1901



        }




×







1902



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







1903



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1904



        }




×







1905












1906



        msg, err := client.StopDaemon(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1907



        return msg, metadata, err




×







1908












1909



}










1910












1911



func local_request_Lightning_StopDaemon_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1912



        var protoReq StopRequest




×







1913



        var metadata runtime.ServerMetadata




×







1914






×







1915



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







1916



        if berr != nil {




×







1917



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







1918



        }




×







1919



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







1920



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1921



        }




×







1922












1923



        msg, err := server.StopDaemon(ctx, &protoReq)




×







1924



        return msg, metadata, err




×







1925












1926



}










1927












1928



func request_Lightning_SubscribeChannelGraph_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (Lightning_SubscribeChannelGraphClient, runtime.ServerMetadata, error) {




×







1929



        var protoReq GraphTopologySubscription




×







1930



        var metadata runtime.ServerMetadata




×







1931






×







1932



        stream, err := client.SubscribeChannelGraph(ctx, &protoReq)




×







1933



        if err != nil {




×







1934



                return nil, metadata, err




×







1935



        }




×







1936



        header, err := stream.Header()




×







1937



        if err != nil {




×







1938



                return nil, metadata, err




×







1939



        }




×







1940



        metadata.HeaderMD = header




×







1941



        return stream, metadata, nil




×







1942












1943



}










1944












1945



func request_Lightning_DebugLevel_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1946



        var protoReq DebugLevelRequest




×







1947



        var metadata runtime.ServerMetadata




×







1948






×







1949



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







1950



        if berr != nil {




×







1951



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







1952



        }




×







1953



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







1954



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1955



        }




×







1956












1957



        msg, err := client.DebugLevel(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1958



        return msg, metadata, err




×







1959












1960



}










1961












1962



func local_request_Lightning_DebugLevel_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1963



        var protoReq DebugLevelRequest




×







1964



        var metadata runtime.ServerMetadata




×







1965






×







1966



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







1967



        if berr != nil {




×







1968



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







1969



        }




×







1970



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







1971



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







1972



        }




×







1973












1974



        msg, err := server.DebugLevel(ctx, &protoReq)




×







1975



        return msg, metadata, err




×







1976












1977



}










1978












1979



func request_Lightning_FeeReport_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1980



        var protoReq FeeReportRequest




×







1981



        var metadata runtime.ServerMetadata




×







1982






×







1983



        msg, err := client.FeeReport(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







1984



        return msg, metadata, err




×







1985






×







1986



}




×







1987












1988



func local_request_Lightning_FeeReport_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1989



        var protoReq FeeReportRequest




×







1990



        var metadata runtime.ServerMetadata




×







1991






×







1992



        msg, err := server.FeeReport(ctx, &protoReq)




×







1993



        return msg, metadata, err




×







1994






×







1995



}




×







1996












1997



func request_Lightning_UpdateChannelPolicy_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







1998



        var protoReq PolicyUpdateRequest




×







1999



        var metadata runtime.ServerMetadata




×







2000






×







2001



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







2002



        if berr != nil {




×







2003



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







2004



        }




×







2005



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







2006



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







2007



        }




×







2008












2009



        msg, err := client.UpdateChannelPolicy(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







2010



        return msg, metadata, err




×







2011












2012



}










2013












2014



func local_request_Lightning_UpdateChannelPolicy_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2015



        var protoReq PolicyUpdateRequest




×







2016



        var metadata runtime.ServerMetadata




×







2017






×







2018



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







2019



        if berr != nil {




×







2020



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







2021



        }




×







2022



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







2023



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







2024



        }




×







2025












2026



        msg, err := server.UpdateChannelPolicy(ctx, &protoReq)




×







2027



        return msg, metadata, err




×







2028












2029



}










2030












2031



func request_Lightning_ForwardingHistory_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2032



        var protoReq ForwardingHistoryRequest




×







2033



        var metadata runtime.ServerMetadata




×







2034






×







2035



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







2036



        if berr != nil {




×







2037



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







2038



        }




×







2039



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







2040



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







2041



        }




×







2042












2043



        msg, err := client.ForwardingHistory(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







2044



        return msg, metadata, err




×







2045












2046



}










2047












2048



func local_request_Lightning_ForwardingHistory_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2049



        var protoReq ForwardingHistoryRequest




×







2050



        var metadata runtime.ServerMetadata




×







2051






×







2052



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







2053



        if berr != nil {




×







2054



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







2055



        }




×







2056



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







2057



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







2058



        }




×







2059












2060



        msg, err := server.ForwardingHistory(ctx, &protoReq)




×







2061



        return msg, metadata, err




×







2062












2063



}










2064












2065



var (










2066



        filter_Lightning_ExportChannelBackup_0 = &utilities.DoubleArray{Encoding: map[string]int{"chan_point": 0, "funding_txid_str": 1, "output_index": 2}, Base: []int{1, 1, 1, 2, 0, 0}, Check: []int{0, 1, 2, 2, 3, 4}}










2067



)










2068












2069



func request_Lightning_ExportChannelBackup_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2070



        var protoReq ExportChannelBackupRequest




×







2071



        var metadata runtime.ServerMetadata




×







2072






×







2073



        var (




×







2074



                val string




×







2075



                ok  bool




×







2076



                err error




×







2077



                _   = err




×







2078



        )




×







2079






×







2080



        val, ok = pathParams["chan_point.funding_txid_str"]




×







2081



        if !ok {




×







2082



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "chan_point.funding_txid_str")




×







2083



        }




×







2084












2085



        err = runtime.PopulateFieldFromPath(&protoReq, "chan_point.funding_txid_str", val)




×







2086



        if err != nil {




×







2087



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "chan_point.funding_txid_str", err)




×







2088



        }




×







2089












2090



        val, ok = pathParams["chan_point.output_index"]




×







2091



        if !ok {




×







2092



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "chan_point.output_index")




×







2093



        }




×







2094












2095



        err = runtime.PopulateFieldFromPath(&protoReq, "chan_point.output_index", val)




×







2096



        if err != nil {




×







2097



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "chan_point.output_index", err)




×







2098



        }




×







2099












2100



        if err := req.ParseForm(); err != nil {




×







2101



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







2102



        }




×







2103



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_ExportChannelBackup_0); err != nil {




×







2104



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







2105



        }




×







2106












2107



        msg, err := client.ExportChannelBackup(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







2108



        return msg, metadata, err




×







2109












2110



}










2111












2112



func local_request_Lightning_ExportChannelBackup_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2113



        var protoReq ExportChannelBackupRequest




×







2114



        var metadata runtime.ServerMetadata




×







2115






×







2116



        var (




×







2117



                val string




×







2118



                ok  bool




×







2119



                err error




×







2120



                _   = err




×







2121



        )




×







2122






×







2123



        val, ok = pathParams["chan_point.funding_txid_str"]




×







2124



        if !ok {




×







2125



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "chan_point.funding_txid_str")




×







2126



        }




×







2127












2128



        err = runtime.PopulateFieldFromPath(&protoReq, "chan_point.funding_txid_str", val)




×







2129



        if err != nil {




×







2130



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "chan_point.funding_txid_str", err)




×







2131



        }




×







2132












2133



        val, ok = pathParams["chan_point.output_index"]




×







2134



        if !ok {




×







2135



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "chan_point.output_index")




×







2136



        }




×







2137












2138



        err = runtime.PopulateFieldFromPath(&protoReq, "chan_point.output_index", val)




×







2139



        if err != nil {




×







2140



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "chan_point.output_index", err)




×







2141



        }




×







2142












2143



        if err := req.ParseForm(); err != nil {




×







2144



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







2145



        }




×







2146



        if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Lightning_ExportChannelBackup_0); err != nil {




×







2147



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







2148



        }




×







2149












2150



        msg, err := server.ExportChannelBackup(ctx, &protoReq)




×







2151



        return msg, metadata, err




×







2152












2153



}










2154












2155



func request_Lightning_ExportAllChannelBackups_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2156



        var protoReq ChanBackupExportRequest




×







2157



        var metadata runtime.ServerMetadata




×







2158






×







2159



        msg, err := client.ExportAllChannelBackups(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







2160



        return msg, metadata, err




×







2161






×







2162



}




×







2163












2164



func local_request_Lightning_ExportAllChannelBackups_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2165



        var protoReq ChanBackupExportRequest




×







2166



        var metadata runtime.ServerMetadata




×







2167






×







2168



        msg, err := server.ExportAllChannelBackups(ctx, &protoReq)




×







2169



        return msg, metadata, err




×







2170






×







2171



}




×







2172












2173



func request_Lightning_VerifyChanBackup_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2174



        var protoReq ChanBackupSnapshot




×







2175



        var metadata runtime.ServerMetadata




×







2176






×







2177



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







2178



        if berr != nil {




×







2179



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







2180



        }




×







2181



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







2182



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







2183



        }




×







2184












2185



        msg, err := client.VerifyChanBackup(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







2186



        return msg, metadata, err




×







2187












2188



}










2189












2190



func local_request_Lightning_VerifyChanBackup_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2191



        var protoReq ChanBackupSnapshot




×







2192



        var metadata runtime.ServerMetadata




×







2193






×







2194



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







2195



        if berr != nil {




×







2196



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







2197



        }




×







2198



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







2199



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







2200



        }




×







2201












2202



        msg, err := server.VerifyChanBackup(ctx, &protoReq)




×







2203



        return msg, metadata, err




×







2204












2205



}










2206












2207



func request_Lightning_RestoreChannelBackups_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2208



        var protoReq RestoreChanBackupRequest




×







2209



        var metadata runtime.ServerMetadata




×







2210






×







2211



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







2212



        if berr != nil {




×







2213



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







2214



        }




×







2215



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







2216



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







2217



        }




×







2218












2219



        msg, err := client.RestoreChannelBackups(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







2220



        return msg, metadata, err




×







2221












2222



}










2223












2224



func local_request_Lightning_RestoreChannelBackups_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2225



        var protoReq RestoreChanBackupRequest




×







2226



        var metadata runtime.ServerMetadata




×







2227






×







2228



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







2229



        if berr != nil {




×







2230



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







2231



        }




×







2232



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







2233



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







2234



        }




×







2235












2236



        msg, err := server.RestoreChannelBackups(ctx, &protoReq)




×







2237



        return msg, metadata, err




×







2238












2239



}










2240












2241



func request_Lightning_SubscribeChannelBackups_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (Lightning_SubscribeChannelBackupsClient, runtime.ServerMetadata, error) {




×







2242



        var protoReq ChannelBackupSubscription




×







2243



        var metadata runtime.ServerMetadata




×







2244






×







2245



        stream, err := client.SubscribeChannelBackups(ctx, &protoReq)




×







2246



        if err != nil {




×







2247



                return nil, metadata, err




×







2248



        }




×







2249



        header, err := stream.Header()




×







2250



        if err != nil {




×







2251



                return nil, metadata, err




×







2252



        }




×







2253



        metadata.HeaderMD = header




×







2254



        return stream, metadata, nil




×







2255












2256



}










2257












2258



func request_Lightning_BakeMacaroon_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2259



        var protoReq BakeMacaroonRequest




×







2260



        var metadata runtime.ServerMetadata




×







2261






×







2262



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







2263



        if berr != nil {




×







2264



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







2265



        }




×







2266



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







2267



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







2268



        }




×







2269












2270



        msg, err := client.BakeMacaroon(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







2271



        return msg, metadata, err




×







2272












2273



}










2274












2275



func local_request_Lightning_BakeMacaroon_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2276



        var protoReq BakeMacaroonRequest




×







2277



        var metadata runtime.ServerMetadata




×







2278






×







2279



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







2280



        if berr != nil {




×







2281



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







2282



        }




×







2283



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







2284



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







2285



        }




×







2286












2287



        msg, err := server.BakeMacaroon(ctx, &protoReq)




×







2288



        return msg, metadata, err




×







2289












2290



}










2291












2292



func request_Lightning_ListMacaroonIDs_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2293



        var protoReq ListMacaroonIDsRequest




×







2294



        var metadata runtime.ServerMetadata




×







2295






×







2296



        msg, err := client.ListMacaroonIDs(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







2297



        return msg, metadata, err




×







2298






×







2299



}




×







2300












2301



func local_request_Lightning_ListMacaroonIDs_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2302



        var protoReq ListMacaroonIDsRequest




×







2303



        var metadata runtime.ServerMetadata




×







2304






×







2305



        msg, err := server.ListMacaroonIDs(ctx, &protoReq)




×







2306



        return msg, metadata, err




×







2307






×







2308



}




×







2309












2310



func request_Lightning_DeleteMacaroonID_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2311



        var protoReq DeleteMacaroonIDRequest




×







2312



        var metadata runtime.ServerMetadata




×







2313






×







2314



        var (




×







2315



                val string




×







2316



                ok  bool




×







2317



                err error




×







2318



                _   = err




×







2319



        )




×







2320






×







2321



        val, ok = pathParams["root_key_id"]




×







2322



        if !ok {




×







2323



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "root_key_id")




×







2324



        }




×







2325












2326



        protoReq.RootKeyId, err = runtime.Uint64(val)




×







2327



        if err != nil {




×







2328



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "root_key_id", err)




×







2329



        }




×







2330












2331



        msg, err := client.DeleteMacaroonID(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







2332



        return msg, metadata, err




×







2333












2334



}










2335












2336



func local_request_Lightning_DeleteMacaroonID_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2337



        var protoReq DeleteMacaroonIDRequest




×







2338



        var metadata runtime.ServerMetadata




×







2339






×







2340



        var (




×







2341



                val string




×







2342



                ok  bool




×







2343



                err error




×







2344



                _   = err




×







2345



        )




×







2346






×







2347



        val, ok = pathParams["root_key_id"]




×







2348



        if !ok {




×







2349



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "root_key_id")




×







2350



        }




×







2351












2352



        protoReq.RootKeyId, err = runtime.Uint64(val)




×







2353



        if err != nil {




×







2354



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "root_key_id", err)




×







2355



        }




×







2356












2357



        msg, err := server.DeleteMacaroonID(ctx, &protoReq)




×







2358



        return msg, metadata, err




×







2359












2360



}










2361












2362



func request_Lightning_ListPermissions_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2363



        var protoReq ListPermissionsRequest




×







2364



        var metadata runtime.ServerMetadata




×







2365






×







2366



        msg, err := client.ListPermissions(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







2367



        return msg, metadata, err




×







2368






×







2369



}




×







2370












2371



func local_request_Lightning_ListPermissions_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2372



        var protoReq ListPermissionsRequest




×







2373



        var metadata runtime.ServerMetadata




×







2374






×







2375



        msg, err := server.ListPermissions(ctx, &protoReq)




×







2376



        return msg, metadata, err




×







2377






×







2378



}




×







2379












2380



func request_Lightning_CheckMacaroonPermissions_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2381



        var protoReq CheckMacPermRequest




×







2382



        var metadata runtime.ServerMetadata




×







2383






×







2384



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







2385



        if berr != nil {




×







2386



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







2387



        }




×







2388



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







2389



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







2390



        }




×







2391












2392



        msg, err := client.CheckMacaroonPermissions(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







2393



        return msg, metadata, err




×







2394












2395



}










2396












2397



func local_request_Lightning_CheckMacaroonPermissions_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2398



        var protoReq CheckMacPermRequest




×







2399



        var metadata runtime.ServerMetadata




×







2400






×







2401



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







2402



        if berr != nil {




×







2403



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







2404



        }




×







2405



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







2406



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







2407



        }




×







2408












2409



        msg, err := server.CheckMacaroonPermissions(ctx, &protoReq)




×







2410



        return msg, metadata, err




×







2411












2412



}










2413












2414



func request_Lightning_RegisterRPCMiddleware_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (Lightning_RegisterRPCMiddlewareClient, runtime.ServerMetadata, error) {




×







2415



        var metadata runtime.ServerMetadata




×







2416



        stream, err := client.RegisterRPCMiddleware(ctx)




×







2417



        if err != nil {




×







2418



                grpclog.Infof("Failed to start streaming: %v", err)




×







2419



                return nil, metadata, err




×







2420



        }




×







2421



        dec := marshaler.NewDecoder(req.Body)




×







2422



        handleSend := func() error {




×







2423



                var protoReq RPCMiddlewareResponse




×







2424



                err := dec.Decode(&protoReq)




×







2425



                if err == io.EOF {




×







2426



                        return err




×







2427



                }




×







2428



                if err != nil {




×







2429



                        grpclog.Infof("Failed to decode request: %v", err)




×







2430



                        return err




×







2431



                }




×







2432



                if err := stream.Send(&protoReq); err != nil {




×







2433



                        grpclog.Infof("Failed to send request: %v", err)




×







2434



                        return err




×







2435



                }




×







2436



                return nil




×







2437



        }










2438



        if err := handleSend(); err != nil {




×







2439



                if cerr := stream.CloseSend(); cerr != nil {




×







2440



                        grpclog.Infof("Failed to terminate client stream: %v", cerr)




×







2441



                }




×







2442



                if err == io.EOF {




×







2443



                        return stream, metadata, nil




×







2444



                }




×







2445



                return nil, metadata, err




×







2446



        }










2447



        go func() {




×







2448



                for {




×







2449



                        if err := handleSend(); err != nil {




×







2450



                                break




×







2451



                        }










2452



                }










2453



                if err := stream.CloseSend(); err != nil {




×







2454



                        grpclog.Infof("Failed to terminate client stream: %v", err)




×







2455



                }




×







2456



        }()










2457



        header, err := stream.Header()




×







2458



        if err != nil {




×







2459



                grpclog.Infof("Failed to get header from client: %v", err)




×







2460



                return nil, metadata, err




×







2461



        }




×







2462



        metadata.HeaderMD = header




×







2463



        return stream, metadata, nil




×







2464



}










2465












2466



func request_Lightning_SendCustomMessage_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2467



        var protoReq SendCustomMessageRequest




×







2468



        var metadata runtime.ServerMetadata




×







2469






×







2470



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







2471



        if berr != nil {




×







2472



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







2473



        }




×







2474



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







2475



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







2476



        }




×







2477












2478



        msg, err := client.SendCustomMessage(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







2479



        return msg, metadata, err




×







2480












2481



}










2482












2483



func local_request_Lightning_SendCustomMessage_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2484



        var protoReq SendCustomMessageRequest




×







2485



        var metadata runtime.ServerMetadata




×







2486






×







2487



        newReader, berr := utilities.IOReaderFactory(req.Body)




×







2488



        if berr != nil {




×







2489



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)




×







2490



        }




×







2491



        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {




×







2492



                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)




×







2493



        }




×







2494












2495



        msg, err := server.SendCustomMessage(ctx, &protoReq)




×







2496



        return msg, metadata, err




×







2497












2498



}










2499












2500



func request_Lightning_SubscribeCustomMessages_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (Lightning_SubscribeCustomMessagesClient, runtime.ServerMetadata, error) {




×







2501



        var protoReq SubscribeCustomMessagesRequest




×







2502



        var metadata runtime.ServerMetadata




×







2503






×







2504



        stream, err := client.SubscribeCustomMessages(ctx, &protoReq)




×







2505



        if err != nil {




×







2506



                return nil, metadata, err




×







2507



        }




×







2508



        header, err := stream.Header()




×







2509



        if err != nil {




×







2510



                return nil, metadata, err




×







2511



        }




×







2512



        metadata.HeaderMD = header




×







2513



        return stream, metadata, nil




×







2514












2515



}










2516












2517



func request_Lightning_ListAliases_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2518



        var protoReq ListAliasesRequest




×







2519



        var metadata runtime.ServerMetadata




×







2520






×







2521



        msg, err := client.ListAliases(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







2522



        return msg, metadata, err




×







2523






×







2524



}




×







2525












2526



func local_request_Lightning_ListAliases_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2527



        var protoReq ListAliasesRequest




×







2528



        var metadata runtime.ServerMetadata




×







2529






×







2530



        msg, err := server.ListAliases(ctx, &protoReq)




×







2531



        return msg, metadata, err




×







2532






×







2533



}




×







2534












2535



func request_Lightning_LookupHtlcResolution_0(ctx context.Context, marshaler runtime.Marshaler, client LightningClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2536



        var protoReq LookupHtlcResolutionRequest




×







2537



        var metadata runtime.ServerMetadata




×







2538






×







2539



        var (




×







2540



                val string




×







2541



                ok  bool




×







2542



                err error




×







2543



                _   = err




×







2544



        )




×







2545






×







2546



        val, ok = pathParams["chan_id"]




×







2547



        if !ok {




×







2548



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "chan_id")




×







2549



        }




×







2550












2551



        protoReq.ChanId, err = runtime.Uint64(val)




×







2552



        if err != nil {




×







2553



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "chan_id", err)




×







2554



        }




×







2555












2556



        val, ok = pathParams["htlc_index"]




×







2557



        if !ok {




×







2558



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "htlc_index")




×







2559



        }




×







2560












2561



        protoReq.HtlcIndex, err = runtime.Uint64(val)




×







2562



        if err != nil {




×







2563



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "htlc_index", err)




×







2564



        }




×







2565












2566



        msg, err := client.LookupHtlcResolution(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))




×







2567



        return msg, metadata, err




×







2568












2569



}










2570












2571



func local_request_Lightning_LookupHtlcResolution_0(ctx context.Context, marshaler runtime.Marshaler, server LightningServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {




×







2572



        var protoReq LookupHtlcResolutionRequest




×







2573



        var metadata runtime.ServerMetadata




×







2574






×







2575



        var (




×







2576



                val string




×







2577



                ok  bool




×







2578



                err error




×







2579



                _   = err




×







2580



        )




×







2581






×







2582



        val, ok = pathParams["chan_id"]




×







2583



        if !ok {




×







2584



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "chan_id")




×







2585



        }




×







2586












2587



        protoReq.ChanId, err = runtime.Uint64(val)




×







2588



        if err != nil {




×







2589



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "chan_id", err)




×







2590



        }




×







2591












2592



        val, ok = pathParams["htlc_index"]




×







2593



        if !ok {




×







2594



                return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "htlc_index")




×







2595



        }




×







2596












2597



        protoReq.HtlcIndex, err = runtime.Uint64(val)




×







2598



        if err != nil {




×







2599



                return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "htlc_index", err)




×







2600



        }




×







2601












2602



        msg, err := server.LookupHtlcResolution(ctx, &protoReq)




×







2603



        return msg, metadata, err




×







2604












2605



}










2606












2607



// RegisterLightningHandlerServer registers the http handlers for service Lightning to "mux".










2608



// UnaryRPC     :call LightningServer directly.










2609



// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.










2610



// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterLightningHandlerFromEndpoint instead.










2611



func RegisterLightningHandlerServer(ctx context.Context, mux *runtime.ServeMux, server LightningServer) error {




×







2612






×







2613



        mux.Handle("GET", pattern_Lightning_WalletBalance_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2614



                ctx, cancel := context.WithCancel(req.Context())




×







2615



                defer cancel()




×







2616



                var stream runtime.ServerTransportStream




×







2617



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







2618



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







2619



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/WalletBalance", runtime.WithHTTPPathPattern("/v1/balance/blockchain"))




×







2620



                if err != nil {




×







2621



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2622



                        return




×







2623



                }




×







2624



                resp, md, err := local_request_Lightning_WalletBalance_0(rctx, inboundMarshaler, server, req, pathParams)




×







2625



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







2626



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







2627



                if err != nil {




×







2628



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2629



                        return




×







2630



                }




×







2631












2632



                forward_Lightning_WalletBalance_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







2633












2634



        })










2635












2636



        mux.Handle("GET", pattern_Lightning_ChannelBalance_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2637



                ctx, cancel := context.WithCancel(req.Context())




×







2638



                defer cancel()




×







2639



                var stream runtime.ServerTransportStream




×







2640



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







2641



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







2642



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/ChannelBalance", runtime.WithHTTPPathPattern("/v1/balance/channels"))




×







2643



                if err != nil {




×







2644



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2645



                        return




×







2646



                }




×







2647



                resp, md, err := local_request_Lightning_ChannelBalance_0(rctx, inboundMarshaler, server, req, pathParams)




×







2648



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







2649



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







2650



                if err != nil {




×







2651



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2652



                        return




×







2653



                }




×







2654












2655



                forward_Lightning_ChannelBalance_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







2656












2657



        })










2658












2659



        mux.Handle("GET", pattern_Lightning_GetTransactions_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2660



                ctx, cancel := context.WithCancel(req.Context())




×







2661



                defer cancel()




×







2662



                var stream runtime.ServerTransportStream




×







2663



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







2664



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







2665



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/GetTransactions", runtime.WithHTTPPathPattern("/v1/transactions"))




×







2666



                if err != nil {




×







2667



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2668



                        return




×







2669



                }




×







2670



                resp, md, err := local_request_Lightning_GetTransactions_0(rctx, inboundMarshaler, server, req, pathParams)




×







2671



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







2672



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







2673



                if err != nil {




×







2674



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2675



                        return




×







2676



                }




×







2677












2678



                forward_Lightning_GetTransactions_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







2679












2680



        })










2681












2682



        mux.Handle("GET", pattern_Lightning_EstimateFee_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2683



                ctx, cancel := context.WithCancel(req.Context())




×







2684



                defer cancel()




×







2685



                var stream runtime.ServerTransportStream




×







2686



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







2687



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







2688



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/EstimateFee", runtime.WithHTTPPathPattern("/v1/transactions/fee"))




×







2689



                if err != nil {




×







2690



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2691



                        return




×







2692



                }




×







2693



                resp, md, err := local_request_Lightning_EstimateFee_0(rctx, inboundMarshaler, server, req, pathParams)




×







2694



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







2695



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







2696



                if err != nil {




×







2697



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2698



                        return




×







2699



                }




×







2700












2701



                forward_Lightning_EstimateFee_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







2702












2703



        })










2704












2705



        mux.Handle("POST", pattern_Lightning_SendCoins_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2706



                ctx, cancel := context.WithCancel(req.Context())




×







2707



                defer cancel()




×







2708



                var stream runtime.ServerTransportStream




×







2709



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







2710



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







2711



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/SendCoins", runtime.WithHTTPPathPattern("/v1/transactions"))




×







2712



                if err != nil {




×







2713



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2714



                        return




×







2715



                }




×







2716



                resp, md, err := local_request_Lightning_SendCoins_0(rctx, inboundMarshaler, server, req, pathParams)




×







2717



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







2718



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







2719



                if err != nil {




×







2720



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2721



                        return




×







2722



                }




×







2723












2724



                forward_Lightning_SendCoins_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







2725












2726



        })










2727












2728



        mux.Handle("GET", pattern_Lightning_ListUnspent_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2729



                ctx, cancel := context.WithCancel(req.Context())




×







2730



                defer cancel()




×







2731



                var stream runtime.ServerTransportStream




×







2732



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







2733



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







2734



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/ListUnspent", runtime.WithHTTPPathPattern("/v1/utxos"))




×







2735



                if err != nil {




×







2736



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2737



                        return




×







2738



                }




×







2739



                resp, md, err := local_request_Lightning_ListUnspent_0(rctx, inboundMarshaler, server, req, pathParams)




×







2740



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







2741



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







2742



                if err != nil {




×







2743



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2744



                        return




×







2745



                }




×







2746












2747



                forward_Lightning_ListUnspent_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







2748












2749



        })










2750












2751



        mux.Handle("GET", pattern_Lightning_SubscribeTransactions_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2752



                err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")




×







2753



                _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







2754



                runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2755



                return




×







2756



        })




×







2757












2758



        mux.Handle("POST", pattern_Lightning_SendMany_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2759



                ctx, cancel := context.WithCancel(req.Context())




×







2760



                defer cancel()




×







2761



                var stream runtime.ServerTransportStream




×







2762



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







2763



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







2764



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/SendMany", runtime.WithHTTPPathPattern("/v1/transactions/many"))




×







2765



                if err != nil {




×







2766



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2767



                        return




×







2768



                }




×







2769



                resp, md, err := local_request_Lightning_SendMany_0(rctx, inboundMarshaler, server, req, pathParams)




×







2770



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







2771



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







2772



                if err != nil {




×







2773



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2774



                        return




×







2775



                }




×







2776












2777



                forward_Lightning_SendMany_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







2778












2779



        })










2780












2781



        mux.Handle("GET", pattern_Lightning_NewAddress_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2782



                ctx, cancel := context.WithCancel(req.Context())




×







2783



                defer cancel()




×







2784



                var stream runtime.ServerTransportStream




×







2785



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







2786



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







2787



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/NewAddress", runtime.WithHTTPPathPattern("/v1/newaddress"))




×







2788



                if err != nil {




×







2789



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2790



                        return




×







2791



                }




×







2792



                resp, md, err := local_request_Lightning_NewAddress_0(rctx, inboundMarshaler, server, req, pathParams)




×







2793



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







2794



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







2795



                if err != nil {




×







2796



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2797



                        return




×







2798



                }




×







2799












2800



                forward_Lightning_NewAddress_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







2801












2802



        })










2803












2804



        mux.Handle("POST", pattern_Lightning_SignMessage_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2805



                ctx, cancel := context.WithCancel(req.Context())




×







2806



                defer cancel()




×







2807



                var stream runtime.ServerTransportStream




×







2808



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







2809



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







2810



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/SignMessage", runtime.WithHTTPPathPattern("/v1/signmessage"))




×







2811



                if err != nil {




×







2812



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2813



                        return




×







2814



                }




×







2815



                resp, md, err := local_request_Lightning_SignMessage_0(rctx, inboundMarshaler, server, req, pathParams)




×







2816



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







2817



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







2818



                if err != nil {




×







2819



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2820



                        return




×







2821



                }




×







2822












2823



                forward_Lightning_SignMessage_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







2824












2825



        })










2826












2827



        mux.Handle("POST", pattern_Lightning_VerifyMessage_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2828



                ctx, cancel := context.WithCancel(req.Context())




×







2829



                defer cancel()




×







2830



                var stream runtime.ServerTransportStream




×







2831



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







2832



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







2833



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/VerifyMessage", runtime.WithHTTPPathPattern("/v1/verifymessage"))




×







2834



                if err != nil {




×







2835



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2836



                        return




×







2837



                }




×







2838



                resp, md, err := local_request_Lightning_VerifyMessage_0(rctx, inboundMarshaler, server, req, pathParams)




×







2839



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







2840



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







2841



                if err != nil {




×







2842



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2843



                        return




×







2844



                }




×







2845












2846



                forward_Lightning_VerifyMessage_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







2847












2848



        })










2849












2850



        mux.Handle("POST", pattern_Lightning_ConnectPeer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2851



                ctx, cancel := context.WithCancel(req.Context())




×







2852



                defer cancel()




×







2853



                var stream runtime.ServerTransportStream




×







2854



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







2855



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







2856



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/ConnectPeer", runtime.WithHTTPPathPattern("/v1/peers"))




×







2857



                if err != nil {




×







2858



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2859



                        return




×







2860



                }




×







2861



                resp, md, err := local_request_Lightning_ConnectPeer_0(rctx, inboundMarshaler, server, req, pathParams)




×







2862



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







2863



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







2864



                if err != nil {




×







2865



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2866



                        return




×







2867



                }




×







2868












2869



                forward_Lightning_ConnectPeer_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







2870












2871



        })










2872












2873



        mux.Handle("DELETE", pattern_Lightning_DisconnectPeer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2874



                ctx, cancel := context.WithCancel(req.Context())




×







2875



                defer cancel()




×







2876



                var stream runtime.ServerTransportStream




×







2877



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







2878



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







2879



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/DisconnectPeer", runtime.WithHTTPPathPattern("/v1/peers/{pub_key}"))




×







2880



                if err != nil {




×







2881



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2882



                        return




×







2883



                }




×







2884



                resp, md, err := local_request_Lightning_DisconnectPeer_0(rctx, inboundMarshaler, server, req, pathParams)




×







2885



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







2886



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







2887



                if err != nil {




×







2888



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2889



                        return




×







2890



                }




×







2891












2892



                forward_Lightning_DisconnectPeer_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







2893












2894



        })










2895












2896



        mux.Handle("GET", pattern_Lightning_ListPeers_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2897



                ctx, cancel := context.WithCancel(req.Context())




×







2898



                defer cancel()




×







2899



                var stream runtime.ServerTransportStream




×







2900



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







2901



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







2902



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/ListPeers", runtime.WithHTTPPathPattern("/v1/peers"))




×







2903



                if err != nil {




×







2904



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2905



                        return




×







2906



                }




×







2907



                resp, md, err := local_request_Lightning_ListPeers_0(rctx, inboundMarshaler, server, req, pathParams)




×







2908



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







2909



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







2910



                if err != nil {




×







2911



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2912



                        return




×







2913



                }




×







2914












2915



                forward_Lightning_ListPeers_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







2916












2917



        })










2918












2919



        mux.Handle("GET", pattern_Lightning_SubscribePeerEvents_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2920



                err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")




×







2921



                _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







2922



                runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2923



                return




×







2924



        })




×







2925












2926



        mux.Handle("GET", pattern_Lightning_GetInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2927



                ctx, cancel := context.WithCancel(req.Context())




×







2928



                defer cancel()




×







2929



                var stream runtime.ServerTransportStream




×







2930



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







2931



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







2932



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/GetInfo", runtime.WithHTTPPathPattern("/v1/getinfo"))




×







2933



                if err != nil {




×







2934



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2935



                        return




×







2936



                }




×







2937



                resp, md, err := local_request_Lightning_GetInfo_0(rctx, inboundMarshaler, server, req, pathParams)




×







2938



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







2939



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







2940



                if err != nil {




×







2941



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2942



                        return




×







2943



                }




×







2944












2945



                forward_Lightning_GetInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







2946












2947



        })










2948












2949



        mux.Handle("GET", pattern_Lightning_GetDebugInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2950



                ctx, cancel := context.WithCancel(req.Context())




×







2951



                defer cancel()




×







2952



                var stream runtime.ServerTransportStream




×







2953



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







2954



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







2955



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/GetDebugInfo", runtime.WithHTTPPathPattern("/v1/getdebuginfo"))




×







2956



                if err != nil {




×







2957



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2958



                        return




×







2959



                }




×







2960



                resp, md, err := local_request_Lightning_GetDebugInfo_0(rctx, inboundMarshaler, server, req, pathParams)




×







2961



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







2962



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







2963



                if err != nil {




×







2964



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2965



                        return




×







2966



                }




×







2967












2968



                forward_Lightning_GetDebugInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







2969












2970



        })










2971












2972



        mux.Handle("GET", pattern_Lightning_GetRecoveryInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2973



                ctx, cancel := context.WithCancel(req.Context())




×







2974



                defer cancel()




×







2975



                var stream runtime.ServerTransportStream




×







2976



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







2977



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







2978



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/GetRecoveryInfo", runtime.WithHTTPPathPattern("/v1/getrecoveryinfo"))




×







2979



                if err != nil {




×







2980



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2981



                        return




×







2982



                }




×







2983



                resp, md, err := local_request_Lightning_GetRecoveryInfo_0(rctx, inboundMarshaler, server, req, pathParams)




×







2984



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







2985



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







2986



                if err != nil {




×







2987



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







2988



                        return




×







2989



                }




×







2990












2991



                forward_Lightning_GetRecoveryInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







2992












2993



        })










2994












2995



        mux.Handle("GET", pattern_Lightning_PendingChannels_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







2996



                ctx, cancel := context.WithCancel(req.Context())




×







2997



                defer cancel()




×







2998



                var stream runtime.ServerTransportStream




×







2999



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3000



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3001



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/PendingChannels", runtime.WithHTTPPathPattern("/v1/channels/pending"))




×







3002



                if err != nil {




×







3003



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3004



                        return




×







3005



                }




×







3006



                resp, md, err := local_request_Lightning_PendingChannels_0(rctx, inboundMarshaler, server, req, pathParams)




×







3007



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3008



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3009



                if err != nil {




×







3010



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3011



                        return




×







3012



                }




×







3013












3014



                forward_Lightning_PendingChannels_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3015












3016



        })










3017












3018



        mux.Handle("GET", pattern_Lightning_ListChannels_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3019



                ctx, cancel := context.WithCancel(req.Context())




×







3020



                defer cancel()




×







3021



                var stream runtime.ServerTransportStream




×







3022



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3023



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3024



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/ListChannels", runtime.WithHTTPPathPattern("/v1/channels"))




×







3025



                if err != nil {




×







3026



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3027



                        return




×







3028



                }




×







3029



                resp, md, err := local_request_Lightning_ListChannels_0(rctx, inboundMarshaler, server, req, pathParams)




×







3030



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3031



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3032



                if err != nil {




×







3033



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3034



                        return




×







3035



                }




×







3036












3037



                forward_Lightning_ListChannels_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3038












3039



        })










3040












3041



        mux.Handle("GET", pattern_Lightning_SubscribeChannelEvents_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3042



                err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")




×







3043



                _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3044



                runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3045



                return




×







3046



        })




×







3047












3048



        mux.Handle("GET", pattern_Lightning_ClosedChannels_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3049



                ctx, cancel := context.WithCancel(req.Context())




×







3050



                defer cancel()




×







3051



                var stream runtime.ServerTransportStream




×







3052



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3053



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3054



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/ClosedChannels", runtime.WithHTTPPathPattern("/v1/channels/closed"))




×







3055



                if err != nil {




×







3056



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3057



                        return




×







3058



                }




×







3059



                resp, md, err := local_request_Lightning_ClosedChannels_0(rctx, inboundMarshaler, server, req, pathParams)




×







3060



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3061



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3062



                if err != nil {




×







3063



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3064



                        return




×







3065



                }




×







3066












3067



                forward_Lightning_ClosedChannels_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3068












3069



        })










3070












3071



        mux.Handle("POST", pattern_Lightning_OpenChannelSync_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3072



                ctx, cancel := context.WithCancel(req.Context())




×







3073



                defer cancel()




×







3074



                var stream runtime.ServerTransportStream




×







3075



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3076



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3077



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/OpenChannelSync", runtime.WithHTTPPathPattern("/v1/channels"))




×







3078



                if err != nil {




×







3079



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3080



                        return




×







3081



                }




×







3082



                resp, md, err := local_request_Lightning_OpenChannelSync_0(rctx, inboundMarshaler, server, req, pathParams)




×







3083



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3084



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3085



                if err != nil {




×







3086



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3087



                        return




×







3088



                }




×







3089












3090



                forward_Lightning_OpenChannelSync_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3091












3092



        })










3093












3094



        mux.Handle("POST", pattern_Lightning_OpenChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3095



                err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")




×







3096



                _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3097



                runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3098



                return




×







3099



        })




×







3100












3101



        mux.Handle("POST", pattern_Lightning_BatchOpenChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3102



                ctx, cancel := context.WithCancel(req.Context())




×







3103



                defer cancel()




×







3104



                var stream runtime.ServerTransportStream




×







3105



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3106



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3107



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/BatchOpenChannel", runtime.WithHTTPPathPattern("/v1/channels/batch"))




×







3108



                if err != nil {




×







3109



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3110



                        return




×







3111



                }




×







3112



                resp, md, err := local_request_Lightning_BatchOpenChannel_0(rctx, inboundMarshaler, server, req, pathParams)




×







3113



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3114



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3115



                if err != nil {




×







3116



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3117



                        return




×







3118



                }




×







3119












3120



                forward_Lightning_BatchOpenChannel_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3121












3122



        })










3123












3124



        mux.Handle("POST", pattern_Lightning_FundingStateStep_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3125



                ctx, cancel := context.WithCancel(req.Context())




×







3126



                defer cancel()




×







3127



                var stream runtime.ServerTransportStream




×







3128



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3129



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3130



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/FundingStateStep", runtime.WithHTTPPathPattern("/v1/funding/step"))




×







3131



                if err != nil {




×







3132



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3133



                        return




×







3134



                }




×







3135



                resp, md, err := local_request_Lightning_FundingStateStep_0(rctx, inboundMarshaler, server, req, pathParams)




×







3136



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3137



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3138



                if err != nil {




×







3139



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3140



                        return




×







3141



                }




×







3142












3143



                forward_Lightning_FundingStateStep_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3144












3145



        })










3146












3147



        mux.Handle("POST", pattern_Lightning_ChannelAcceptor_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3148



                err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")




×







3149



                _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3150



                runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3151



                return




×







3152



        })




×







3153












3154



        mux.Handle("DELETE", pattern_Lightning_CloseChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3155



                err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")




×







3156



                _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3157



                runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3158



                return




×







3159



        })




×







3160












3161



        mux.Handle("DELETE", pattern_Lightning_AbandonChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3162



                ctx, cancel := context.WithCancel(req.Context())




×







3163



                defer cancel()




×







3164



                var stream runtime.ServerTransportStream




×







3165



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3166



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3167



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/AbandonChannel", runtime.WithHTTPPathPattern("/v1/channels/abandon/{channel_point.funding_txid_str}/{channel_point.output_index}"))




×







3168



                if err != nil {




×







3169



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3170



                        return




×







3171



                }




×







3172



                resp, md, err := local_request_Lightning_AbandonChannel_0(rctx, inboundMarshaler, server, req, pathParams)




×







3173



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3174



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3175



                if err != nil {




×







3176



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3177



                        return




×







3178



                }




×







3179












3180



                forward_Lightning_AbandonChannel_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3181












3182



        })










3183












3184



        mux.Handle("POST", pattern_Lightning_SendPayment_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3185



                err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")




×







3186



                _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3187



                runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3188



                return




×







3189



        })




×







3190












3191



        mux.Handle("POST", pattern_Lightning_SendPaymentSync_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3192



                ctx, cancel := context.WithCancel(req.Context())




×







3193



                defer cancel()




×







3194



                var stream runtime.ServerTransportStream




×







3195



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3196



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3197



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/SendPaymentSync", runtime.WithHTTPPathPattern("/v1/channels/transactions"))




×







3198



                if err != nil {




×







3199



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3200



                        return




×







3201



                }




×







3202



                resp, md, err := local_request_Lightning_SendPaymentSync_0(rctx, inboundMarshaler, server, req, pathParams)




×







3203



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3204



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3205



                if err != nil {




×







3206



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3207



                        return




×







3208



                }




×







3209












3210



                forward_Lightning_SendPaymentSync_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3211












3212



        })










3213












3214



        mux.Handle("POST", pattern_Lightning_SendToRouteSync_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3215



                ctx, cancel := context.WithCancel(req.Context())




×







3216



                defer cancel()




×







3217



                var stream runtime.ServerTransportStream




×







3218



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3219



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3220



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/SendToRouteSync", runtime.WithHTTPPathPattern("/v1/channels/transactions/route"))




×







3221



                if err != nil {




×







3222



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3223



                        return




×







3224



                }




×







3225



                resp, md, err := local_request_Lightning_SendToRouteSync_0(rctx, inboundMarshaler, server, req, pathParams)




×







3226



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3227



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3228



                if err != nil {




×







3229



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3230



                        return




×







3231



                }




×







3232












3233



                forward_Lightning_SendToRouteSync_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3234












3235



        })










3236












3237



        mux.Handle("POST", pattern_Lightning_AddInvoice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3238



                ctx, cancel := context.WithCancel(req.Context())




×







3239



                defer cancel()




×







3240



                var stream runtime.ServerTransportStream




×







3241



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3242



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3243



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/AddInvoice", runtime.WithHTTPPathPattern("/v1/invoices"))




×







3244



                if err != nil {




×







3245



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3246



                        return




×







3247



                }




×







3248



                resp, md, err := local_request_Lightning_AddInvoice_0(rctx, inboundMarshaler, server, req, pathParams)




×







3249



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3250



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3251



                if err != nil {




×







3252



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3253



                        return




×







3254



                }




×







3255












3256



                forward_Lightning_AddInvoice_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3257












3258



        })










3259












3260



        mux.Handle("GET", pattern_Lightning_ListInvoices_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3261



                ctx, cancel := context.WithCancel(req.Context())




×







3262



                defer cancel()




×







3263



                var stream runtime.ServerTransportStream




×







3264



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3265



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3266



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/ListInvoices", runtime.WithHTTPPathPattern("/v1/invoices"))




×







3267



                if err != nil {




×







3268



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3269



                        return




×







3270



                }




×







3271



                resp, md, err := local_request_Lightning_ListInvoices_0(rctx, inboundMarshaler, server, req, pathParams)




×







3272



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3273



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3274



                if err != nil {




×







3275



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3276



                        return




×







3277



                }




×







3278












3279



                forward_Lightning_ListInvoices_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3280












3281



        })










3282












3283



        mux.Handle("GET", pattern_Lightning_LookupInvoice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3284



                ctx, cancel := context.WithCancel(req.Context())




×







3285



                defer cancel()




×







3286



                var stream runtime.ServerTransportStream




×







3287



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3288



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3289



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/LookupInvoice", runtime.WithHTTPPathPattern("/v1/invoice/{r_hash_str}"))




×







3290



                if err != nil {




×







3291



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3292



                        return




×







3293



                }




×







3294



                resp, md, err := local_request_Lightning_LookupInvoice_0(rctx, inboundMarshaler, server, req, pathParams)




×







3295



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3296



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3297



                if err != nil {




×







3298



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3299



                        return




×







3300



                }




×







3301












3302



                forward_Lightning_LookupInvoice_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3303












3304



        })










3305












3306



        mux.Handle("GET", pattern_Lightning_SubscribeInvoices_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3307



                err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")




×







3308



                _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3309



                runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3310



                return




×







3311



        })




×







3312












3313



        mux.Handle("GET", pattern_Lightning_DecodePayReq_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3314



                ctx, cancel := context.WithCancel(req.Context())




×







3315



                defer cancel()




×







3316



                var stream runtime.ServerTransportStream




×







3317



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3318



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3319



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/DecodePayReq", runtime.WithHTTPPathPattern("/v1/payreq/{pay_req}"))




×







3320



                if err != nil {




×







3321



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3322



                        return




×







3323



                }




×







3324



                resp, md, err := local_request_Lightning_DecodePayReq_0(rctx, inboundMarshaler, server, req, pathParams)




×







3325



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3326



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3327



                if err != nil {




×







3328



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3329



                        return




×







3330



                }




×







3331












3332



                forward_Lightning_DecodePayReq_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3333












3334



        })










3335












3336



        mux.Handle("GET", pattern_Lightning_ListPayments_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3337



                ctx, cancel := context.WithCancel(req.Context())




×







3338



                defer cancel()




×







3339



                var stream runtime.ServerTransportStream




×







3340



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3341



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3342



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/ListPayments", runtime.WithHTTPPathPattern("/v1/payments"))




×







3343



                if err != nil {




×







3344



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3345



                        return




×







3346



                }




×







3347



                resp, md, err := local_request_Lightning_ListPayments_0(rctx, inboundMarshaler, server, req, pathParams)




×







3348



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3349



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3350



                if err != nil {




×







3351



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3352



                        return




×







3353



                }




×







3354












3355



                forward_Lightning_ListPayments_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3356












3357



        })










3358












3359



        mux.Handle("DELETE", pattern_Lightning_DeletePayment_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3360



                ctx, cancel := context.WithCancel(req.Context())




×







3361



                defer cancel()




×







3362



                var stream runtime.ServerTransportStream




×







3363



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3364



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3365



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/DeletePayment", runtime.WithHTTPPathPattern("/v1/payment"))




×







3366



                if err != nil {




×







3367



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3368



                        return




×







3369



                }




×







3370



                resp, md, err := local_request_Lightning_DeletePayment_0(rctx, inboundMarshaler, server, req, pathParams)




×







3371



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3372



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3373



                if err != nil {




×







3374



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3375



                        return




×







3376



                }




×







3377












3378



                forward_Lightning_DeletePayment_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3379












3380



        })










3381












3382



        mux.Handle("DELETE", pattern_Lightning_DeleteAllPayments_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3383



                ctx, cancel := context.WithCancel(req.Context())




×







3384



                defer cancel()




×







3385



                var stream runtime.ServerTransportStream




×







3386



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3387



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3388



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/DeleteAllPayments", runtime.WithHTTPPathPattern("/v1/payments"))




×







3389



                if err != nil {




×







3390



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3391



                        return




×







3392



                }




×







3393



                resp, md, err := local_request_Lightning_DeleteAllPayments_0(rctx, inboundMarshaler, server, req, pathParams)




×







3394



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3395



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3396



                if err != nil {




×







3397



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3398



                        return




×







3399



                }




×







3400












3401



                forward_Lightning_DeleteAllPayments_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3402












3403



        })










3404












3405



        mux.Handle("GET", pattern_Lightning_DescribeGraph_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3406



                ctx, cancel := context.WithCancel(req.Context())




×







3407



                defer cancel()




×







3408



                var stream runtime.ServerTransportStream




×







3409



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3410



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3411



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/DescribeGraph", runtime.WithHTTPPathPattern("/v1/graph"))




×







3412



                if err != nil {




×







3413



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3414



                        return




×







3415



                }




×







3416



                resp, md, err := local_request_Lightning_DescribeGraph_0(rctx, inboundMarshaler, server, req, pathParams)




×







3417



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3418



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3419



                if err != nil {




×







3420



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3421



                        return




×







3422



                }




×







3423












3424



                forward_Lightning_DescribeGraph_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3425












3426



        })










3427












3428



        mux.Handle("GET", pattern_Lightning_GetNodeMetrics_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3429



                ctx, cancel := context.WithCancel(req.Context())




×







3430



                defer cancel()




×







3431



                var stream runtime.ServerTransportStream




×







3432



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3433



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3434



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/GetNodeMetrics", runtime.WithHTTPPathPattern("/v1/graph/nodemetrics"))




×







3435



                if err != nil {




×







3436



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3437



                        return




×







3438



                }




×







3439



                resp, md, err := local_request_Lightning_GetNodeMetrics_0(rctx, inboundMarshaler, server, req, pathParams)




×







3440



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3441



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3442



                if err != nil {




×







3443



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3444



                        return




×







3445



                }




×







3446












3447



                forward_Lightning_GetNodeMetrics_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3448












3449



        })










3450












3451



        mux.Handle("GET", pattern_Lightning_GetChanInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3452



                ctx, cancel := context.WithCancel(req.Context())




×







3453



                defer cancel()




×







3454



                var stream runtime.ServerTransportStream




×







3455



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3456



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3457



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/GetChanInfo", runtime.WithHTTPPathPattern("/v1/graph/edge/{chan_id}"))




×







3458



                if err != nil {




×







3459



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3460



                        return




×







3461



                }




×







3462



                resp, md, err := local_request_Lightning_GetChanInfo_0(rctx, inboundMarshaler, server, req, pathParams)




×







3463



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3464



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3465



                if err != nil {




×







3466



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3467



                        return




×







3468



                }




×







3469












3470



                forward_Lightning_GetChanInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3471












3472



        })










3473












3474



        mux.Handle("GET", pattern_Lightning_GetNodeInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3475



                ctx, cancel := context.WithCancel(req.Context())




×







3476



                defer cancel()




×







3477



                var stream runtime.ServerTransportStream




×







3478



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3479



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3480



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/GetNodeInfo", runtime.WithHTTPPathPattern("/v1/graph/node/{pub_key}"))




×







3481



                if err != nil {




×







3482



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3483



                        return




×







3484



                }




×







3485



                resp, md, err := local_request_Lightning_GetNodeInfo_0(rctx, inboundMarshaler, server, req, pathParams)




×







3486



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3487



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3488



                if err != nil {




×







3489



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3490



                        return




×







3491



                }




×







3492












3493



                forward_Lightning_GetNodeInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3494












3495



        })










3496












3497



        mux.Handle("GET", pattern_Lightning_QueryRoutes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3498



                ctx, cancel := context.WithCancel(req.Context())




×







3499



                defer cancel()




×







3500



                var stream runtime.ServerTransportStream




×







3501



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3502



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3503



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/QueryRoutes", runtime.WithHTTPPathPattern("/v1/graph/routes/{pub_key}/{amt}"))




×







3504



                if err != nil {




×







3505



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3506



                        return




×







3507



                }




×







3508



                resp, md, err := local_request_Lightning_QueryRoutes_0(rctx, inboundMarshaler, server, req, pathParams)




×







3509



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3510



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3511



                if err != nil {




×







3512



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3513



                        return




×







3514



                }




×







3515












3516



                forward_Lightning_QueryRoutes_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3517












3518



        })










3519












3520



        mux.Handle("POST", pattern_Lightning_QueryRoutes_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3521



                ctx, cancel := context.WithCancel(req.Context())




×







3522



                defer cancel()




×







3523



                var stream runtime.ServerTransportStream




×







3524



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3525



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3526



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/QueryRoutes", runtime.WithHTTPPathPattern("/v1/graph/routes/{pub_key}/{amt}"))




×







3527



                if err != nil {




×







3528



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3529



                        return




×







3530



                }




×







3531



                resp, md, err := local_request_Lightning_QueryRoutes_1(rctx, inboundMarshaler, server, req, pathParams)




×







3532



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3533



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3534



                if err != nil {




×







3535



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3536



                        return




×







3537



                }




×







3538












3539



                forward_Lightning_QueryRoutes_1(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3540












3541



        })










3542












3543



        mux.Handle("GET", pattern_Lightning_GetNetworkInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3544



                ctx, cancel := context.WithCancel(req.Context())




×







3545



                defer cancel()




×







3546



                var stream runtime.ServerTransportStream




×







3547



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3548



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3549



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/GetNetworkInfo", runtime.WithHTTPPathPattern("/v1/graph/info"))




×







3550



                if err != nil {




×







3551



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3552



                        return




×







3553



                }




×







3554



                resp, md, err := local_request_Lightning_GetNetworkInfo_0(rctx, inboundMarshaler, server, req, pathParams)




×







3555



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3556



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3557



                if err != nil {




×







3558



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3559



                        return




×







3560



                }




×







3561












3562



                forward_Lightning_GetNetworkInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3563












3564



        })










3565












3566



        mux.Handle("POST", pattern_Lightning_StopDaemon_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3567



                ctx, cancel := context.WithCancel(req.Context())




×







3568



                defer cancel()




×







3569



                var stream runtime.ServerTransportStream




×







3570



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3571



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3572



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/StopDaemon", runtime.WithHTTPPathPattern("/v1/stop"))




×







3573



                if err != nil {




×







3574



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3575



                        return




×







3576



                }




×







3577



                resp, md, err := local_request_Lightning_StopDaemon_0(rctx, inboundMarshaler, server, req, pathParams)




×







3578



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3579



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3580



                if err != nil {




×







3581



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3582



                        return




×







3583



                }




×







3584












3585



                forward_Lightning_StopDaemon_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3586












3587



        })










3588












3589



        mux.Handle("GET", pattern_Lightning_SubscribeChannelGraph_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3590



                err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")




×







3591



                _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3592



                runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3593



                return




×







3594



        })




×







3595












3596



        mux.Handle("POST", pattern_Lightning_DebugLevel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3597



                ctx, cancel := context.WithCancel(req.Context())




×







3598



                defer cancel()




×







3599



                var stream runtime.ServerTransportStream




×







3600



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3601



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3602



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/DebugLevel", runtime.WithHTTPPathPattern("/v1/debuglevel"))




×







3603



                if err != nil {




×







3604



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3605



                        return




×







3606



                }




×







3607



                resp, md, err := local_request_Lightning_DebugLevel_0(rctx, inboundMarshaler, server, req, pathParams)




×







3608



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3609



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3610



                if err != nil {




×







3611



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3612



                        return




×







3613



                }




×







3614












3615



                forward_Lightning_DebugLevel_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3616












3617



        })










3618












3619



        mux.Handle("GET", pattern_Lightning_FeeReport_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3620



                ctx, cancel := context.WithCancel(req.Context())




×







3621



                defer cancel()




×







3622



                var stream runtime.ServerTransportStream




×







3623



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3624



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3625



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/FeeReport", runtime.WithHTTPPathPattern("/v1/fees"))




×







3626



                if err != nil {




×







3627



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3628



                        return




×







3629



                }




×







3630



                resp, md, err := local_request_Lightning_FeeReport_0(rctx, inboundMarshaler, server, req, pathParams)




×







3631



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3632



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3633



                if err != nil {




×







3634



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3635



                        return




×







3636



                }




×







3637












3638



                forward_Lightning_FeeReport_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3639












3640



        })










3641












3642



        mux.Handle("POST", pattern_Lightning_UpdateChannelPolicy_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3643



                ctx, cancel := context.WithCancel(req.Context())




×







3644



                defer cancel()




×







3645



                var stream runtime.ServerTransportStream




×







3646



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3647



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3648



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/UpdateChannelPolicy", runtime.WithHTTPPathPattern("/v1/chanpolicy"))




×







3649



                if err != nil {




×







3650



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3651



                        return




×







3652



                }




×







3653



                resp, md, err := local_request_Lightning_UpdateChannelPolicy_0(rctx, inboundMarshaler, server, req, pathParams)




×







3654



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3655



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3656



                if err != nil {




×







3657



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3658



                        return




×







3659



                }




×







3660












3661



                forward_Lightning_UpdateChannelPolicy_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3662












3663



        })










3664












3665



        mux.Handle("POST", pattern_Lightning_ForwardingHistory_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3666



                ctx, cancel := context.WithCancel(req.Context())




×







3667



                defer cancel()




×







3668



                var stream runtime.ServerTransportStream




×







3669



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3670



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3671



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/ForwardingHistory", runtime.WithHTTPPathPattern("/v1/switch"))




×







3672



                if err != nil {




×







3673



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3674



                        return




×







3675



                }




×







3676



                resp, md, err := local_request_Lightning_ForwardingHistory_0(rctx, inboundMarshaler, server, req, pathParams)




×







3677



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3678



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3679



                if err != nil {




×







3680



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3681



                        return




×







3682



                }




×







3683












3684



                forward_Lightning_ForwardingHistory_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3685












3686



        })










3687












3688



        mux.Handle("GET", pattern_Lightning_ExportChannelBackup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3689



                ctx, cancel := context.WithCancel(req.Context())




×







3690



                defer cancel()




×







3691



                var stream runtime.ServerTransportStream




×







3692



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3693



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3694



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/ExportChannelBackup", runtime.WithHTTPPathPattern("/v1/channels/backup/{chan_point.funding_txid_str}/{chan_point.output_index}"))




×







3695



                if err != nil {




×







3696



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3697



                        return




×







3698



                }




×







3699



                resp, md, err := local_request_Lightning_ExportChannelBackup_0(rctx, inboundMarshaler, server, req, pathParams)




×







3700



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3701



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3702



                if err != nil {




×







3703



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3704



                        return




×







3705



                }




×







3706












3707



                forward_Lightning_ExportChannelBackup_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3708












3709



        })










3710












3711



        mux.Handle("GET", pattern_Lightning_ExportAllChannelBackups_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3712



                ctx, cancel := context.WithCancel(req.Context())




×







3713



                defer cancel()




×







3714



                var stream runtime.ServerTransportStream




×







3715



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3716



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3717



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/ExportAllChannelBackups", runtime.WithHTTPPathPattern("/v1/channels/backup"))




×







3718



                if err != nil {




×







3719



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3720



                        return




×







3721



                }




×







3722



                resp, md, err := local_request_Lightning_ExportAllChannelBackups_0(rctx, inboundMarshaler, server, req, pathParams)




×







3723



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3724



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3725



                if err != nil {




×







3726



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3727



                        return




×







3728



                }




×







3729












3730



                forward_Lightning_ExportAllChannelBackups_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3731












3732



        })










3733












3734



        mux.Handle("POST", pattern_Lightning_VerifyChanBackup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3735



                ctx, cancel := context.WithCancel(req.Context())




×







3736



                defer cancel()




×







3737



                var stream runtime.ServerTransportStream




×







3738



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3739



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3740



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/VerifyChanBackup", runtime.WithHTTPPathPattern("/v1/channels/backup/verify"))




×







3741



                if err != nil {




×







3742



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3743



                        return




×







3744



                }




×







3745



                resp, md, err := local_request_Lightning_VerifyChanBackup_0(rctx, inboundMarshaler, server, req, pathParams)




×







3746



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3747



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3748



                if err != nil {




×







3749



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3750



                        return




×







3751



                }




×







3752












3753



                forward_Lightning_VerifyChanBackup_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3754












3755



        })










3756












3757



        mux.Handle("POST", pattern_Lightning_RestoreChannelBackups_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3758



                ctx, cancel := context.WithCancel(req.Context())




×







3759



                defer cancel()




×







3760



                var stream runtime.ServerTransportStream




×







3761



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3762



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3763



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/RestoreChannelBackups", runtime.WithHTTPPathPattern("/v1/channels/backup/restore"))




×







3764



                if err != nil {




×







3765



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3766



                        return




×







3767



                }




×







3768



                resp, md, err := local_request_Lightning_RestoreChannelBackups_0(rctx, inboundMarshaler, server, req, pathParams)




×







3769



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3770



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3771



                if err != nil {




×







3772



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3773



                        return




×







3774



                }




×







3775












3776



                forward_Lightning_RestoreChannelBackups_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3777












3778



        })










3779












3780



        mux.Handle("GET", pattern_Lightning_SubscribeChannelBackups_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3781



                err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")




×







3782



                _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3783



                runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3784



                return




×







3785



        })




×







3786












3787



        mux.Handle("POST", pattern_Lightning_BakeMacaroon_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3788



                ctx, cancel := context.WithCancel(req.Context())




×







3789



                defer cancel()




×







3790



                var stream runtime.ServerTransportStream




×







3791



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3792



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3793



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/BakeMacaroon", runtime.WithHTTPPathPattern("/v1/macaroon"))




×







3794



                if err != nil {




×







3795



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3796



                        return




×







3797



                }




×







3798



                resp, md, err := local_request_Lightning_BakeMacaroon_0(rctx, inboundMarshaler, server, req, pathParams)




×







3799



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3800



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3801



                if err != nil {




×







3802



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3803



                        return




×







3804



                }




×







3805












3806



                forward_Lightning_BakeMacaroon_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3807












3808



        })










3809












3810



        mux.Handle("GET", pattern_Lightning_ListMacaroonIDs_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3811



                ctx, cancel := context.WithCancel(req.Context())




×







3812



                defer cancel()




×







3813



                var stream runtime.ServerTransportStream




×







3814



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3815



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3816



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/ListMacaroonIDs", runtime.WithHTTPPathPattern("/v1/macaroon/ids"))




×







3817



                if err != nil {




×







3818



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3819



                        return




×







3820



                }




×







3821



                resp, md, err := local_request_Lightning_ListMacaroonIDs_0(rctx, inboundMarshaler, server, req, pathParams)




×







3822



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3823



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3824



                if err != nil {




×







3825



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3826



                        return




×







3827



                }




×







3828












3829



                forward_Lightning_ListMacaroonIDs_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3830












3831



        })










3832












3833



        mux.Handle("DELETE", pattern_Lightning_DeleteMacaroonID_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3834



                ctx, cancel := context.WithCancel(req.Context())




×







3835



                defer cancel()




×







3836



                var stream runtime.ServerTransportStream




×







3837



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3838



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3839



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/DeleteMacaroonID", runtime.WithHTTPPathPattern("/v1/macaroon/{root_key_id}"))




×







3840



                if err != nil {




×







3841



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3842



                        return




×







3843



                }




×







3844



                resp, md, err := local_request_Lightning_DeleteMacaroonID_0(rctx, inboundMarshaler, server, req, pathParams)




×







3845



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3846



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3847



                if err != nil {




×







3848



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3849



                        return




×







3850



                }




×







3851












3852



                forward_Lightning_DeleteMacaroonID_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3853












3854



        })










3855












3856



        mux.Handle("GET", pattern_Lightning_ListPermissions_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3857



                ctx, cancel := context.WithCancel(req.Context())




×







3858



                defer cancel()




×







3859



                var stream runtime.ServerTransportStream




×







3860



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3861



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3862



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/ListPermissions", runtime.WithHTTPPathPattern("/v1/macaroon/permissions"))




×







3863



                if err != nil {




×







3864



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3865



                        return




×







3866



                }




×







3867



                resp, md, err := local_request_Lightning_ListPermissions_0(rctx, inboundMarshaler, server, req, pathParams)




×







3868



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3869



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3870



                if err != nil {




×







3871



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3872



                        return




×







3873



                }




×







3874












3875



                forward_Lightning_ListPermissions_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3876












3877



        })










3878












3879



        mux.Handle("POST", pattern_Lightning_CheckMacaroonPermissions_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3880



                ctx, cancel := context.WithCancel(req.Context())




×







3881



                defer cancel()




×







3882



                var stream runtime.ServerTransportStream




×







3883



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3884



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3885



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/CheckMacaroonPermissions", runtime.WithHTTPPathPattern("/v1/macaroon/checkpermissions"))




×







3886



                if err != nil {




×







3887



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3888



                        return




×







3889



                }




×







3890



                resp, md, err := local_request_Lightning_CheckMacaroonPermissions_0(rctx, inboundMarshaler, server, req, pathParams)




×







3891



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3892



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3893



                if err != nil {




×







3894



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3895



                        return




×







3896



                }




×







3897












3898



                forward_Lightning_CheckMacaroonPermissions_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3899












3900



        })










3901












3902



        mux.Handle("POST", pattern_Lightning_RegisterRPCMiddleware_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3903



                err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")




×







3904



                _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3905



                runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3906



                return




×







3907



        })




×







3908












3909



        mux.Handle("POST", pattern_Lightning_SendCustomMessage_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3910



                ctx, cancel := context.WithCancel(req.Context())




×







3911



                defer cancel()




×







3912



                var stream runtime.ServerTransportStream




×







3913



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3914



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3915



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/SendCustomMessage", runtime.WithHTTPPathPattern("/v1/custommessage"))




×







3916



                if err != nil {




×







3917



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3918



                        return




×







3919



                }




×







3920



                resp, md, err := local_request_Lightning_SendCustomMessage_0(rctx, inboundMarshaler, server, req, pathParams)




×







3921



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3922



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3923



                if err != nil {




×







3924



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3925



                        return




×







3926



                }




×







3927












3928



                forward_Lightning_SendCustomMessage_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3929












3930



        })










3931












3932



        mux.Handle("GET", pattern_Lightning_SubscribeCustomMessages_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3933



                err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")




×







3934



                _, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3935



                runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3936



                return




×







3937



        })




×







3938












3939



        mux.Handle("GET", pattern_Lightning_ListAliases_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3940



                ctx, cancel := context.WithCancel(req.Context())




×







3941



                defer cancel()




×







3942



                var stream runtime.ServerTransportStream




×







3943



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3944



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3945



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/ListAliases", runtime.WithHTTPPathPattern("/v1/aliases/list"))




×







3946



                if err != nil {




×







3947



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3948



                        return




×







3949



                }




×







3950



                resp, md, err := local_request_Lightning_ListAliases_0(rctx, inboundMarshaler, server, req, pathParams)




×







3951



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3952



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3953



                if err != nil {




×







3954



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3955



                        return




×







3956



                }




×







3957












3958



                forward_Lightning_ListAliases_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3959












3960



        })










3961












3962



        mux.Handle("GET", pattern_Lightning_LookupHtlcResolution_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







3963



                ctx, cancel := context.WithCancel(req.Context())




×







3964



                defer cancel()




×







3965



                var stream runtime.ServerTransportStream




×







3966



                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)




×







3967



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







3968



                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/lnrpc.Lightning/LookupHtlcResolution", runtime.WithHTTPPathPattern("/v1/htlc-resolution/{chan_id}/{htlc_index}"))




×







3969



                if err != nil {




×







3970



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3971



                        return




×







3972



                }




×







3973



                resp, md, err := local_request_Lightning_LookupHtlcResolution_0(rctx, inboundMarshaler, server, req, pathParams)




×







3974



                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())




×







3975



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







3976



                if err != nil {




×







3977



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







3978



                        return




×







3979



                }




×







3980












3981



                forward_Lightning_LookupHtlcResolution_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







3982












3983



        })










3984












3985



        return nil




×







3986



}










3987












3988



// RegisterLightningHandlerFromEndpoint is same as RegisterLightningHandler but










3989



// automatically dials to "endpoint" and closes the connection when "ctx" gets done.










3990



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




×







3991



        conn, err := grpc.Dial(endpoint, opts...)




×







3992



        if err != nil {




×







3993



                return err




×







3994



        }




×







3995



        defer func() {




×







3996



                if err != nil {




×







3997



                        if cerr := conn.Close(); cerr != nil {




×







3998



                                grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)




×







3999



                        }




×







4000



                        return




×







4001



                }










4002



                go func() {




×







4003



                        <-ctx.Done()




×







4004



                        if cerr := conn.Close(); cerr != nil {




×







4005



                                grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)




×







4006



                        }




×







4007



                }()










4008



        }()










4009












4010



        return RegisterLightningHandler(ctx, mux, conn)




×







4011



}










4012












4013



// RegisterLightningHandler registers the http handlers for service Lightning to "mux".










4014



// The handlers forward requests to the grpc endpoint over "conn".










4015



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




×







4016



        return RegisterLightningHandlerClient(ctx, mux, NewLightningClient(conn))




×







4017



}




×







4018












4019



// RegisterLightningHandlerClient registers the http handlers for service Lightning










4020



// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "LightningClient".










4021



// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "LightningClient"










4022



// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in










4023



// "LightningClient" to call the correct interceptors.










4024



func RegisterLightningHandlerClient(ctx context.Context, mux *runtime.ServeMux, client LightningClient) error {




×







4025






×







4026



        mux.Handle("GET", pattern_Lightning_WalletBalance_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4027



                ctx, cancel := context.WithCancel(req.Context())




×







4028



                defer cancel()




×







4029



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4030



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/WalletBalance", runtime.WithHTTPPathPattern("/v1/balance/blockchain"))




×







4031



                if err != nil {




×







4032



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4033



                        return




×







4034



                }




×







4035



                resp, md, err := request_Lightning_WalletBalance_0(rctx, inboundMarshaler, client, req, pathParams)




×







4036



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4037



                if err != nil {




×







4038



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4039



                        return




×







4040



                }




×







4041












4042



                forward_Lightning_WalletBalance_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4043












4044



        })










4045












4046



        mux.Handle("GET", pattern_Lightning_ChannelBalance_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4047



                ctx, cancel := context.WithCancel(req.Context())




×







4048



                defer cancel()




×







4049



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4050



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/ChannelBalance", runtime.WithHTTPPathPattern("/v1/balance/channels"))




×







4051



                if err != nil {




×







4052



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4053



                        return




×







4054



                }




×







4055



                resp, md, err := request_Lightning_ChannelBalance_0(rctx, inboundMarshaler, client, req, pathParams)




×







4056



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4057



                if err != nil {




×







4058



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4059



                        return




×







4060



                }




×







4061












4062



                forward_Lightning_ChannelBalance_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4063












4064



        })










4065












4066



        mux.Handle("GET", pattern_Lightning_GetTransactions_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4067



                ctx, cancel := context.WithCancel(req.Context())




×







4068



                defer cancel()




×







4069



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4070



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/GetTransactions", runtime.WithHTTPPathPattern("/v1/transactions"))




×







4071



                if err != nil {




×







4072



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4073



                        return




×







4074



                }




×







4075



                resp, md, err := request_Lightning_GetTransactions_0(rctx, inboundMarshaler, client, req, pathParams)




×







4076



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4077



                if err != nil {




×







4078



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4079



                        return




×







4080



                }




×







4081












4082



                forward_Lightning_GetTransactions_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4083












4084



        })










4085












4086



        mux.Handle("GET", pattern_Lightning_EstimateFee_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4087



                ctx, cancel := context.WithCancel(req.Context())




×







4088



                defer cancel()




×







4089



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4090



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/EstimateFee", runtime.WithHTTPPathPattern("/v1/transactions/fee"))




×







4091



                if err != nil {




×







4092



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4093



                        return




×







4094



                }




×







4095



                resp, md, err := request_Lightning_EstimateFee_0(rctx, inboundMarshaler, client, req, pathParams)




×







4096



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4097



                if err != nil {




×







4098



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4099



                        return




×







4100



                }




×







4101












4102



                forward_Lightning_EstimateFee_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4103












4104



        })










4105












4106



        mux.Handle("POST", pattern_Lightning_SendCoins_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4107



                ctx, cancel := context.WithCancel(req.Context())




×







4108



                defer cancel()




×







4109



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4110



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/SendCoins", runtime.WithHTTPPathPattern("/v1/transactions"))




×







4111



                if err != nil {




×







4112



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4113



                        return




×







4114



                }




×







4115



                resp, md, err := request_Lightning_SendCoins_0(rctx, inboundMarshaler, client, req, pathParams)




×







4116



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4117



                if err != nil {




×







4118



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4119



                        return




×







4120



                }




×







4121












4122



                forward_Lightning_SendCoins_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4123












4124



        })










4125












4126



        mux.Handle("GET", pattern_Lightning_ListUnspent_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4127



                ctx, cancel := context.WithCancel(req.Context())




×







4128



                defer cancel()




×







4129



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4130



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/ListUnspent", runtime.WithHTTPPathPattern("/v1/utxos"))




×







4131



                if err != nil {




×







4132



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4133



                        return




×







4134



                }




×







4135



                resp, md, err := request_Lightning_ListUnspent_0(rctx, inboundMarshaler, client, req, pathParams)




×







4136



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4137



                if err != nil {




×







4138



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4139



                        return




×







4140



                }




×







4141












4142



                forward_Lightning_ListUnspent_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4143












4144



        })










4145












4146



        mux.Handle("GET", pattern_Lightning_SubscribeTransactions_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4147



                ctx, cancel := context.WithCancel(req.Context())




×







4148



                defer cancel()




×







4149



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4150



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/SubscribeTransactions", runtime.WithHTTPPathPattern("/v1/transactions/subscribe"))




×







4151



                if err != nil {




×







4152



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4153



                        return




×







4154



                }




×







4155



                resp, md, err := request_Lightning_SubscribeTransactions_0(rctx, inboundMarshaler, client, req, pathParams)




×







4156



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4157



                if err != nil {




×







4158



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4159



                        return




×







4160



                }




×







4161












4162



                forward_Lightning_SubscribeTransactions_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)




×







4163












4164



        })










4165












4166



        mux.Handle("POST", pattern_Lightning_SendMany_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4167



                ctx, cancel := context.WithCancel(req.Context())




×







4168



                defer cancel()




×







4169



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4170



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/SendMany", runtime.WithHTTPPathPattern("/v1/transactions/many"))




×







4171



                if err != nil {




×







4172



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4173



                        return




×







4174



                }




×







4175



                resp, md, err := request_Lightning_SendMany_0(rctx, inboundMarshaler, client, req, pathParams)




×







4176



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4177



                if err != nil {




×







4178



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4179



                        return




×







4180



                }




×







4181












4182



                forward_Lightning_SendMany_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4183












4184



        })










4185












4186



        mux.Handle("GET", pattern_Lightning_NewAddress_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4187



                ctx, cancel := context.WithCancel(req.Context())




×







4188



                defer cancel()




×







4189



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4190



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/NewAddress", runtime.WithHTTPPathPattern("/v1/newaddress"))




×







4191



                if err != nil {




×







4192



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4193



                        return




×







4194



                }




×







4195



                resp, md, err := request_Lightning_NewAddress_0(rctx, inboundMarshaler, client, req, pathParams)




×







4196



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4197



                if err != nil {




×







4198



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4199



                        return




×







4200



                }




×







4201












4202



                forward_Lightning_NewAddress_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4203












4204



        })










4205












4206



        mux.Handle("POST", pattern_Lightning_SignMessage_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4207



                ctx, cancel := context.WithCancel(req.Context())




×







4208



                defer cancel()




×







4209



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4210



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/SignMessage", runtime.WithHTTPPathPattern("/v1/signmessage"))




×







4211



                if err != nil {




×







4212



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4213



                        return




×







4214



                }




×







4215



                resp, md, err := request_Lightning_SignMessage_0(rctx, inboundMarshaler, client, req, pathParams)




×







4216



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4217



                if err != nil {




×







4218



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4219



                        return




×







4220



                }




×







4221












4222



                forward_Lightning_SignMessage_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4223












4224



        })










4225












4226



        mux.Handle("POST", pattern_Lightning_VerifyMessage_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4227



                ctx, cancel := context.WithCancel(req.Context())




×







4228



                defer cancel()




×







4229



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4230



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/VerifyMessage", runtime.WithHTTPPathPattern("/v1/verifymessage"))




×







4231



                if err != nil {




×







4232



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4233



                        return




×







4234



                }




×







4235



                resp, md, err := request_Lightning_VerifyMessage_0(rctx, inboundMarshaler, client, req, pathParams)




×







4236



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4237



                if err != nil {




×







4238



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4239



                        return




×







4240



                }




×







4241












4242



                forward_Lightning_VerifyMessage_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4243












4244



        })










4245












4246



        mux.Handle("POST", pattern_Lightning_ConnectPeer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4247



                ctx, cancel := context.WithCancel(req.Context())




×







4248



                defer cancel()




×







4249



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4250



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/ConnectPeer", runtime.WithHTTPPathPattern("/v1/peers"))




×







4251



                if err != nil {




×







4252



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4253



                        return




×







4254



                }




×







4255



                resp, md, err := request_Lightning_ConnectPeer_0(rctx, inboundMarshaler, client, req, pathParams)




×







4256



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4257



                if err != nil {




×







4258



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4259



                        return




×







4260



                }




×







4261












4262



                forward_Lightning_ConnectPeer_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4263












4264



        })










4265












4266



        mux.Handle("DELETE", pattern_Lightning_DisconnectPeer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4267



                ctx, cancel := context.WithCancel(req.Context())




×







4268



                defer cancel()




×







4269



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4270



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/DisconnectPeer", runtime.WithHTTPPathPattern("/v1/peers/{pub_key}"))




×







4271



                if err != nil {




×







4272



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4273



                        return




×







4274



                }




×







4275



                resp, md, err := request_Lightning_DisconnectPeer_0(rctx, inboundMarshaler, client, req, pathParams)




×







4276



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4277



                if err != nil {




×







4278



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4279



                        return




×







4280



                }




×







4281












4282



                forward_Lightning_DisconnectPeer_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4283












4284



        })










4285












4286



        mux.Handle("GET", pattern_Lightning_ListPeers_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4287



                ctx, cancel := context.WithCancel(req.Context())




×







4288



                defer cancel()




×







4289



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4290



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/ListPeers", runtime.WithHTTPPathPattern("/v1/peers"))




×







4291



                if err != nil {




×







4292



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4293



                        return




×







4294



                }




×







4295



                resp, md, err := request_Lightning_ListPeers_0(rctx, inboundMarshaler, client, req, pathParams)




×







4296



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4297



                if err != nil {




×







4298



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4299



                        return




×







4300



                }




×







4301












4302



                forward_Lightning_ListPeers_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4303












4304



        })










4305












4306



        mux.Handle("GET", pattern_Lightning_SubscribePeerEvents_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4307



                ctx, cancel := context.WithCancel(req.Context())




×







4308



                defer cancel()




×







4309



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4310



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/SubscribePeerEvents", runtime.WithHTTPPathPattern("/v1/peers/subscribe"))




×







4311



                if err != nil {




×







4312



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4313



                        return




×







4314



                }




×







4315



                resp, md, err := request_Lightning_SubscribePeerEvents_0(rctx, inboundMarshaler, client, req, pathParams)




×







4316



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4317



                if err != nil {




×







4318



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4319



                        return




×







4320



                }




×







4321












4322



                forward_Lightning_SubscribePeerEvents_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)




×







4323












4324



        })










4325












4326



        mux.Handle("GET", pattern_Lightning_GetInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4327



                ctx, cancel := context.WithCancel(req.Context())




×







4328



                defer cancel()




×







4329



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4330



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/GetInfo", runtime.WithHTTPPathPattern("/v1/getinfo"))




×







4331



                if err != nil {




×







4332



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4333



                        return




×







4334



                }




×







4335



                resp, md, err := request_Lightning_GetInfo_0(rctx, inboundMarshaler, client, req, pathParams)




×







4336



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4337



                if err != nil {




×







4338



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4339



                        return




×







4340



                }




×







4341












4342



                forward_Lightning_GetInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4343












4344



        })










4345












4346



        mux.Handle("GET", pattern_Lightning_GetDebugInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4347



                ctx, cancel := context.WithCancel(req.Context())




×







4348



                defer cancel()




×







4349



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4350



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/GetDebugInfo", runtime.WithHTTPPathPattern("/v1/getdebuginfo"))




×







4351



                if err != nil {




×







4352



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4353



                        return




×







4354



                }




×







4355



                resp, md, err := request_Lightning_GetDebugInfo_0(rctx, inboundMarshaler, client, req, pathParams)




×







4356



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4357



                if err != nil {




×







4358



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4359



                        return




×







4360



                }




×







4361












4362



                forward_Lightning_GetDebugInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4363












4364



        })










4365












4366



        mux.Handle("GET", pattern_Lightning_GetRecoveryInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4367



                ctx, cancel := context.WithCancel(req.Context())




×







4368



                defer cancel()




×







4369



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4370



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/GetRecoveryInfo", runtime.WithHTTPPathPattern("/v1/getrecoveryinfo"))




×







4371



                if err != nil {




×







4372



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4373



                        return




×







4374



                }




×







4375



                resp, md, err := request_Lightning_GetRecoveryInfo_0(rctx, inboundMarshaler, client, req, pathParams)




×







4376



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4377



                if err != nil {




×







4378



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4379



                        return




×







4380



                }




×







4381












4382



                forward_Lightning_GetRecoveryInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4383












4384



        })










4385












4386



        mux.Handle("GET", pattern_Lightning_PendingChannels_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4387



                ctx, cancel := context.WithCancel(req.Context())




×







4388



                defer cancel()




×







4389



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4390



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/PendingChannels", runtime.WithHTTPPathPattern("/v1/channels/pending"))




×







4391



                if err != nil {




×







4392



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4393



                        return




×







4394



                }




×







4395



                resp, md, err := request_Lightning_PendingChannels_0(rctx, inboundMarshaler, client, req, pathParams)




×







4396



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4397



                if err != nil {




×







4398



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4399



                        return




×







4400



                }




×







4401












4402



                forward_Lightning_PendingChannels_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4403












4404



        })










4405












4406



        mux.Handle("GET", pattern_Lightning_ListChannels_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4407



                ctx, cancel := context.WithCancel(req.Context())




×







4408



                defer cancel()




×







4409



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4410



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/ListChannels", runtime.WithHTTPPathPattern("/v1/channels"))




×







4411



                if err != nil {




×







4412



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4413



                        return




×







4414



                }




×







4415



                resp, md, err := request_Lightning_ListChannels_0(rctx, inboundMarshaler, client, req, pathParams)




×







4416



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4417



                if err != nil {




×







4418



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4419



                        return




×







4420



                }




×







4421












4422



                forward_Lightning_ListChannels_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4423












4424



        })










4425












4426



        mux.Handle("GET", pattern_Lightning_SubscribeChannelEvents_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4427



                ctx, cancel := context.WithCancel(req.Context())




×







4428



                defer cancel()




×







4429



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4430



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/SubscribeChannelEvents", runtime.WithHTTPPathPattern("/v1/channels/subscribe"))




×







4431



                if err != nil {




×







4432



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4433



                        return




×







4434



                }




×







4435



                resp, md, err := request_Lightning_SubscribeChannelEvents_0(rctx, inboundMarshaler, client, req, pathParams)




×







4436



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4437



                if err != nil {




×







4438



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4439



                        return




×







4440



                }




×







4441












4442



                forward_Lightning_SubscribeChannelEvents_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)




×







4443












4444



        })










4445












4446



        mux.Handle("GET", pattern_Lightning_ClosedChannels_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4447



                ctx, cancel := context.WithCancel(req.Context())




×







4448



                defer cancel()




×







4449



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4450



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/ClosedChannels", runtime.WithHTTPPathPattern("/v1/channels/closed"))




×







4451



                if err != nil {




×







4452



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4453



                        return




×







4454



                }




×







4455



                resp, md, err := request_Lightning_ClosedChannels_0(rctx, inboundMarshaler, client, req, pathParams)




×







4456



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4457



                if err != nil {




×







4458



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4459



                        return




×







4460



                }




×







4461












4462



                forward_Lightning_ClosedChannels_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4463












4464



        })










4465












4466



        mux.Handle("POST", pattern_Lightning_OpenChannelSync_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4467



                ctx, cancel := context.WithCancel(req.Context())




×







4468



                defer cancel()




×







4469



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4470



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/OpenChannelSync", runtime.WithHTTPPathPattern("/v1/channels"))




×







4471



                if err != nil {




×







4472



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4473



                        return




×







4474



                }




×







4475



                resp, md, err := request_Lightning_OpenChannelSync_0(rctx, inboundMarshaler, client, req, pathParams)




×







4476



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4477



                if err != nil {




×







4478



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4479



                        return




×







4480



                }




×







4481












4482



                forward_Lightning_OpenChannelSync_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4483












4484



        })










4485












4486



        mux.Handle("POST", pattern_Lightning_OpenChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4487



                ctx, cancel := context.WithCancel(req.Context())




×







4488



                defer cancel()




×







4489



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4490



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/OpenChannel", runtime.WithHTTPPathPattern("/v1/channels/stream"))




×







4491



                if err != nil {




×







4492



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4493



                        return




×







4494



                }




×







4495



                resp, md, err := request_Lightning_OpenChannel_0(rctx, inboundMarshaler, client, req, pathParams)




×







4496



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4497



                if err != nil {




×







4498



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4499



                        return




×







4500



                }




×







4501












4502



                forward_Lightning_OpenChannel_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)




×







4503












4504



        })










4505












4506



        mux.Handle("POST", pattern_Lightning_BatchOpenChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4507



                ctx, cancel := context.WithCancel(req.Context())




×







4508



                defer cancel()




×







4509



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4510



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/BatchOpenChannel", runtime.WithHTTPPathPattern("/v1/channels/batch"))




×







4511



                if err != nil {




×







4512



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4513



                        return




×







4514



                }




×







4515



                resp, md, err := request_Lightning_BatchOpenChannel_0(rctx, inboundMarshaler, client, req, pathParams)




×







4516



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4517



                if err != nil {




×







4518



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4519



                        return




×







4520



                }




×







4521












4522



                forward_Lightning_BatchOpenChannel_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4523












4524



        })










4525












4526



        mux.Handle("POST", pattern_Lightning_FundingStateStep_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4527



                ctx, cancel := context.WithCancel(req.Context())




×







4528



                defer cancel()




×







4529



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4530



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/FundingStateStep", runtime.WithHTTPPathPattern("/v1/funding/step"))




×







4531



                if err != nil {




×







4532



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4533



                        return




×







4534



                }




×







4535



                resp, md, err := request_Lightning_FundingStateStep_0(rctx, inboundMarshaler, client, req, pathParams)




×







4536



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4537



                if err != nil {




×







4538



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4539



                        return




×







4540



                }




×







4541












4542



                forward_Lightning_FundingStateStep_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4543












4544



        })










4545












4546



        mux.Handle("POST", pattern_Lightning_ChannelAcceptor_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4547



                ctx, cancel := context.WithCancel(req.Context())




×







4548



                defer cancel()




×







4549



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4550



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/ChannelAcceptor", runtime.WithHTTPPathPattern("/v1/channels/acceptor"))




×







4551



                if err != nil {




×







4552



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4553



                        return




×







4554



                }




×







4555



                resp, md, err := request_Lightning_ChannelAcceptor_0(rctx, inboundMarshaler, client, req, pathParams)




×







4556



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4557



                if err != nil {




×







4558



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4559



                        return




×







4560



                }




×







4561












4562



                forward_Lightning_ChannelAcceptor_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)




×







4563












4564



        })










4565












4566



        mux.Handle("DELETE", pattern_Lightning_CloseChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4567



                ctx, cancel := context.WithCancel(req.Context())




×







4568



                defer cancel()




×







4569



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4570



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/CloseChannel", runtime.WithHTTPPathPattern("/v1/channels/{channel_point.funding_txid_str}/{channel_point.output_index}"))




×







4571



                if err != nil {




×







4572



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4573



                        return




×







4574



                }




×







4575



                resp, md, err := request_Lightning_CloseChannel_0(rctx, inboundMarshaler, client, req, pathParams)




×







4576



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4577



                if err != nil {




×







4578



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4579



                        return




×







4580



                }




×







4581












4582



                forward_Lightning_CloseChannel_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)




×







4583












4584



        })










4585












4586



        mux.Handle("DELETE", pattern_Lightning_AbandonChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4587



                ctx, cancel := context.WithCancel(req.Context())




×







4588



                defer cancel()




×







4589



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4590



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/AbandonChannel", runtime.WithHTTPPathPattern("/v1/channels/abandon/{channel_point.funding_txid_str}/{channel_point.output_index}"))




×







4591



                if err != nil {




×







4592



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4593



                        return




×







4594



                }




×







4595



                resp, md, err := request_Lightning_AbandonChannel_0(rctx, inboundMarshaler, client, req, pathParams)




×







4596



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4597



                if err != nil {




×







4598



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4599



                        return




×







4600



                }




×







4601












4602



                forward_Lightning_AbandonChannel_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4603












4604



        })










4605












4606



        mux.Handle("POST", pattern_Lightning_SendPayment_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4607



                ctx, cancel := context.WithCancel(req.Context())




×







4608



                defer cancel()




×







4609



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4610



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/SendPayment", runtime.WithHTTPPathPattern("/v1/channels/transaction-stream"))




×







4611



                if err != nil {




×







4612



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4613



                        return




×







4614



                }




×







4615



                resp, md, err := request_Lightning_SendPayment_0(rctx, inboundMarshaler, client, req, pathParams)




×







4616



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4617



                if err != nil {




×







4618



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4619



                        return




×







4620



                }




×







4621












4622



                forward_Lightning_SendPayment_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)




×







4623












4624



        })










4625












4626



        mux.Handle("POST", pattern_Lightning_SendPaymentSync_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4627



                ctx, cancel := context.WithCancel(req.Context())




×







4628



                defer cancel()




×







4629



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4630



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/SendPaymentSync", runtime.WithHTTPPathPattern("/v1/channels/transactions"))




×







4631



                if err != nil {




×







4632



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4633



                        return




×







4634



                }




×







4635



                resp, md, err := request_Lightning_SendPaymentSync_0(rctx, inboundMarshaler, client, req, pathParams)




×







4636



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4637



                if err != nil {




×







4638



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4639



                        return




×







4640



                }




×







4641












4642



                forward_Lightning_SendPaymentSync_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4643












4644



        })










4645












4646



        mux.Handle("POST", pattern_Lightning_SendToRouteSync_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4647



                ctx, cancel := context.WithCancel(req.Context())




×







4648



                defer cancel()




×







4649



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4650



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/SendToRouteSync", runtime.WithHTTPPathPattern("/v1/channels/transactions/route"))




×







4651



                if err != nil {




×







4652



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4653



                        return




×







4654



                }




×







4655



                resp, md, err := request_Lightning_SendToRouteSync_0(rctx, inboundMarshaler, client, req, pathParams)




×







4656



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4657



                if err != nil {




×







4658



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4659



                        return




×







4660



                }




×







4661












4662



                forward_Lightning_SendToRouteSync_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4663












4664



        })










4665












4666



        mux.Handle("POST", pattern_Lightning_AddInvoice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4667



                ctx, cancel := context.WithCancel(req.Context())




×







4668



                defer cancel()




×







4669



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4670



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/AddInvoice", runtime.WithHTTPPathPattern("/v1/invoices"))




×







4671



                if err != nil {




×







4672



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4673



                        return




×







4674



                }




×







4675



                resp, md, err := request_Lightning_AddInvoice_0(rctx, inboundMarshaler, client, req, pathParams)




×







4676



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4677



                if err != nil {




×







4678



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4679



                        return




×







4680



                }




×







4681












4682



                forward_Lightning_AddInvoice_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4683












4684



        })










4685












4686



        mux.Handle("GET", pattern_Lightning_ListInvoices_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4687



                ctx, cancel := context.WithCancel(req.Context())




×







4688



                defer cancel()




×







4689



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4690



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/ListInvoices", runtime.WithHTTPPathPattern("/v1/invoices"))




×







4691



                if err != nil {




×







4692



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4693



                        return




×







4694



                }




×







4695



                resp, md, err := request_Lightning_ListInvoices_0(rctx, inboundMarshaler, client, req, pathParams)




×







4696



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4697



                if err != nil {




×







4698



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4699



                        return




×







4700



                }




×







4701












4702



                forward_Lightning_ListInvoices_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4703












4704



        })










4705












4706



        mux.Handle("GET", pattern_Lightning_LookupInvoice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4707



                ctx, cancel := context.WithCancel(req.Context())




×







4708



                defer cancel()




×







4709



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4710



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/LookupInvoice", runtime.WithHTTPPathPattern("/v1/invoice/{r_hash_str}"))




×







4711



                if err != nil {




×







4712



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4713



                        return




×







4714



                }




×







4715



                resp, md, err := request_Lightning_LookupInvoice_0(rctx, inboundMarshaler, client, req, pathParams)




×







4716



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4717



                if err != nil {




×







4718



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4719



                        return




×







4720



                }




×







4721












4722



                forward_Lightning_LookupInvoice_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4723












4724



        })










4725












4726



        mux.Handle("GET", pattern_Lightning_SubscribeInvoices_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4727



                ctx, cancel := context.WithCancel(req.Context())




×







4728



                defer cancel()




×







4729



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4730



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/SubscribeInvoices", runtime.WithHTTPPathPattern("/v1/invoices/subscribe"))




×







4731



                if err != nil {




×







4732



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4733



                        return




×







4734



                }




×







4735



                resp, md, err := request_Lightning_SubscribeInvoices_0(rctx, inboundMarshaler, client, req, pathParams)




×







4736



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4737



                if err != nil {




×







4738



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4739



                        return




×







4740



                }




×







4741












4742



                forward_Lightning_SubscribeInvoices_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)




×







4743












4744



        })










4745












4746



        mux.Handle("GET", pattern_Lightning_DecodePayReq_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4747



                ctx, cancel := context.WithCancel(req.Context())




×







4748



                defer cancel()




×







4749



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4750



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/DecodePayReq", runtime.WithHTTPPathPattern("/v1/payreq/{pay_req}"))




×







4751



                if err != nil {




×







4752



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4753



                        return




×







4754



                }




×







4755



                resp, md, err := request_Lightning_DecodePayReq_0(rctx, inboundMarshaler, client, req, pathParams)




×







4756



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4757



                if err != nil {




×







4758



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4759



                        return




×







4760



                }




×







4761












4762



                forward_Lightning_DecodePayReq_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4763












4764



        })










4765












4766



        mux.Handle("GET", pattern_Lightning_ListPayments_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4767



                ctx, cancel := context.WithCancel(req.Context())




×







4768



                defer cancel()




×







4769



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4770



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/ListPayments", runtime.WithHTTPPathPattern("/v1/payments"))




×







4771



                if err != nil {




×







4772



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4773



                        return




×







4774



                }




×







4775



                resp, md, err := request_Lightning_ListPayments_0(rctx, inboundMarshaler, client, req, pathParams)




×







4776



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4777



                if err != nil {




×







4778



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4779



                        return




×







4780



                }




×







4781












4782



                forward_Lightning_ListPayments_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4783












4784



        })










4785












4786



        mux.Handle("DELETE", pattern_Lightning_DeletePayment_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4787



                ctx, cancel := context.WithCancel(req.Context())




×







4788



                defer cancel()




×







4789



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4790



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/DeletePayment", runtime.WithHTTPPathPattern("/v1/payment"))




×







4791



                if err != nil {




×







4792



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4793



                        return




×







4794



                }




×







4795



                resp, md, err := request_Lightning_DeletePayment_0(rctx, inboundMarshaler, client, req, pathParams)




×







4796



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4797



                if err != nil {




×







4798



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4799



                        return




×







4800



                }




×







4801












4802



                forward_Lightning_DeletePayment_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4803












4804



        })










4805












4806



        mux.Handle("DELETE", pattern_Lightning_DeleteAllPayments_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4807



                ctx, cancel := context.WithCancel(req.Context())




×







4808



                defer cancel()




×







4809



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4810



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/DeleteAllPayments", runtime.WithHTTPPathPattern("/v1/payments"))




×







4811



                if err != nil {




×







4812



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4813



                        return




×







4814



                }




×







4815



                resp, md, err := request_Lightning_DeleteAllPayments_0(rctx, inboundMarshaler, client, req, pathParams)




×







4816



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4817



                if err != nil {




×







4818



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4819



                        return




×







4820



                }




×







4821












4822



                forward_Lightning_DeleteAllPayments_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4823












4824



        })










4825












4826



        mux.Handle("GET", pattern_Lightning_DescribeGraph_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4827



                ctx, cancel := context.WithCancel(req.Context())




×







4828



                defer cancel()




×







4829



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4830



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/DescribeGraph", runtime.WithHTTPPathPattern("/v1/graph"))




×







4831



                if err != nil {




×







4832



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4833



                        return




×







4834



                }




×







4835



                resp, md, err := request_Lightning_DescribeGraph_0(rctx, inboundMarshaler, client, req, pathParams)




×







4836



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4837



                if err != nil {




×







4838



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4839



                        return




×







4840



                }




×







4841












4842



                forward_Lightning_DescribeGraph_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4843












4844



        })










4845












4846



        mux.Handle("GET", pattern_Lightning_GetNodeMetrics_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4847



                ctx, cancel := context.WithCancel(req.Context())




×







4848



                defer cancel()




×







4849



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4850



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/GetNodeMetrics", runtime.WithHTTPPathPattern("/v1/graph/nodemetrics"))




×







4851



                if err != nil {




×







4852



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4853



                        return




×







4854



                }




×







4855



                resp, md, err := request_Lightning_GetNodeMetrics_0(rctx, inboundMarshaler, client, req, pathParams)




×







4856



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4857



                if err != nil {




×







4858



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4859



                        return




×







4860



                }




×







4861












4862



                forward_Lightning_GetNodeMetrics_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4863












4864



        })










4865












4866



        mux.Handle("GET", pattern_Lightning_GetChanInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4867



                ctx, cancel := context.WithCancel(req.Context())




×







4868



                defer cancel()




×







4869



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4870



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/GetChanInfo", runtime.WithHTTPPathPattern("/v1/graph/edge/{chan_id}"))




×







4871



                if err != nil {




×







4872



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4873



                        return




×







4874



                }




×







4875



                resp, md, err := request_Lightning_GetChanInfo_0(rctx, inboundMarshaler, client, req, pathParams)




×







4876



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4877



                if err != nil {




×







4878



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4879



                        return




×







4880



                }




×







4881












4882



                forward_Lightning_GetChanInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4883












4884



        })










4885












4886



        mux.Handle("GET", pattern_Lightning_GetNodeInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4887



                ctx, cancel := context.WithCancel(req.Context())




×







4888



                defer cancel()




×







4889



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4890



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/GetNodeInfo", runtime.WithHTTPPathPattern("/v1/graph/node/{pub_key}"))




×







4891



                if err != nil {




×







4892



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4893



                        return




×







4894



                }




×







4895



                resp, md, err := request_Lightning_GetNodeInfo_0(rctx, inboundMarshaler, client, req, pathParams)




×







4896



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4897



                if err != nil {




×







4898



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4899



                        return




×







4900



                }




×







4901












4902



                forward_Lightning_GetNodeInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4903












4904



        })










4905












4906



        mux.Handle("GET", pattern_Lightning_QueryRoutes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4907



                ctx, cancel := context.WithCancel(req.Context())




×







4908



                defer cancel()




×







4909



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4910



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/QueryRoutes", runtime.WithHTTPPathPattern("/v1/graph/routes/{pub_key}/{amt}"))




×







4911



                if err != nil {




×







4912



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4913



                        return




×







4914



                }




×







4915



                resp, md, err := request_Lightning_QueryRoutes_0(rctx, inboundMarshaler, client, req, pathParams)




×







4916



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4917



                if err != nil {




×







4918



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4919



                        return




×







4920



                }




×







4921












4922



                forward_Lightning_QueryRoutes_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4923












4924



        })










4925












4926



        mux.Handle("POST", pattern_Lightning_QueryRoutes_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4927



                ctx, cancel := context.WithCancel(req.Context())




×







4928



                defer cancel()




×







4929



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4930



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/QueryRoutes", runtime.WithHTTPPathPattern("/v1/graph/routes/{pub_key}/{amt}"))




×







4931



                if err != nil {




×







4932



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4933



                        return




×







4934



                }




×







4935



                resp, md, err := request_Lightning_QueryRoutes_1(rctx, inboundMarshaler, client, req, pathParams)




×







4936



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4937



                if err != nil {




×







4938



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4939



                        return




×







4940



                }




×







4941












4942



                forward_Lightning_QueryRoutes_1(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4943












4944



        })










4945












4946



        mux.Handle("GET", pattern_Lightning_GetNetworkInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4947



                ctx, cancel := context.WithCancel(req.Context())




×







4948



                defer cancel()




×







4949



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4950



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/GetNetworkInfo", runtime.WithHTTPPathPattern("/v1/graph/info"))




×







4951



                if err != nil {




×







4952



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4953



                        return




×







4954



                }




×







4955



                resp, md, err := request_Lightning_GetNetworkInfo_0(rctx, inboundMarshaler, client, req, pathParams)




×







4956



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4957



                if err != nil {




×







4958



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4959



                        return




×







4960



                }




×







4961












4962



                forward_Lightning_GetNetworkInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4963












4964



        })










4965












4966



        mux.Handle("POST", pattern_Lightning_StopDaemon_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4967



                ctx, cancel := context.WithCancel(req.Context())




×







4968



                defer cancel()




×







4969



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4970



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/StopDaemon", runtime.WithHTTPPathPattern("/v1/stop"))




×







4971



                if err != nil {




×







4972



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4973



                        return




×







4974



                }




×







4975



                resp, md, err := request_Lightning_StopDaemon_0(rctx, inboundMarshaler, client, req, pathParams)




×







4976



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4977



                if err != nil {




×







4978



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4979



                        return




×







4980



                }




×







4981












4982



                forward_Lightning_StopDaemon_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







4983












4984



        })










4985












4986



        mux.Handle("GET", pattern_Lightning_SubscribeChannelGraph_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







4987



                ctx, cancel := context.WithCancel(req.Context())




×







4988



                defer cancel()




×







4989



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







4990



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/SubscribeChannelGraph", runtime.WithHTTPPathPattern("/v1/graph/subscribe"))




×







4991



                if err != nil {




×







4992



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4993



                        return




×







4994



                }




×







4995



                resp, md, err := request_Lightning_SubscribeChannelGraph_0(rctx, inboundMarshaler, client, req, pathParams)




×







4996



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







4997



                if err != nil {




×







4998



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







4999



                        return




×







5000



                }




×







5001












5002



                forward_Lightning_SubscribeChannelGraph_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)




×







5003












5004



        })










5005












5006



        mux.Handle("POST", pattern_Lightning_DebugLevel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5007



                ctx, cancel := context.WithCancel(req.Context())




×







5008



                defer cancel()




×







5009



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5010



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/DebugLevel", runtime.WithHTTPPathPattern("/v1/debuglevel"))




×







5011



                if err != nil {




×







5012



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5013



                        return




×







5014



                }




×







5015



                resp, md, err := request_Lightning_DebugLevel_0(rctx, inboundMarshaler, client, req, pathParams)




×







5016



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5017



                if err != nil {




×







5018



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5019



                        return




×







5020



                }




×







5021












5022



                forward_Lightning_DebugLevel_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







5023












5024



        })










5025












5026



        mux.Handle("GET", pattern_Lightning_FeeReport_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5027



                ctx, cancel := context.WithCancel(req.Context())




×







5028



                defer cancel()




×







5029



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5030



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/FeeReport", runtime.WithHTTPPathPattern("/v1/fees"))




×







5031



                if err != nil {




×







5032



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5033



                        return




×







5034



                }




×







5035



                resp, md, err := request_Lightning_FeeReport_0(rctx, inboundMarshaler, client, req, pathParams)




×







5036



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5037



                if err != nil {




×







5038



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5039



                        return




×







5040



                }




×







5041












5042



                forward_Lightning_FeeReport_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







5043












5044



        })










5045












5046



        mux.Handle("POST", pattern_Lightning_UpdateChannelPolicy_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5047



                ctx, cancel := context.WithCancel(req.Context())




×







5048



                defer cancel()




×







5049



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5050



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/UpdateChannelPolicy", runtime.WithHTTPPathPattern("/v1/chanpolicy"))




×







5051



                if err != nil {




×







5052



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5053



                        return




×







5054



                }




×







5055



                resp, md, err := request_Lightning_UpdateChannelPolicy_0(rctx, inboundMarshaler, client, req, pathParams)




×







5056



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5057



                if err != nil {




×







5058



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5059



                        return




×







5060



                }




×







5061












5062



                forward_Lightning_UpdateChannelPolicy_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







5063












5064



        })










5065












5066



        mux.Handle("POST", pattern_Lightning_ForwardingHistory_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5067



                ctx, cancel := context.WithCancel(req.Context())




×







5068



                defer cancel()




×







5069



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5070



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/ForwardingHistory", runtime.WithHTTPPathPattern("/v1/switch"))




×







5071



                if err != nil {




×







5072



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5073



                        return




×







5074



                }




×







5075



                resp, md, err := request_Lightning_ForwardingHistory_0(rctx, inboundMarshaler, client, req, pathParams)




×







5076



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5077



                if err != nil {




×







5078



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5079



                        return




×







5080



                }




×







5081












5082



                forward_Lightning_ForwardingHistory_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







5083












5084



        })










5085












5086



        mux.Handle("GET", pattern_Lightning_ExportChannelBackup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5087



                ctx, cancel := context.WithCancel(req.Context())




×







5088



                defer cancel()




×







5089



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5090



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/ExportChannelBackup", runtime.WithHTTPPathPattern("/v1/channels/backup/{chan_point.funding_txid_str}/{chan_point.output_index}"))




×







5091



                if err != nil {




×







5092



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5093



                        return




×







5094



                }




×







5095



                resp, md, err := request_Lightning_ExportChannelBackup_0(rctx, inboundMarshaler, client, req, pathParams)




×







5096



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5097



                if err != nil {




×







5098



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5099



                        return




×







5100



                }




×







5101












5102



                forward_Lightning_ExportChannelBackup_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







5103












5104



        })










5105












5106



        mux.Handle("GET", pattern_Lightning_ExportAllChannelBackups_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5107



                ctx, cancel := context.WithCancel(req.Context())




×







5108



                defer cancel()




×







5109



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5110



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/ExportAllChannelBackups", runtime.WithHTTPPathPattern("/v1/channels/backup"))




×







5111



                if err != nil {




×







5112



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5113



                        return




×







5114



                }




×







5115



                resp, md, err := request_Lightning_ExportAllChannelBackups_0(rctx, inboundMarshaler, client, req, pathParams)




×







5116



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5117



                if err != nil {




×







5118



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5119



                        return




×







5120



                }




×







5121












5122



                forward_Lightning_ExportAllChannelBackups_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







5123












5124



        })










5125












5126



        mux.Handle("POST", pattern_Lightning_VerifyChanBackup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5127



                ctx, cancel := context.WithCancel(req.Context())




×







5128



                defer cancel()




×







5129



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5130



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/VerifyChanBackup", runtime.WithHTTPPathPattern("/v1/channels/backup/verify"))




×







5131



                if err != nil {




×







5132



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5133



                        return




×







5134



                }




×







5135



                resp, md, err := request_Lightning_VerifyChanBackup_0(rctx, inboundMarshaler, client, req, pathParams)




×







5136



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5137



                if err != nil {




×







5138



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5139



                        return




×







5140



                }




×







5141












5142



                forward_Lightning_VerifyChanBackup_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







5143












5144



        })










5145












5146



        mux.Handle("POST", pattern_Lightning_RestoreChannelBackups_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5147



                ctx, cancel := context.WithCancel(req.Context())




×







5148



                defer cancel()




×







5149



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5150



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/RestoreChannelBackups", runtime.WithHTTPPathPattern("/v1/channels/backup/restore"))




×







5151



                if err != nil {




×







5152



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5153



                        return




×







5154



                }




×







5155



                resp, md, err := request_Lightning_RestoreChannelBackups_0(rctx, inboundMarshaler, client, req, pathParams)




×







5156



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5157



                if err != nil {




×







5158



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5159



                        return




×







5160



                }




×







5161












5162



                forward_Lightning_RestoreChannelBackups_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







5163












5164



        })










5165












5166



        mux.Handle("GET", pattern_Lightning_SubscribeChannelBackups_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5167



                ctx, cancel := context.WithCancel(req.Context())




×







5168



                defer cancel()




×







5169



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5170



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/SubscribeChannelBackups", runtime.WithHTTPPathPattern("/v1/channels/backup/subscribe"))




×







5171



                if err != nil {




×







5172



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5173



                        return




×







5174



                }




×







5175



                resp, md, err := request_Lightning_SubscribeChannelBackups_0(rctx, inboundMarshaler, client, req, pathParams)




×







5176



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5177



                if err != nil {




×







5178



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5179



                        return




×







5180



                }




×







5181












5182



                forward_Lightning_SubscribeChannelBackups_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)




×







5183












5184



        })










5185












5186



        mux.Handle("POST", pattern_Lightning_BakeMacaroon_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5187



                ctx, cancel := context.WithCancel(req.Context())




×







5188



                defer cancel()




×







5189



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5190



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/BakeMacaroon", runtime.WithHTTPPathPattern("/v1/macaroon"))




×







5191



                if err != nil {




×







5192



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5193



                        return




×







5194



                }




×







5195



                resp, md, err := request_Lightning_BakeMacaroon_0(rctx, inboundMarshaler, client, req, pathParams)




×







5196



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5197



                if err != nil {




×







5198



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5199



                        return




×







5200



                }




×







5201












5202



                forward_Lightning_BakeMacaroon_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







5203












5204



        })










5205












5206



        mux.Handle("GET", pattern_Lightning_ListMacaroonIDs_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5207



                ctx, cancel := context.WithCancel(req.Context())




×







5208



                defer cancel()




×







5209



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5210



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/ListMacaroonIDs", runtime.WithHTTPPathPattern("/v1/macaroon/ids"))




×







5211



                if err != nil {




×







5212



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5213



                        return




×







5214



                }




×







5215



                resp, md, err := request_Lightning_ListMacaroonIDs_0(rctx, inboundMarshaler, client, req, pathParams)




×







5216



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5217



                if err != nil {




×







5218



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5219



                        return




×







5220



                }




×







5221












5222



                forward_Lightning_ListMacaroonIDs_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







5223












5224



        })










5225












5226



        mux.Handle("DELETE", pattern_Lightning_DeleteMacaroonID_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5227



                ctx, cancel := context.WithCancel(req.Context())




×







5228



                defer cancel()




×







5229



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5230



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/DeleteMacaroonID", runtime.WithHTTPPathPattern("/v1/macaroon/{root_key_id}"))




×







5231



                if err != nil {




×







5232



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5233



                        return




×







5234



                }




×







5235



                resp, md, err := request_Lightning_DeleteMacaroonID_0(rctx, inboundMarshaler, client, req, pathParams)




×







5236



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5237



                if err != nil {




×







5238



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5239



                        return




×







5240



                }




×







5241












5242



                forward_Lightning_DeleteMacaroonID_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







5243












5244



        })










5245












5246



        mux.Handle("GET", pattern_Lightning_ListPermissions_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5247



                ctx, cancel := context.WithCancel(req.Context())




×







5248



                defer cancel()




×







5249



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5250



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/ListPermissions", runtime.WithHTTPPathPattern("/v1/macaroon/permissions"))




×







5251



                if err != nil {




×







5252



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5253



                        return




×







5254



                }




×







5255



                resp, md, err := request_Lightning_ListPermissions_0(rctx, inboundMarshaler, client, req, pathParams)




×







5256



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5257



                if err != nil {




×







5258



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5259



                        return




×







5260



                }




×







5261












5262



                forward_Lightning_ListPermissions_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







5263












5264



        })










5265












5266



        mux.Handle("POST", pattern_Lightning_CheckMacaroonPermissions_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5267



                ctx, cancel := context.WithCancel(req.Context())




×







5268



                defer cancel()




×







5269



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5270



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/CheckMacaroonPermissions", runtime.WithHTTPPathPattern("/v1/macaroon/checkpermissions"))




×







5271



                if err != nil {




×







5272



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5273



                        return




×







5274



                }




×







5275



                resp, md, err := request_Lightning_CheckMacaroonPermissions_0(rctx, inboundMarshaler, client, req, pathParams)




×







5276



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5277



                if err != nil {




×







5278



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5279



                        return




×







5280



                }




×







5281












5282



                forward_Lightning_CheckMacaroonPermissions_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







5283












5284



        })










5285












5286



        mux.Handle("POST", pattern_Lightning_RegisterRPCMiddleware_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5287



                ctx, cancel := context.WithCancel(req.Context())




×







5288



                defer cancel()




×







5289



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5290



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/RegisterRPCMiddleware", runtime.WithHTTPPathPattern("/v1/middleware"))




×







5291



                if err != nil {




×







5292



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5293



                        return




×







5294



                }




×







5295



                resp, md, err := request_Lightning_RegisterRPCMiddleware_0(rctx, inboundMarshaler, client, req, pathParams)




×







5296



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5297



                if err != nil {




×







5298



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5299



                        return




×







5300



                }




×







5301












5302



                forward_Lightning_RegisterRPCMiddleware_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)




×







5303












5304



        })










5305












5306



        mux.Handle("POST", pattern_Lightning_SendCustomMessage_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5307



                ctx, cancel := context.WithCancel(req.Context())




×







5308



                defer cancel()




×







5309



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5310



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/SendCustomMessage", runtime.WithHTTPPathPattern("/v1/custommessage"))




×







5311



                if err != nil {




×







5312



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5313



                        return




×







5314



                }




×







5315



                resp, md, err := request_Lightning_SendCustomMessage_0(rctx, inboundMarshaler, client, req, pathParams)




×







5316



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5317



                if err != nil {




×







5318



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5319



                        return




×







5320



                }




×







5321












5322



                forward_Lightning_SendCustomMessage_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







5323












5324



        })










5325












5326



        mux.Handle("GET", pattern_Lightning_SubscribeCustomMessages_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5327



                ctx, cancel := context.WithCancel(req.Context())




×







5328



                defer cancel()




×







5329



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5330



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/SubscribeCustomMessages", runtime.WithHTTPPathPattern("/v1/custommessage/subscribe"))




×







5331



                if err != nil {




×







5332



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5333



                        return




×







5334



                }




×







5335



                resp, md, err := request_Lightning_SubscribeCustomMessages_0(rctx, inboundMarshaler, client, req, pathParams)




×







5336



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5337



                if err != nil {




×







5338



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5339



                        return




×







5340



                }




×







5341












5342



                forward_Lightning_SubscribeCustomMessages_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)




×







5343












5344



        })










5345












5346



        mux.Handle("GET", pattern_Lightning_ListAliases_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5347



                ctx, cancel := context.WithCancel(req.Context())




×







5348



                defer cancel()




×







5349



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5350



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/ListAliases", runtime.WithHTTPPathPattern("/v1/aliases/list"))




×







5351



                if err != nil {




×







5352



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5353



                        return




×







5354



                }




×







5355



                resp, md, err := request_Lightning_ListAliases_0(rctx, inboundMarshaler, client, req, pathParams)




×







5356



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5357



                if err != nil {




×







5358



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5359



                        return




×







5360



                }




×







5361












5362



                forward_Lightning_ListAliases_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







5363












5364



        })










5365












5366



        mux.Handle("GET", pattern_Lightning_LookupHtlcResolution_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {




×







5367



                ctx, cancel := context.WithCancel(req.Context())




×







5368



                defer cancel()




×







5369



                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)




×







5370



                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/lnrpc.Lightning/LookupHtlcResolution", runtime.WithHTTPPathPattern("/v1/htlc-resolution/{chan_id}/{htlc_index}"))




×







5371



                if err != nil {




×







5372



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5373



                        return




×







5374



                }




×







5375



                resp, md, err := request_Lightning_LookupHtlcResolution_0(rctx, inboundMarshaler, client, req, pathParams)




×







5376



                ctx = runtime.NewServerMetadataContext(ctx, md)




×







5377



                if err != nil {




×







5378



                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)




×







5379



                        return




×







5380



                }




×







5381












5382



                forward_Lightning_LookupHtlcResolution_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)




×







5383












5384



        })










5385












5386



        return nil




×







5387



}










5388












5389



var (










5390



        pattern_Lightning_WalletBalance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "balance", "blockchain"}, ""))










5391












5392



        pattern_Lightning_ChannelBalance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "balance", "channels"}, ""))










5393












5394



        pattern_Lightning_GetTransactions_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "transactions"}, ""))










5395












5396



        pattern_Lightning_EstimateFee_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "transactions", "fee"}, ""))










5397












5398



        pattern_Lightning_SendCoins_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "transactions"}, ""))










5399












5400



        pattern_Lightning_ListUnspent_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "utxos"}, ""))










5401












5402



        pattern_Lightning_SubscribeTransactions_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "transactions", "subscribe"}, ""))










5403












5404



        pattern_Lightning_SendMany_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "transactions", "many"}, ""))










5405












5406



        pattern_Lightning_NewAddress_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "newaddress"}, ""))










5407












5408



        pattern_Lightning_SignMessage_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "signmessage"}, ""))










5409












5410



        pattern_Lightning_VerifyMessage_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "verifymessage"}, ""))










5411












5412



        pattern_Lightning_ConnectPeer_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "peers"}, ""))










5413












5414



        pattern_Lightning_DisconnectPeer_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"v1", "peers", "pub_key"}, ""))










5415












5416



        pattern_Lightning_ListPeers_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "peers"}, ""))










5417












5418



        pattern_Lightning_SubscribePeerEvents_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "peers", "subscribe"}, ""))










5419












5420



        pattern_Lightning_GetInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "getinfo"}, ""))










5421












5422



        pattern_Lightning_GetDebugInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "getdebuginfo"}, ""))










5423












5424



        pattern_Lightning_GetRecoveryInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "getrecoveryinfo"}, ""))










5425












5426



        pattern_Lightning_PendingChannels_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "channels", "pending"}, ""))










5427












5428



        pattern_Lightning_ListChannels_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "channels"}, ""))










5429












5430



        pattern_Lightning_SubscribeChannelEvents_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "channels", "subscribe"}, ""))










5431












5432



        pattern_Lightning_ClosedChannels_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "channels", "closed"}, ""))










5433












5434



        pattern_Lightning_OpenChannelSync_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "channels"}, ""))










5435












5436



        pattern_Lightning_OpenChannel_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "channels", "stream"}, ""))










5437












5438



        pattern_Lightning_BatchOpenChannel_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "channels", "batch"}, ""))










5439












5440



        pattern_Lightning_FundingStateStep_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "funding", "step"}, ""))










5441












5442



        pattern_Lightning_ChannelAcceptor_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "channels", "acceptor"}, ""))










5443












5444



        pattern_Lightning_CloseChannel_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "channels", "channel_point.funding_txid_str", "channel_point.output_index"}, ""))










5445












5446



        pattern_Lightning_AbandonChannel_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "channels", "abandon", "channel_point.funding_txid_str", "channel_point.output_index"}, ""))










5447












5448



        pattern_Lightning_SendPayment_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "channels", "transaction-stream"}, ""))










5449












5450



        pattern_Lightning_SendPaymentSync_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "channels", "transactions"}, ""))










5451












5452



        pattern_Lightning_SendToRouteSync_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "channels", "transactions", "route"}, ""))










5453












5454



        pattern_Lightning_AddInvoice_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "invoices"}, ""))










5455












5456



        pattern_Lightning_ListInvoices_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "invoices"}, ""))










5457












5458



        pattern_Lightning_LookupInvoice_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"v1", "invoice", "r_hash_str"}, ""))










5459












5460



        pattern_Lightning_SubscribeInvoices_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "invoices", "subscribe"}, ""))










5461












5462



        pattern_Lightning_DecodePayReq_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"v1", "payreq", "pay_req"}, ""))










5463












5464



        pattern_Lightning_ListPayments_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "payments"}, ""))










5465












5466



        pattern_Lightning_DeletePayment_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "payment"}, ""))










5467












5468



        pattern_Lightning_DeleteAllPayments_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "payments"}, ""))










5469












5470



        pattern_Lightning_DescribeGraph_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "graph"}, ""))










5471












5472



        pattern_Lightning_GetNodeMetrics_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "graph", "nodemetrics"}, ""))










5473












5474



        pattern_Lightning_GetChanInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "graph", "edge", "chan_id"}, ""))










5475












5476



        pattern_Lightning_GetNodeInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "graph", "node", "pub_key"}, ""))










5477












5478



        pattern_Lightning_QueryRoutes_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "graph", "routes", "pub_key", "amt"}, ""))










5479












5480



        pattern_Lightning_QueryRoutes_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "graph", "routes", "pub_key", "amt"}, ""))










5481












5482



        pattern_Lightning_GetNetworkInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "graph", "info"}, ""))










5483












5484



        pattern_Lightning_StopDaemon_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "stop"}, ""))










5485












5486



        pattern_Lightning_SubscribeChannelGraph_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "graph", "subscribe"}, ""))










5487












5488



        pattern_Lightning_DebugLevel_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "debuglevel"}, ""))










5489












5490



        pattern_Lightning_FeeReport_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "fees"}, ""))










5491












5492



        pattern_Lightning_UpdateChannelPolicy_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "chanpolicy"}, ""))










5493












5494



        pattern_Lightning_ForwardingHistory_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "switch"}, ""))










5495












5496



        pattern_Lightning_ExportChannelBackup_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "channels", "backup", "chan_point.funding_txid_str", "chan_point.output_index"}, ""))










5497












5498



        pattern_Lightning_ExportAllChannelBackups_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "channels", "backup"}, ""))










5499












5500



        pattern_Lightning_VerifyChanBackup_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "channels", "backup", "verify"}, ""))










5501












5502



        pattern_Lightning_RestoreChannelBackups_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "channels", "backup", "restore"}, ""))










5503












5504



        pattern_Lightning_SubscribeChannelBackups_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "channels", "backup", "subscribe"}, ""))










5505












5506



        pattern_Lightning_BakeMacaroon_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "macaroon"}, ""))










5507












5508



        pattern_Lightning_ListMacaroonIDs_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "macaroon", "ids"}, ""))










5509












5510



        pattern_Lightning_DeleteMacaroonID_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"v1", "macaroon", "root_key_id"}, ""))










5511












5512



        pattern_Lightning_ListPermissions_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "macaroon", "permissions"}, ""))










5513












5514



        pattern_Lightning_CheckMacaroonPermissions_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "macaroon", "checkpermissions"}, ""))










5515












5516



        pattern_Lightning_RegisterRPCMiddleware_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "middleware"}, ""))










5517












5518



        pattern_Lightning_SendCustomMessage_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "custommessage"}, ""))










5519












5520



        pattern_Lightning_SubscribeCustomMessages_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "custommessage", "subscribe"}, ""))










5521












5522



        pattern_Lightning_ListAliases_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "aliases", "list"}, ""))










5523












5524



        pattern_Lightning_LookupHtlcResolution_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "htlc-resolution", "chan_id", "htlc_index"}, ""))










5525



)










5526












5527



var (










5528



        forward_Lightning_WalletBalance_0 = runtime.ForwardResponseMessage










5529












5530



        forward_Lightning_ChannelBalance_0 = runtime.ForwardResponseMessage










5531












5532



        forward_Lightning_GetTransactions_0 = runtime.ForwardResponseMessage










5533












5534



        forward_Lightning_EstimateFee_0 = runtime.ForwardResponseMessage










5535












5536



        forward_Lightning_SendCoins_0 = runtime.ForwardResponseMessage










5537












5538



        forward_Lightning_ListUnspent_0 = runtime.ForwardResponseMessage










5539












5540



        forward_Lightning_SubscribeTransactions_0 = runtime.ForwardResponseStream










5541












5542



        forward_Lightning_SendMany_0 = runtime.ForwardResponseMessage










5543












5544



        forward_Lightning_NewAddress_0 = runtime.ForwardResponseMessage










5545












5546



        forward_Lightning_SignMessage_0 = runtime.ForwardResponseMessage










5547












5548



        forward_Lightning_VerifyMessage_0 = runtime.ForwardResponseMessage










5549












5550



        forward_Lightning_ConnectPeer_0 = runtime.ForwardResponseMessage










5551












5552



        forward_Lightning_DisconnectPeer_0 = runtime.ForwardResponseMessage










5553












5554



        forward_Lightning_ListPeers_0 = runtime.ForwardResponseMessage










5555












5556



        forward_Lightning_SubscribePeerEvents_0 = runtime.ForwardResponseStream










5557












5558



        forward_Lightning_GetInfo_0 = runtime.ForwardResponseMessage










5559












5560



        forward_Lightning_GetDebugInfo_0 = runtime.ForwardResponseMessage










5561












5562



        forward_Lightning_GetRecoveryInfo_0 = runtime.ForwardResponseMessage










5563












5564



        forward_Lightning_PendingChannels_0 = runtime.ForwardResponseMessage










5565












5566



        forward_Lightning_ListChannels_0 = runtime.ForwardResponseMessage










5567












5568



        forward_Lightning_SubscribeChannelEvents_0 = runtime.ForwardResponseStream










5569












5570



        forward_Lightning_ClosedChannels_0 = runtime.ForwardResponseMessage










5571












5572



        forward_Lightning_OpenChannelSync_0 = runtime.ForwardResponseMessage










5573












5574



        forward_Lightning_OpenChannel_0 = runtime.ForwardResponseStream










5575












5576



        forward_Lightning_BatchOpenChannel_0 = runtime.ForwardResponseMessage










5577












5578



        forward_Lightning_FundingStateStep_0 = runtime.ForwardResponseMessage










5579












5580



        forward_Lightning_ChannelAcceptor_0 = runtime.ForwardResponseStream










5581












5582



        forward_Lightning_CloseChannel_0 = runtime.ForwardResponseStream










5583












5584



        forward_Lightning_AbandonChannel_0 = runtime.ForwardResponseMessage










5585












5586



        forward_Lightning_SendPayment_0 = runtime.ForwardResponseStream










5587












5588



        forward_Lightning_SendPaymentSync_0 = runtime.ForwardResponseMessage










5589












5590



        forward_Lightning_SendToRouteSync_0 = runtime.ForwardResponseMessage










5591












5592



        forward_Lightning_AddInvoice_0 = runtime.ForwardResponseMessage










5593












5594



        forward_Lightning_ListInvoices_0 = runtime.ForwardResponseMessage










5595












5596



        forward_Lightning_LookupInvoice_0 = runtime.ForwardResponseMessage










5597












5598



        forward_Lightning_SubscribeInvoices_0 = runtime.ForwardResponseStream










5599












5600



        forward_Lightning_DecodePayReq_0 = runtime.ForwardResponseMessage










5601












5602



        forward_Lightning_ListPayments_0 = runtime.ForwardResponseMessage










5603












5604



        forward_Lightning_DeletePayment_0 = runtime.ForwardResponseMessage










5605












5606



        forward_Lightning_DeleteAllPayments_0 = runtime.ForwardResponseMessage










5607












5608



        forward_Lightning_DescribeGraph_0 = runtime.ForwardResponseMessage










5609












5610



        forward_Lightning_GetNodeMetrics_0 = runtime.ForwardResponseMessage










5611












5612



        forward_Lightning_GetChanInfo_0 = runtime.ForwardResponseMessage










5613












5614



        forward_Lightning_GetNodeInfo_0 = runtime.ForwardResponseMessage










5615












5616



        forward_Lightning_QueryRoutes_0 = runtime.ForwardResponseMessage










5617












5618



        forward_Lightning_QueryRoutes_1 = runtime.ForwardResponseMessage










5619












5620



        forward_Lightning_GetNetworkInfo_0 = runtime.ForwardResponseMessage










5621












5622



        forward_Lightning_StopDaemon_0 = runtime.ForwardResponseMessage










5623












5624



        forward_Lightning_SubscribeChannelGraph_0 = runtime.ForwardResponseStream










5625












5626



        forward_Lightning_DebugLevel_0 = runtime.ForwardResponseMessage










5627












5628



        forward_Lightning_FeeReport_0 = runtime.ForwardResponseMessage










5629












5630



        forward_Lightning_UpdateChannelPolicy_0 = runtime.ForwardResponseMessage










5631












5632



        forward_Lightning_ForwardingHistory_0 = runtime.ForwardResponseMessage










5633












5634



        forward_Lightning_ExportChannelBackup_0 = runtime.ForwardResponseMessage










5635












5636



        forward_Lightning_ExportAllChannelBackups_0 = runtime.ForwardResponseMessage










5637












5638



        forward_Lightning_VerifyChanBackup_0 = runtime.ForwardResponseMessage










5639












5640



        forward_Lightning_RestoreChannelBackups_0 = runtime.ForwardResponseMessage










5641












5642



        forward_Lightning_SubscribeChannelBackups_0 = runtime.ForwardResponseStream










5643












5644



        forward_Lightning_BakeMacaroon_0 = runtime.ForwardResponseMessage










5645












5646



        forward_Lightning_ListMacaroonIDs_0 = runtime.ForwardResponseMessage










5647












5648



        forward_Lightning_DeleteMacaroonID_0 = runtime.ForwardResponseMessage










5649












5650



        forward_Lightning_ListPermissions_0 = runtime.ForwardResponseMessage










5651












5652



        forward_Lightning_CheckMacaroonPermissions_0 = runtime.ForwardResponseMessage










5653












5654



        forward_Lightning_RegisterRPCMiddleware_0 = runtime.ForwardResponseStream










5655












5656



        forward_Lightning_SendCustomMessage_0 = runtime.ForwardResponseMessage










5657












5658



        forward_Lightning_SubscribeCustomMessages_0 = runtime.ForwardResponseStream










5659












5660



        forward_Lightning_ListAliases_0 = runtime.ForwardResponseMessage










5661












5662



        forward_Lightning_LookupHtlcResolution_0 = runtime.ForwardResponseMessage










5663



)
























    

  • 

    •