13412100018

Committed 19 Feb 2025 12:05PM UTC coverage: 44.914% (-13.9%) from 58.794%

Build # 13412100018

Build Type

Pull #9521

github

Committed by

web-flow

Commit Message

Merge 861d6970e into 0e8786348

Pull Request Pull Request #9521: unit: remove GOACC, use Go 1.20 native coverage functionality

Run Details

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/signrpc/signer.pb.gw.go

// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
// source: signrpc/signer.proto

/*
Package signrpc is a reverse proxy.

It translates gRPC into RESTful JSON APIs.
*/
package signrpc

import (
        "context"
        "io"
        "net/http"

        "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
        "github.com/grpc-ecosystem/grpc-gateway/v2/utilities"
        "google.golang.org/grpc"
        "google.golang.org/grpc/codes"
        "google.golang.org/grpc/grpclog"
        "google.golang.org/grpc/metadata"
        "google.golang.org/grpc/status"
        "google.golang.org/protobuf/proto"
)

// Suppress "imported and not used" errors
var _ codes.Code
var _ io.Reader
var _ status.Status
var _ = runtime.String
var _ = utilities.NewDoubleArray
var _ = metadata.Join

func request_Signer_SignOutputRaw_0(ctx context.Context, marshaler runtime.Marshaler, client SignerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq SignReq
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

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

}

func local_request_Signer_SignOutputRaw_0(ctx context.Context, marshaler runtime.Marshaler, server SignerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq SignReq
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

        msg, err := server.SignOutputRaw(ctx, &protoReq)
        return msg, metadata, err

}

func request_Signer_ComputeInputScript_0(ctx context.Context, marshaler runtime.Marshaler, client SignerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq SignReq
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

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

}

func local_request_Signer_ComputeInputScript_0(ctx context.Context, marshaler runtime.Marshaler, server SignerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq SignReq
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

        msg, err := server.ComputeInputScript(ctx, &protoReq)
        return msg, metadata, err

}

func request_Signer_SignMessage_0(ctx context.Context, marshaler runtime.Marshaler, client SignerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq SignMessageReq
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

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

}

func local_request_Signer_SignMessage_0(ctx context.Context, marshaler runtime.Marshaler, server SignerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq SignMessageReq
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

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

}

func request_Signer_VerifyMessage_0(ctx context.Context, marshaler runtime.Marshaler, client SignerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq VerifyMessageReq
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

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

}

func local_request_Signer_VerifyMessage_0(ctx context.Context, marshaler runtime.Marshaler, server SignerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq VerifyMessageReq
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

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

}

func request_Signer_DeriveSharedKey_0(ctx context.Context, marshaler runtime.Marshaler, client SignerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq SharedKeyRequest
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

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

}

func local_request_Signer_DeriveSharedKey_0(ctx context.Context, marshaler runtime.Marshaler, server SignerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq SharedKeyRequest
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

        msg, err := server.DeriveSharedKey(ctx, &protoReq)
        return msg, metadata, err

}

func request_Signer_MuSig2CombineKeys_0(ctx context.Context, marshaler runtime.Marshaler, client SignerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq MuSig2CombineKeysRequest
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

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

}

func local_request_Signer_MuSig2CombineKeys_0(ctx context.Context, marshaler runtime.Marshaler, server SignerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq MuSig2CombineKeysRequest
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

        msg, err := server.MuSig2CombineKeys(ctx, &protoReq)
        return msg, metadata, err

}

func request_Signer_MuSig2CreateSession_0(ctx context.Context, marshaler runtime.Marshaler, client SignerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq MuSig2SessionRequest
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

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

}

func local_request_Signer_MuSig2CreateSession_0(ctx context.Context, marshaler runtime.Marshaler, server SignerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq MuSig2SessionRequest
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

        msg, err := server.MuSig2CreateSession(ctx, &protoReq)
        return msg, metadata, err

}

func request_Signer_MuSig2RegisterNonces_0(ctx context.Context, marshaler runtime.Marshaler, client SignerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq MuSig2RegisterNoncesRequest
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

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

}

func local_request_Signer_MuSig2RegisterNonces_0(ctx context.Context, marshaler runtime.Marshaler, server SignerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq MuSig2RegisterNoncesRequest
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

        msg, err := server.MuSig2RegisterNonces(ctx, &protoReq)
        return msg, metadata, err

}

func request_Signer_MuSig2Sign_0(ctx context.Context, marshaler runtime.Marshaler, client SignerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq MuSig2SignRequest
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

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

}

func local_request_Signer_MuSig2Sign_0(ctx context.Context, marshaler runtime.Marshaler, server SignerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq MuSig2SignRequest
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

        msg, err := server.MuSig2Sign(ctx, &protoReq)
        return msg, metadata, err

}

func request_Signer_MuSig2CombineSig_0(ctx context.Context, marshaler runtime.Marshaler, client SignerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq MuSig2CombineSigRequest
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

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

}

func local_request_Signer_MuSig2CombineSig_0(ctx context.Context, marshaler runtime.Marshaler, server SignerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq MuSig2CombineSigRequest
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

        msg, err := server.MuSig2CombineSig(ctx, &protoReq)
        return msg, metadata, err

}

func request_Signer_MuSig2Cleanup_0(ctx context.Context, marshaler runtime.Marshaler, client SignerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq MuSig2CleanupRequest
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

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

}

func local_request_Signer_MuSig2Cleanup_0(ctx context.Context, marshaler runtime.Marshaler, server SignerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
        var protoReq MuSig2CleanupRequest
        var metadata runtime.ServerMetadata

        newReader, berr := utilities.IOReaderFactory(req.Body)
        if berr != nil {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
        }
        if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
                return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
        }

        msg, err := server.MuSig2Cleanup(ctx, &protoReq)
        return msg, metadata, err

}

// RegisterSignerHandlerServer registers the http handlers for service Signer to "mux".
// UnaryRPC     :call SignerServer directly.
// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterSignerHandlerFromEndpoint instead.
func RegisterSignerHandlerServer(ctx context.Context, mux *runtime.ServeMux, server SignerServer) error {

        mux.Handle("POST", pattern_Signer_SignOutputRaw_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/signrpc.Signer/SignOutputRaw", runtime.WithHTTPPathPattern("/v2/signer/signraw"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Signer_SignOutputRaw_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_ComputeInputScript_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/signrpc.Signer/ComputeInputScript", runtime.WithHTTPPathPattern("/v2/signer/inputscript"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Signer_ComputeInputScript_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_SignMessage_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/signrpc.Signer/SignMessage", runtime.WithHTTPPathPattern("/v2/signer/signmessage"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Signer_SignMessage_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_VerifyMessage_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/signrpc.Signer/VerifyMessage", runtime.WithHTTPPathPattern("/v2/signer/verifymessage"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Signer_VerifyMessage_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_DeriveSharedKey_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/signrpc.Signer/DeriveSharedKey", runtime.WithHTTPPathPattern("/v2/signer/sharedkey"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Signer_DeriveSharedKey_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_MuSig2CombineKeys_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/signrpc.Signer/MuSig2CombineKeys", runtime.WithHTTPPathPattern("/v2/signer/musig2/combinekeys"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Signer_MuSig2CombineKeys_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_MuSig2CreateSession_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/signrpc.Signer/MuSig2CreateSession", runtime.WithHTTPPathPattern("/v2/signer/musig2/createsession"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Signer_MuSig2CreateSession_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_MuSig2RegisterNonces_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/signrpc.Signer/MuSig2RegisterNonces", runtime.WithHTTPPathPattern("/v2/signer/musig2/registernonces"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Signer_MuSig2RegisterNonces_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_MuSig2Sign_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/signrpc.Signer/MuSig2Sign", runtime.WithHTTPPathPattern("/v2/signer/musig2/sign"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Signer_MuSig2Sign_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_MuSig2CombineSig_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/signrpc.Signer/MuSig2CombineSig", runtime.WithHTTPPathPattern("/v2/signer/musig2/combinesig"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Signer_MuSig2CombineSig_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_MuSig2Cleanup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                var stream runtime.ServerTransportStream
                ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/signrpc.Signer/MuSig2Cleanup", runtime.WithHTTPPathPattern("/v2/signer/musig2/cleanup"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := local_request_Signer_MuSig2Cleanup_0(rctx, inboundMarshaler, server, req, pathParams)
                md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        return nil
}

// RegisterSignerHandlerFromEndpoint is same as RegisterSignerHandler but
// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
func RegisterSignerHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
        conn, err := grpc.Dial(endpoint, opts...)
        if err != nil {
                return err
        }
        defer func() {
                if err != nil {
                        if cerr := conn.Close(); cerr != nil {
                                grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
                        }
                        return
                }
                go func() {
                        <-ctx.Done()
                        if cerr := conn.Close(); cerr != nil {
                                grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
                        }
                }()
        }()

        return RegisterSignerHandler(ctx, mux, conn)
}

// RegisterSignerHandler registers the http handlers for service Signer to "mux".
// The handlers forward requests to the grpc endpoint over "conn".
func RegisterSignerHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
        return RegisterSignerHandlerClient(ctx, mux, NewSignerClient(conn))
}

// RegisterSignerHandlerClient registers the http handlers for service Signer
// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "SignerClient".
// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "SignerClient"
// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
// "SignerClient" to call the correct interceptors.
func RegisterSignerHandlerClient(ctx context.Context, mux *runtime.ServeMux, client SignerClient) error {

        mux.Handle("POST", pattern_Signer_SignOutputRaw_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/signrpc.Signer/SignOutputRaw", runtime.WithHTTPPathPattern("/v2/signer/signraw"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Signer_SignOutputRaw_0(rctx, inboundMarshaler, client, req, pathParams)
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_ComputeInputScript_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/signrpc.Signer/ComputeInputScript", runtime.WithHTTPPathPattern("/v2/signer/inputscript"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Signer_ComputeInputScript_0(rctx, inboundMarshaler, client, req, pathParams)
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_SignMessage_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/signrpc.Signer/SignMessage", runtime.WithHTTPPathPattern("/v2/signer/signmessage"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Signer_SignMessage_0(rctx, inboundMarshaler, client, req, pathParams)
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_VerifyMessage_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/signrpc.Signer/VerifyMessage", runtime.WithHTTPPathPattern("/v2/signer/verifymessage"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Signer_VerifyMessage_0(rctx, inboundMarshaler, client, req, pathParams)
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_DeriveSharedKey_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/signrpc.Signer/DeriveSharedKey", runtime.WithHTTPPathPattern("/v2/signer/sharedkey"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Signer_DeriveSharedKey_0(rctx, inboundMarshaler, client, req, pathParams)
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_MuSig2CombineKeys_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/signrpc.Signer/MuSig2CombineKeys", runtime.WithHTTPPathPattern("/v2/signer/musig2/combinekeys"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Signer_MuSig2CombineKeys_0(rctx, inboundMarshaler, client, req, pathParams)
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_MuSig2CreateSession_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/signrpc.Signer/MuSig2CreateSession", runtime.WithHTTPPathPattern("/v2/signer/musig2/createsession"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Signer_MuSig2CreateSession_0(rctx, inboundMarshaler, client, req, pathParams)
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_MuSig2RegisterNonces_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/signrpc.Signer/MuSig2RegisterNonces", runtime.WithHTTPPathPattern("/v2/signer/musig2/registernonces"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Signer_MuSig2RegisterNonces_0(rctx, inboundMarshaler, client, req, pathParams)
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_MuSig2Sign_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/signrpc.Signer/MuSig2Sign", runtime.WithHTTPPathPattern("/v2/signer/musig2/sign"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Signer_MuSig2Sign_0(rctx, inboundMarshaler, client, req, pathParams)
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_MuSig2CombineSig_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/signrpc.Signer/MuSig2CombineSig", runtime.WithHTTPPathPattern("/v2/signer/musig2/combinesig"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Signer_MuSig2CombineSig_0(rctx, inboundMarshaler, client, req, pathParams)
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        mux.Handle("POST", pattern_Signer_MuSig2Cleanup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
                ctx, cancel := context.WithCancel(req.Context())
                defer cancel()
                inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
                rctx, err := runtime.AnnotateContext(ctx, mux, req, "/signrpc.Signer/MuSig2Cleanup", runtime.WithHTTPPathPattern("/v2/signer/musig2/cleanup"))
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }
                resp, md, err := request_Signer_MuSig2Cleanup_0(rctx, inboundMarshaler, client, req, pathParams)
                ctx = runtime.NewServerMetadataContext(ctx, md)
                if err != nil {
                        runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
                        return
                }

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

        })

        return nil
}

var (
        pattern_Signer_SignOutputRaw_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "signer", "signraw"}, ""))

        pattern_Signer_ComputeInputScript_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "signer", "inputscript"}, ""))

        pattern_Signer_SignMessage_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "signer", "signmessage"}, ""))

        pattern_Signer_VerifyMessage_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "signer", "verifymessage"}, ""))

        pattern_Signer_DeriveSharedKey_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "signer", "sharedkey"}, ""))

        pattern_Signer_MuSig2CombineKeys_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "signer", "musig2", "combinekeys"}, ""))

        pattern_Signer_MuSig2CreateSession_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "signer", "musig2", "createsession"}, ""))

        pattern_Signer_MuSig2RegisterNonces_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "signer", "musig2", "registernonces"}, ""))

        pattern_Signer_MuSig2Sign_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "signer", "musig2", "sign"}, ""))

        pattern_Signer_MuSig2CombineSig_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "signer", "musig2", "combinesig"}, ""))

        pattern_Signer_MuSig2Cleanup_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "signer", "musig2", "cleanup"}, ""))
)

var (
        forward_Signer_SignOutputRaw_0 = runtime.ForwardResponseMessage

        forward_Signer_ComputeInputScript_0 = runtime.ForwardResponseMessage

        forward_Signer_SignMessage_0 = runtime.ForwardResponseMessage

        forward_Signer_VerifyMessage_0 = runtime.ForwardResponseMessage

        forward_Signer_DeriveSharedKey_0 = runtime.ForwardResponseMessage

        forward_Signer_MuSig2CombineKeys_0 = runtime.ForwardResponseMessage

        forward_Signer_MuSig2CreateSession_0 = runtime.ForwardResponseMessage

        forward_Signer_MuSig2RegisterNonces_0 = runtime.ForwardResponseMessage

        forward_Signer_MuSig2Sign_0 = runtime.ForwardResponseMessage

        forward_Signer_MuSig2CombineSig_0 = runtime.ForwardResponseMessage

        forward_Signer_MuSig2Cleanup_0 = runtime.ForwardResponseMessage
)

lightningnetwork / lnd / 13412100018

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

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